public void Start() { _context = NetMQContext.Create(); _frontend = _context.CreateRouterSocket(); _backend = _context.CreateRouterSocket(); _frontend.Bind("tcp://localhost:5555"); // For Clients _backend.Bind("tcp://localhost:5556"); // For Workers _frontend.ReceiveReady += _frontEnd_ReceiveReady; _backend.ReceiveReady += _backEnd_ReceiveReady; var heartbeatTimer = new NetMQTimer(Paranoid.HEARTBEAT_INTERVAL_MS); heartbeatTimer.Elapsed += heartbeatTimer_Elapsed; _poller = new Poller(); _poller.AddSocket(_frontend); _poller.AddSocket(_backend); _poller.AddTimer(heartbeatTimer); _nextHeartbeatAt = DateTime.Now.AddMilliseconds(Paranoid.HEARTBEAT_INTERVAL_MS); Task.Factory.StartNew(t => Run(t), _tokenSource.Token, TaskCreationOptions.LongRunning); Task.Factory.StartNew(_poller.Start, TaskCreationOptions.LongRunning); }
public void AddSocketDuringWork() { using (NetMQContext contex = NetMQContext.Create()) { // we are using three responses to make sure we actually move the correct socket and other sockets still work using (var router = contex.CreateRouterSocket()) using (var router2 = contex.CreateRouterSocket()) { router.Bind("tcp://127.0.0.1:5002"); router2.Bind("tcp://127.0.0.1:5003"); using (var dealer = contex.CreateDealerSocket()) using (var dealer2 = contex.CreateDealerSocket()) using (Poller poller = new Poller()) { dealer.Connect("tcp://127.0.0.1:5002"); dealer2.Connect("tcp://127.0.0.1:5003"); bool router1arrived = false; bool router2arrived = false; bool more; router2.ReceiveReady += (s, a) => { router2.Receive(out more); router2.Receive(out more); router2arrived = true; }; router.ReceiveReady += (s, a) => { router1arrived = true; router.Receive(out more); router.Receive(out more); poller.AddSocket(router2); }; poller.AddSocket(router); Task task = Task.Factory.StartNew(poller.Start); dealer.Send("1"); Thread.Sleep(300); dealer2.Send("2"); Thread.Sleep(300); poller.Stop(true); task.Wait(); Assert.IsTrue(router1arrived); Assert.IsTrue(router2arrived); } } } }
void CreateServer() { switch (_type) { case ServerType.Response: _serverSocket = _context.CreateResponseSocket(); break; case ServerType.Pub: _serverSocket = _context.CreatePushSocket(); break; case ServerType.Router: _serverSocket = _context.CreateRouterSocket(); break; case ServerType.Stream: _serverSocket = _context.CreateStreamSocket(); break; case ServerType.Push: _serverSocket = _context.CreatePushSocket(); break; case ServerType.XPub: _serverSocket = _context.CreateXPublisherSocket(); break; default: _serverSocket = _context.CreateResponseSocket(); break; } _serverSocket.Bind("tcp://*:" + _port); Task.Factory.StartNew(() => AsyncRead(_serverSocket), TaskCreationOptions.LongRunning); }
/// <summary> /// Initializes a new instance of the <see cref="QueueDevice"/> class. /// </summary> /// <param name="context">The <see cref="NetMQContext"/> to use when creating the sockets.</param> /// <param name="poller">The <see cref="Poller"/> to use.</param> /// <param name="frontendBindAddress">The endpoint used to bind the frontend socket.</param> /// <param name="backendBindAddress">The endpoint used to bind the backend socket.</param> /// <param name="mode">The <see cref="DeviceMode"/> for the device.</param> public QueueDevice(NetMQContext context, Poller poller, string frontendBindAddress, string backendBindAddress, DeviceMode mode = DeviceMode.Threaded) : base(poller, context.CreateRouterSocket(), context.CreateDealerSocket(), mode) { FrontendSetup.Bind(frontendBindAddress); BackendSetup.Bind(backendBindAddress); }
protected void CreateServer() { switch (_type) { case MQServerType.Response: _serverSocket = _context.CreateResponseSocket(); break; case MQServerType.Publisher: _serverSocket = _context.CreatePublisherSocket(); break; case MQServerType.Router: _serverSocket = _context.CreateRouterSocket(); break; case MQServerType.Stream: _serverSocket = _context.CreateStreamSocket(); break; case MQServerType.Push: _serverSocket = _context.CreatePushSocket(); break; case MQServerType.XPublisher: _serverSocket = _context.CreateXPublisherSocket(); break; default: _serverSocket = _context.CreateResponseSocket(); break; } _serverSocket.Bind("tcp://*:" + _port); }
/// <summary> /// Initializes a new instance of the Server class /// </summary> /// <param name="connectionString">How the server should be set up, to listen on TCP port 7954 to all incoming connections: "tcp://*:7954"</param> public Server(string connectionString) { serverConnectionString = connectionString; NetMQContext context = NetMQContext.Create(); netMqSocket = context.CreateRouterSocket(); netMqSocket.Bind(serverConnectionString); }
public static void Main(string[] args) { var workers = new List <Thread>(WORKERS_COUNT); using (NetMQContext context = NetMQContext.Create()) { using (RouterSocket client = context.CreateRouterSocket()) { string cnn = string.Format("tcp://localhost:{0}", PORT_NUMBER); client.Bind(cnn); Console.WriteLine("[B] Connect to {0}", cnn); for (int workerNumber = 0; workerNumber < WORKERS_COUNT; workerNumber++) { workers.Add(new Thread(WorkerTask)); workers[workerNumber].Start(PORT_NUMBER); } for (int taskNumber = 0; taskNumber < WORKERS_COUNT * 10; taskNumber++) { // LRU worker is next waiting in queue string address = client.ReceiveString(); //Console.WriteLine("[B] Message received: {0}", address); string empty = client.ReceiveString(); //Console.WriteLine("[B] Message received: {0}", empty); string ready = client.ReceiveString(); //Console.WriteLine("[B] Message received: {0}", ready); client.SendMore(address); //Console.WriteLine("[B] Message sent: {0}", address); client.SendMore(""); //Console.WriteLine("[B] Message sent: {0}", ""); client.Send("This is the workload"); //Console.WriteLine("[B] Message sent: {0}", "This is the workload"); } // Now ask mamas to shut down and report their results for (int taskNbr = 0; taskNbr < WORKERS_COUNT; taskNbr++) { string address = client.ReceiveString(); //Console.WriteLine("[B] Message received: {0}", address); string empty = client.ReceiveString(); //Console.WriteLine("[B] Message received: {0}", empty); string ready = client.ReceiveString(); //Console.WriteLine("[B] Message received: {0}", ready); client.SendMore(address); //Console.WriteLine("[B] Message sent: {0}", address); client.SendMore(""); //Console.WriteLine("[B] Message sent: {0}", ""); client.Send("END"); //Console.WriteLine("[B] Message sent: {0}", "END"); } } } Console.ReadLine(); }
/// <summary> /// ctor initializing all local variables /// </summary> private MDPBroker() { m_ctx = NetMQContext.Create(); Socket = m_ctx.CreateRouterSocket(); m_services = new List <Service> (); m_knownWorkers = new List <Worker> (); HeartbeatLiveliness = 3; m_isBound = false; }
public void BinaryTest() { Action <Example> setMessage = m => { m.Id = Example.MessageId.Binary; m.Binary.Sequence = 123; FillArray(m.Binary.Flags, 123); m.Binary.PublicKey = Encoding.ASCII.GetBytes("Captcha Diem"); m.Binary.Identifier = Guid.Parse("DED9D22A-FCE1-488B-8761-84752ACC113E"); }; Action <Example> checkMessage = m => { Assert.That(m.Id, Is.EqualTo(Example.MessageId.Binary)); Assert.That(m.Binary.Sequence, Is.EqualTo(123)); Assert.That(m.Binary.Flags[0], Is.EqualTo(123)); Assert.That(m.Binary.Flags[m.Binary.Flags.Length - 1], Is.EqualTo(123)); Assert.That(m.Binary.PublicKey, Is.EqualTo(Encoding.ASCII.GetBytes("Captcha Diem"))); Assert.That(m.Binary.Identifier, Is.EqualTo(Guid.Parse("DED9D22A-FCE1-488B-8761-84752ACC113E"))); }; using (NetMQContext context = NetMQContext.Create()) using (var client = context.CreateDealerSocket()) using (var server = context.CreateRouterSocket()) { server.Bind("inproc://zprototest"); client.Connect("inproc://zprototest"); Example clientMessage = new Example(); Example serverMessage = new Example(); 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 CancelTimer() { using (NetMQContext contex = NetMQContext.Create()) { // we are using three responses to make sure we actually move the correct socket and other sockets still work using (var router = contex.CreateRouterSocket()) { router.Bind("tcp://127.0.0.1:5002"); using (var dealer = contex.CreateDealerSocket()) using (Poller poller = new Poller()) { dealer.Connect("tcp://127.0.0.1:5002"); bool timerTriggered = false; NetMQTimer timer = new NetMQTimer(TimeSpan.FromMilliseconds(100)); timer.Elapsed += (a, s) => { timerTriggered = true; }; // the timer will jump after 100ms poller.AddTimer(timer); bool messageArrived = false; router.ReceiveReady += (s, a) => { bool isMore; router.Receive(out isMore); router.Receive(out isMore); messageArrived = true; poller.RemoveTimer(timer); }; poller.AddSocket(router); Task.Factory.StartNew(poller.Start); Thread.Sleep(20); dealer.Send("hello"); Thread.Sleep(300); poller.Stop(); Assert.IsTrue(messageArrived); Assert.IsFalse(timerTriggered); } } } }
/// <summary> /// ctor initializing all local variables /// <para>DEFAULTS:</para> /// <para>heartbeat interval 2,500ms</para> /// <para>max retries for waiting on heartbeats 3 times</para> /// </summary> private MDPBroker() { m_ctx = NetMQContext.Create(); Socket = m_ctx.CreateRouterSocket(); m_services = new List <Service> (); m_knownWorkers = new List <Worker> (); m_heartbeatInterval = TimeSpan.FromMilliseconds(2500); // otherwise the expiry would be 0(!) HeartbeatLiveliness = 3; // so m_heartbeatExpiry = value * m_heartbeatInterval = 7.500 ms m_isBound = false; }
static void Main(string[] args) { int count = 1000000; //BufferPool.SetBufferManagerBufferPool(1024 * 1024 * 10, 1024); using (NetMQContext context = NetMQContext.Create()) { using (var router = context.CreateRouterSocket()) { router.Options.SendHighWatermark = 0; router.Bind("tcp://*:5555"); List <DealerSocket> dealers = new List <DealerSocket>(); List <byte[]> identities = new List <byte[]>(); Random random = new Random(); for (int i = 0; i < 100; i++) { var dealer = context.CreateDealerSocket(); byte[] identity = new byte[50]; random.NextBytes(identity); dealer.Options.Identity = identity; dealer.Options.ReceiveHighWatermark = 0; dealer.Connect("tcp://localhost:5555"); dealers.Add(dealer); identities.Add(identity); } Thread.Sleep(1000); Stopwatch stopwatch = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { router.SendMore(identities[i % identities.Count]).Send("E"); } stopwatch.Stop(); Console.WriteLine("{0:N1} in second", count / stopwatch.Elapsed.TotalSeconds); Console.ReadLine(); foreach (var dealerSocket in dealers) { dealerSocket.Dispose(); } } } }
private void ProxyThread() { RouterSocket router = null; DealerSocket dealer = null; try { router = _ctx.CreateRouterSocket(); dealer = _ctx.CreateDealerSocket(); router.Bind(_frontendAddress); switch (_backendCxMode) { case ConnectionMode.Connect: dealer.Connect(_backendAddress); break; case ConnectionMode.Bind: dealer.Bind(_backendAddress); break; } router.Options.Linger = TimeSpan.Zero; dealer.Options.Linger = TimeSpan.Zero; var xproxy = new Proxy(router, dealer, null); xproxy.Start(); } catch (TerminatingException) { } finally { if (router != null) { try { router.Dispose(); } catch (NetMQException) { } } if (dealer != null) { try { dealer.Dispose(); } catch (NetMQException) { } } } }
public void CheckRecvAgainException() { using (NetMQContext context = NetMQContext.Create()) { using (var routerSocket = context.CreateRouterSocket()) { routerSocket.Bind("tcp://127.0.0.1:5555"); routerSocket.Receive(SendReceiveOptions.DontWait); } } }
public void Mandatory() { using (NetMQContext context = NetMQContext.Create()) { using (var router = context.CreateRouterSocket()) { router.Options.RouterMandatory = true; router.Bind("tcp://*:5555"); Assert.Throws <HostUnreachableException>(() => router.SendMore("UNKOWN").Send("Hello")); } } }
public void Run() { using (NetMQContext ctx = NetMQContext.Create()) { using (var server = ctx.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5556"); CreateClient(ctx, "A_"); CreateClient(ctx, "B_"); CreateClient(ctx, "C_"); CreateClient(ctx, "D_"); while (true) { var clientMessage = server.ReceiveMessage(); Console.WriteLine("========================"); Console.WriteLine(" INCOMING CLIENT MESSAGE "); Console.WriteLine("========================"); for (int i = 0; i < clientMessage.FrameCount; i++) { Console.WriteLine("Frame[{0}] = {1}", i, clientMessage[i].ConvertToString()); } var clientAddress = clientMessage[0]; var clientOriginalMessage = clientMessage[2].ConvertToString(); string response = string.Format("{0} back from server", clientOriginalMessage); // "B_" client is special if (clientOriginalMessage.StartsWith("B_")) { response = string.Format( "special Message for 'B' back from server"); } var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(response); server.SendMessage(messageToClient); } } } Console.ReadLine(); }
public void ReceiveReadyDot35Bug() { using (NetMQContext context = NetMQContext.Create()) { using (var server = context.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5555"); server.ReceiveReady += (sender, e) => { //no data receive but every 1s to display ReceiveReady. Console.WriteLine("ReceiveReady!"); }; Assert.IsFalse(server.Poll(TimeSpan.FromMilliseconds(1000))); } } }
static void Main(string[] args) { using (NetMQContext context = NetMQContext.Create()) using (RouterSocket router = context.CreateRouterSocket()) { router.Bind("tcp://*:33333"); while (true) { byte[] identity = router.Receive(); string message = router.ReceiveString(); Console.WriteLine(message); router.SendMore(identity).Send(message); } } }
protected override void ProducerAction() { using (NetMQContext ctx = NetMQContext.Create()) { using (RouterSocket socket = ctx.CreateRouterSocket()) { socket.Bind(Address); while (true) { NetMQMessage message = socket.ReceiveMessage(); if (!IsEmpty) { Queue.Add(message); } } } } }
public void CheckSendAgainException() { using (NetMQContext context = NetMQContext.Create()) { using (var routerSocket = context.CreateRouterSocket()) { routerSocket.Bind("tcp://127.0.0.1:5555"); routerSocket.Options.Linger = TimeSpan.Zero; using (var dealerSocket = context.CreateDealerSocket()) { dealerSocket.Options.SendHighWatermark = 1; dealerSocket.Options.Linger = TimeSpan.Zero; dealerSocket.Connect("tcp://127.0.0.1:5555"); dealerSocket.Send("1", true, false); dealerSocket.Send("2", true, false); } } } }
public void RouterDealerMessaging() { using (NetMQContext context = NetMQContext.Create()) { using (var server = context.CreateRouterSocket()) { server.Bind("tcp://127.0.0.1:5555"); using (var client = context.CreateDealerSocket()) { client.Connect("tcp://127.0.0.1:5555"); NetMQMessage clientOutgoingMessage = new NetMQMessage(); clientOutgoingMessage.Append("Hello"); client.SendMessage(clientOutgoingMessage); NetMQMessage serverIncomingMessage = server.ReceiveMessage(); // 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()); NetMQMessage serverOutgoingMessage = new NetMQMessage(); // first adding the identity serverOutgoingMessage.Append(serverIncomingMessage[0]); serverOutgoingMessage.Append("World"); server.SendMessage(serverOutgoingMessage); NetMQMessage incomingClientMessage = new NetMQMessage(); client.ReceiveMessage(incomingClientMessage); Assert.AreEqual(1, incomingClientMessage.FrameCount); Assert.AreEqual("World", incomingClientMessage[0].ConvertToString()); } } } }
public void HasInTest() { using (NetMQContext context = NetMQContext.Create()) { using (NetMQSocket server = context.CreateRouterSocket()) { server.Bind("tcp://*:5557"); // no one sent a message so it should be fasle Assert.IsFalse(server.HasIn); using (NetMQSocket client = context.CreateDealerSocket()) { client.Connect("tcp://localhost:5557"); // 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.Send("1"); // wait for the message to arrive Thread.Sleep(100); // the has in should indicate a message is ready Assert.IsTrue(server.HasIn); byte[] identity = server.Receive(); string message = server.ReceiveString(); Assert.AreEqual(message, "1"); // we read the message, it should false again Assert.IsFalse(server.HasIn); } } } }
// We have two workers, here we copy the code, normally these would // run on different boxes… public static void Main(string[] args) { var randomizer = new Random(DateTime.Now.Millisecond); var workers = new List <Thread>(new[] { new Thread(WorkerTaskA), new Thread(WorkerTaskB) }); using (NetMQContext context = NetMQContext.Create()) { using (RouterSocket client = context.CreateRouterSocket()) { client.Bind(string.Format("tcp://localhost:{0}", PORT_NUMBER)); foreach (Thread thread in workers) { thread.Start(PORT_NUMBER); } // Wait for threads to connect, since otherwise the messages we send won't be routable. Thread.Sleep(1000); for (int taskNumber = 0; taskNumber < 1000; taskNumber++) { // Send two message parts, first the address… client.SendMore(randomizer.Next(3) > 0 ? Encoding.Unicode.GetBytes("A") : Encoding.Unicode.GetBytes("B")); // And then the workload client.Send("This is the workload"); } client.SendMore(Encoding.Unicode.GetBytes("A")); client.Send("END"); client.SendMore(Encoding.Unicode.GetBytes("B")); client.Send("END"); } } Console.ReadKey(); }
public void RawSocket() { byte[] message; byte[] id; using (NetMQContext context = NetMQContext.Create()) { using (var routerSocket = context.CreateRouterSocket()) { routerSocket.Options.RouterRawSocket = true; routerSocket.Bind("tcp://127.0.0.1:5556"); using (var clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { clientSocket.Connect("127.0.0.1", 5556); clientSocket.NoDelay = true; byte[] clientMessage = Encoding.ASCII.GetBytes("HelloRaw"); int bytesSent = clientSocket.Send(clientMessage); Assert.Greater(bytesSent, 0); id = routerSocket.Receive(); message = routerSocket.Receive(); routerSocket.SendMore(id). SendMore(message); // SNDMORE option is ignored byte[] buffer = new byte[16]; int bytesRead = clientSocket.Receive(buffer); Assert.Greater(bytesRead, 0); Assert.AreEqual(Encoding.ASCII.GetString(buffer, 0, bytesRead), "HelloRaw"); } } } }
private void RouterAction() { using (NetMQContext ctx = NetMQContext.Create()) { using (RouterSocket socket = ctx.CreateRouterSocket()) { socket.Bind(Address); while (true) { NetMQMessage message = socket.ReceiveMessage(); string topic = message.Last.ConvertToString(); byte[] snapshot = _snapshotFactory(topic); var response = new NetMQMessage(); response.Append(message.First); response.AppendEmptyFrame(); response.Append(snapshot); socket.SendMessage(response); } } } }
public void AddTwoSocketAfterRemoving() { using (NetMQContext contex = NetMQContext.Create()) { // we are using three responses to make sure we actually move the correct socket and other sockets still work using (var router = contex.CreateRouterSocket()) using (var router2 = contex.CreateRouterSocket()) using (var router3 = contex.CreateRouterSocket()) using (var router4 = contex.CreateRouterSocket()) { router.Bind("tcp://127.0.0.1:5002"); router2.Bind("tcp://127.0.0.1:5003"); router3.Bind("tcp://127.0.0.1:5004"); router4.Bind("tcp://127.0.0.1:5005"); using (var dealer = contex.CreateDealerSocket()) using (var dealer2 = contex.CreateDealerSocket()) using (var dealer3 = contex.CreateDealerSocket()) using (var dealer4 = contex.CreateDealerSocket()) using (Poller poller = new Poller()) { dealer.Connect("tcp://127.0.0.1:5002"); dealer2.Connect("tcp://127.0.0.1:5003"); dealer3.Connect("tcp://127.0.0.1:5004"); dealer4.Connect("tcp://127.0.0.1:5005"); int router1arrived = 0; int router2arrived = 0; bool router3arrived = false; bool router4arrived = false; bool more; router.ReceiveReady += (s, a) => { router1arrived++; router.Receive(out more); router.Receive(out more); poller.RemoveSocket(router); }; poller.AddSocket(router); router3.ReceiveReady += (s, a) => { router3.Receive(out more); router3.Receive(out more); router3arrived = true; }; router4.ReceiveReady += (s, a) => { router4.Receive(out more); router4.Receive(out more); router4arrived = true; }; router2.ReceiveReady += (s, a) => { router2arrived++; router2.Receive(out more); router2.Receive(out more); if (router2arrived == 1) { poller.AddSocket(router3); poller.AddSocket(router4); } }; poller.AddSocket(router2); Task task = Task.Factory.StartNew(poller.Start); dealer.Send("1"); Thread.Sleep(300); dealer2.Send("2"); Thread.Sleep(300); dealer3.Send("3"); dealer4.Send("4"); dealer2.Send("2"); dealer.Send("1"); Thread.Sleep(300); poller.Stop(true); task.Wait(); router.Receive(true, out more); Assert.IsTrue(more); router.Receive(true, out more); Assert.IsFalse(more); Assert.AreEqual(1, router1arrived); Assert.AreEqual(2, router2arrived); Assert.IsTrue(router3arrived); Assert.IsTrue(router4arrived); } } } }
public void SimpleTimer() { using (NetMQContext contex = NetMQContext.Create()) { // we are using three responses to make sure we actually move the correct socket and other sockets still work using (var router = contex.CreateRouterSocket()) { router.Bind("tcp://127.0.0.1:5002"); using (var dealer = contex.CreateDealerSocket()) using (Poller poller = new Poller()) { dealer.Connect("tcp://127.0.0.1:5002"); bool messageArrived = false; router.ReceiveReady += (s, a) => { bool isMore; router.Receive(out isMore); router.Receive(out isMore); messageArrived = true; }; poller.AddSocket(router); bool timerTriggered = false; int count = 0; NetMQTimer timer = new NetMQTimer(TimeSpan.FromMilliseconds(100)); timer.Elapsed += (a, s) => { // the timer should jump before the message Assert.IsFalse(messageArrived); timerTriggered = true; timer.Enable = false; count++; }; poller.AddTimer(timer); poller.PollTillCancelledNonBlocking(); Thread.Sleep(150); dealer.Send("hello"); Thread.Sleep(300); poller.CancelAndJoin(); Assert.IsTrue(messageArrived); Assert.IsTrue(timerTriggered); Assert.AreEqual(1, count); } } } }
public void CancelSocket() { using (NetMQContext contex = NetMQContext.Create()) { // we are using three responses to make sure we actually move the correct socket and other sockets still work using (var router = contex.CreateRouterSocket()) using (var router2 = contex.CreateRouterSocket()) using (var router3 = contex.CreateRouterSocket()) { router.Bind("tcp://127.0.0.1:5002"); router2.Bind("tcp://127.0.0.1:5003"); router3.Bind("tcp://127.0.0.1:5004"); using (var dealer = contex.CreateDealerSocket()) using (var dealer2 = contex.CreateDealerSocket()) using (var dealer3 = contex.CreateDealerSocket()) using (Poller poller = new Poller()) { dealer.Connect("tcp://127.0.0.1:5002"); dealer2.Connect("tcp://127.0.0.1:5003"); dealer3.Connect("tcp://127.0.0.1:5004"); bool first = true; router2.ReceiveReady += (s, a) => { bool more; // identity byte[] identity = a.Socket.Receive(out more); // message a.Socket.Receive(out more); a.Socket.SendMore(identity); a.Socket.Send("2"); }; poller.AddSocket(router2); router.ReceiveReady += (s, a) => { if (!first) { Assert.Fail("This should happen because we cancelled the socket"); } first = false; bool more; // identity a.Socket.Receive(out more); string m = a.Socket.ReceiveString(out more); Assert.False(more); Assert.AreEqual("Hello", m); // cancellign the socket poller.RemoveSocket(a.Socket); }; poller.AddSocket(router); router3.ReceiveReady += (s, a) => { bool more; // identity byte[] identity = a.Socket.Receive(out more); // message a.Socket.Receive(out more); a.Socket.SendMore(identity).Send("3"); }; poller.AddSocket(router3); Task pollerTask = Task.Factory.StartNew(poller.Start); dealer.Send("Hello"); // sending this should not arrive on the poller, therefore response for this will never arrive dealer.Send("Hello2"); Thread.Sleep(100); // sending this should not arrive on the poller, therefore response for this will never arrive dealer.Send("Hello3"); Thread.Sleep(500); bool more2; // making sure the socket defined before the one cancelled still works dealer2.Send("1"); string msg = dealer2.ReceiveString(out more2); Assert.AreEqual("2", msg); // making sure the socket defined after the one cancelled still works dealer3.Send("1"); msg = dealer3.ReceiveString(out more2); Assert.AreEqual("3", msg); // we have to give this some time if we want to make sure it's really not happening and it not only because of time Thread.Sleep(300); poller.Stop(); Thread.Sleep(100); Assert.IsTrue(pollerTask.IsCompleted); } } } }
public void AddSocketAfterRemoving() { using (NetMQContext contex = NetMQContext.Create()) { // we are using three responses to make sure we actually move the correct socket and other sockets still work using (var router = contex.CreateRouterSocket()) using (var router2 = contex.CreateRouterSocket()) using (var router3 = contex.CreateRouterSocket()) { router.Bind("tcp://127.0.0.1:5002"); router2.Bind("tcp://127.0.0.1:5003"); router3.Bind("tcp://127.0.0.1:5004"); using (var dealer = contex.CreateDealerSocket()) using (var dealer2 = contex.CreateDealerSocket()) using (var dealer3 = contex.CreateDealerSocket()) using (Poller poller = new Poller()) { dealer.Connect("tcp://127.0.0.1:5002"); dealer2.Connect("tcp://127.0.0.1:5003"); dealer3.Connect("tcp://127.0.0.1:5004"); bool router1arrived = false; bool router2arrived = false; bool router3arrived = false; bool more; router.ReceiveReady += (s, a) => { router1arrived = true; router.Receive(out more); router.Receive(out more); poller.RemoveSocket(router); }; poller.AddSocket(router); router3.ReceiveReady += (s, a) => { router3.Receive(out more); router3.Receive(out more); router3arrived = true; }; router2.ReceiveReady += (s, a) => { router2arrived = true; router2.Receive(out more); router2.Receive(out more); poller.AddSocket(router3); }; poller.AddSocket(router2); poller.PollTillCancelledNonBlocking(); dealer.Send("1"); Thread.Sleep(300); dealer2.Send("2"); Thread.Sleep(300); dealer3.Send("3"); Thread.Sleep(300); poller.Stop(true); Assert.IsTrue(router1arrived); Assert.IsTrue(router2arrived); Assert.IsTrue(router3arrived); } } } }
public void StructuresTest() { Action <Example> setMessage = m => { m.Id = Example.MessageId.Structures; m.Sequence = 123; m.Aliases = new List <string>(); m.Aliases.Add("Name: Brutus"); m.Aliases.Add("Age: 43"); m.Headers = new Dictionary <string, string>(); m.Headers.Add("Name", "Brutus"); m.Headers.Add("Age", "43"); }; Action <Example> checkMessage = m => { Assert.That(m.Id, Is.EqualTo(Example.MessageId.Structures)); Assert.That(m.Sequence, Is.EqualTo(123)); Assert.That(m.Aliases.Count, Is.EqualTo(2)); Assert.That(m.Aliases[0], Is.EqualTo("Name: Brutus")); Assert.That(m.Aliases[1], Is.EqualTo("Age: 43")); Assert.That(m.Headers.Count, Is.EqualTo(2)); Assert.That(m.Headers["Name"], Is.EqualTo("Brutus")); Assert.That(m.Headers["Age"], Is.EqualTo("43")); }; using (NetMQContext context = NetMQContext.Create()) using (var client = context.CreateDealerSocket()) using (var server = context.CreateRouterSocket()) { server.Bind("inproc://zprototest"); client.Connect("inproc://zprototest"); Example clientMessage = new Example(); Example serverMessage = new Example(); 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); } clientMessage.Dispose(); serverMessage.Dispose(); } }