public async Task <bool> Send(StageAddress address, byte[] data) { if (address.Address == null) { address = await LocalAddress(); } //try send on known peers var reqSocket = new NetMQ.Sockets.DealerSocket(); reqSocket.Options.Identity = Guid.NewGuid().ToByteArray(); reqSocket.Connect(address.Address); var messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(data); reqSocket.SendMultipartMessage(messageToServer); return(true); }
public void BindRandom() { using (var randomDealer = new DealerSocket()) using (var connectingDealer = new DealerSocket()) { int port = randomDealer.BindRandomPort("tcp://*"); connectingDealer.Connect("tcp://127.0.0.1:" + port); randomDealer.SendFrame("test"); Assert.AreEqual("test", connectingDealer.ReceiveFrameString()); } }
public void CheckTrySendFails() { using (var dealer = new DealerSocket()) { dealer.Options.SendHighWatermark = 1; dealer.Options.Linger = TimeSpan.Zero; dealer.Connect("tcp://127.0.0.1:55555"); Thread.Sleep(100); var success = dealer.TrySendFrame("1"); Assert.IsTrue(success); // because the SendHighWatermark allows it into the buffers success = dealer.TrySendFrame("2"); Assert.IsFalse(success); } }
public void CheckTrySendSucceeds() { using (var router = new RouterSocket()) using (var dealer = new DealerSocket()) { var port = router.BindRandomPort("tcp://127.0.0.1"); router.Options.Linger = TimeSpan.Zero; dealer.Options.SendHighWatermark = 1; dealer.Options.Linger = TimeSpan.Zero; dealer.Connect("tcp://127.0.0.1:" + port); Thread.Sleep(100); Assert.IsTrue(dealer.TrySendFrame("1")); } }
public void CheckSendAgainException() { using (var router = new RouterSocket()) using (var dealer = new DealerSocket()) { var port = router.BindRandomPort("tcp://127.0.0.1"); router.Options.Linger = TimeSpan.Zero; dealer.Options.SendHighWatermark = 1; dealer.Options.Linger = TimeSpan.Zero; dealer.Connect("tcp://127.0.0.1:" + port); #pragma warning disable 618 dealer.Send("1", dontWait: true, sendMore: false); dealer.Send("2", dontWait: true, sendMore: false); #pragma warning restore 618 } }
public void TwoMessagesFromRouterToDealer() { using (var server = new RouterSocket()) using (var client = new DealerSocket()) using (var poller = new NetMQPoller { client }) { var port = server.BindRandomPort("tcp://*"); client.Connect("tcp://127.0.0.1:" + port); var cnt = 0; client.ReceiveReady += (sender, e) => { var strs = e.Socket.ReceiveMultipartStrings(); foreach (var str in strs) { Console.WriteLine(str); } cnt++; if (cnt == 2) { poller.Stop(); } }; byte[] clientId = Encoding.Unicode.GetBytes("ClientId"); client.Options.Identity = clientId; const string request = "GET /\r\n"; const string response = "HTTP/1.0 200 OK\r\n" + "Content-Type: text/plain\r\n" + "\r\n" + "Hello, World!"; client.SendFrame(request); byte[] serverId = server.ReceiveFrameBytes(); Assert.AreEqual(request, server.ReceiveFrameString()); // two messages in a row, not frames server.SendMoreFrame(serverId).SendFrame(response); server.SendMoreFrame(serverId).SendFrame(response); poller.Run(); } }
public void BindToLocal() { var validAliasesForLocalHost = new[] { "127.0.0.1", "localhost", Dns.GetHostName() }; foreach (var alias in validAliasesForLocalHost) { using (var localDealer = new DealerSocket()) using (var connectingDealer = new DealerSocket()) { var port = localDealer.BindRandomPort("tcp://*"); connectingDealer.Connect(string.Format("tcp://{0}:{1}", alias, port)); localDealer.SendFrame("test"); Assert.AreEqual("test", connectingDealer.ReceiveFrameString()); Console.WriteLine(alias + " connected "); } } }
public void Mandatory() { using (var router = new RouterSocket()) { router.Options.RouterMandatory = true; router.Bind("tcp://127.0.0.1:5555"); using (var dealer = new DealerSocket()) { dealer.Options.Identity = Encoding.ASCII.GetBytes("1"); dealer.Connect("tcp://127.0.0.1:5555"); dealer.SendFrame("Hello"); Assert.AreEqual("1", router.ReceiveFrameString()); Assert.AreEqual("Hello", router.ReceiveFrameString()); } Thread.Sleep(100); Assert.Throws<HostUnreachableException>(() => router.SendMoreFrame("1").SendFrame("Hello")); } }
public void Handover() { using (var router = new RouterSocket()) using (var dealer1 = new DealerSocket()) { router.Options.RouterHandover = true; router.Bind("inproc://127.0.0.1:5555"); dealer1.Options.Identity = Encoding.ASCII.GetBytes("ID"); dealer1.Connect("inproc://127.0.0.1:5555"); dealer1.SendMoreFrame("Hello").SendFrame("World"); var identity = router.ReceiveFrameString(); Assert.AreEqual("ID", identity); using (var dealer2 = new DealerSocket()) { dealer2.Options.Identity = Encoding.ASCII.GetBytes("ID"); dealer2.Connect("inproc://127.0.0.1:5555"); // We have new peer which should take over, however we are still reading a message var message = router.ReceiveFrameString(); Assert.AreEqual("Hello", message); message = router.ReceiveFrameString(); Assert.AreEqual("World", message); dealer2.SendMoreFrame("Hello").SendFrame("World"); identity = router.ReceiveFrameString(); Assert.AreEqual("ID", identity); message = router.ReceiveFrameString(); Assert.AreEqual("Hello", message); message = router.ReceiveFrameString(); Assert.AreEqual("World", message); } } }
public void AddSocketDuringWork() { using (var router1 = new RouterSocket()) using (var router2 = new RouterSocket()) using (var dealer1 = new DealerSocket()) using (var dealer2 = new DealerSocket()) using (var poller = new NetMQPoller { router1 }) { int port1 = router1.BindRandomPort("tcp://127.0.0.1"); int port2 = router2.BindRandomPort("tcp://127.0.0.1"); dealer1.Connect("tcp://127.0.0.1:" + port1); dealer2.Connect("tcp://127.0.0.1:" + port2); bool router1Arrived = false; bool router2Arrived = false; var signal1 = new ManualResetEvent(false); var signal2 = new ManualResetEvent(false); router1.ReceiveReady += (s, e) => { router1.SkipFrame(); router1.SkipFrame(); router1Arrived = true; poller.Add(router2); signal1.Set(); }; router2.ReceiveReady += (s, e) => { router2.SkipFrame(); router2.SkipFrame(); router2Arrived = true; signal2.Set(); }; poller.RunAsync(); dealer1.SendFrame("1"); Assert.IsTrue(signal1.WaitOne(300)); dealer2.SendFrame("2"); Assert.IsTrue(signal2.WaitOne(300)); poller.Stop(); Assert.IsTrue(router1Arrived); Assert.IsTrue(router2Arrived); } }
public void RemoveTimer() { using (var router = new RouterSocket()) using (var dealer = new DealerSocket()) using (var poller = new NetMQPoller { router }) { int port = router.BindRandomPort("tcp://127.0.0.1"); dealer.Connect("tcp://127.0.0.1:" + port); bool timerTriggered = false; var timer = new NetMQTimer(TimeSpan.FromMilliseconds(100)); timer.Elapsed += (s, a) => { timerTriggered = true; }; // The timer will fire after 100ms poller.Add(timer); bool messageArrived = false; router.ReceiveReady += (s, e) => { router.SkipFrame(); router.SkipFrame(); messageArrived = true; // Remove timer poller.Remove(timer); }; poller.RunAsync(); Thread.Sleep(20); dealer.SendFrame("hello"); Thread.Sleep(300); poller.Stop(); Assert.IsTrue(messageArrived); Assert.IsFalse(timerTriggered); } }
public void LeaveTest() { Action<ZreMsg> setMessage = m => { m.Id = ZreMsg.MessageId.Leave; m.Leave.Sequence = 123; m.Leave.Group = "Life is short but Now lasts for ever"; m.Leave.Status = 123; }; Action<ZreMsg> checkMessage = m => { Assert.That(m.Id, Is.EqualTo(ZreMsg.MessageId.Leave)); Assert.That(m.Leave.Sequence, Is.EqualTo(123)); Assert.That(m.Leave.Group, Is.EqualTo("Life is short but Now lasts for ever")); Assert.That(m.Leave.Status, Is.EqualTo(123)); }; using (var client = new DealerSocket()) using (var server = new RouterSocket()) { // Cannot bind address ( inproc://zprototest ) - already in use. // But only when I run all these tests at the same time. server.Bind("inproc://zprototestLeave"); client.Connect("inproc://zprototestLeave"); ZreMsg clientMessage = new ZreMsg(); ZreMsg serverMessage = new ZreMsg(); for (int i = 0; i < 2; i++) { // client send message to server setMessage(clientMessage); clientMessage.Send(client); // server receive the message serverMessage.Receive(server); // check that message received ok Assert.That(serverMessage.RoutingId, Is.Not.Null); checkMessage(serverMessage); // reply to client, no need to set the message, using client data serverMessage.Send(server); // client receive the message clientMessage.Receive(client); // check that message received ok Assert.That(clientMessage.RoutingId, Is.Null); checkMessage(clientMessage); } } }
public void Ipv6ToIpv6() { using (var localDealer = new DealerSocket()) using (var connectingDealer = new DealerSocket()) { localDealer.Options.IPv4Only = false; var port = localDealer.BindRandomPort("tcp://*"); connectingDealer.Options.IPv4Only = false; connectingDealer.Connect(string.Format("tcp://{0}:{1}", IPAddress.IPv6Loopback, port)); connectingDealer.SendFrame("test"); Assert.AreEqual("test", localDealer.ReceiveFrameString()); } }
public void HasOutTest() { using (var server = new DealerSocket()) { using (var client = new DealerSocket()) { var port = server.BindRandomPort("tcp://*"); // no client is connected so we don't have out Assert.IsFalse(server.HasOut); Assert.IsFalse(client.HasOut); client.Connect("tcp://localhost:" + port); Thread.Sleep(200); // client is connected so server should have out now, client as well Assert.IsTrue(server.HasOut); Assert.IsTrue(client.HasOut); } //Thread.Sleep(2000); // client is disposed,server shouldn't have out now //Assert.IsFalse(server.HasOut); } }
public void Router_Dealer_Demonstrating_Messages_From_Publisher_To_Subscribers() { // NOTES // 1. Use ThreadLocal<DealerSocket> where each thread has // its own client DealerSocket to talk to server // 2. Each thread can send using it own socket // 3. Each thread socket is added to poller const int delay = 500; // millis var clientSocketPerThread = new ThreadLocal<DealerSocket>(); string endpoint; using (var server = new RouterSocket("@tcp://127.0.0.1:0")) // If we specify 0, it will choose a random port for us. { endpoint = server.Options.LastEndpoint; // Lets us know which port was chosen. Console.Write("Last endpoint, including port: {0}\n", server.Options.LastEndpoint); using (var poller = new NetMQPoller()) { // Start some threads, each with its own DealerSocket // to talk to the server socket. Creates lots of sockets, // but no nasty race conditions no shared state, each // thread has its own socket, happy days. for (int i = 0; i < 4; i++) { Task.Factory.StartNew(state => { DealerSocket client = null; if (!clientSocketPerThread.IsValueCreated) { client = new DealerSocket(); client.Options.Identity = Encoding.Unicode.GetBytes(state.ToString()); client.Connect(endpoint); //client.ReceiveReady += Client_ReceiveReady; clientSocketPerThread.Value = client; poller.Add(client); } else { client = clientSocketPerThread.Value; } Thread.Sleep(3000); // Wait until server is up. client.SendFrame("Ping"); while (true) { Console.Write("Client {0}: Waiting for ping...\n", i); // Work around "feature" of router/dealer: the publisher does not know the subscriber exists, until it // sends at least one message which makes it necessary to open the connection. I believe this is a // low-level feature of the TCP/IP transport. var clientMessage = client.ReceiveMultipartMessage(); Console.WriteLine("======================================"); Console.WriteLine(" INCOMING CLIENT MESSAGE FROM SERVER"); Console.WriteLine("======================================"); PrintFrames("Server receiving", clientMessage); } }, string.Format("client {0}", i), TaskCreationOptions.LongRunning); } // start the poller poller.RunAsync(); // server loop int sequenceNo = 0; for (int i=0;i<10;i++) { NetMQMessage messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(sequenceNo.ToString()); sequenceNo++; Console.WriteLine("======================================"); Console.WriteLine(" OUTGOING MESSAGE {0} TO CLIENTS ", sequenceNo); Console.WriteLine("======================================"); PrintFrames("Client Sending", messageToServer); server.SendMultipartMessage(messageToServer); Thread.Sleep(delay); } Console.WriteLine("Finished."); } } }
public void Messages_From_Router_To_Dealer_With_Subscription() { Console.Write("Test sending message from publisher(router) to subscribers (dealer).\n"); int maxMessage = 5; CountdownEvent cd = new CountdownEvent(maxMessage); string endpoint; using (var publisher = new RouterSocket()) using (var subscriber = new DealerSocket()) using (var poller = new NetMQPoller { subscriber }) { publisher.Bind("tcp://127.0.0.1:0"); endpoint = publisher.Options.LastEndpoint; subscriber.Connect(endpoint); subscriber.ReceiveReady += (sender, e) => { var strs = e.Socket.ReceiveMultipartStrings(); foreach (var str in strs) { Console.WriteLine("Subscribe: " + str); } cd.Signal(); }; byte[] clientId = Encoding.Unicode.GetBytes("ClientIdTheIsLongerThen32BytesForSureAbsolutelySure"); subscriber.Options.Identity = clientId; const string request = "Ping"; // Work around "feature" of router/dealer: the publisher does not know the subscriber exists, until it // sends at least one message which makes it necessary to open the connection. I believe this is a // low-level feature of the TCP/IP transport. subscriber.SendFrame(request); // Ping. byte[] serverId = publisher.ReceiveFrameBytes(); //Assert.AreEqual(request, publisher.ReceiveFrameString()); for (int i = 0; i < maxMessage; i++) { string msg = string.Format("[message: {0}]", i); Console.Write("Publish: {0}\n", msg); publisher.SendMoreFrame(serverId).SendFrame(msg); //publisher.SendMoreFrame("").SendFrame(msg); } poller.RunAsync(); if (cd.Wait(TimeSpan.FromSeconds(10)) == false) // Blocks until _countdown.Signal has been called. { Assert.Fail("Timed out, this test should complete in less than 10 seconds."); } } }
public void Messages_From_Dealer_To_Router() { int maxMessage = 5; CountdownEvent cd = new CountdownEvent(maxMessage); Console.Write("Test sending message from subscribers (dealer) to publisher(router).\n"); using (var publisher = new RouterSocket()) using (var subscriber = new DealerSocket()) using (var poller = new NetMQPoller { subscriber }) { var port = publisher.BindRandomPort("tcp://*"); subscriber.Connect("tcp://127.0.0.1:" + port); subscriber.ReceiveReady += (sender, e) => { var strs = e.Socket.ReceiveMultipartStrings(); foreach (var str in strs) { Console.WriteLine(str); } cd.Signal(); }; byte[] clientId = Encoding.Unicode.GetBytes("ClientId"); subscriber.Options.Identity = clientId; const string request = "GET /\r\n"; const string response = "HTTP/1.0 200 OK\r\n" + "Content-Type: text/plain\r\n" + "\r\n" + "Hello, World!"; subscriber.SendFrame(request); byte[] serverId = publisher.ReceiveFrameBytes(); Assert.AreEqual(request, publisher.ReceiveFrameString()); for (int i = 0; i < maxMessage; i++) { publisher.SendMoreFrame(serverId).SendFrame(response); } poller.RunAsync(); if (cd.Wait(TimeSpan.FromSeconds(10)) == false) // Blocks until _countdown.Signal has been called. { Assert.Fail("Timed out, this test should complete in less than 10 seconds."); } } }
public void WhisperTest() { Action<ZreMsg> setMessage = m => { m.Id = ZreMsg.MessageId.Whisper; m.Whisper.Sequence = 123; m.Whisper.Content = new NetMQMessage(); m.Whisper.Content.Append("Hello"); m.Whisper.Content.Append("World"); }; Action<ZreMsg> checkMessage = m => { Assert.That(m.Id, Is.EqualTo(ZreMsg.MessageId.Whisper)); Assert.That(m.Whisper.Sequence, Is.EqualTo(123)); Assert.That(m.Whisper.Content.FrameCount, Is.EqualTo(2)); var str1 = m.Whisper.Content[0].ConvertToString(); Assert.That(str1, Is.EqualTo("Hello")); var str2 = m.Whisper.Content[1].ConvertToString(); Assert.That(str2, Is.EqualTo("World")); }; using (var client = new DealerSocket()) using (var server = new RouterSocket()) { server.Bind("inproc://zprototestWhisper"); client.Connect("inproc://zprototestWhisper"); ZreMsg clientMessage = new ZreMsg(); ZreMsg serverMessage = new ZreMsg(); for (int i = 0; i < 2; i++) { // client send message to server setMessage(clientMessage); clientMessage.Send(client); // server receive the message serverMessage.Receive(server); // check that message received ok Assert.That(serverMessage.RoutingId, Is.Not.Null); checkMessage(serverMessage); // reply to client, no need to set the message, using client data serverMessage.Send(server); // client receive the message clientMessage.Receive(client); // check that message received ok Assert.That(clientMessage.RoutingId, Is.Null); checkMessage(clientMessage); } } }
public void PingOkTest() { Action<ZreMsg> setMessage = m => { m.Id = ZreMsg.MessageId.PingOk; m.PingOk.Sequence = 123; }; Action<ZreMsg> checkMessage = m => { Assert.That(m.Id, Is.EqualTo(ZreMsg.MessageId.PingOk)); Assert.That(m.PingOk.Sequence, Is.EqualTo(123)); }; using (var client = new DealerSocket()) using (var server = new RouterSocket()) { server.Bind("inproc://zprototestPingOk"); client.Connect("inproc://zprototestPingOk"); ZreMsg clientMessage = new ZreMsg(); ZreMsg serverMessage = new ZreMsg(); for (int i = 0; i < 2; i++) { // client send message to server setMessage(clientMessage); clientMessage.Send(client); // server receive the message serverMessage.Receive(server); // check that message received ok Assert.That(serverMessage.RoutingId, Is.Not.Null); checkMessage(serverMessage); // reply to client, no need to set the message, using client data serverMessage.Send(server); // client receive the message clientMessage.Receive(client); // check that message received ok Assert.That(clientMessage.RoutingId, Is.Null); checkMessage(clientMessage); } } }
public void Router_Dealer_Demonstrating_Messages_From_Subscribers_To_Publisher() { // NOTES // 1. Use ThreadLocal<DealerSocket> where each thread has // its own client DealerSocket to talk to server // 2. Each thread can send using it own socket // 3. Each thread socket is added to poller const int delay = 500; // millis var clientSocketPerThread = new ThreadLocal<DealerSocket>(); using (var server = new RouterSocket("@tcp://127.0.0.1:5556")) { using (var poller = new NetMQPoller()) { // Start some threads, each with its own DealerSocket // to talk to the server socket. Creates lots of sockets, // but no nasty race conditions no shared state, each // thread has its own socket, happy days. for (int i = 0; i < 4; i++) { Task.Factory.StartNew(state => { DealerSocket client = null; if (!clientSocketPerThread.IsValueCreated) { client = new DealerSocket(); client.Options.Identity = Encoding.Unicode.GetBytes(state.ToString()); client.Connect("tcp://127.0.0.1:5556"); client.ReceiveReady += Client_ReceiveReady; clientSocketPerThread.Value = client; poller.Add(client); } else { client = clientSocketPerThread.Value; } while (true) { NetMQMessage messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(state.ToString()); Console.WriteLine("======================================"); Console.WriteLine(" OUTGOING MESSAGE TO SERVER "); Console.WriteLine("======================================"); PrintFrames("Client Sending", messageToServer); client.SendMultipartMessage(messageToServer); Thread.Sleep(delay); } }, string.Format("client {0}", i), TaskCreationOptions.LongRunning); } // start the poller poller.RunAsync(); // server loop for(int i=0;i<6;i++) { NetMQMessage clientMessage = server.ReceiveMessage(); Console.WriteLine("======================================"); Console.WriteLine(" INCOMING CLIENT MESSAGE FROM CLIENT "); Console.WriteLine("======================================"); PrintFrames("Server receiving", clientMessage); if (clientMessage.FrameCount == 3) { var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server {1}", clientOriginalMessage, DateTime.Now.ToLongTimeString()); var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMultipartMessage(messageToClient); } } } } }
public void Unbind(string protocol) { using (var server = new DealerSocket()) { string address1, address2; // just making sure can bind on both addresses using (var client1 = new DealerSocket()) using (var client2 = new DealerSocket()) { if (protocol == "tcp") { var port1 = server.BindRandomPort("tcp://localhost"); var port2 = server.BindRandomPort("tcp://localhost"); address1 = "tcp://localhost:" + port1; address2 = "tcp://localhost:" + port2; client1.Connect(address1); client2.Connect(address2); } else { Debug.Assert(protocol == "inproc"); address1 = "inproc://localhost1"; address2 = "inproc://localhost2"; server.Bind(address1); server.Bind(address2); client1.Connect(address1); client2.Connect(address2); } Thread.Sleep(100); // we should be connected to both server client1.SendFrame("1"); client2.SendFrame("2"); // the server receive from both server.SkipFrame(); server.SkipFrame(); } // unbind second address server.Unbind(address2); Thread.Sleep(100); using (var client1 = new DealerSocket()) using (var client2 = new DealerSocket()) { client1.Options.DelayAttachOnConnect = true; client1.Connect(address1); client2.Options.DelayAttachOnConnect = true; if (protocol == "tcp") { client2.Connect(address2); client1.SendFrame("1"); server.SkipFrame(); Assert.IsFalse(client2.TrySendFrame(TimeSpan.FromSeconds(2), "2")); } else { Assert.Throws<EndpointNotFoundException>(() => { client2.Connect(address2); }); } } } }
public void RouterDealerMessaging() { using (var server = new RouterSocket()) using (var client = new DealerSocket()) { int port = server.BindRandomPort("tcp://127.0.0.1"); client.Connect("tcp://127.0.0.1:" + port); var clientOutgoingMessage = new NetMQMessage(); clientOutgoingMessage.Append("Hello"); client.SendMultipartMessage(clientOutgoingMessage); NetMQMessage serverIncomingMessage = server.ReceiveMultipartMessage(); // number of frames should be one because first message should be identity of client Assert.AreEqual(2, serverIncomingMessage.FrameCount); Assert.AreEqual("Hello", serverIncomingMessage[1].ConvertToString()); var serverOutgoingMessage = new NetMQMessage(); // first adding the identity serverOutgoingMessage.Append(serverIncomingMessage[0]); serverOutgoingMessage.Append("World"); server.SendMultipartMessage(serverOutgoingMessage); var incomingClientMessage = client.ReceiveMultipartMessage(); Assert.AreEqual(1, incomingClientMessage.FrameCount); Assert.AreEqual("World", incomingClientMessage[0].ConvertToString()); } }
public void JoinTest() { Action<ZreMsg> setMessage = m => { m.Id = ZreMsg.MessageId.Join; m.Join.Sequence = 123; m.Join.Group = "Life is short but Now lasts for ever"; m.Join.Status = 123; }; Action<ZreMsg> checkMessage = m => { Assert.That(m.Id, Is.EqualTo(ZreMsg.MessageId.Join)); Assert.That(m.Join.Sequence, Is.EqualTo(123)); Assert.That(m.Join.Group, Is.EqualTo("Life is short but Now lasts for ever")); Assert.That(m.Join.Status, Is.EqualTo(123)); }; using (var client = new DealerSocket()) using (var server = new RouterSocket()) { server.Bind("inproc://zprototestJoin"); client.Connect("inproc://zprototestJoin"); ZreMsg clientMessage = new ZreMsg(); ZreMsg serverMessage = new ZreMsg(); for (int i = 0; i < 2; i++) { // client send message to server setMessage(clientMessage); clientMessage.Send(client); // server receive the message serverMessage.Receive(server); // check that message received ok Assert.That(serverMessage.RoutingId, Is.Not.Null); checkMessage(serverMessage); // reply to client, no need to set the message, using client data serverMessage.Send(server); // client receive the message clientMessage.Receive(client); // check that message received ok Assert.That(clientMessage.RoutingId, Is.Null); checkMessage(clientMessage); } } }
public void AddSocketDuringWork() { using (var router1 = new RouterSocket()) using (var router2 = new RouterSocket()) using (var dealer1 = new DealerSocket()) using (var dealer2 = new DealerSocket()) using (var poller = new Poller(router1) { PollTimeout = TestPollTimeoutMillis }) { int port1 = router1.BindRandomPort("tcp://127.0.0.1"); int port2 = router2.BindRandomPort("tcp://127.0.0.1"); dealer1.Connect("tcp://127.0.0.1:" + port1); dealer2.Connect("tcp://127.0.0.1:" + port2); bool router1Arrived = false; bool router2Arrived = false; var signal1 = new ManualResetEvent(false); var signal2 = new ManualResetEvent(false); router1.ReceiveReady += (s, e) => { router1.SkipFrame(); router1.SkipFrame(); router1Arrived = true; poller.AddSocket(router2); signal1.Set(); }; router2.ReceiveReady += (s, e) => { router2.SkipFrame(); router2.SkipFrame(); router2Arrived = true; signal2.Set(); }; poller.PollTillCancelledNonBlocking(); dealer1.SendFrame("1"); Assert.IsTrue(signal1.WaitOne(300)); dealer2.SendFrame("2"); Assert.IsTrue(signal1.WaitOne(300)); poller.CancelAndJoin(); Assert.IsTrue(router1Arrived); Assert.IsTrue(router2Arrived); } }
public void HelloTest() { Action<ZreMsg> setMessage = m => { m.Id = ZreMsg.MessageId.Hello; m.Hello.Sequence = 123; m.Hello.Endpoint = "Life is short but Now lasts for ever"; m.Hello.Groups = new List<string>(); m.Hello.Groups.Add("Name: Brutus"); m.Hello.Groups.Add("Age: 43"); m.Hello.Status = 123; m.Hello.Name = "Life is short but Now lasts for ever"; m.Hello.Headers = new Dictionary<string, string>(); m.Hello.Headers.Add("Name", "Brutus"); m.Hello.Headers.Add("Age", "43"); }; Action<ZreMsg> checkMessage = m => { Assert.That(m.Id, Is.EqualTo(ZreMsg.MessageId.Hello)); Assert.That(m.Hello.Sequence, Is.EqualTo(123)); Assert.That(m.Hello.Endpoint, Is.EqualTo("Life is short but Now lasts for ever")); Assert.That(m.Hello.Groups.Count, Is.EqualTo(2)); Assert.That(m.Hello.Groups[0], Is.EqualTo("Name: Brutus")); Assert.That(m.Hello.Groups[1], Is.EqualTo("Age: 43")); Assert.That(m.Hello.Status, Is.EqualTo(123)); Assert.That(m.Hello.Name, Is.EqualTo("Life is short but Now lasts for ever")); Assert.That(m.Hello.Headers.Count, Is.EqualTo(2)); Assert.That(m.Hello.Headers["Name"], Is.EqualTo("Brutus")); Assert.That(m.Hello.Headers["Age"], Is.EqualTo("43")); }; using (var client = new DealerSocket()) using (var server = new RouterSocket()) { server.Bind("inproc://zprototestHello"); client.Connect("inproc://zprototestHello"); ZreMsg clientMessage = new ZreMsg(); ZreMsg serverMessage = new ZreMsg(); for (int i = 0; i < 2; i++) { // client send message to server setMessage(clientMessage); clientMessage.Send(client); // server receive the message serverMessage.Receive(server); // check that message received ok Assert.That(serverMessage.RoutingId, Is.Not.Null); checkMessage(serverMessage); // reply to client, no need to set the message, using client data serverMessage.Send(server); // client receive the message clientMessage.Receive(client); // check that message received ok Assert.That(clientMessage.RoutingId, Is.Null); checkMessage(clientMessage); } } }
public void HasInTest() { using (var server = new RouterSocket()) using (var client = new DealerSocket()) { var port = server.BindRandomPort("tcp://*"); // no one sent a message so it should be false Assert.IsFalse(server.HasIn); client.Connect("tcp://localhost:" + port); // wait for the client to connect Thread.Sleep(100); // now we have one client connected but didn't send a message yet Assert.IsFalse(server.HasIn); client.SendFrame("1"); // wait for the message to arrive Thread.Sleep(100); // the has in should indicate a message is ready Assert.IsTrue(server.HasIn); server.SkipFrame(); // identity string message = server.ReceiveFrameString(); Assert.AreEqual(message, "1"); // we read the message, it should false again Assert.IsFalse(server.HasIn); } }
public void AddTwoSocketAfterRemoving() { using (var router1 = new RouterSocket()) using (var router2 = new RouterSocket()) using (var router3 = new RouterSocket()) using (var router4 = new RouterSocket()) using (var dealer1 = new DealerSocket()) using (var dealer2 = new DealerSocket()) using (var dealer3 = new DealerSocket()) using (var dealer4 = new DealerSocket()) using (var poller = new NetMQPoller { router1, router2 }) { int port1 = router1.BindRandomPort("tcp://127.0.0.1"); int port2 = router2.BindRandomPort("tcp://127.0.0.1"); int port3 = router3.BindRandomPort("tcp://127.0.0.1"); int port4 = router4.BindRandomPort("tcp://127.0.0.1"); dealer1.Connect("tcp://127.0.0.1:" + port1); dealer2.Connect("tcp://127.0.0.1:" + port2); dealer3.Connect("tcp://127.0.0.1:" + port3); dealer4.Connect("tcp://127.0.0.1:" + port4); int router1Arrived = 0; int router2Arrived = 0; bool router3Arrived = false; bool router4Arrived = false; var signal1 = new ManualResetEvent(false); var signal2 = new ManualResetEvent(false); var signal3 = new ManualResetEvent(false); var signal4 = new ManualResetEvent(false); router1.ReceiveReady += (s, e) => { router1Arrived++; router1.SkipFrame(); // identity router1.SkipFrame(); // message poller.Remove(router1); signal1.Set(); }; router2.ReceiveReady += (s, e) => { router2Arrived++; router2.SkipFrame(); // identity router2.SkipFrame(); // message if (router2Arrived == 1) { poller.Add(router3); poller.Add(router4); signal2.Set(); } }; router3.ReceiveReady += (s, e) => { router3.SkipFrame(); // identity router3.SkipFrame(); // message router3Arrived = true; signal3.Set(); }; router4.ReceiveReady += (s, e) => { router4.SkipFrame(); // identity router4.SkipFrame(); // message router4Arrived = true; signal4.Set(); }; poller.RunAsync(); dealer1.SendFrame("1"); Assert.IsTrue(signal1.WaitOne(300)); dealer2.SendFrame("2"); Assert.IsTrue(signal2.WaitOne(300)); dealer3.SendFrame("3"); dealer4.SendFrame("4"); dealer2.SendFrame("2"); dealer1.SendFrame("1"); Assert.IsTrue(signal3.WaitOne(300)); Assert.IsTrue(signal4.WaitOne(300)); poller.Stop(); router1.SkipFrame(); bool more; Assert.AreEqual("1", router1.ReceiveFrameString(out more)); Assert.IsFalse(more); Assert.AreEqual(1, router1Arrived); Assert.AreEqual(2, router2Arrived); Assert.IsTrue(router3Arrived); Assert.IsTrue(router4Arrived); } }
public void Disconnect(string protocol) { using (var server1 = new DealerSocket()) using (var server2 = new DealerSocket()) using (var client = new DealerSocket()) { string address2; if (protocol == "tcp") { var port1 = server1.BindRandomPort("tcp://localhost"); var port2 = server2.BindRandomPort("tcp://localhost"); client.Connect("tcp://localhost:" + port1); client.Connect("tcp://localhost:" + port2); address2 = "tcp://localhost:" + port2; } else { server1.Bind("inproc://localhost1"); server2.Bind("inproc://localhost2"); client.Connect("inproc://localhost1"); client.Connect("inproc://localhost2"); address2 = "inproc://localhost2"; } Thread.Sleep(100); // we should be connected to both server client.SendFrame("1"); client.SendFrame("2"); // make sure client is connected to both servers server1.SkipFrame(); server2.SkipFrame(); // disconnect from server2, server 1 should receive all messages client.Disconnect(address2); Thread.Sleep(100); client.SendFrame("1"); client.SendFrame("2"); server1.SkipFrame(); server1.SkipFrame(); } }
public void RemoveSocket() { using (var router1 = new RouterSocket()) using (var router2 = new RouterSocket()) using (var router3 = new RouterSocket()) using (var dealer1 = new DealerSocket()) using (var dealer2 = new DealerSocket()) using (var dealer3 = new DealerSocket()) using (var poller = new NetMQPoller { router1, router2, router3 }) { int port1 = router1.BindRandomPort("tcp://127.0.0.1"); int port2 = router2.BindRandomPort("tcp://127.0.0.1"); int port3 = router3.BindRandomPort("tcp://127.0.0.1"); dealer1.Connect("tcp://127.0.0.1:" + port1); dealer2.Connect("tcp://127.0.0.1:" + port2); dealer3.Connect("tcp://127.0.0.1:" + port3); bool first = true; router1.ReceiveReady += (s, e) => { if (!first) Assert.Fail("This should not happen because we cancelled the socket"); first = false; // identity e.Socket.SkipFrame(); bool more; Assert.AreEqual("Hello", e.Socket.ReceiveFrameString(out more)); Assert.False(more); // cancelling the socket poller.Remove(e.Socket); // remove self }; router2.ReceiveReady += (s, e) => { // identity byte[] identity = e.Socket.ReceiveFrameBytes(); // message e.Socket.SkipFrame(); e.Socket.SendMoreFrame(identity); e.Socket.SendFrame("2"); }; router3.ReceiveReady += (s, e) => { // identity byte[] identity = e.Socket.ReceiveFrameBytes(); // message e.Socket.SkipFrame(); e.Socket.SendMoreFrame(identity).SendFrame("3"); }; Task pollerTask = Task.Factory.StartNew(poller.Run); // Send three messages. Only the first will be processed, as then handler removes // the socket from the poller. dealer1.SendFrame("Hello"); dealer1.SendFrame("Hello2"); dealer1.SendFrame("Hello3"); // making sure the socket defined before the one cancelled still works dealer2.SendFrame("1"); Assert.AreEqual("2", dealer2.ReceiveFrameString()); // making sure the socket defined after the one cancelled still works dealer3.SendFrame("1"); Assert.AreEqual("3", dealer3.ReceiveFrameString()); poller.Stop(); Assert.IsTrue(pollerTask.IsCompleted); } }
public void InprocRouterDealerTest() { // The main thread simply starts several clients and a server, and then // waits for the server to finish. var readyMsg = Encoding.UTF8.GetBytes("RDY"); var freeWorkers = new Queue<byte[]>(); using (var backendsRouter = new RouterSocket()) { backendsRouter.Options.Identity = Guid.NewGuid().ToByteArray(); backendsRouter.Bind("inproc://backend"); backendsRouter.ReceiveReady += (o, e) => { // Handle worker activity on backend while (e.Socket.HasIn) { var msg = e.Socket.ReceiveMultipartMessage(); var idRouter = msg.Pop(); // forget the empty frame if (msg.First.IsEmpty) msg.Pop(); var id = msg.Pop(); if (msg.First.IsEmpty) msg.Pop(); if (msg.FrameCount == 1) { // worker send RDY message queue his Identity to the free workers queue if (readyMsg[0] == msg[0].Buffer[0] && readyMsg[1] == msg[0].Buffer[1] && readyMsg[2] == msg[0].Buffer[2]) { lock (freeWorkers) { freeWorkers.Enqueue(id.Buffer); } } } } }; var poller = new NetMQPoller { backendsRouter }; for (int i = 0; i < 2; i++) { var workerThread = new Thread(state => { byte[] routerId = (byte[])state; byte[] workerId = Guid.NewGuid().ToByteArray(); using (var workerSocket = new DealerSocket()) { workerSocket.Options.Identity = workerId; workerSocket.Connect("inproc://backend"); var workerReadyMsg = new NetMQMessage(); workerReadyMsg.Append(workerId); workerReadyMsg.AppendEmptyFrame(); workerReadyMsg.Append(readyMsg); workerSocket.SendMultipartMessage(workerReadyMsg); Thread.Sleep(1000); } }); workerThread.IsBackground = true; workerThread.Name = "worker" + i; workerThread.Start(backendsRouter.Options.Identity); } poller.RunAsync(); Thread.Sleep(1000); poller.Stop(); Assert.AreEqual(2, freeWorkers.Count); } }
public void SimpleTimer() { // TODO it is not really clear what this test is actually testing -- maybe split it into a few smaller tests using (var router = new RouterSocket()) using (var dealer = new DealerSocket()) using (var poller = new NetMQPoller { router }) { int port = router.BindRandomPort("tcp://127.0.0.1"); dealer.Connect("tcp://127.0.0.1:" + port); bool messageArrived = false; router.ReceiveReady += (s, e) => { Assert.IsFalse(messageArrived); router.SkipFrame(); router.SkipFrame(); messageArrived = true; }; bool timerTriggered = false; int count = 0; const int timerIntervalMillis = 100; var timer = new NetMQTimer(TimeSpan.FromMilliseconds(timerIntervalMillis)); timer.Elapsed += (s, a) => { // the timer should jump before the message Assert.IsFalse(messageArrived); timerTriggered = true; timer.Enable = false; count++; }; poller.Add(timer); poller.RunAsync(); Thread.Sleep(150); dealer.SendFrame("hello"); Thread.Sleep(300); poller.Stop(); Assert.IsTrue(messageArrived); Assert.IsTrue(timerTriggered); Assert.AreEqual(1, count); } }