private static void XSubscriberSocket() { using var subSocket = new SubscriberSocket(); string loginMark = ""; string userName = ""; subSocket.Connect(_subscriberAddress); subSocket.Subscribe($"{_topic}/{TopicType.EquipAddEvent}"); subSocket.Subscribe($"{_topic}/{TopicType.EquipChangeEvent}"); subSocket.Subscribe($"{_topic}/{TopicType.EquipDeleteEvent}"); subSocket.Subscribe($"{_topic}/{TopicType.YcChangeEvent}/{11151}"); subSocket.Subscribe($"{_topic}/{TopicType.YxChangeEvent}/{11151}"); subSocket.Subscribe($"{_topic}/{TopicType.SendControl}/{11151}"); subSocket.Subscribe($"{_topic}/{TopicType.AddRealTimeSnapshot}"); subSocket.Subscribe($"{_topic}/{TopicType.EquipStateEvent}"); subSocket.Subscribe($"{_topic}/{TopicType.DeleteRealTimeSnapshot}"); subSocket.Subscribe($"{_topic}/{TopicType.OpenPage4InterScreen}"); subSocket.Subscribe($"{_topic}/{TopicType.ShowOrClosePage}"); subSocket.Subscribe($"{_topic}/{TopicType.KickClient}/{loginMark}"); subSocket.Subscribe($"{_topic}/{TopicType.ShowMsg}"); subSocket.Subscribe($"{_topic}/{TopicType.NotifyOffLine}"); subSocket.Subscribe($"{_topic}/{TopicType.NotifyRoleOffLine}"); subSocket.Subscribe($"{_topic}/{TopicType.ShowLockSetParmMsg}"); subSocket.Subscribe($"{_topic}/{TopicType.VOpenPage}/{userName}"); subSocket.Subscribe($"{_topic}/{TopicType.ShowInfo}"); subSocket.SubscribeToAnyTopic(); Console.WriteLine("Subscriber socket connecting...\n"); ReceiveFrameString(); }
private void Run() { using var publisher = new PublisherSocket(); publisher.Bind(@"tcp://127.0.0.1:17232"); using var subscriber = new SubscriberSocket(); subscriber.Bind(@"tcp://127.0.0.1:17233"); subscriber.SubscribeToAnyTopic(); running.Set(); using var server = new TelnetServer(IPAddress.Any, port, publisher, subscriber) { OptionReuseAddress = true }; Log.Information("Server starting ..."); server.Start(); while (running.WaitOne(TimeSpan.Zero)) { if (subscriber.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(100), out var frame)) { server.Multicast(frame); } } server.Stop(); Log.Information("Server stopped."); }
public async Task ListenToEddn() { var utf8 = new UTF8Encoding(); using (var client = new SubscriberSocket()) { client.Options.ReceiveHighWatermark = 1000; client.Connect("tcp://eddn.edcd.io:9500"); client.SubscribeToAnyTopic(); while (true) { var bytes = client.ReceiveFrameBytes(); var uncompressed = ZlibStream.UncompressBuffer(bytes); var result = utf8.GetString(uncompressed); // ignore all outfitting and commodity responses if (!result.Contains(@"""Influence""")) { continue; } Submissions.Add(EddnRequest.FromJson(result)); } } }
public void RequestResponseMultipartMessageWithRetryFails() { const string address = "tcp://127.0.0.1:50002"; const string pubAddress = "tcp://127.0.0.1:60002"; const int numTries = 5; var requestTimeout = TimeSpan.FromMilliseconds(100); var requestMessage = new NetMQMessage(1); requestMessage.Append("Hi"); using (var progressPublisher = new PublisherSocket(pubAddress)) using (var progressSubscriber = new SubscriberSocket(pubAddress)) using (var server = new RouterSocket(address)) { progressSubscriber.SubscribeToAnyTopic(); var progressProactor = new NetMQProactor(progressSubscriber, (socket, message) => Console.WriteLine("C: {0} {1:ss.fff}", message[0].ConvertToString(), DateTime.Now)); var serverProactor = new NetMQProactor(server, (socket, message) => { Console.WriteLine("ResponseEcho recieved message {0} at {1:ss.fff}", message[2].ConvertToString(), DateTime.Now); }); using (serverProactor) using (progressProactor) { var responseMessage = RequestSocket.RequestResponseMultipartMessageWithRetry(address, requestMessage, numTries, requestTimeout, progressPublisher); Assert.IsNull(responseMessage); } } }
static void Main(string[] args) { var utf8 = new UTF8Encoding(); try { using (var client = new SubscriberSocket()) { client.Options.ReceiveHighWatermark = 1000; client.Connect("tcp://eddn.edcd.io:9500"); client.SubscribeToAnyTopic(); while (true) { var bytes = client.ReceiveFrameBytes(); var uncompressed = ZlibStream.UncompressBuffer(bytes); var result = utf8.GetString(uncompressed); addmessage(result); } } } catch (Exception e) { Console.WriteLine(e.Message); Console.Read(); } }
public void Run() { try { while (true) { using (SubscriberSocket sock = new SubscriberSocket()) { sock.Connect("tcp://eddn-relay.elite-markets.net:9500"); sock.SubscribeToAnyTopic(); Msg msg = new Msg(); msg.InitEmpty(); while (sock.TryReceive(ref msg, TimeSpan.FromMinutes(10))) { Process(msg); msg.Close(); msg.InitEmpty(); } } } } finally { NetMQConfig.Cleanup(); } }
private async Task ClientAsync() { var utf8 = new UTF8Encoding(); using (var client = new SubscriberSocket()) { client.Connect(_eddnClientSettings.ConnectionString); client.SubscribeToAnyTopic(); while (true) { try { (var bytes, _) = await client.ReceiveFrameBytesAsync(); var uncompressed = ZlibStream.UncompressBuffer(bytes); var result = utf8.GetString(uncompressed); await _messageDistributor.DistributeAsync(result); _logger.LogInformation(result); } catch (Exception ex) { _logger.LogError(ex, "Error reading message queue"); } } } }
private void HandleWork() { using (var stateUpdate = new SubscriberSocket()) { stateUpdate.SubscribeToAnyTopic(); stateUpdate.Bind(_configuration.ToPublisherEndpoint); using (var stateUpdatePublish = new PublisherSocket()) { stateUpdatePublish.Bind(_configuration.ToSubscribersEndpoint); stateUpdate.ReceiveReady += async(s, e) => { var message = e.Socket.ReceiveMultipartMessage(); var subject = message[0].ConvertToString(); var payload = message[1]; var eventId = await _cache.AppendToStream(subject, payload.Buffer); stateUpdatePublish.SendMoreFrame(message[0].Buffer) .SendMoreFrame(_serializer.Serialize(eventId)) .SendFrame(payload.Buffer); }; using (_poller = new NetMQPoller { stateUpdate, stateUpdatePublish }) { _poller.Run(); } } } }
private void StartStationNetMQ() { try { _subscriber = new SubscriberSocket(); _subscriber.ReceiveReady += _subscriber_ReceiveReady; //_fileSubscriber = new SubscriberSocket(); _requester = new RequestSocket(); _poller = new NetMQPoller(); IsLocalClient = CheckIsLocalIP(this.Options.ServerAddress); _subscriber.Connect(string.Format("tcp://{0}:{1}", this.Options.ServerAddress, this.Options.MsgPubPort)); _subscriber.SubscribeToAnyTopic(); _requester.Connect(string.Format("tcp://{0}:{1}", this.Options.ServerAddress, this.Options.MsgResPort)); //_fileSubscriber.Connect(string.Format("tcp://{0}:{1}", this.Options.ServerAddress, this.Options.FilePubPort)); //_fileSubscriber.SubscribeToAnyTopic(); logger.InfoFormat("peripheral client netmq info: IP-{0},msg pub port:{1},msg res port:{2}", this.Options.ServerAddress, this.Options.MsgPubPort, this.Options.MsgResPort); // HockSocketEvents(true); //_poller.Add(_fileSubscriber); _poller.Add(_subscriber); _poller.Add(_requester); _poller.RunAsync(); Console.WriteLine("[Progress]:[4] Sub Listening"); // this.OnConnected(); } catch (Exception ex) { } }
private void ThreadSub() { List <SubscriberSocket> socklist = new List <SubscriberSocket>(); var sock = new SubscriberSocket(); sock.Options.IPv4Only = true; sock.SubscribeToAnyTopic(); foreach (var port in PortList) { string addr = $"tcp://{IPAddress.Loopback}:{port}"; sock.Connect(addr); } Thread.Sleep(2000); while (EventStop.Wait(WaitInterval) == false) { var buffer = sock.ReceiveFrameBytes(); string msg = Encoding.Unicode.GetString(buffer); textBox1.AppendLine(msg); } sock.Close(); }
public ZeroMqNotificationReader Init() { if (Initialized) { throw new InvalidOperationException($"{nameof(ZeroMqNotificationReader)} already initialized."); } var completionSource = new TaskCompletionSource <object>(); var token = _source.Token; _receiveTask = Task.Factory.StartNew(() => { var timeout = TimeSpan.FromSeconds(1); using (var subSocket = new SubscriberSocket(EndPoint)) { try { subSocket.Options.ReceiveHighWatermark = 1000; subSocket.SubscribeToAnyTopic(); while (!token.IsCancellationRequested) { var zMessage = new NetMQMessage(2); var messageReceived = subSocket.TryReceiveMultipartMessage(timeout, ref zMessage, 2); completionSource.TrySetResult(null); if (!messageReceived) { continue; } var topic = zMessage.Pop().ConvertToString(Encoding.UTF8); var json = zMessage.Pop().ConvertToString(Encoding.UTF8); OnNotificationReceived?.Invoke(topic, json); } } catch (Exception e) { OnError?.Invoke(e); } } }, TaskCreationOptions.LongRunning); _receiveTask.ContinueWith(t => { // Propagate exception from initialization if occured if (t.Exception != null) { completionSource.TrySetException(t.Exception); } }); completionSource.Task.GetAwaiter().GetResult(); Initialized = true; return(this); }
// Start is called before the first frame update private void Start() { _hip = GetComponent <Rigidbody>(); _pub.Bind(pubAddress); _sub.Connect(subAddress); _sub.SubscribeToAnyTopic(); _sub.Options.ReceiveHighWatermark = 1; }
static void Main(string[] args) { //TestSerilog(); using (var subSocket = new SubscriberSocket()) { var tcpLocalhost = "tcp://localhost:12345"; subSocket.Connect(tcpLocalhost); subSocket.SubscribeToAnyTopic(); Console.WriteLine("Waiting to Connect"); var connectMessage = subSocket.ReceiveMultipartMessage(); if (connectMessage[0].ConvertToString(Encoding.UTF8) == "CONNECT") { Console.WriteLine("Connected"); var port = connectMessage[1].ConvertToString(Encoding.UTF8); using (var reqSocket = new RequestSocket(port)) { var syncMessage = new NetMQMessage(); syncMessage.Append(new NetMQFrame("SYNC", Encoding.UTF8)); syncMessage.Append(new NetMQFrame(tcpLocalhost, Encoding.UTF8)); reqSocket.SendMultipartMessage(syncMessage); Console.WriteLine("Syncing"); var syncOk = reqSocket.ReceiveFrameString(); Console.WriteLine($"Synced: {syncOk}"); } using (var poller = new NetMQPoller()) { poller.Add(subSocket); subSocket.ReceiveReady += (sender, eventArgs) => { var subMessage = eventArgs.Socket.ReceiveMultipartMessage(); var topic = subMessage[0].ConvertToString(Encoding.UTF8); if (topic == "TopicA") { var decodedMessage = MessagePackSerializer.Deserialize <string>(subMessage[1].ToByteArray()); Console.WriteLine( $"{subMessage[0].ConvertToString(Encoding.UTF8)}: {decodedMessage}"); } }; poller.RunAsync(); Console.WriteLine("Press Enter to Exit"); Console.ReadLine(); poller.StopAsync(); } } } }
private void Register(SubscriberSocket subscriber, List <string> topics = null) { if (topics == null) { subscriber.SubscribeToAnyTopic(); } else { topics.ForEach(item => subscriber.Subscribe(item)); timeout.Add(subscriber, DateTime.Now); } }
private void InitSub() { subscriber = new SubscriberSocket(); subscriber.Connect(Address); subscriber.ReceiveReady += _Subscire_ReceiveReady; subscriber.SubscribeToAnyTopic(); subscriberPoller = new NetMQPoller { subscriber }; subscriberPoller.RunAsync(); }
private void Subscribe() { subscribing = true; subscriberSocket.Connect(@"tcp://127.0.0.1:17232"); subscriberSocket.SubscribeToAnyTopic(); while (subscribing) { if (subscriberSocket.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(100), out var frame)) { teleprinter.Read(frame[^ 1]);
public void ConnectSubscribe() { subscriber = new SubscriberSocket(); subscriber.Connect(SubscribeAddress); subscriber.ReceiveReady += _Subscire_ReceiveReady; subscriber.SubscribeToAnyTopic(); subscriberPoller = new NetMQPoller { subscriber }; subscriberPoller.RunAsync(); }
public async Task StartAsync(CancellationToken cancellationToken) { _subscriberSocket.Connect(_options.Address); _subscriberSocket.SubscribeToAnyTopic(); while (true) { var bytesReceived = _subscriberSocket.ReceiveFrameBytes(); var uncompressed = ZlibStream.UncompressBuffer(bytesReceived); var entity = _encoding.GetString(uncompressed); await _importTargetFactory.ImportAsync(entity); _logger.LogInformation(entity); } }
private static void Main(string[] args) { var deciSecond = new TimeSpan(10000); using (var subscriber = new SubscriberSocket()) // For receiving updates from presentation host using (var publisher = new WSPublisher()) // For publishing updates from presentation host to audience using (var responder = new WSRouter()) // Handling on-demand requests for late-joining or crashing clients { subscriber.Bind("tcp://*:3000"); subscriber.SubscribeToAnyTopic(); publisher.Bind("ws://*:3001"); responder.Bind("ws://*:3002"); byte step = 0; subscriber.ReceiveReady += (_, __) => { if (!subscriber.TryReceiveFrameBytes(deciSecond, out var received)) { return; } step = received[0]; Console.Out.WriteLine("Sending " + step + " to audience."); publisher.TrySendFrame(deciSecond, new[] { step }); }; responder.ReceiveReady += (_, __) => { NetMQMessage msg = null; if (!responder.TryReceiveMultipartMessage(deciSecond, ref msg)) { return; } var identity = msg.Pop().Buffer; var request = msg.Pop().ConvertToString(); msg.Clear(); if (request == "Which slide are we on?") { responder.TrySendMultipartBytes(deciSecond, identity, new[] { step }); } else { if (!responder.TrySendFrame(deciSecond, identity, true)) { return; } responder.TrySendFrameEmpty(deciSecond); } }; new NetMQPoller { subscriber, responder }.Run(); // Polling both subscriber and router sockets. } }
public void Start() { _publishStateUpdate = new PublisherSocket(); _publishStateUpdate.Bind(_brokerConfiguration.PublishUpdatesEndpoint); _subscribeToUpdates = new SubscriberSocket(); _subscribeToUpdates.SubscribeToAnyTopic(); _subscribeToUpdates.Bind(_brokerConfiguration.SubscribeToUpdatesEndpoint); _stateRequest = new RouterSocket(); _stateRequest.Bind(_brokerConfiguration.SendStateEndpoint); _workProc = Task.Run(DoStart, _cancel.Token).ConfigureAwait(false); _heartBeartProc = Task.Run(HandleHeartbeat, _cancel.Token).ConfigureAwait(false); }
private void SubscribeThread() { // Place subscribe socket initialization inside thread to make all subscribe calls happen on the same thread // Trying to prevent "Cannot close an uninitialised Msg" exceptions _subscribeSocket = new SubscriberSocket(); _subscribeSocket.Connect(_subscribeAddress); _subscribeSocket.SubscribeToAnyTopic(); _subscribeThreadRunning = true; while (!_subscribeThreadCancellation.IsCancellationRequested) { try { if (!_subscribeSocket.TryReceiveFrameBytes(new TimeSpan(0, 0, 0, 0, 200), out byte[] messageBytes))
public void ThreadB() { try { using (var subSocket = new SubscriberSocket()) { subSocket.Options.ReceiveHighWatermark = 1000; FillIP = ConfigurationManager.AppSettings["FillIP"]; FillPort = ConfigurationManager.AppSettings["FillPort"]; subSocket.Connect("tcp://" + FillIP + ":" + FillPort); subSocket.SubscribeToAnyTopic(); //subSocket.Subscribe(OrderClient.MachineGuid + ":" + OrderClient.UserGuid); //Console.WriteLine("Subscriber socket connecting..."); while (true) { try { if (ScannerBox.openedMainForm == false) { break; } string messageReceived; if (subSocket.TryReceiveFrameString(out messageReceived)) { //string messageReceived = subSocket.ReceiveFrameString(); Console.WriteLine("messageReceived " + messageReceived); string[] arr = messageReceived.Split(':'); //machineID + ":" + userID+":"+OrderNo+":"+ExchangeOrderId+":"+status+":"+status_msg+":"+other_msg //[3d0e9dfa-5c5d-85a2-1833-e1e1cf52c13e:b5479e69-9bab-1023-068f-f8bafaafb7de:35:1470420475:0:0:0 //machineID + ":" + userID + ":" + OrderNo + ":" + OrderStatus + ":" + ExchangeOrderId + ":" + status + ":" + status_msg + ":" + other_msg; dictFillDetails[arr[2]] = arr[3] + ":" + arr[4] + ":" + arr[5] + ":" + arr[6] + ":" + arr[7]; } } catch (Exception e) { Console.WriteLine("fillsubscriber : " + e.Message); } System.Threading.Thread.Sleep(100); } } } finally { NetMQConfig.Cleanup(); } }
private void HandleWork() { using (var stateUpdate = new SubscriberSocket()) { stateUpdate.SubscribeToAnyTopic(); stateUpdate.Bind(_configuration.ToPublisherEndpoint); stateUpdate.Options.ReceiveHighWatermark = _configuration.ZmqHighWatermark; using (var stateUpdatePublish = new PublisherSocket()) { stateUpdatePublish.Bind(_configuration.ToSubscribersEndpoint); stateUpdate.ReceiveReady += async(s, e) => { try { NetMQMessage message = null; while (e.Socket.TryReceiveMultipartMessage(ref message)) { var subject = message[0]; var payload = message[1]; stateUpdatePublish.SendMoreFrame(subject.Buffer) .SendMoreFrame(_serializer.Serialize(await _cache.AppendToStream(subject.Buffer, payload.Buffer))) .SendFrame(payload.Buffer); } } catch (Exception ex) { Errors.Add(new ActorMonitoringError() { CacheErrorStatus = ActorErrorType.DynamicCacheEventHandlingFailure, Exception = ex }); } }; using (_workPoller = new NetMQPoller { stateUpdate, stateUpdatePublish }) { _workPoller.Run(); } } } }
private void ConnectServer(string subAddress) { _subscriber = new SubscriberSocket(); _subscriber.SubscribeToAnyTopic(); _subscriber.Connect(subAddress); _subscriber.ReceiveReady += _subscriber_ReceiveReady; _poller = new NetMQPoller { _subscriber }; _poller.RunAsync(); Thread.Sleep(1000); //如果改变参数 2台client 会收不到信息 //this._beacon.SelfNode.Arguments = string.Format("-c {0}", this.IsConnected); }
private async Task ConnectToBroker() { _cancel = new CancellationTokenSource(); _getMarketState = new DealerSocket(); _getMarketState.Connect(_currentBroker.GetStateEndpoint); _getMarketState.Options.Identity = Id.ToByteArray(); _getMarketUpdates = new SubscriberSocket(); _getMarketUpdates.SubscribeToAnyTopic(); _getMarketUpdates.Connect(_currentBroker.SubscribeToUpdatesEndpoint); _heartbeatProc = Task.Run(() => DoHeartbeat(_configuration.HearbeatDelay, _configuration.HearbeatMaxDelay), _cancel.Token).ConfigureAwait(false); _workProc = Task.Run(ReceiveUpdates, _cancel.Token).ConfigureAwait(false); await Synchronize(); }
/// <summary> /// Creates a new instance of the <see cref="DualSocketBusSubscriber"/> type. /// </summary> /// <param name="messageBusEndpoint"> The subscribed message bus' endpoint. </param> /// <param name="dispatcher"> The dispatcher that is used for incoming messages from the subscibed bus. </param> /// <param name="scheduler"> /// An optional scheduler that can be used to deserialize incoming <see cref="NetMQMessage"/> instances on a separate thread. /// </param> protected DualSocketBusSubscriber( IDualSocketEndpoint messageBusEndpoint, ISocketDispatcherThread dispatcher, IScheduler?scheduler = null) { Dispatcher = dispatcher; MessageBusEndpoint = messageBusEndpoint; IncomingMessages = new Lazy <SubscriberSocket>(() => { var incomingMessages = new SubscriberSocket(); incomingMessages.SubscribeToAnyTopic(); incomingMessages.Connect(MessageBusEndpoint.Outgoing); incomingMessages.ReceiveReady += OnIncomingMessageReceived; return(incomingMessages); }, true); Scheduler = scheduler; }
public void RequestResponseMultipartMessageWithRetrySucceedsNotOnFirstTry() { const string address = "tcp://127.0.0.1:50001"; const string pubAddress = "tcp://127.0.0.1:60001"; const int numTries = 5; var requestTimeout = TimeSpan.FromMilliseconds(100); var requestMessage = new NetMQMessage(1); requestMessage.Append("Hi"); using (var progressPublisher = new PublisherSocket(pubAddress)) using (var progressSubscriber = new SubscriberSocket(pubAddress)) using (var server = new RouterSocket(address)) { progressSubscriber.SubscribeToAnyTopic(); var progressProactor = new NetMQProactor(progressSubscriber, (socket, message) => Console.WriteLine("C: {0} {1:ss.fff}", message[0].ConvertToString(), DateTime.Now)); int attempt = 0; var serverProactor = new NetMQProactor(server, (socket, message) => { Console.WriteLine("ResponseEcho recieved message {0} at {1:ss.fff}", message[2].ConvertToString(), DateTime.Now); attempt++; if (attempt > 1) { // reply same message socket.SendMultipartMessage(message); } }); using (serverProactor) using (progressProactor) { var responseMessage = RequestSocket.RequestResponseMultipartMessageWithRetry(address, requestMessage, numTries, requestTimeout, progressPublisher); Assert.IsNotNull(responseMessage); Assert.AreEqual(1, responseMessage.FrameCount); var responseString = responseMessage.First.ConvertToString(); Assert.AreEqual("Hi", responseString); } } }
private void Work() { using (var subscriberSocket = new SubscriberSocket()) { subscriberSocket.Options.ReceiveHighWatermark = 1000; subscriberSocket.SubscribeToAnyTopic(); subscriberSocket.Connect(_toPublisherEndpoint); using (var publisherSocket = new XPublisherSocket()) { publisherSocket.Options.XPubVerbose = true; publisherSocket.Bind(_toSubscribersEndpoint); using (_poller = new NetMQPoller { new NetMQTimer(TimeSpan.FromMilliseconds(1)), subscriberSocket, publisherSocket }) { subscriberSocket.ReceiveReady += (s, e) => { var message = e.Socket.ReceiveMultipartBytes(); var topic = Encoding.UTF8.GetString(message[0]); var payload = message[1]; _cache[topic] = payload; publisherSocket.SendMultipartBytes(message); }; publisherSocket.ReceiveReady += (s, e) => { var message = e.Socket.ReceiveFrameBytes(); var isSub = message[0] == 1; var topic = Encoding.UTF8.GetString(message.Skip(1).ToArray()); if (_cache.ContainsKey(topic)) { publisherSocket.SendMoreFrame(Encoding.UTF8.GetBytes(topic)).SendFrame(_cache[topic]); } }; _poller.Run(); } } } }
public Receiver(string sFile = "") { if (sFile.Equals("") == false) { sLogfile = sFile; } subscriber = new SubscriberSocket(); subscriber.Connect(sEndpoint); subscriber.SubscribeToAnyTopic(); file = new System.IO.StreamWriter(sLogfile); file.AutoFlush = true; }
/// <summary> /// Starts the local to external message transfering. /// </summary> /// <param name="proxyForPublishersPort">The port for local publishers.</param> /// <param name="busPublisherPort">Broker's publisher port for other brokers subscription.</param> private void StartLocalToExternalTransfer(int proxyForPublishersPort, int busPublisherPort) { Task.Run(() => { using (var subSocket = new SubscriberSocket()) using (var pubSocket = new PublisherSocket()) { subSocket.SubscribeToAnyTopic(); subSocket.Bind($"tcp://localhost:{proxyForPublishersPort}"); pubSocket.Bind($"tcp://localhost:{busPublisherPort}"); _localToExternalProxy = new NetMQ.Proxy(subSocket, pubSocket); _localToExternalProxy.Start(); } }); }