/// <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 ZmqService(YahooFinancialDataProvider primitiveQuoteService) { this.primitiveQuoteService = primitiveQuoteService; subscribedTickerList.AddRange(MarketDataSettings.StartupTickers); refreshInterval = MarketDataSettings.ServerRefreshMillis; socketFactory = NetMQContext.Create(); }
static int Main(string[] args) { if (args.Length != 3) { Console.WriteLine("usage: local_thr <bind-to> <message-size> <message-count>"); return(1); } string bindTo = args[0]; int messageSize = int.Parse(args[1]); int messageCount = int.Parse(args[2]); var context = NetMQContext.Create(); var pullSocket = context.CreatePullSocket(); pullSocket.Bind(bindTo); var message = new Msg(); message.InitEmpty(); pullSocket.Receive(ref message, SendReceiveOptions.None); var stopWatch = Stopwatch.StartNew(); for (int i = 0; i != messageCount - 1; i++) { pullSocket.Receive(ref message, SendReceiveOptions.None); if (message.Size != messageSize) { Console.WriteLine("message of incorrect size received. Received: " + message.Size + " Expected: " + messageSize); return(-1); } } stopWatch.Stop(); var millisecondsElapsed = stopWatch.ElapsedMilliseconds; if (millisecondsElapsed == 0) { millisecondsElapsed = 1; } message.Close(); double messagesPerSecond = (double)messageCount / millisecondsElapsed * 1000; double megabits = messagesPerSecond * messageSize * 8 / 1000000; Console.WriteLine("message size: {0} [B]", messageSize); Console.WriteLine("message count: {0}", messageCount); Console.WriteLine("mean throughput: {0:0.000} [msg/s]", messagesPerSecond); Console.WriteLine("mean throughput: {0:0.000} [Mb/s]", megabits); pullSocket.Close(); context.Terminate(); return(0); }
/// <summary> /// create worker with standard parameter /// HeartbeatDelay == 2500 milliseconds /// ReconnectDelay == 2500 milliseconds /// ConnectionRetries == 3 /// Verbose == false /// </summary> private MDPWorker() { m_ctx = NetMQContext.Create(); HeartbeatDelay = TimeSpan.FromMilliseconds(2500); ReconnectDelay = TimeSpan.FromMilliseconds(2500); m_exit = false; m_connected = false; }
public void Monitoring() { ManualResetEvent listeningEvent = new ManualResetEvent(false); ManualResetEvent acceptedEvent = new ManualResetEvent(false); ManualResetEvent connectedEvent = new ManualResetEvent(false); using (NetMQContext contex = NetMQContext.Create()) using (Poller poller = new Poller()) { using (var rep = contex.CreateResponseSocket()) { using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening)) { monitor.Accepted += (s, a) => acceptedEvent.Set(); monitor.Listening += (s, a) => listeningEvent.Set(); monitor.AttachToPoller(poller); rep.Bind("tcp://127.0.0.1:5002"); using (var req = contex.CreateRequestSocket()) { using (NetMQMonitor reqMonitor = new NetMQMonitor(contex, req, "inproc://req.inproc", SocketEvent.Connected)) { reqMonitor.Connected += (s, a) => connectedEvent.Set(); reqMonitor.AttachToPoller(poller); try { poller.PollTillCancelledNonBlocking(); req.Connect("tcp://127.0.0.1:5002"); req.Send("a"); bool more; string m = rep.ReceiveString(out more); rep.Send("b"); string m2 = req.ReceiveString(out more); Assert.IsTrue(listeningEvent.WaitOne(300)); Assert.IsTrue(connectedEvent.WaitOne(300)); Assert.IsTrue(acceptedEvent.WaitOne(300)); } finally { poller.CancelAndJoin(); } } } } } } }
public void Receive_RequestWithWrongFirstFrame_ShouldThrowApplicationException() { const string hostAddress = "tcp://localhost:5555"; // setup the counter socket for communication using (var context = NetMQContext.Create()) using (var broker = context.CreateRouterSocket()) using (var poller = new Poller()) using (var session = new MDPWorker(hostAddress, "test")) { broker.Bind(hostAddress); // we need to pick up any message in order to avoid errors broker.ReceiveReady += (s, e) => { var msg = e.Socket.ReceiveMultipartMessage(); // we expect to receive a 5 Frame message // [WORKER ADR][EMPTY]["MDPW01"]["READY"]["test"] if (msg.FrameCount != 5) { Assert.Fail("Message with wrong count of frames {0}", msg.FrameCount); } // make sure the frames are as expected Assert.That(msg[1], Is.EqualTo(NetMQFrame.Empty)); Assert.That(msg[2].ConvertToString(), Is.EqualTo("MDPW01")); Assert.That(msg[3].BufferSize, Is.EqualTo(1)); Assert.That(msg[3].Buffer[0], Is.EqualTo((byte)MDPCommand.Ready)); Assert.That(msg[4].ConvertToString(), Is.EqualTo("test")); // tell worker to stop gracefully var reply = new NetMQMessage(); reply.Push(new[] { (byte)MDPCommand.Kill }); // push MDP Version reply.Push("MDPW01"); // push separator reply.Push("Should be empty"); // push worker address reply.Push(msg[0]); // send reply which is a request for the worker e.Socket.SendMessage(reply); }; poller.AddSocket(broker); Task.Factory.StartNew(poller.PollTillCancelled); try { session.Receive(null); } catch (ApplicationException ex) { Assert.That(ex.Message, Is.EqualTo("First frame must be an empty frame!")); } poller.CancelAndJoin(); poller.RemoveSocket(broker); } }
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 Start(int publishPort) { ctx = NetMQContext.Create(); publishSocket = ctx.CreatePublisherSocket(); publishSocket.Bind("tcp://*:" + publishPort); logger.Info("Message publisher started on port " + publishPort); }
public void NeverConfigured() { using (NetMQContext context = NetMQContext.Create()) { using (NetMQBeacon speaker = new NetMQBeacon(context)) { } } }
/// <summary> /// Initializes a new instance of the <see cref="NmqMessageServer"/> class. /// </summary> /// <param name="messageReceiver">The message receiver.</param> /// <param name="port">The port.</param> internal NmqMessageServer(IMessageReceiver messageReceiver, int port) { tokenSource = new CancellationTokenSource(); this.port = port; this.messageReceiver = messageReceiver; context = NetMQContext.Create(); responseQueue = new NmqResponseQueue(context, port); }
public ZeroNotificationEnqueue() { _context = NetMQContext.Create(); _poller = new Poller(); _client = _context.CreatePushSocket(); _client.Connect(QueueAddress); _scheduler = new NetMQScheduler(_context, _poller); Task.Factory.StartNew(_poller.PollTillCancelled, TaskCreationOptions.LongRunning); }
public void HelloWorldTest() { // context must be created to create sockets, one context per application using (NetMQContext context = NetMQContext.Create()) { Task.Factory.StartNew(() => Server(context)); Client(context); } }
public void Init(string ip, int port, MQClientType type) { _type = type; _ip = ip; _port = port; _isStart = true; _context = NetMQContext.Create(); CreateClient(); }
public static void StartServer(IDistributedApp app, string url, int expectedClients = 0, Action <Exception> connected = null) { Task.Run(() => { using (var context = NetMQContext.Create()) using (var input = context.CreateDealerSocket()) { Dictionary <string, DealerSocket> clients = null; try { input.Bind(url); if (expectedClients > 0) { clients = new Dictionary <string, DealerSocket>(); awaitClients(input, expectedClients, clients, context, app); app.SendToClient = (client, msg) => writeMessage(clients[client], msg); } connected(null); } catch (Exception ex) { connected(ex); return; } //loop var message = new NetMQMessage(expectedFrameCount: 7); var appMessage = new DistributedAppMessage(); for (;;) { message = input.ReceiveMultipartMessage(expectedFrameCount: 7); try { if (!readMessage(message, appMessage)) { continue; } app.Receive(appMessage); } catch { //td: log? } finally { message.Clear(); } } } }); }
public static void Main() { var workers = new List <Thread>(WorkersCount); using (var context = NetMQContext.Create()) using (var client = context.CreateRouterSocket()) { string cnn = string.Format("tcp://localhost:{0}", PortNumber); client.Bind(cnn); Console.WriteLine("[B] Connect to {0}", cnn); for (int workerNumber = 0; workerNumber < WorkersCount; workerNumber++) { workers.Add(new Thread(WorkerTask)); workers[workerNumber].Start(PortNumber); } for (int taskNumber = 0; taskNumber < WorkersCount * 10; taskNumber++) { // LRU worker is next waiting in queue string address = client.ReceiveFrameString(); //Console.WriteLine("[B] Message received: {0}", address); string empty = client.ReceiveFrameString(); //Console.WriteLine("[B] Message received: {0}", empty); string ready = client.ReceiveFrameString(); //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 < WorkersCount; taskNbr++) { string address = client.ReceiveFrameString(); //Console.WriteLine("[B] Message received: {0}", address); string empty = client.ReceiveFrameString(); //Console.WriteLine("[B] Message received: {0}", empty); string ready = client.ReceiveFrameString(); //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(); }
public void Send_WrongHeaderFromBrokerNoLogging_ShouldThrowApplicationException() { const string hostAddress = "tcp://localhost:5555"; // setup the counter socket for communication using (var context = NetMQContext.Create()) using (var broker = context.CreateRouterSocket()) using (var poller = new Poller()) using (var session = new MDPClient(hostAddress)) { broker.Bind(hostAddress); // we need to pick up any message in order to avoid errors broker.ReceiveReady += (s, e) => { // return empty reply var msg = e.Socket.ReceiveMultipartMessage(); // we expect to receive a 4 Frame message // [REQ ADR][EMPTY]["MDPC01"]["echo"]["REQUEST"] if (msg.FrameCount != 5) { Assert.Fail("Message with wrong count of frames {0}", msg.FrameCount); } // REQUEST socket will strip the his address + empty frame // ROUTER has to add the address prelude in order to identify the correct socket(!) // [REQ ADR][EMPTY]["MDPC00"]["echo"]["REQUEST"] var clientAddress = msg.Pop(); msg.Pop(); // forget empty frame var mdpVersion = msg.Pop(); msg.Pop(); // drop service name version msg.Push("NoService"); msg.Push(mdpVersion); msg.Push(NetMQFrame.Empty); msg.Push(clientAddress); // reinsert the client's address e.Socket.SendMessage(msg); }; poller.AddSocket(broker); Task.Factory.StartNew(poller.PollTillCancelled); // well formed message var requestMessage = new NetMQMessage(new[] { new NetMQFrame("REQUEST") }); try { session.Send("echo", requestMessage); } catch (ApplicationException ex) { Assert.That(ex.Message, Is.EqualTo("[CLIENT INFO] answered by wrong service: NoService")); } poller.CancelAndJoin(); poller.RemoveSocket(broker); } }
public void Monitoring() { bool listening = false; bool accepted = false; using (NetMQContext contex = NetMQContext.Create()) { using (var rep = contex.CreateResponseSocket()) { using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening)) { monitor.Accepted += (s, a) => { accepted = true; //Console.WriteLine(a.Socket.LocalEndPoint.ToString()); }; monitor.Listening += (s, a) => { listening = true; Console.WriteLine(a.Socket.LocalEndPoint.ToString()); }; monitor.Timeout = TimeSpan.FromMilliseconds(100); var pollerTask = Task.Factory.StartNew(monitor.Start); rep.Bind("tcp://127.0.0.1:5002"); using (var req = contex.CreateRequestSocket()) { req.Connect("tcp://127.0.0.1:5002"); req.Send("a"); bool more; string m = rep.ReceiveString(out more); rep.Send("b"); string m2 = req.ReceiveString(out more); Thread.Sleep(200); Assert.IsTrue(listening); Assert.IsTrue(accepted); monitor.Stop(); Thread.Sleep(200); Assert.IsTrue(pollerTask.IsCompleted); } } } } }
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); } } } }
public void NativeSocket() { using (NetMQContext context = NetMQContext.Create()) { using (var streamServer = context.CreateStreamSocket()) { streamServer.Bind("tcp://*:5557"); using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { socket.Connect("127.0.0.1", 5557); byte[] buffer = new byte[] { 1 }; socket.Send(buffer); byte[] identity = streamServer.Receive(); byte[] message = streamServer.Receive(); Assert.AreEqual(buffer[0], message[0]); ManualResetEvent socketSignal = new ManualResetEvent(false); Poller poller = new Poller(); poller.AddPollInSocket(socket, s => { socket.Receive(buffer); socketSignal.Set(); // removing the socket poller.RemovePollInSocket(socket); }); poller.PollTillCancelledNonBlocking(); // no message is waiting for the socket so it should fail Assert.IsFalse(socketSignal.WaitOne(200)); // sending a message back to the socket streamServer.SendMore(identity).Send("a"); Assert.IsTrue(socketSignal.WaitOne(200)); socketSignal.Reset(); // sending a message back to the socket streamServer.SendMore(identity).Send("a"); // we remove the native socket so it should fail Assert.IsFalse(socketSignal.WaitOne(200)); poller.Stop(true); } } } }
public void EnqueueDequeue() { using (NetMQContext context = NetMQContext.Create()) using (NetMQQueue <int> queue = new NetMQQueue <int>(context)) { queue.Enqueue(1); Assert.AreEqual(1, queue.Dequeue()); } }
public void CheckReceiveAgainException() { using (var context = NetMQContext.Create()) using (var router = context.CreateRouterSocket()) { router.BindRandomPort("tcp://127.0.0.1"); router.Receive(SendReceiveOptions.DontWait); } }
public virtual void OnImportsSatisfied() { var context = NetMQContext.Create(); FPort.Changed += UpdatePort; FProtocol.Changed += UpdateProtocol; FAddress.Changed += UpdateAddress; FContext.Changed += UpdateContext; }
public static string ZMQRequest(string endpoint, string requestText) { string answer = ""; using (NetMQContext context = NetMQContext.Create()) { answer = Client(context, endpoint, requestText); } return(answer); }
public void DefaultValues() { using (var context = NetMQContext.Create()) using (var socket = context.CreateRouterSocket()) { Assert.IsNull(socket.Options.Identity); // Assert.IsNull(socket.Options.TcpAcceptFilter); Assert.AreEqual(false, socket.Options.ReceiveMore); } }
/// <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; }
/// <summary> /// Default ctor. /// </summary> public FeedMuxMessageBroker() { context = NetMQContext.Create(); pubSocket = context.CreatePublisherSocket(); pubSocket.Connect(PublisherAddress); pollerCancelled = new ManualResetEvent(false); source = new CancellationTokenSource(); token = source.Token; StartPolling(); }
public void DisposeImmediatly() { using (NetMQContext context = NetMQContext.Create()) { using (NetMQSocket server = context.CreateDealerSocket()) { server.Bind("tcp://*:5557"); } } }
public void Mandatory() { using (var context = NetMQContext.Create()) using (var router = context.CreateRouterSocket()) { router.Options.RouterMandatory = true; router.BindRandomPort("tcp://*"); Assert.Throws <HostUnreachableException>(() => router.SendMoreFrame("UNKNOWN").SendFrame("Hello")); } }
static void Main(string[] args) { string username = args[0]; string password = args[1]; string subscription = args[2].ToUpper(); using (var context = NetMQContext.Create()) { string token; // first we try to get a token using (var request = context.CreateRequestSocket()) { request.Connect("tcp://localhost:" + AuthorizationProtocol.Port); // send token request request. SendMore(AuthorizationProtocol.GetTokenCommand). SendMore(username). SendMore(password). Send(subscription); string result = request.ReceiveString(); if (result == AuthorizationProtocol.SuccessReply) { token = request.ReceiveString(); } else { throw new Exception("Invalid username or password"); } } // we must use XSUB because using (var subscriber = context.CreateXSubscriberSocket()) { subscriber.Connect("tcp://localhost:" + StreamingProtocol.Port); // create the subscription message byte[] subscriptionMessage = new byte[token.Length + 1]; subscriptionMessage[0] = 1; Encoding.ASCII.GetBytes(token, 0, token.Length, subscriptionMessage, 1); subscriber.Send(subscriptionMessage); while (true) { string symbol = subscriber.ReceiveString(); string price = subscriber.ReceiveString(); Console.WriteLine("{0} {1}", symbol, price); } } } }
public void Sending1000Messages() { // creating two different context and sending 1000 messages int count = 0; var subReady = new ManualResetEvent(false); Task subTask = Task.Factory.StartNew(() => { using (var context = NetMQContext.Create()) using (var sub = context.CreateSubscriberSocket()) { sub.Bind("pgm://224.0.0.1:5555"); sub.Subscribe(""); subReady.Set(); while (count < 1000) { bool more; Assert.AreEqual(count, BitConverter.ToInt32(sub.ReceiveFrameBytes(out more), 0)); Assert.IsFalse(more); count++; } } }); subReady.WaitOne(); Task pubTask = Task.Factory.StartNew(() => { using (var context = NetMQContext.Create()) using (var pub = context.CreatePublisherSocket()) { pub.Connect("pgm://224.0.0.1:5555"); for (int i = 0; i < 1000; i++) { pub.Send(BitConverter.GetBytes(i)); } // if we close the socket before the subscriber receives all messages subscriber // might miss messages, lets wait another second Thread.Sleep(1000); } }); pubTask.Wait(); subTask.Wait(); Thread.MemoryBarrier(); Assert.AreEqual(1000, count); }