public void should_reuse_last_endpoint_port_when_available_in_current_dir()
{
const string peerId = "Abc.Peer.0";
var expectedPortFilePath = PathUtil.InBaseDirectory(peerId + ".inboundport.test");
var expectedPort = TcpUtil.GetRandomUnusedPort();
File.WriteAllText(expectedPortFilePath, expectedPort.ToString());
var transport = CreateAndStartZmqTransport(peerId: peerId);
var endpoint = new ZmqEndPoint(transport.InboundEndPoint);
endpoint.GetPort().ShouldEqual(expectedPort);
}
public void Test_Find_Tcp_Port()
{
int port = TcpUtil.FindFreePort(9000);
Console.Out.WriteLine("Port found: " + port);
Assert.IsTrue(port >= 9000);
IPEndPoint localEndPoint = new IPEndPoint(IPAddress.Loopback, port);
Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
newsock.Bind(localEndPoint);
newsock.Listen(10);
newsock.Close();
}
public void RnComunicarFimExclusaoTarefaConcluidaTest()
{
DateUtil.CurrentDateTime = DateTime.Now;
//inicializar o Dicionário tarefasGrid
const string ipServidor = "127.0.0.1";
const int porta = 8092;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
WexMultiAccessClientMock client = new WexMultiAccessClientMock();
client.Porta = porta;
client.EnderecoIp = ipServidor;
client.Login = "******";
client.OidCronograma = "C1";
client.Conectar();
client.AoServidorDesconectar += (mensagemDto) => { };
TcpClient conexaoClienteNoServidor = servidor.AcceptTcpClient();
//efetuar a leitura da autenticacao do client
TcpUtil.ReceberMensagemTcp(conexaoClienteNoServidor);
//representar as tarefas no grid
Dictionary <string, Int16> tarefasGrid = new Dictionary <string, short>();
//preencher as tarefas no grid
//representar as tarefas excluidas
string[] tarefasExcluidas = new string[] { "T1", "T2" };
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T3", 1);
tarefasImpactadas.Add("T4", 2);
client.RnComunicarFimExclusaoTarefaConcluida(tarefasExcluidas, tarefasImpactadas, new string[] { }, DateUtil.CurrentDateTime);
string msgJson = TcpUtil.ReceberMensagemTcp(conexaoClienteNoServidor);
msgJson = TcpUtil.RemoverStringProtecaoDeIntegridade(msgJson);
MensagemDto mensagemRecebida = Mensagem.DeserializarMensagemDto(msgJson);
Assert.AreEqual(CsTipoMensagem.ExclusaoTarefaFinalizada, mensagemRecebida.Tipo, string.Format("A mensagem deveria ser do tipo {0}", CsTipoMensagem.ExclusaoTarefaFinalizada));
Assert.AreEqual("C1", (string)mensagemRecebida.Propriedades[Constantes.OIDCRONOGRAMA], "O cronograma da mensagem deveria ser C1");
Assert.AreEqual("Joao", (string)mensagemRecebida.Propriedades[Constantes.AUTOR_ACAO], "O login do colaborador que comunicou a exclusão da mensagem deveria ser Joao");
CollectionAssert.AreEquivalent(tarefasImpactadas, (Dictionary <string, Int16>)mensagemRecebida.Propriedades[Constantes.TAREFAS_IMPACTADAS], "Deveria possuir as " +
"mesmas tarefas na ordem indicada da reordenação");
CollectionAssert.AreEquivalent(new string[] { }, (string[])mensagemRecebida.Propriedades[Constantes.TAREFAS_NAO_EXCLUIDAS]);
}
public void RnProcessarEventosRecebendoMensagemDoTipoExclusaoTarefaFinalizada()
{
DateUtil.CurrentDateTime = DateTime.Now;
const string ipServidor = "127.0.0.1";
const int porta = 8091;
bool disparoEvento = false;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>()
{
CallBase = true
};
WexMultiAccessClientMock cliente = clienteMock.Object;
cliente.EnderecoIp = ipServidor;
cliente.OidCronograma = "C1";
cliente.Porta = porta;
cliente.Login = "******";
cliente.Conectar();
cliente.AoSerExcluidaTarefaPorOutroUsuario += (mensagemDto) => { disparoEvento = true; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
TcpClient tcpEmServidor = servidor.AcceptTcpClient();
//interceptando a mensagem de conexão
TcpUtil.ReceberMensagemTcp(tcpEmServidor);
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T3", 3);
tarefasImpactadas.Add("T4", 4);
MensagemDto mensagem = Mensagem.RnCriarMensagemComunicarExclusaoTarefaConcluida(new string[] { "T1", "T5" }, tarefasImpactadas, "C1", "Joao", DateUtil.CurrentDateTime, new string[] { "T2" });
string mensagemJson = JsonConvert.SerializeObject(mensagem);
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
//enviando mensagem ao cliente
TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor);
ControleDeEsperaUtil.AguardarAte(() => { return(disparoEvento); });
Assert.IsTrue(disparoEvento, "Deveria ter sido acionado o evento AoSerExcluidaTarefaPorOutroUsuario");
MensagemDto mensagemEsperada = cliente.MensagensRecebidas.Where(o => o.Tipo == CsTipoMensagem.ExclusaoTarefaFinalizada).FirstOrDefault();
Assert.IsNotNull(mensagemEsperada, "Deveria ter sido recebida uma mensagem do tipo AoSerExcluidaTarefaPorOutroUsuario");
CollectionAssert.AreEqual(tarefasImpactadas, (Dictionary <string, Int16>)mensagemEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS]);
CollectionAssert.AreEqual(new string[] { "T1", "T5" }, (string[])mensagemEsperada.Propriedades[Constantes.TAREFAS]);
CollectionAssert.AreEqual(new string[] { "T2" }, (string[])mensagemEsperada.Propriedades[Constantes.TAREFAS_NAO_EXCLUIDAS]);
Assert.AreEqual("C1", (string)mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA]);
Assert.AreEqual("Joao", (string)mensagemEsperada.Propriedades[Constantes.AUTOR_ACAO]);
Assert.AreEqual(DateUtil.CurrentDateTime, (DateTime)mensagemEsperada.Propriedades[Constantes.DATAHORA_ACAO]);
cliente.RnDesconectar();
}
public void should_not_reuse_a_port_used_in_another_envionment()
{
const string peerId = "Abc.Peer.0";
var doNotUsePortFilePath = PathUtil.InBaseDirectory(peerId + ".inboundport.secondenv");
var expectedPort = TcpUtil.GetRandomUnusedPort() + 5; // scientifical method to determine what port will be used by the transport :P
File.WriteAllText(doNotUsePortFilePath, expectedPort.ToString());
var transport = CreateAndStartZmqTransport(peerId: peerId);
var endpoint = new ZmqEndPoint(transport.InboundEndPoint);
endpoint.GetPort().ShouldNotEqual(expectedPort);
Console.WriteLine("{0} => {1}", endpoint.GetPort(), expectedPort);
}
public bool Ping(string host, int port)
{
var ping = new PingTest()
{
Address = $"{host}:{port}",
Date = DateTime.Now,
Success = TcpUtil.PingHost(host, port)
};
if (!Pings.ContainsKey(ping.Date))
{
Pings.Add(ping.Date, ping);
}
return(ping.Success);
}
public void OkNowIKnowThatMyMessagesAreNotLostAfterDisconnect()
{
var message = new byte[100];
var receiveBuffer = new byte[100];
Console.WriteLine("ZMQ v{0}", ZmqUtil.GetVersion().ToString(3));
Console.WriteLine(Environment.Is64BitProcess ? "x64" : "x86");
using (var context = new ZmqContext())
using (var receiver = new ZmqSocket(context, ZmqSocketType.PULL))
using (var sender = new ZmqSocket(context, ZmqSocketType.PUSH))
{
var port = TcpUtil.GetRandomUnusedPort();
var receiveEndpoint = $"tcp://*:{port}";
var sendEndpoint = $"tcp://localhost:{port}";
receiver.SetOption(ZmqSocketOption.RCVHWM, 2_000);
receiver.SetOption(ZmqSocketOption.RCVTIMEO, 200);
receiver.SetOption(ZmqSocketOption.RCVBUF, 100_000);
receiver.Bind(receiveEndpoint);
sender.SetOption(ZmqSocketOption.SNDHWM, 2_000);
//sender.SetOption(ZmqSocketOption.RCVHWM, 1);
sender.SetOption(ZmqSocketOption.SNDTIMEO, 200);
receiver.SetOption(ZmqSocketOption.SNDBUF, 100_000);
sender.Connect(sendEndpoint);
var sendCount = 0;
while (sender.TrySend(message, 0, message.Length, out _))
{
sendCount++;
}
Console.WriteLine("{0} sent messages", sendCount);
sender.TryDisconnect(sendEndpoint);
sender.Connect(sendEndpoint);
var receivedMessageCount = 0;
while (receiver.TryReadMessage(ref receiveBuffer, out _, out _))
{
receivedMessageCount++;
}
Console.WriteLine("{0} received messages", receivedMessageCount);
}
}
public void RnProcessarEventosRecebendoMensagemDoTipoExclusaoTarefaPermitida()
{
const string ipServidor = "127.0.0.1";
const int porta = 8090;
int contador = 0;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
MensagemDto mensagemEsperada = new MensagemDto();
Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>()
{
CallBase = true
};
WexMultiAccessClientMock cliente = clienteMock.Object;
cliente.EnderecoIp = ipServidor;
cliente.OidCronograma = "C1";
cliente.Porta = porta;
cliente.Login = "******";
cliente.Conectar();
cliente.ExecutarExclusaoTarefa += (mensagemDto) => { contador++; mensagemEsperada = mensagemDto; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
TcpClient tcpEmServidor = servidor.AcceptTcpClient();
//interceptando a mensagem de conexão
TcpUtil.ReceberMensagemTcp(tcpEmServidor);
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T3", 3);
tarefasImpactadas.Add("T4", 4);
//MensagemDto mensagem = Mensagem.RnCriarMensagemEdicaoTarefaAutorizada(2 ,4 ,"T2","Joao" ,"C1");
MensagemDto mensagem = Mensagem.RnCriarMensagemEfetuarExclusaoTarefas(new string[] { "T1", "T2" }, new string[] { }, "C1", "Joao");
string mensagemJson = JsonConvert.SerializeObject(mensagem);
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
//enviando mensagem ao cliente
TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor);
ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); });
Assert.AreEqual(1, contador, "Deveria ter sido acionado o evento ExecutarExclusaoTarefa");
//MensagemDto mensagemEsperada = cliente.mensagensDtoEvento.Where(o => o.Tipo == CsTipoMensagem.ExclusaoTarefaPermitida).FirstOrDefault();
Assert.IsNotNull(mensagemEsperada, "Deveria ter sido recebida uma mensagem do tipo ExecutarExclusaoTarefa");
CollectionAssert.AreEqual(new string[] { "T1", "T2" }, (string[])mensagemEsperada.Propriedades[Constantes.TAREFAS]);
Assert.AreEqual("C1", (string)mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA]);
Assert.AreEqual("Joao", (string)mensagemEsperada.Propriedades[Constantes.AUTOR_ACAO]);
cliente.RnDesconectar();
}
async public Task StartAsync()
{
NetworkStream stream;
IPacket received;
byte[] receiveHeader, receiveData, decompressData;
int nbytes, receiveDataLength;
// 클라이언트에서 오는 메세지를 듣기 위해 별도의 쓰레드를 돌린다.
await Task.Factory.StartNew(async() =>
{
while (this.client.Connected)
{
try
{
stream = this.client.GetStream();
// 1. 결과의 헤더를 받는다.
receiveHeader = new byte[Consts.SIZE_HEADER];
nbytes = await stream.ReadAsync(buffer: receiveHeader, offset: 0, count: receiveHeader.Length);
// 2. 결과의 데이터를 받는다.
receiveDataLength = BitConverter.ToInt32(value: receiveHeader, startIndex: 0);
receiveData = await TcpUtil.ReceiveDataAsync(networkStream: stream, dataLength: receiveDataLength);
await stream.FlushAsync();
// 3. 결과는 압축되어 있으므로 푼다.
decompressData = await NetUtil.DecompressAsync(data: receiveData);
received = NetUtil.DeserializeObject(data: decompressData) as IPacket;
await Receive(this.stageID, received);
}
catch (SocketException)
{
await Disconnect(this.stageID, this.userID);
}
catch (Exception ex)
{
Console.WriteLine(ex);
await Disconnect(this.stageID, this.userID);
}
}
});
}
/// <summary>
/// Responsável por finalizar a conexão, avisando o servidor de que está se desconectando
/// </summary>
public void RnFinalizarConexao(bool forcarAtualizacao = false)
{
if (ValidarConexao())
{
ChamadaAssincrona metodo = () =>
{
MensagemDto mensagemDesconectar = Mensagem.RnCriarMensagemUsuarioDesconectado(new string[] { Login }, OidCronograma, forcarAtualizacao);
string mensagemJson = JsonConvert.SerializeObject(mensagemDesconectar);
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
tcpAdapter.EnviarMensagem(mensagemJson);
};
IAsyncResult result = metodo.BeginInvoke(null, null);
result.AsyncWaitHandle.WaitOne();
}
RnDesconectar();
}
public void RnProcessarEventosRecebendoMensagemDoTipoMovimentacaoPosicaoTarefa()
{
DateUtil.CurrentDateTime = DateTime.Now;
const string ipServidor = "127.0.0.1";
const int porta = 8089;
int contador = 0;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>()
{
CallBase = true
};
WexMultiAccessClientMock cliente = clienteMock.Object;
cliente.EnderecoIp = ipServidor;
cliente.OidCronograma = "C1";
cliente.Porta = porta;
cliente.Login = "******";
cliente.Conectar();
cliente.AoOcorrerMovimentacaoPosicaoTarefa += (mensagemDto) => { contador++; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
TcpClient tcpEmServidor = servidor.AcceptTcpClient();
//interceptando a mensagem de conexão
TcpUtil.ReceberMensagemTcp(tcpEmServidor);
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T3", 3);
tarefasImpactadas.Add("T4", 4);
MensagemDto mensagem = Mensagem.RnCriarMensagemMovimentacaoTarefa(2, 4, "T2", tarefasImpactadas, "Joao", "C1", DateUtil.CurrentDateTime);
string mensagemJson = JsonConvert.SerializeObject(mensagem);
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
//enviando mensagem ao cliente
TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor);
ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); });
Assert.AreEqual(1, contador, "Deveria ter sido acionado o evento AoOcorrerMovimentacaoPosicaoTarefa");
MensagemDto mensagemEsperada = cliente.MensagensRecebidas.Where(o => o.Tipo == CsTipoMensagem.MovimentacaoPosicaoTarefa).FirstOrDefault();
Assert.IsNotNull(mensagemEsperada, "Deveria ter sido recebida uma mensagem do tipo MovimentacaoPosicaoTarefa");
CollectionAssert.AreEqual(tarefasImpactadas, (Dictionary <string, Int16>)mensagemEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS]);
cliente.RnDesconectar();
}
public void should_support_peer_endpoint_modifications()
{
var senderTransport = CreateAndStartZmqTransport();
var receivedMessages = new ConcurrentBag <TransportMessage>();
var receiverTransport = CreateAndStartZmqTransport(onMessageReceived: receivedMessages.Add);
var receiver = new Peer(receiverTransport.PeerId, receiverTransport.InboundEndPoint);
senderTransport.Send(new FakeCommand(0).ToTransportMessage(), new[] { receiver });
Wait.Until(() => receivedMessages.Count == 1, 2.Seconds());
var newEndPoint = "tcp://127.0.0.1:" + TcpUtil.GetRandomUnusedPort();
receiverTransport.Stop();
receiverTransport = CreateAndStartZmqTransport(newEndPoint, receivedMessages.Add);
receiver.EndPoint = receiverTransport.InboundEndPoint;
senderTransport.Send(new FakeCommand(0).ToTransportMessage(), new[] { receiver });
Wait.Until(() => receivedMessages.Count == 2, 2.Seconds(), "unable to receive message");
}
public void EnviarEReceberApenasUmaMensagemDeTextoTest()
{
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8050;
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
string m1 = "Este texto deve chegar ao destino completamente intacto";
TcpClient tcp = new TcpClient();
tcp.Connect(ipServidor, portaServidor);
TcpClient tcpServidor = servidor.AcceptTcpClient();
TcpUtil.EnviarMensagemTcp(m1, tcp);
string m1Result = TcpUtil.ReceberMensagemTcp(tcpServidor);
Assert.AreEqual(m1, m1Result, "A mensagem retornada deveria estar intacta portanto igual a de origem");
servidor.Stop();
tcp.Close();
}
public void EnviarEReceberUmaMensagemDtoTest()
{
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8051;
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
MensagemDto mensagemDto = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { "Joao" }, "C1");
string m1 = JsonConvert.SerializeObject(mensagemDto);
TcpClient tcp = new TcpClient();
tcp.Connect(ipServidor, portaServidor);
TcpClient tcpServidor = servidor.AcceptTcpClient();
TcpUtil.EnviarMensagemTcp(m1, tcp);
string m1Result = TcpUtil.ReceberMensagemTcp(tcpServidor);
Assert.AreEqual(m1, m1Result, "A mensagem retornada deveria estar intacta portanto igual a de origem");
servidor.Stop();
tcp.Close();
}
public void RnProcessarEventosRecebendoMensagemDoTipoEdicaoTarefaAutorizada()
{
const string ipServidor = "127.0.0.1";
const int porta = 8088;
int contador = 0;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
Mock <WexMultiAccessClientMock> clienteMock = new Mock <WexMultiAccessClientMock>()
{
CallBase = true
};
WexMultiAccessClientMock cliente = clienteMock.Object;
cliente.EnderecoIp = ipServidor;
cliente.OidCronograma = "C1";
cliente.Porta = porta;
cliente.Login = "******";
cliente.Conectar();
cliente.AoSerAutorizadaEdicaoTarefa += (mensagem) => { contador++; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
TcpClient tcpEmServidor = servidor.AcceptTcpClient();
//interceptando a mensagem de conexão
TcpUtil.ReceberMensagemTcp(tcpEmServidor);
MensagemDto mensagemEdicaoAutorizada = Mensagem.RnCriarMensagemEdicaoTarefaAutorizada("Joao", "C1", "T1");
string mensagemJson = JsonConvert.SerializeObject(mensagemEdicaoAutorizada);
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
TcpUtil.EnviarMensagemTcp(mensagemJson, tcpEmServidor);
ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); });
Assert.AreEqual(1, contador, "Deveria ter siso disparado o evento AoEdicaoTarefaSerRecusada");
MensagemDto mensagemEsperada = cliente.MensagensRecebidas.Where(o => o.Tipo == CsTipoMensagem.EdicaoTarefaAutorizada).First();
Assert.AreEqual("C1", (string)mensagemEsperada.Propriedades[Constantes.OIDCRONOGRAMA], "A mensagem recebida deveria ser do cronograma indicado");
Assert.AreEqual("T1", (string)mensagemEsperada.Propriedades[Constantes.OIDTAREFA], "O oid da tarefa da mensagem recebida deveria ser o passado na criação da mensagem");
cliente.RnDesconectar();
}
public void ReceberMensagemQuandoHouverMaisDeUmJsonNaMensagem()
{
const string USUARIOS = "usuarios";
//Configurações de Ip e porta do servidor
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8002;
const string login = "******";
const string oidCronograma = "C1";
string[] usuarios = new string[1];
//Instanciação do Servidor para escutar o cliente
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
//Instanciação do cliente que irá conectar no servidor
TcpClient cliente = new TcpClient();
cliente.Connect(ipServidor, portaServidor);
//Servidor Aceitando a solicitação do cliente
TcpClient conexao = servidor.AcceptTcpClient();
//Fila de processamento
Queue <MensagemDto> filaProcessamento = new Queue <MensagemDto>();
usuarios[0] = login;
ConexaoCliente conexaoCliente = new ConexaoCliente(login, conexao, filaProcessamento);
//Configurando propriedades da mensagem
Hashtable propriedades = new Hashtable();
propriedades.Add(USUARIOS, usuarios);
propriedades.Add(oidCronograma, oidCronograma);
//Montando a Mensagem que será enviada
MensagemDto mensagem = new MensagemDto()
{
Tipo = CsTipoMensagem.NovosUsuariosConectados, Propriedades = propriedades
};
//Serializando a Mensagem que será enviada
string mensagemJsonEnviada = JsonConvert.SerializeObject(mensagem);
mensagemJsonEnviada = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJsonEnviada);
//Enviando a Mensagem através da conexão do cliente
const string login2 = "Pedro";
//Configurando propriedades da mensagem
propriedades = new Hashtable();
usuarios = new string[1];
usuarios[0] = login2;
propriedades.Add(Constantes.USUARIOS, usuarios);
propriedades.Add(Constantes.OIDCRONOGRAMA, oidCronograma);
//Montando a Mensagem que será enviada
mensagem = new MensagemDto()
{
Tipo = CsTipoMensagem.NovosUsuariosConectados, Propriedades = propriedades
};
//Serializando a Mensagem que será enviada
string mensagemJsonEnviada2 = JsonConvert.SerializeObject(mensagem);
mensagemJsonEnviada2 = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJsonEnviada2);
//Enviando a Mensagem através da conexão do cliente
TcpUtil.EnviarMensagemTcp(mensagemJsonEnviada + mensagemJsonEnviada2, cliente);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count == 2); });
Assert.AreEqual(2, filaProcessamento.Count, "Deveria possuir 2 mensagens enfileiradas");
Assert.IsTrue(conexaoCliente.Buffer == "", "Buffer deveria estar vazio pois as mensagens json eram mensagens válidas");
conexaoCliente.Desconectar();
servidor.Stop();
cliente.Close();
conexao.Close();
}
public void OkNowIKnowThatMyMessagesAreLostAfterDisconnect()
{
var message = new byte[50];
var receiveBuffer = new byte[100];
Console.WriteLine("ZMQ v{0}", ZmqUtil.GetVersion().ToString(3));
Console.WriteLine(Environment.Is64BitProcess ? "x64" : "x86");
using (var context = new ZmqContext())
using (var receiver = new ZmqSocket(context, ZmqSocketType.PULL))
using (var sender = new ZmqSocket(context, ZmqSocketType.PUSH))
{
var sendEndpoint = $"tcp://localhost:{TcpUtil.GetRandomUnusedPort()}";
var receiveEndpoint = sendEndpoint.Replace("localhost", "*");
receiver.SetOption(ZmqSocketOption.RCVHWM, 10);
receiver.SetOption(ZmqSocketOption.RCVTIMEO, 200);
receiver.Bind(receiveEndpoint);
sender.SetOption(ZmqSocketOption.SNDHWM, 10);
sender.Connect(sendEndpoint);
for (var i = 0; i < 10; ++i)
{
var sendStatus = sender.TrySend(message, 0, message.Length, out var error);
Console.WriteLine($"SEND: {sendStatus} - {error.ToErrorMessage()}");
}
for (var i = 0; i < 10; ++i)
{
var receiveStatus = receiver.TryReadMessage(ref receiveBuffer, out var bytes, out var error);
Console.WriteLine($"RECV: {receiveStatus} - {bytes} - {error.ToErrorMessage()}");
}
receiver.TryUnbind(receiver.GetOptionString(ZmqSocketOption.LAST_ENDPOINT));
for (var i = 0; i < 10; ++i)
{
var sendStatus = sender.TrySend(message, 0, message.Length, out var error);
Console.WriteLine($"SEND: {sendStatus} - {error.ToErrorMessage()}");
}
sender.TryDisconnect(sender.GetOptionString(ZmqSocketOption.LAST_ENDPOINT));
sender.SetOption(ZmqSocketOption.SNDTIMEO, 1000);
sender.Connect(sendEndpoint);
{
var sendStatus = sender.TrySend(message, 0, message.Length, out var error);
Console.WriteLine($"SEND: {sendStatus} - {error.ToErrorMessage()}");
}
receiver.SetOption(ZmqSocketOption.RCVTIMEO, 2000);
receiver.Bind(receiveEndpoint);
var receivedMessageCount = 0;
while (receiver.TryReadMessage(ref receiveBuffer, out _, out _))
{
++receivedMessageCount;
}
Console.WriteLine("{0} received messages", receivedMessageCount);
}
}
/// <summary>
/// Responsável por fazer a escuta em tempo real da threadComunicaoServidor
/// </summary>
protected virtual void RnProcessarEventos()
{
String mensagemJson = "";
MensagemDto m;
List <string> mensagens;
string msgAtual = "";
try
{
while (autenticado)
{
if (tcpAdapter == null || !tcpAdapter.ValidarConexao())
{
ProcessarMensagemEvento(Mensagem.RnCriarMensagemServidorDesconectando("Você acabou se ser desconectado, verifique sua rede ou contate o administrador"));
continue;
}
if (!autenticado)
{
continue;
}
if (!tcpAdapter.PossuiDadosParaLeitura())
{
Thread.Sleep(15);
continue;
}
mensagemJson = tcpAdapter.EfetuarLeitura();
if (mensagemJson.Trim() == "")
{
continue;
}
if (mensagemJson.Contains("\n"))
{
mensagens = mensagemJson.Split('\n').ToList();
foreach (string msg in mensagens)
{
if (String.IsNullOrEmpty(msg))
{
continue;
}
msgAtual = msg.Trim();
if (Buffer != "")
{
msgAtual = Buffer + msgAtual;
Buffer = "";
}
m = Mensagem.DeserializarMensagemDto(TcpUtil.RemoverStringProtecaoDeIntegridade(msgAtual));
ProcessarMensagemEvento(m);
msgAtual = "";
}
}
else
{
Buffer += mensagemJson;
}
Thread.Sleep(10);
}
}
catch (JsonException excessao)
{
Debug.WriteLine(string.Format("MultiAccessClient do {3} (Leitura) - Mensagem Json:{2}Excessão:{0}\nCallStack{1}", excessao.Message, excessao.StackTrace, msgAtual, Login), "JsonConvert:");
//continue;
throw excessao;
}
catch (InvalidOperationException e)
{
Debug.WriteLine(string.Format("Ocorreu a excessão:{0}\nLocal:{1}", e.Message, e.StackTrace), Thread.CurrentThread.Name);
ProcessarMensagemEvento(Mensagem.RnCriarMensagemServidorDesconectando(String.Format("{0}\n {1}", e.Message, e.StackTrace)));
RnDesconectar();
throw e;
}
catch (Exception e)
{
DumperExtension.ShowStackTrace("Exception no client.");
Debug.WriteLine(string.Format("Ocorreu a excessão:{0}\nLocal:{1}\n Target Site:{2}", e.Message, e.StackTrace, e.TargetSite), Thread.CurrentThread.Name);
RnDesconectar();
throw e;
}
}
public void ReceberMensagemFimEdicaoTarefaTest()
{
//Configurações do Servidor
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8007;
//Instanciar e iniciar o Servidor (Listener)
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
Queue <MensagemDto> filaProcessamento = new Queue <MensagemDto>();
//Instanciar os Clientes (2x TcpClient)
TcpClient cliente1 = new TcpClient();
TcpClient cliente2 = new TcpClient();
const string login1 = "Joao";
const string login2 = "Pedro";
const string oidCronograma = "C1";
//Tentativa de conexao do cliente1
cliente1.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente1EmServidor = servidor.AcceptTcpClient();
//Tentativa de conexao do cliente2
cliente2.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente2EmServidor = servidor.AcceptTcpClient();
//Iniciar ConexaoCliente do cliente1
ConexaoClienteMock c1 = new ConexaoClienteMock(login1, cliente1EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Iniciar ConexaoCliente do cliente2
ConexaoClienteMock c2 = new ConexaoClienteMock(login2, cliente2EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Criar mensagemDto novoUsuarioConectado para o cliente1
MensagemDto m1 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login1 }, oidCronograma);
string m1Json = JsonConvert.SerializeObject(m1);
m1Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m1Json);
//Criar mensagemDto novoUsuarioConectado para o cliente2
MensagemDto m2 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login2 }, oidCronograma);
string m2Json = JsonConvert.SerializeObject(m2);
m2Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m2Json);
//Enviar a mensagem Json do primeiro cliente atráves do tcp cliente1;
TcpUtil.EnviarMensagemTcp(m1Json, cliente1);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 0); });
//Enviar a mensagem Json do segundo cliente atráves do tcp cliente2;
TcpUtil.EnviarMensagemTcp(m2Json, cliente2);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 1); });
Assert.AreEqual(2, filaProcessamento.Count, "Deveria ser enfileirada 2 objetos MensagemDto");
MensagemDto m3 = Mensagem.RnCriarMensagemFinalizarEdicaoTarefa("T1", "gabriel", "C1");
string m3Json = JsonConvert.SerializeObject(m3);
m3Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m3Json);
TcpUtil.EnviarMensagemTcp(m3Json, cliente2);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 2); });
c1.Desconectar();
c2.Desconectar();
servidor.Stop();
cliente1.Close();
cliente2.Close();
cliente1EmServidor.Close();
cliente2EmServidor.Close();
}
public void ReceberMensagemQuandoJsonEstiverCompleto()
{
#region Estimativa de Teste:
/*
* Estimativa Teste:
* Receber uma mensagemDto Json e enfileirar na fila de leitura;
* Cenário:
* - Instanciar um Listener (gerenciar as conexoes)
* - Instanciar 2 TcpClients (Efetuar a comunicação de conexão)
* - Montar as MensagemDTOs de NovoUsarioConectado
* - Serializar as Mensagens
* - Escrever cada mensagem no stream de seu respectivo tcp
* - Ler a Mensagem no stream
* - Processar Cada Mensagem e enfileirar na fila de leitura
* Resultado Estimado:
* - Deve ter sido possivel o enfileiramento das 2 mensagens dto recebidas
*/
#endregion
//Configurações do Servidor
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8000;
//Instanciar e iniciar o Servidor (Listener)
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
Queue <MensagemDto> filaProcessamento = new Queue <MensagemDto>();
//Instanciar os Clientes (2x TcpClient)
TcpClient cliente1 = new TcpClient();
TcpClient cliente2 = new TcpClient();
const string login1 = "Joao";
const string login2 = "Pedro";
const string oidCronograma = "C1";
//Tentativa de conexao do cliente1
cliente1.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente1EmServidor = servidor.AcceptTcpClient();
//Tentativa de conexao do cliente2
cliente2.Connect(ipServidor, portaServidor);
// Servidor aceitar a conexao do cliente1 e armazenar
TcpClient cliente2EmServidor = servidor.AcceptTcpClient();
//Iniciar ConexaoCliente do cliente1
ConexaoClienteMock c1 = new ConexaoClienteMock(login1, cliente1EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Iniciar ConexaoCliente do cliente2
ConexaoClienteMock c2 = new ConexaoClienteMock(login2, cliente2EmServidor, filaProcessamento)
{
PermissaoDeEscrita = false
};
//Criar mensagemDto novoUsuarioConectado para o cliente1
MensagemDto m1 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login1 }, oidCronograma);
string m1Json = JsonConvert.SerializeObject(m1);
m1Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m1Json);
//Criar mensagemDto novoUsuarioConectado para o cliente2
MensagemDto m2 = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login2 }, oidCronograma);
string m2Json = JsonConvert.SerializeObject(m2);
m2Json = TcpUtil.AdicionarStringProtecaoDeIntegridade(m2Json);
//Enviar a mensagem Json do primeiro cliente atráves do tcp cliente1;
TcpUtil.EnviarMensagemTcp(m1Json, cliente1);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 0); });
//Enviar a mensagem Json do segundo cliente atráves do tcp cliente2;
TcpUtil.EnviarMensagemTcp(m2Json, cliente2);
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count > 1); });
Assert.AreEqual(2, filaProcessamento.Count, "Deveria ser enfileirada 2 objetos MensagemDto");
#region Testes:
//Verificar see enfileirou as mensagens recebidas
// Assert.AreEqual(2, filaProcessamento.Count, "Deveria possuir 2 mensagens enfileiradas");
//Checar se não há nenhuma mensagem incompleta no buffer de mensagens das conexões
// Assert.IsTrue(string.IsNullOrEmpty(conexaoCliente.Buffer), "Buffer deveria estar vazio pois as mensagens json eram mensagens válidas");
// Assert.IsTrue(string.IsNullOrEmpty(conexaoCliente2.Buffer), "Buffer deveria estar vazio pois as mensagens json eram mensagens válidas");
#endregion
#region Finalização Cenário
c1.Desconectar();
c2.Desconectar();
servidor.Stop();
cliente1.Close();
cliente2.Close();
cliente1EmServidor.Close();
cliente2EmServidor.Close();
#endregion
}
public void ReceberMensagemQuandoJsonIncompleto()
{
#region Estimativa do teste:
/*
* Estimativa do teste:
* - Receber uma mensagem json incompleta e armazenar no buffer e a fila deve estar vazia
* - receber o resto da mensagem processar e enfileirar
* Cenário:
* - conexão instanciada e configurada
* - filaProcessamento
* - MensagemJson convertida
* - MensagemJson repartida em 2
* - enviar as 2 partes separadamente
* Acontecimento Estimado:
* - Armazenar no buffer a mensagem incompleta
* - Verificar quando ela completar
* - Enfileirar a mensagem(somente se for completa)
* Resultado Estimado:
* - Deve conseguir enfileirar a mensagem
*/
#endregion
//Configurações de Ip e porta do servidor
IPAddress ipServidor = IPAddress.Parse("127.0.0.1");
const int portaServidor = 8001;
const string login = "******";
string[] usuarios = new string[1];
//Instanciação do Servidor para escutar o cliente
TcpListener servidor = new TcpListener(ipServidor, portaServidor);
servidor.Start();
//Instanciação do cliente que irá conectar no servidor
TcpClient cliente = new TcpClient();
cliente.Connect(ipServidor, portaServidor);
//Servidor Aceitando a solicitação do cliente
TcpClient conexao = servidor.AcceptTcpClient();
//Fila de processamento
Queue <MensagemDto> filaProcessamento = new Queue <MensagemDto>();
ConexaoCliente conexaoCliente = new ConexaoCliente(login, conexao, filaProcessamento);
//Montando a Mensagem que será enviada
MensagemDto mensagem = Mensagem.RnCriarMensagemNovoUsuarioConectado(new string[] { login }, "C1");
//Serializando a Mensagem que será enviada
string mensagemEnvio = JsonConvert.SerializeObject(mensagem);
//Adicionando string de verificação de integridade
mensagemEnvio = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemEnvio);
//Dividindo a mensagem em 2 partes
string mensagemParte1 = mensagemEnvio.Substring(0, 12);
string mensagemParte2 = mensagemEnvio.Substring(12, (mensagemEnvio.Length - 12));
Assert.AreEqual(mensagemEnvio, mensagemParte1 + mensagemParte2, "Deveriam Ser Iguais");
//Enviando a Mensagem através da conexão do cliente
TcpUtil.EnviarMensagemTcp(mensagemParte1, cliente);
TcpUtil.EnviarMensagemTcp(mensagemParte2, cliente);
//Aguardando o enfileiramento
ControleDeEsperaUtil.AguardarAte(() => { return(filaProcessamento.Count == 1); });
Assert.AreEqual(1, filaProcessamento.Count, "Deveria possuir 1 mensagem enfileirada");
Assert.IsTrue(conexaoCliente.Buffer == "", "Deveria ter resolvido o buffer e enfileirado o evento");
conexaoCliente.Desconectar();
servidor.Stop();
conexao.Close();
}
public void RnProcessarEventosReceberMensagensComStringDeProtecao()
{
int contador = 0;
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
Porta = porta, EnderecoIp = ipServidor, Login = "******", OidCronograma = "C1", TcpAdapterStubAtivo = true
};
TcpAdapterPool pool = new TcpAdapterPool();
// mensagemDto que serão preenchidas no disparo dos eventos do client
MensagemDto mensagemAutenticacaoEsperada = new MensagemDto();
MensagemDto mensagemNovaTarefaCriadaEsperada = new MensagemDto();
MensagemDto mensagemInicioEdicaoTarefaCriada = new MensagemDto();
//eventos que deverão preencher as mensagensDto anteriores para comparação posterior
cliente.AoSerAutenticadoComSucesso += (mensagem) => { contador++; mensagemAutenticacaoEsperada = mensagem; };
cliente.AoSerCriadaNovaTarefa += (mensagem) => { contador++; mensagemNovaTarefaCriadaEsperada = mensagem; };
cliente.AoIniciarEdicaoTarefa += (mensagem) => { contador++; mensagemInicioEdicaoTarefaCriada = mensagem; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
cliente.Conectar();
pool.AceitarConexao(cliente);
//dicionário de tarefas impactadas
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T2", 1);
tarefasImpactadas.Add("T3", 2);
tarefasImpactadas.Add("T4", 3);
tarefasImpactadas.Add("T5", 4);
//mensagens que serão comunicadas ao client e deverão ser recebidas com sucesso no client
MensagemDto autenticacaoEnviada, novaTarefaCriadaEnviada, inicioEdicaoTarefaEnviada;
//criando mensagem de conexão aceita e retornando a mensagem ao client
autenticacaoEnviada = Mensagem.RnCriarMensagemConexaoEfetuadaComSucesso(new string[] { "Joao", "Pedro" }, "C1", null);
string json = JsonConvert.SerializeObject(autenticacaoEnviada);
json = TcpUtil.AdicionarStringProtecaoDeIntegridade(json);
//criando mensagem de inicio de edição de uma tarefa e comunicando ao client
inicioEdicaoTarefaEnviada = Mensagem.RnCriarMensagemInicioEdicaoTarefa("T1", "Joao", "C1");
string json2 = JsonConvert.SerializeObject(inicioEdicaoTarefaEnviada);
json2 = TcpUtil.AdicionarStringProtecaoDeIntegridade(json2);
DateUtil.CurrentDateTime = DateTime.Now;
//criando mensagem de criação de uma nova tarefa
novaTarefaCriadaEnviada = Mensagem.RnCriarMensagemNovaTarefaCriada("T2", "Gabriel", "C2", tarefasImpactadas, DateUtil.CurrentDateTime);
string json3 = JsonConvert.SerializeObject(novaTarefaCriadaEnviada);
json3 = TcpUtil.AdicionarStringProtecaoDeIntegridade(json3);
//unindo as mensagens em uma unica para testar o envio e o recebimento de mensagens coladas
json = json + json2 + json3;
pool.EnviarMensagemPara(cliente, json);
//aguardar até que os 3 eventos do client sejam disparados ao receber e tratar as mensagens enviadas
ControleDeEsperaUtil.AguardarAte(() => { return(contador == 3); });
Assert.AreEqual(3, contador, "Deveria ter contado 3 pois foram é a quantidade de mensagens acumuladas no tcp");
//asserts para a mensagem de autenticação
Assert.AreEqual(mensagemAutenticacaoEsperada.Tipo, autenticacaoEnviada.Tipo, "A mensagem recebida de autenticação deveria ser do mesmo tipo");
Assert.AreEqual((string)mensagemAutenticacaoEsperada.Propriedades[Constantes.OIDCRONOGRAMA], (string)autenticacaoEnviada.Propriedades["oidCronograma"], "Deveria possuir o mesmo" +
" cronograma nas mensagens de autenticação");
CollectionAssert.AreEquivalent((string[])mensagemAutenticacaoEsperada.Propriedades[Constantes.USUARIOS], (string[])autenticacaoEnviada.Propriedades[Constantes.USUARIOS], "Deveria possuir a mesma lista de usuários online");
//asserts para mensagem de criação de nova tarefa
Assert.AreEqual(mensagemNovaTarefaCriadaEsperada.Tipo, novaTarefaCriadaEnviada.Tipo, "A mensagem recebida de nova tarefa criada deveria ser do mesmo tipo");
Assert.AreEqual((string)mensagemNovaTarefaCriadaEsperada.Propriedades[Constantes.OIDCRONOGRAMA], (string)novaTarefaCriadaEnviada.Propriedades[Constantes.OIDCRONOGRAMA], "A mensagem recebida de nova tarefa criada deveria ser do mesmo tipo");
CollectionAssert.AreEquivalent((Dictionary <string, Int16>)mensagemNovaTarefaCriadaEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS], (Dictionary <string, Int16>)novaTarefaCriadaEnviada.Propriedades[Constantes.TAREFAS_IMPACTADAS], "Deveria possuir as tarefas impactadas com a mesma ordenacao");
}
