public void TwoSubscribers() { using (NetMQContext context = NetMQContext.Create()) { using (var pub = context.CreatePublisherSocket()) { pub.Connect("pgm://224.0.0.1:5555"); using (var sub = context.CreateSubscriberSocket()) { using (var sub2 = context.CreateSubscriberSocket()) { sub.Bind("pgm://224.0.0.1:5555"); sub2.Bind("pgm://224.0.0.1:5555"); sub.Subscribe(""); sub2.Subscribe(""); pub.Send("Hi"); bool more; string message = sub.ReceiveString(out more); Assert.IsFalse(more); Assert.AreEqual("Hi", message); message = sub2.ReceiveString(out more); Assert.IsFalse(more); Assert.AreEqual("Hi", message); } } } } }
/// <summary> /// Subscribe To Start Auction /// </summary> public void subscribeToStartAuctionCmd() { // Bind the publisher to the address _publisher = _context.CreatePublisherSocket(); _publisher.Bind(ConfigurationManager.AppSettings["pubAddr"]); // Connect to address for StartAuction and subscribe to the topic - StartAuction var startAuctionSub = _context.CreateSubscriberSocket(); var startAuctionTopic = ConfigurationManager.AppSettings["startAuctionTopic"]; startAuctionSub.Connect(ConfigurationManager.AppSettings["startAuctionAddr"]); startAuctionSub.Subscribe(startAuctionTopic); Console.WriteLine("SUB: " + startAuctionTopic); while (true) { string startAuctionCmd = startAuctionSub.ReceiveString(); Console.WriteLine("REC: " + startAuctionCmd); publishAcknowledgement(startAuctionCmd); // Extract the ID and get the bidders emails string id = MessageParser.parseMessage(startAuctionCmd, "<id>", "</id>"); IDatabase database = DatabaseFacade.GetDatabase(); string[] emails = database.getBidderEmails(id); if (emails != null) { publishNotifyBiddersCommand(id, emails); } publishAuctionStartedEvent(id); } }
void CreateClient() { switch (_type) { case MQClientType.Request: _clientSocket = _context.CreateRequestSocket(); break; case MQClientType.Subscriber: _clientSocket = _context.CreateSubscriberSocket(); break; case MQClientType.Dealer: _clientSocket = _context.CreateDealerSocket(); break; case MQClientType.Stream: _clientSocket = _context.CreateStreamSocket(); break; case MQClientType.Pull: _clientSocket = _context.CreatePullSocket(); break; case MQClientType.XSubscriber: _clientSocket = _context.CreateXSubscriberSocket(); break; default: _clientSocket = _context.CreateRequestSocket(); break; } _clientSocket.Connect("tcp://" + _ip + ":" + _port); }
/// <summary> /// Initializes a new instance of the <see cref="ForwarderDevice"/> 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 ForwarderDevice(NetMQContext context, Poller poller, string frontendBindAddress, string backendBindAddress, DeviceMode mode = DeviceMode.Threaded) : base(poller, context.CreateSubscriberSocket(), context.CreatePublisherSocket(), mode) { FrontendSetup.Bind(frontendBindAddress); BackendSetup.Bind(backendBindAddress); }
public void Sending1000Messages() { // creating two different context and sending 1000 messages int count = 0; ManualResetEvent subReady = new ManualResetEvent(false); Task subTask = Task.Factory.StartNew(() => { using (NetMQContext 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; byte[] data = sub.Receive(out more); Assert.IsFalse(more); int num = BitConverter.ToInt32(data, 0); Assert.AreEqual(num, count); count++; } } } }); subReady.WaitOne(); Task pubTask = Task.Factory.StartNew(() => { using (NetMQContext 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)); } } } }); pubTask.Wait(); subTask.Wait(); Thread.MemoryBarrier(); Assert.AreEqual(1000, count); }
public void Start() { if (!ServerSpecified) { return; } if (context == null) { context = NetMQContext.Create(); subscriber = context.CreateSubscriberSocket(); subscriber.Connect("tcp://127.0.0.1:5252"); subscriber.Subscribe(String.Empty); sender = context.CreatePushSocket(); sender.Connect("tcp://127.0.0.1:5253"); // Start listening.. Task.Run(() => { while (!tokenSource.IsCancellationRequested) { var message = subscriber.ReceiveString(); var eventObject = Serialization.DeserializeEnvelope <ContractMarker>(message); eventReceivedSubject.OnNext(eventObject); } }); } }
public void UseInterface() { var hostEntry = Dns.GetHostEntry(Dns.GetHostName()); string ip = ( from addr in hostEntry.AddressList where addr.AddressFamily == AddressFamily.InterNetwork select addr.ToString() ).FirstOrDefault(); using (NetMQContext context = NetMQContext.Create()) { using (var pub = context.CreatePublisherSocket()) { pub.Connect(string.Format("pgm://{0};224.0.0.1:5555", ip)); using (var sub = context.CreateSubscriberSocket()) { sub.Bind(string.Format("pgm://{0};224.0.0.1:5555", ip)); sub.Subscribe(""); pub.Send("Hi"); bool more; string message = sub.ReceiveString(out more); Assert.IsFalse(more); Assert.AreEqual("Hi", message); } } } }
public void MultipleSubscriptions() { using (NetMQContext contex = NetMQContext.Create()) { using (var pub = contex.CreatePublisherSocket()) { pub.Bind("tcp://127.0.0.1:5002"); using (var sub = contex.CreateSubscriberSocket()) { sub.Connect("tcp://127.0.0.1:5002"); sub.Subscribe("C"); sub.Subscribe("B"); sub.Subscribe("A"); sub.Subscribe("D"); sub.Subscribe("E"); Thread.Sleep(500); sub.Unsubscribe("C"); sub.Unsubscribe("B"); sub.Unsubscribe("A"); sub.Unsubscribe("D"); sub.Unsubscribe("E"); Thread.Sleep(500); } } } }
protected override void ProducerAction() { using (NetMQContext ctx = NetMQContext.Create()) { using (SubscriberSocket socket = ctx.CreateSubscriberSocket()) { using ( var monitor = new NetMQMonitor(ctx, socket, "inproc://monitor.sub/" + Guid.NewGuid(), SocketEvent.Connected | SocketEvent.Disconnected)) { monitor.Connected += monitor_Connected; monitor.Disconnected += monitor_Disconnected; monitor.Timeout = TimeSpan.FromMilliseconds(100); Task.Factory.StartNew(monitor.Start); socket.Connect(Address); socket.Subscribe(string.Empty); while (true) { _commandProcessor.ExecuteAll(socket); NetMQMessage message = socket.ReceiveMessage(); if (message != null && !IsEmpty) { Queue.Add(message); } } } } } }
public void SimplePubSub() { using (NetMQContext contex = NetMQContext.Create()) { using (var pub = contex.CreatePublisherSocket()) { pub.Bind("tcp://127.0.0.1:5002"); using (var sub = contex.CreateSubscriberSocket()) { sub.Connect("tcp://127.0.0.1:5002"); sub.Subscribe(""); // let the subscrbier connect to the publisher before sending a message Thread.Sleep(500); pub.Send("Hello"); bool more; string m = sub.ReceiveString(out more); Assert.AreEqual("Hello", m); Assert.False(more); } } } }
public void WelcomeMessage() { using (NetMQContext contex = NetMQContext.Create()) { using (var pub = contex.CreateXPublisherSocket()) { pub.Bind("inproc://welcome"); pub.SetWelcomeMessage("W"); using (var sub = contex.CreateSubscriberSocket()) { sub.Subscribe("W"); sub.Connect("inproc://welcome"); var subscription = pub.Receive(); Assert.AreEqual(subscription[1], (byte)'W'); var welcomeMessage = sub.ReceiveString(); Assert.AreEqual("W", welcomeMessage); } } } }
/// <summary> /// Start polling for messages. /// </summary> private void StartPolling() { Task.Run(() => { using (var subSocket = context.CreateSubscriberSocket()) { byte[] buffer = null; subSocket.Options.ReceiveHighWatermark = 1000; subSocket.Connect(SubscriberAddress); subSocket.Subscribe(String.Empty); subSocket.ReceiveReady += (s, a) => { buffer = subSocket.Receive(); if (MessageRecieved != null) { MessageRecieved.Report(buffer.ToObject <Taurus.FeedMux>()); } }; // Poll. poller = new Poller(); poller.AddSocket(subSocket); poller.PollTillCancelled(); token.ThrowIfCancellationRequested(); } }, token).ContinueWith(ant => { pollerCancelled.Set(); }, TaskContinuationOptions.OnlyOnCanceled); }
public void LargeMessage() { using (NetMQContext context = NetMQContext.Create()) { using (var pubSocket = context.CreatePublisherSocket()) { pubSocket.Bind("tcp://127.0.0.1:5556"); using (var subSocket = context.CreateSubscriberSocket()) { subSocket.Connect("tcp://127.0.0.1:5556"); subSocket.Subscribe(""); Thread.Sleep(100); byte[] msg = new byte[300]; pubSocket.Send(msg); byte[] msg2 = subSocket.Receive(); Assert.AreEqual(300, msg2.Length); } } } }
/// <summary> /// Initializes a new instance of the <see cref="ForwarderDevice"/> 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 ForwarderDevice(NetMQContext context, Poller poller, string frontendBindAddress, string backendBindAddress, DeviceMode mode = DeviceMode.Threaded) : base(poller, context.CreateSubscriberSocket(), context.CreatePublisherSocket(), mode) { FrontendSetup.Bind(frontendBindAddress); BackendSetup.Bind(backendBindAddress); }
void t_Elapsed() { NetMQContext ctx = NetMQContext.Create(); NetMQSocket socket = ctx.CreateSubscriberSocket(); // TODO: change socket connection ip, port socket.Connect("tcp://172.16.12.188:5555"); socket.Subscribe(_tagID.ToString("000")); socket.ReceiveReady += (s, a) => { string topic = socket.ReceiveString(); string message = socket.ReceiveString(); msg m = JsonConvert.DeserializeObject <msg>(message); WriteText(m); //Application.DoEvents(); }; Poller poller = new Poller(); poller.AddSocket(socket); poller.Start(); }
private NetMQSocket GetInboundSocket(NetMQContext context) { NetMQSocket socket; switch (Connection.Pattern) { case MessagePattern.FireAndForget: socket = context.CreatePullSocket(); socket.Bind(Connection.Address); break; case MessagePattern.RequestResponse: socket = context.CreateResponseSocket(); socket.Bind(Connection.Address); break; case MessagePattern.PublishSubscribe: var subSocket = context.CreateSubscriberSocket(); subSocket.SubscribeToAnyTopic(); subSocket.Connect(Connection.Address); socket = subSocket; break; default: throw new Exception($"Cannot create an inbound socket for pattern {Connection.Pattern}"); } return(socket); }
public ZmqClient() { context = NetMQContext.Create(); subSocket = context.CreateSubscriberSocket(); subSocket.Options.ReceiveHighWatermark = 1000; subSocket.Connect(MarketDataSettings.RealTimeUpdateServerAddress); }
private void createRSocket() { clientR = context.CreateSubscriberSocket(); string[] addrs = cfg.ServerS.Split(','); foreach (string addr in addrs) { clientR.Connect(addr); } clientR.Subscribe(Global.DC_CTRL_HB); //接收心跳数据包 clientR.Subscribe(Global.Encoding.GetBytes(string.Concat(Global.DC_HEAD_AS_RPLY, Global.ENVELOPE_SPLITTER, this.guidStr))); //接收Act操作的回复数据包 }
public void Connect(string givenAddress) { if (IsConnected) { return; } subSocket = context.CreateSubscriberSocket(); subSocket.Connect(givenAddress); subSocket.Subscribe("EasyErgsocket"); IsConnected = true; }
private void Subscribe(object state) { _running = true; foreach (string subscriberAddress in _configuration.SubscriberAddresses) { SubscriberSocket subscriberSocket = _context.CreateSubscriberSocket(); subscriberSocket.Connect(subscriberAddress); subscriberSocket.Subscribe(""); _subscriberSockets.Add(subscriberSocket); Task.Factory.StartNew(() => WaitForMessages(subscriberSocket)); } }
public void MultipleSubscribers() { using (NetMQContext contex = NetMQContext.Create()) { using (var pub = contex.CreatePublisherSocket()) { pub.Bind("tcp://127.0.0.1:5002"); using (var sub = contex.CreateSubscriberSocket()) using (var sub2 = contex.CreateSubscriberSocket()) { sub.Connect("tcp://127.0.0.1:5002"); sub.Subscribe("A"); sub.Subscribe("AB"); sub.Subscribe("B"); sub.Subscribe("C"); sub2.Connect("tcp://127.0.0.1:5002"); sub2.Subscribe("A"); sub2.Subscribe("AB"); sub2.Subscribe("C"); Thread.Sleep(500); pub.SendMore("AB"); pub.Send("1"); string message = sub.ReceiveStringMessages().First(); Assert.AreEqual("AB", message, "First subscriber is expected to receive the message"); message = sub2.ReceiveStringMessages().First(); Assert.AreEqual("AB", message, "Second subscriber is expected to receive the message"); } } } }
public void Start(string serverAddress, int serverPublishPort, int clientId, Action <ServerToClientMessage> messageHandler) { this.messageHandler = messageHandler; ctx = NetMQContext.Create(); subscribeSocket = ctx.CreateSubscriberSocket(); subscribeSocket.Connect(string.Format("tcp://{0}:{1}", serverAddress, serverPublishPort)); subscribeSocket.Subscribe(clientId.ToString()); subscribeSocket.Subscribe("a"); isRunning = true; receiveThread = new Thread(Run); receiveThread.Name = "ClientMessageListenThread"; receiveThread.Start(); logger.Info("Server message subscriber started"); }
// initialized sprites void Start() { AsyncIO.ForceDotNet.Force(); calImages = new Sprite[10]; calImages[0] = Resources.Load <Sprite>("notargets"); calImages[1] = Resources.Load <Sprite>("targetTL"); calImages[2] = Resources.Load <Sprite>("targetTM"); calImages[3] = Resources.Load <Sprite>("targetTR"); calImages[4] = Resources.Load <Sprite>("targetML"); calImages[5] = Resources.Load <Sprite>("targetMM"); calImages[6] = Resources.Load <Sprite>("targetMR"); calImages[7] = Resources.Load <Sprite>("targetBL"); calImages[8] = Resources.Load <Sprite>("targetBM"); calImages[9] = Resources.Load <Sprite>("targetBR"); calCount = 0; curCount = 0; gameObject.GetComponent <Image> ().sprite = calImages [calCount]; //max coords 1180*564 transX = 0; transY = 0; targetPrefab = GameObject.FindGameObjectWithTag("RaycastTarget"); targetPrefab.SetActive(false); targetPrefab.layer = 2; //ignore raycast layer isVisible = false; AsyncIO.ForceDotNet.Force(); //setup sockets //hangs???? //http://forum.unity3d.com/threads/netmq-basic.298104/ //must compile myself //https://github.com/zeromq/netmq/issues/98 context = NetMQContext.Create(); server = context.CreatePublisherSocket(); server.Bind("tcp://127.0.0.1:5556"); client = context.CreateSubscriberSocket(); client.Connect("tcp://127.0.0.1:5556"); client.Subscribe("coord"); Debug.Log(System.Environment.Version); /*server.SendMore("coord").Send ("200 200"); * string top = client.ReceiveString (); * string message = client.ReceiveString (); * Debug.Log (message); * string[] coord = message.Split (); * transX = int.Parse (coord [0]); * transY = int.Parse (coord [1]);*/ }
protected override void StartMethod() { _zmqContext = NetMQContext.Create(); _zmqSocket = _zmqContext.CreateSubscriberSocket(); if (string.IsNullOrEmpty(_subsPrefix)) { _zmqSocket.Subscribe(string.Empty); } else { _zmqSocket.Subscribe(Encoding.UTF8.GetBytes(_subsPrefix)); } _zmqSocket.Connect(_endPoint); }
private void start(CancellationToken token, string address, TaskCompletionSource <bool> ready) { using (var socket = _context.CreateSubscriberSocket()) { socket.Subscribe(Encoding.ASCII.GetBytes(_topic)); socket.Connect(address); ready.SetResult(true); while (token.IsCancellationRequested == false) { socket.Receive(); //ignore topic var messageBytes = socket.Receive(); var message = Encoding.ASCII.GetString(messageBytes); Console.WriteLine("[{0}] Received - {1}", _id, message); } } }
private void Connect() { // getting the snapshot using (RequestSocket requestSocket = context.CreateRequestSocket()) { requestSocket.Connect(string.Format("tcp://{0}:{1}", address, SnapshotProtocol.Port)); requestSocket.Send(SnapshotProtocol.GetTradessCommand); string json; requestSocket.Options.ReceiveTimeout = SnapshotProtocol.RequestTimeout; try { json = requestSocket.ReceiveString(); } catch (AgainException ex) { // Fail to receive trades, we call on error and don't try to do anything with subscriber // calling on error from poller thread block the application Task.Run(() => subject.OnError(new Exception("No response from server"))); return; } while (json != SnapshotProtocol.EndOfTickers) { PublishTicker(json); json = requestSocket.ReceiveString(); } } subscriberSocket = context.CreateSubscriberSocket(); subscriberSocket.Subscribe(StreamingProtocol.TradesTopic); subscriberSocket.Subscribe(StreamingProtocol.HeartbeatTopic); subscriberSocket.Connect(string.Format("tcp://{0}:{1}", address, StreamingProtocol.Port)); subscriberSocket.ReceiveReady += OnSubscriberReady; poller.AddSocket(subscriberSocket); // reset timeout timer timeoutTimer.Enable = false; timeoutTimer.Enable = true; }
public void init(string address, int port) { this.address = address; this.port = port; //create context context = NetMQContext.Create(); //create client client = context.CreateSubscriberSocket(); //subscribe (must be before Connect!) client.Subscribe(""); //connect client client.Connect("tcp://" + address + ":" + port); //add "getData" as callback client.ReceiveReady += getData; }
/// <summary> /// Subscribe /// </summary> private void subscribe() { // Create a subscriber and connect to the same address and port as the publisher SubscriberSocket subscriber = _context.CreateSubscriberSocket(); subscriber.Connect("tcp://127.0.0.1:9999"); // Set the topic subscriber.Subscribe("Test"); string message = String.Empty; // Receive the message and perform the assertion while (message == String.Empty) { message = subscriber.ReceiveString(); } Console.WriteLine(message); Assert.AreEqual("Test", message); }
private void Connect() { subscriberSocket = context.CreateSubscriberSocket(); subscriberSocket.Subscribe(StreamingProtocol.HeartbeatTopic); subscriberSocket.Connect(string.Format("tcp://{0}:{1}", address, StreamingProtocol.Port)); subject.OnNext(new ConnectionInfo(ConnectionStatus.Connecting, this.address)); subscriberSocket.ReceiveReady += OnSubscriberReady; poller.AddSocket(subscriberSocket); // reset timeout timer timeoutTimer.Enable = false; timeoutTimer.Enable = true; }
void Start() { trackManager = GetComponent <TrackManager>(); statDisplayManager = GetComponent <StatDisplayManager>(); cameraManager = GetComponent <CameraManager>(); //if there is no otherBoatType set just use the playerBoatType... if this isn't set either we're screwed anyways... if (otherBoatType == null) { otherBoatType = playerBoatType; } initLanes(); Debug.Log("Starting up NetMQ interface on " + address); context = NetMQContext.Create(); subSocket = context.CreateSubscriberSocket(); subSocket.Connect(address); subSocket.Subscribe("EasyErgsocket"); }
private static void ListeningQueue() { using (NetMQContext context = NetMQContext.Create()) { using (var subscriber = context.CreateSubscriberSocket()) { subscriber.Connect("tcp://127.0.0.1:5555"); subscriber.Subscribe(""); while (true) { bool more; var bytes = subscriber.Receive(out more); System.Console.WriteLine("0x{0:X}", bytes[0]); } } } }