/// <summary> /// Create new client /// </summary> /// <param name="serializer">Serialize to to use to serialize the message to byte array</param> /// <param name="address">Address of the server</param> public Client(ISerializer serializer, string address) { this.Serializer = serializer; this.Address = address; m_outgoingQueue = new NetMQQueue <ClientEngine.OutgoingMessage>(); Engine = new ClientEngine(Serializer, m_outgoingQueue, Address); }
public LogCollectService(ILogRepository logRepository, IAppConfiguration config) { this.logRepository = logRepository; queue = new NetMQQueue <RawLogData>(); poller = new NetMQPoller { queue }; queue.ReceiveReady += (sender, args) => { var item = queue.Dequeue(); var lst = new List <RawLogData> { item }; if (config.BatchSizeToIndex > 1) { for (int i = 0; i < config.BatchSizeToIndex; ++i) { if (queue.TryDequeue(out RawLogData outData, new TimeSpan(10)) == false) { break; //no more items in the Queue so we''ll make the system wait for the Queue } lst.Add(outData); } } Thread.Sleep(1000); ProcessLogFromQueue(lst); }; poller.RunAsync(); }
public Swarm( PrivateKey privateKey, Uri listenUrl, TimeSpan?dialTimeout = null, DateTime?createdAt = null) { _privateKey = privateKey; _listenUrl = listenUrl; _dialTimeout = dialTimeout ?? TimeSpan.FromMilliseconds(15000); _peers = new Dictionary <Peer, DateTime>(); _removedPeers = new Dictionary <Peer, DateTime>(); LastSeenTimestamps = new Dictionary <Peer, DateTime>(); DateTime now = createdAt.GetValueOrDefault(DateTime.UtcNow); LastDistributed = now; LastReceived = now; DeltaDistributed = new AsyncManualResetEvent(); DeltaReceived = new AsyncManualResetEvent(); TxReceived = new AsyncAutoResetEvent(); _dealers = new Dictionary <Address, DealerSocket>(); _router = new RouterSocket(); _deltas = new NetMQQueue <PeerSetDelta>(); _distributeMutex = new AsyncLock(); _receiveMutex = new AsyncLock(); _logger = Log.ForContext <Swarm>() .ForContext("Swarm_listenUrl", _listenUrl.ToString()); _contextInitialized = false; }
static void Main(string[] args) { Console.WriteLine("Press any key to start!"); Console.Read(); NetMQPoller Poller2 = new NetMQPoller(); NetMQQueue <int> Queue = new NetMQQueue <int>(); for (var i = 0; i < 10; i++) { Task.Factory.StartNew((o) => { using (var req = new RequestSocket(">tcp://127.0.0.1:5001")) { if (req.TrySendFrame(TimeSpan.FromSeconds(1), $"task:{o}")) { var msg = req.ReceiveFrameString(); Console.WriteLine(msg); } else { Console.WriteLine($"task:{i} timeout!"); } } }, i); } Console.WriteLine("Press any key to stop!"); Console.Read(); Console.Read(); }
public ClientEngine(ISerializer serializer, NetMQQueue <OutgoingMessage> outgoingQueue, string address) { m_serializer = serializer; m_outgoingQueue = outgoingQueue; m_address = address; m_pendingRequests = new Dictionary <ulong, PendingMessage>(); m_nextMessageId = 0; }
public void EnqueueDequeue() { using (var queue = new NetMQQueue<int>()) { queue.Enqueue(1); Assert.AreEqual(1, queue.Dequeue()); } }
public void EnqueueDequeue() { using (var queue = new NetMQQueue <int>()) { queue.Enqueue(1); Assert.AreEqual(1, queue.Dequeue()); } }
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 EnqueueDequeue() { using (NetMQContext context = NetMQContext.Create()) using (NetMQQueue<int> queue = new NetMQQueue<int>(context)) { queue.Enqueue(1); Assert.AreEqual(1, queue.Dequeue()); } }
/// <summary> /// Client constructor. /// </summary> /// <param name="connectionString">Valid NetMQ client socket connection string.</param> /// <param name="identity">Client identifier passed to the server in Zero Knowledge authentication. /// Null for unsecured hosts.</param> /// <param name="identityKey">Secret key used by NOT passed to the server in Zero Knowledge authentication /// but used in memory to validate authentication of the server. Null for /// unsecured hosts</param> /// <param name="logger">ILogger implementation for logging operations. Null is replaced with NullLogger.</param> /// <param name="stats">IStats implementation for logging perf metrics. Null is replaced with NullStats.</param> /// <param name="heartBeatIntervalMs">Number of milliseconds between client sending heartbeat message to the server. /// Default 30,000 (30 seconds). Min is 1000 (1 second) and max is 600,000 (10 mins).</param> /// <param name="maxSkippedHeartBeatReplies">Maximum heartbeat intervals skipped without a heartbeat reply /// from the server before the client begins throwing on Send and returns false for the IsHostAlive property. /// Default is 3. Min is 1 and max is 10.</param> public Client(string connectionString, string identity = null, string identityKey = null, ILog logger = null, IStats stats = null, int heartBeatIntervalMs = 30000, int maxSkippedHeartBeatReplies = 3) { _identity = identity; _identityKey = identityKey; _connectionString = connectionString; _logger = logger ?? new NullLogger(); _stats = stats ?? new NullStats(); _heartBeatMs = (heartBeatIntervalMs < 1000) ? 1000 : (heartBeatIntervalMs > 600000) ? 600000 : heartBeatIntervalMs; _maxSkippedHeartBeatReplies = (maxSkippedHeartBeatReplies < 1) ? 1 : (maxSkippedHeartBeatReplies > 10) ? 10 : maxSkippedHeartBeatReplies; _clientId = Guid.NewGuid(); _clientIdBytes = _clientId.ToByteArray(); _sendQueue = new NetMQQueue <List <byte[]> >(); _dealerSocket = new DealerSocket(_connectionString); _dealerSocket.Options.Identity = _clientIdBytes; _sendQueue.ReceiveReady += SendQueue_ReceiveReady; _dealerSocket.ReceiveReady += DealerSocket_ReceiveReady; _socketPoller = new NetMQPoller { _dealerSocket, _sendQueue }; _socketPoller.RunAsync(); _receiveQueue = new NetMQQueue <List <byte[]> >(); _receiveQueue.ReceiveReady += ReceivedQueue_ReceiveReady; if (null != _identity && null != _identityKey) { _throwOnSend = true; _heartBeatTimer = new NetMQTimer(_heartBeatMs); _heartBeatTimer.Elapsed += HeartBeatTimer_Elapsed; _clientPoller = new NetMQPoller { _receiveQueue, _heartBeatTimer }; _heartBeatTimer.Enable = true; _logger.Debug("Client created with protocol enabled."); } else { _clientPoller = new NetMQPoller { _receiveQueue }; _logger.Debug("Client created. Protocol NOT enabled."); } _clientPoller.RunAsync(); }
/// <summary> /// Host constructor. Supply an IZkRepository to enable Zero Knowledge authentication and encryption. /// </summary> /// <param name="connectionString">Valid NetMQ server socket connection string.</param> /// <param name="authRepository">External authentication repository. Null creates host with no encryption.</param> /// <param name="logger">ILogger implementation for logging operations. Null is replaced with NullLogger.</param> /// <param name="stats">IStats implementation for logging perf metrics. Null is replaced with NullStats.</param> /// <param name="sessionTimeoutMins">Session timout check interval. If no heartbeats or messages /// received on a given session in this period of time, the session will be removed from memory /// and futher attempts from the client will fail. Default is 20 minutes. Min is 1 and Max is 3600.</param> public Host(string connectionString, IKeyRepository authRepository = null, ILog logger = null, IStats stats = null, int sessionTimeoutMins = 20) { if (string.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentNullException("Connection string cannot be null.", nameof(connectionString)); } _connectionString = connectionString; _logger = logger ?? new NullLogger(); _stats = stats ?? new NullStats(); //enforce min and max session check _sessionTimeoutMins = (sessionTimeoutMins < 1) ? 1 : (sessionTimeoutMins > 3600) ? 3600 : sessionTimeoutMins; _authRepository = authRepository; _sessions = new ConcurrentDictionary <Guid, HostSession>(); _sendQueue = new NetMQQueue <NetMQMessage>(); _routerSocket = new RouterSocket(_connectionString); _routerSocket.Options.RouterMandatory = true; _sendQueue.ReceiveReady += SendQueue_ReceiveReady; _routerSocket.ReceiveReady += RouterSocket_ReceiveReady; _socketPoller = new NetMQPoller { _routerSocket, _sendQueue }; _socketPoller.RunAsync(); _sendFailureQueue = new NetMQQueue <MessageFailure>(); _receivedQueue = new NetMQQueue <Message>(); _sendFailureQueue.ReceiveReady += SendFailureQueue_ReceiveReady; _receivedQueue.ReceiveReady += ReceivedQueue_ReceiveReady; if (null == _authRepository) { _hostPoller = new NetMQPoller { _receivedQueue, _sendFailureQueue }; _logger.Debug("Hoste created. Protocol NOT enabled."); } else { _sessionCleanupTimer = new NetMQTimer(new TimeSpan(0, _sessionTimeoutMins, 0)); _sessionCleanupTimer.Elapsed += SessionCleanupTimer_Elapsed; _hostPoller = new NetMQPoller { _receivedQueue, _sendFailureQueue, _sessionCleanupTimer }; _sessionCleanupTimer.Enable = true; _logger.Debug("Host created with protocol enabled."); } _hostPoller.RunAsync(); }
public void TryDequeue() { using (var queue = new NetMQQueue <int>()) { Assert.IsFalse(queue.TryDequeue(out int result, TimeSpan.FromMilliseconds(100))); queue.Enqueue(1); Assert.IsTrue(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100))); Assert.AreEqual(1, result); } }
public void TryDequeue() { using (var queue = new NetMQQueue<int>()) { int result; Assert.IsFalse(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100))); queue.Enqueue(1); Assert.IsTrue(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100))); Assert.AreEqual(1, result); } }
public ZeroMqPublisher() { _pubSocket = new PublisherSocket(); _pubSocket.Options.SendHighWatermark = 10; _pubSocket.Options.DelayAttachOnConnect = true; _queue = new NetMQQueue <object>(10); _queue.ReceiveReady += (sender, args) => Publish(_queue.Dequeue()); _poller = new NetMQPoller { _queue }; }
public void TryDequeue() { using (NetMQContext context = NetMQContext.Create()) using (NetMQQueue <int> queue = new NetMQQueue <int>(context)) { int result; Assert.IsFalse(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100))); queue.Enqueue(1); Assert.IsTrue(queue.TryDequeue(out result, TimeSpan.FromMilliseconds(100))); Assert.AreEqual(1, result); } }
/// <summary> /// Creates a new instance of the <see cref="DualSocketBusPublisher"/> type. /// </summary> /// <param name="messageBusEndpoint"> The subscribed message bus' endpoint. </param> /// <param name="dispatcher"> The dispatcher that is used for outgoing messages from the subscibed bus. </param> public DualSocketBusPublisher( IDualSocketEndpoint messageBusEndpoint, ISocketDispatcherThread dispatcher) { Dispatcher = dispatcher; MessageBusEndpoint = messageBusEndpoint; OutgoingMessages = new Lazy <PublisherSocket>(() => { var socket = new PublisherSocket(); socket.Connect(MessageBusEndpoint.Incoming); return(socket); }, true); OutgoingMessageQueue = new Lazy <NetMQQueue <NetMQMessage> >(() => { var queue = new NetMQQueue <NetMQMessage>(); queue.ReceiveReady += OnMessageQueued; return(queue); }, true); }
public void WithPoller() { using (var queue = new NetMQQueue<int>()) using (var poller = new NetMQPoller { queue }) { var manualResetEvent = new ManualResetEvent(false); queue.ReceiveReady += (sender, args) => { Assert.AreEqual(1, queue.Dequeue()); manualResetEvent.Set(); }; poller.RunAsync(); Assert.IsFalse(manualResetEvent.WaitOne(100)); queue.Enqueue(1); Assert.IsTrue(manualResetEvent.WaitOne(100)); } }
/// <summary> /// create worker with standard parameter /// HeartbeatDelay == 2500 milliseconds /// ReconnectDelay == 2500 milliseconds /// ConnectionRetries == 3 /// Verbose == false /// </summary> private MDPWorker() { HeartbeatDelay = TimeSpan.FromMilliseconds(2500); ReconnectDelay = TimeSpan.FromMilliseconds(2500); m_timer = new NetMQTimer(HeartbeatDelay); m_timer.Enable = false; m_timer.Elapsed += (s, e) => OnHeartbeat(); m_pollerQueue = new NetMQQueue <Action>(); m_pollerQueue.ReceiveReady += (sender, args) => { var action = args.Queue.Dequeue(); action.Invoke(); }; m_poller = new NetMQPoller(); m_poller.Add(m_pollerQueue); m_poller.Add(m_timer); m_poller.RunAsync(); }
/// <summary> /// create worker with standard parameter /// HeartbeatDelay == 2500 milliseconds /// ReconnectDelay == 2500 milliseconds /// ConnectionRetries == 3 /// Verbose == false /// </summary> private MDPWorker() { HeartbeatDelay = TimeSpan.FromMilliseconds(2500); ReconnectDelay = TimeSpan.FromMilliseconds(2500); m_timer = new NetMQTimer(HeartbeatDelay); m_timer.Enable = false; m_timer.Elapsed += (s, e) => OnHeartbeat(); m_pollerQueue = new NetMQQueue<Action>(); m_pollerQueue.ReceiveReady += (sender, args) => { var action = args.Queue.Dequeue(); action.Invoke(); }; m_poller = new NetMQPoller(); m_poller.Add(m_pollerQueue); m_poller.Add(m_timer); m_poller.RunAsync(); }
public static void Main() { int count = 10000000; using (NetMQContext context = NetMQContext.Create()) { NetMQQueue<int> queue = new NetMQQueue<int>(context); var task = Task.Factory.StartNew(() => { queue.Dequeue(); Stopwatch stopwatch = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { queue.Dequeue(); } stopwatch.Stop(); Console.WriteLine("Dequeueing items per second: {0:N0}", count /stopwatch.Elapsed.TotalSeconds); }); queue.Enqueue(-1); Stopwatch writeStopwatch = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { queue.Enqueue(i); } writeStopwatch.Stop(); Console.WriteLine("Enqueueing items per second: {0:N0}", count/writeStopwatch.Elapsed.TotalSeconds); task.Wait(); } }
public static void Main() { int count = 10000000; using (NetMQContext context = NetMQContext.Create()) { NetMQQueue <int> queue = new NetMQQueue <int>(context); var task = Task.Factory.StartNew(() => { queue.Dequeue(); Stopwatch stopwatch = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { queue.Dequeue(); } stopwatch.Stop(); Console.WriteLine("Dequeueing items per second: {0:N0}", count / stopwatch.Elapsed.TotalSeconds); }); queue.Enqueue(-1); Stopwatch writeStopwatch = Stopwatch.StartNew(); for (int i = 0; i < count; i++) { queue.Enqueue(i); } writeStopwatch.Stop(); Console.WriteLine("Enqueueing items per second: {0:N0}", count / writeStopwatch.Elapsed.TotalSeconds); task.Wait(); } }
public void WithPoller() { using (var queue = new NetMQQueue <int>()) using (var poller = new NetMQPoller { queue }) { var manualResetEvent = new ManualResetEvent(false); queue.ReceiveReady += (sender, args) => { Assert.AreEqual(1, queue.Dequeue()); manualResetEvent.Set(); }; poller.RunAsync(); Assert.IsFalse(manualResetEvent.WaitOne(100)); queue.Enqueue(1); Assert.IsTrue(manualResetEvent.WaitOne(100)); } }
/// <summary> /// setup the client with standard values /// verbose == false /// Connect the client to broker /// </summary> private MDPClientAsync() { m_client = null; m_connected = false; m_currentBrokerIndex = -1; // TODO use random!? m_pollerQueue = new NetMQQueue <Action>(); m_pollerQueue.ReceiveReady += (sender, args) => OnAction(args); m_requestQueue = new RequestsQueue(); m_requestQueue.FailedRequest += (s, e) => OnFailedRequest(e); m_poller = new NetMQPoller(); Timeout = m_defaultTimeOut; m_timer = new NetMQTimer(m_purgeCheckTime); m_timer.Enable = false; m_timer.Elapsed += (s, e) => OnPurgeRequest(); m_poller.Add(m_timer); m_poller.Add(m_pollerQueue); m_poller.Add(m_timer); m_poller.RunAsync(); }
public void WithPoller() { using (NetMQContext context = NetMQContext.Create()) using (NetMQQueue<int> queue = new NetMQQueue<int>(context)) { Poller poller = new Poller(); poller.AddSocket(queue); ManualResetEvent manualResetEvent = new ManualResetEvent(false); queue.ReceiveReady += (sender, args) => { manualResetEvent.Set(); }; poller.PollTillCancelledNonBlocking(); Assert.IsFalse(manualResetEvent.WaitOne(100)); queue.Enqueue(1); Assert.IsTrue(manualResetEvent.WaitOne(100)); poller.CancelAndJoin(); } }
public void WithPoller() { using (NetMQContext context = NetMQContext.Create()) using (NetMQQueue <int> queue = new NetMQQueue <int>(context)) { Poller poller = new Poller(); poller.AddSocket(queue); ManualResetEvent manualResetEvent = new ManualResetEvent(false); queue.ReceiveReady += (sender, args) => { manualResetEvent.Set(); }; poller.PollTillCancelledNonBlocking(); Assert.IsFalse(manualResetEvent.WaitOne(100)); queue.Enqueue(1); Assert.IsTrue(manualResetEvent.WaitOne(100)); poller.CancelAndJoin(); } }
public void Start() { _frontend = new RouterSocket(); _backend = new RouterSocket(); _workQueue = new NetMQQueue <Work>(); _workerQueue = new NetMQQueue <Guid>(); _frontend.Bind(_frontendRouterEndpoint); _backend.Bind(_backendRouterEndpoint); _poller = new NetMQPoller { _frontend, _backend, _workQueue, _workerQueue }; _workQueue.ReceiveReady += (s, e) => { if (_workerQueue.TryDequeue(out Guid worker, TimeSpan.FromMilliseconds(0))) { var work = e.Queue.Dequeue(); work.WorkerId = worker; _backend.SendMoreFrame(worker.ToByteArray()) .SendMoreFrameEmpty() .SendFrame(work.Serialize()); } }; _workerQueue.ReceiveReady += (s, e) => { if (_workQueue.TryDequeue(out Work work, TimeSpan.FromMilliseconds(0))) { var worker = e.Queue.Dequeue(); work.WorkerId = worker; _backend.SendMoreFrame(worker.ToByteArray()) .SendMoreFrameEmpty() .SendFrame(work.Serialize()); } }; _frontend.ReceiveReady += (s, e) => { var transportMessage = e.Socket.ReceiveMultipartMessage() .GetMessageFromRouter <Work>(); var work = transportMessage.Message; work.ClientId = new Guid(transportMessage.SenderId); if (work.MessageType == MessageType.Ask) { _workQueue.Enqueue(work); } }; _backend.ReceiveReady += (s, e) => { var transportMessage = e.Socket.ReceiveMultipartMessage() .GetMessageFromRouter <Work>(); var work = transportMessage.Message; if (work.MessageType == MessageType.Ready) { _workerQueue.Enqueue(new Guid(transportMessage.SenderId)); } if (work.MessageType == MessageType.Finished) { _frontend.SendMoreFrame(work.ClientId.ToByteArray()) .SendMoreFrameEmpty() .SendFrame(transportMessage.MessageBytes); _workerQueue.Enqueue(new Guid(transportMessage.SenderId)); } }; _poller.Run(); }
/// <summary> /// setup the client with standard values /// verbose == false /// Connect the client to broker /// </summary> private MDPClientAsync() { m_client = null; m_connected = false; m_currentBrokerIndex = -1; // TODO use random!? m_pollerQueue = new NetMQQueue<Action>(); m_pollerQueue.ReceiveReady += (sender, args) => OnAction(args); m_requestQueue = new RequestsQueue(); m_requestQueue.FailedRequest += (s, e) => OnFailedRequest(e); m_poller = new NetMQPoller(); Timeout = m_defaultTimeOut; m_timer = new NetMQTimer(m_purgeCheckTime); m_timer.Enable = false; m_timer.Elapsed += (s, e) => OnPurgeRequest(); m_poller.Add(m_timer); m_poller.Add(m_pollerQueue); m_poller.Add(m_timer); m_poller.RunAsync(); }
public ClientSafeEngine(ISerializer serializer, NetMQQueue <OutgoingMessage> outgoingQueue, string address, TaskCompletionSource <object> source) : base(serializer, outgoingQueue, address) => this.source = source;
/// <summary> /// Create new client /// </summary> /// <param name="serializer">Serialize to to use to serialize the message to byte array</param> /// <param name="address">Address of the server</param> public Client(ISerializer serializer, string address) { m_outgoingQueue = new NetMQQueue<ClientEngine.OutgoingMessage>(); m_actor = NetMQActor.Create(new ClientEngine(serializer, m_outgoingQueue, address)); }
public PublisherService() : base(new PublisherSocket()) { Queue = new NetMQQueue <IInvocation>(); Poller.Add(Queue); Queue.ReceiveReady += Queue_ReceiveReady; }
/// <summary> /// Create new client /// </summary> /// <param name="serializer">Serialize to to use to serialize the message to byte array</param> /// <param name="address">Address of the server</param> public Client(ISerializer serializer, string address) { m_outgoingQueue = new NetMQQueue <ClientEngine.OutgoingMessage>(); m_actor = NetMQActor.Create(new ClientEngine(serializer, m_outgoingQueue, address)); }
private async Task Handler() { while (this.IsRunning) { try { bool isListening = false; var connectionString = this.FrontendEndpoint.ToConnectionString(); using (var frontendSocket = new RouterSocket()) using (this.FrontendBuffer = new NetMQQueue <TransportMessage>()) using (var poller = new NetMQPoller() { frontendSocket, this.FrontendBuffer }) using (var monitor = new NetMQ.Monitoring.NetMQMonitor(frontendSocket, $"inproc://monitor.forwarderdevice.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Accepted | SocketEvents.Disconnected | SocketEvents.Closed)) { frontendSocket.ReceiveReady += (sender, e) => { try { var netmqMessage = new NetMQMessage(); while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage)) { var message = netmqMessage.ToMessage(out var envelope); string serviceIdentifier = message.Metadata.TryGetLast("serviceIdentifier", out var encodedService) ? Encoding.UTF8.GetString(encodedService) : null; try { var cancellationSource = new CancellationTokenSource(5000); var registeredBackend = this.ResolveBackend(serviceIdentifier, cancellationSource.Token); //var registeredBackend = this.InprocTransportScope.GetNextServerTransport(serviceIdentifier, cancellationSource.Token); message.Metadata.Add($"envelope[{this.Identity}]", envelope); //registeredBackend.ReceiveBuffer.QueueMessage(message); registeredBackend.Send(message).ContinueWith(task => { this.OnDiagnosticMessage($"Failed to forward to backend [{task.Exception.InnerException.Message}]"); }, TaskContinuationOptions.OnlyOnFaulted); } catch (OperationCanceledException) { this.OnDiagnosticMessage($"No backends available for {serviceIdentifier}!!!"); var nmqm = MessageHelpers.CreateNetMQErrorMessage(envelope, "No backends found", message.Metadata); e.Socket.SendMultipartMessage(nmqm); } } } catch (Exception ex) { this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace); } }; this.FrontendBuffer.ReceiveReady += (sender, e) => { try { while (this.FrontendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero)) { if (!message.Metadata.TryPluckLast($"envelope[{this.Identity}]", out var envelope)) { throw new Exception("Message envelope not found"); } if (!frontendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope))) { this.OnDiagnosticMessage("Failed to forward to frontend"); } } } catch (Exception ex) { this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace); } }; monitor.Listening += (sender, e) => { this.OnDiagnosticMessage($"Frontend router socket listening at {connectionString}"); isListening = true; }; monitor.Closed += (sender, e) => { this.OnDiagnosticMessage($"Frontend router socket closed on {connectionString}"); isListening = false; }; monitor.Accepted += (sender, e) => { this.OnDiagnosticMessage($"Frontend router socket connection accepted at {connectionString}"); }; monitor.Disconnected += (sender, e) => { this.OnDiagnosticMessage($"Frontend router socket disconnected at {connectionString}"); }; this.OnDiagnosticMessage($"Attempting to bind frontend socket to {connectionString}"); monitor.StartAsync(); monitor.AttachToPoller(poller); var pollerTask = new Task(poller.Run); pollerTask.ContinueWith(task => { var ex = task.Exception; this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace); isListening = false; }, TaskContinuationOptions.OnlyOnFaulted); pollerTask.Start(); frontendSocket.Bind(connectionString); var start = DateTime.Now; while (!isListening) { if ((DateTime.Now - start).TotalMilliseconds > 5000) { throw new Exception($"Frontend socket bind timeout ({connectionString})"); } await Task.Delay(1000); } while (this.IsRunning && isListening) { await Task.Delay(1000); } poller.StopAsync(); frontendSocket.Disconnect(connectionString); monitor.DetachFromPoller(); monitor.Stop(); } } catch (Exception ex) { this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace); } } }
static void Main(string[] args) { Console.WriteLine("Press any key to start!"); Console.Read(); NetMQPoller Poller2 = new NetMQPoller(); NetMQQueue <int> Queue = new NetMQQueue <int>(); var index = 0; var client = new DealerSocket(">tcp://127.0.0.1:5001"); prereceivecount = testcount; new Thread(() => { while (true) { Console.WriteLine($"send:{(sendcount) / 10}/s,receive:{(receivecount) / 10}/s"); sendcount = 0; receivecount = 0; Thread.Sleep(1000 * 10); } }).Start(); new Thread(() => { while (true) { if (prereceivecount >= testcount) { prereceivecount = 0; for (var i = 0; i < testcount; i++) { Queue.Enqueue(++index); } } Thread.Sleep(0); } }).Start(); client.Options.Identity = Encoding.UTF8.GetBytes($"clientid-{Process.GetCurrentProcess().Id}"); client.ReceiveReady += (s, e) => { e.Socket.ReceiveFrameBytes(); var msg = e.Socket.ReceiveFrameString(); //Console.WriteLine($"RECEIVE:{msg}"); receivecount++; prereceivecount++; }; Queue.ReceiveReady += (s, e) => { var msg = e.Queue.Dequeue(); client.SendMoreFrameEmpty().SendFrame($"{Encoding.UTF8.GetString(client.Options.Identity)}-{msg}"); //Console.WriteLine($"SEND:{msg}"); sendcount++; }; Poller2.Add(Queue); Poller2.Add(client); Poller2.RunAsync(); Console.WriteLine("Press any key to stop!"); Console.Read(); }
public async Task <bool> RunSimulationAsync(Options options, TextWriter logger, CancellationToken token = default) { Logger = logger; try { Id = options.Id; _socket = new DealerSocket(); _socket.Options.Linger = TimeSpan.FromSeconds(30); _socket.Options.Identity = Encoding.ASCII.GetBytes(Id); if (options.Connect) { _socket.Connect(options.URL); } else { _socket.Bind(options.URL); } using (Outgoing = new NetMQQueue <NetMQMessage>()) { using var poller = new NetMQPoller() { _socket, Outgoing }; _socket.ReceiveReady += (sender, e) => { var msg = _socket.ReceiveMultipartMessage(); if (msg.FrameCount < 3) { logger.WriteLine($"Received message with only {msg.FrameCount} frames."); return; } var type = msg[1].ConvertToString(); logger.WriteLine($"Received {type} message."); switch (type) { case "crane": OnCraneMessageReceived(msg[2].Buffer); break; case "sim": OnSimMessageReceived(msg[2].Buffer); break; default: //Console.WriteLine($"Received message with unmapped type {type}"); break; } }; Outgoing.ReceiveReady += (sender, e) => { var msg = Outgoing.Dequeue(); if (_socket.TrySendMultipartMessage(TimeSpan.FromMinutes(1), msg)) // Note that for policyruns (virtual time) a lot of events are generated { logger.WriteLine($"Sent {msg[1].ConvertToString()} message."); } //else logger.WriteLine($"Discarded outgoing {msg[1].ConvertToString()} message."); }; if (!options.RunSync || options.Connect) { poller.RunAsync(); } if (!string.IsNullOrEmpty(options.SettingsPath)) { if (options.SettingsPath.Equals("Default", StringComparison.OrdinalIgnoreCase)) { logger.WriteLine("Using default settings"); _settingsReceived.SetResult(GetDefaultSettings()); } else { logger.WriteLine($"Reading settings from {options.SettingsPath}"); _settingsReceived.SetResult(File.ReadAllBytes(options.SettingsPath)); } } var result = false; try { if (!options.RunSync) { result = await RunSimulationAsync(await _settingsReceived.Task, options.PolicyRun); // wait until the outgoing queue is cleared var remaining = Outgoing.Count; while (remaining > 0) { await Task.Delay(1000, token); if (Outgoing.Count == remaining) { break; // assume nobody is listening for world states } remaining = Outgoing.Count; } } else { result = RunSimulation(await _settingsReceived.Task, options.SyncURL, options.Id); } } finally { poller.Stop(); } return(result); } } finally { DisposeSocket(); } }
private async Task Handler() { while (this.IsRunning) { try { bool isListening = false; var connectionString = this.FrontendEndpoint.ToConnectionString(); using (var frontendSocket = new RouterSocket()) using (this.frontendBuffer = new NetMQQueue <TransportMessage>()) using (var poller = new NetMQPoller() { frontendSocket, this.frontendBuffer }) using (var monitor = new NetMQ.Monitoring.NetMQMonitor(frontendSocket, $"inproc://monitor.forwarderdevice.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Accepted | SocketEvents.Disconnected | SocketEvents.Closed)) { frontendSocket.ReceiveReady += (sender, e) => { try { var netmqMessage = new NetMQMessage(); while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage)) { var message = netmqMessage.ToMessage(out var envelope); //var sourceEnvelope = message.Envelope; this.OnFrontendReceived(message); var forwardStart = DateTime.UtcNow; RegisteredBackend registeredBackend = null; while (this.IsRunning && registeredBackend == null) { while (this.backendEndpointIds.TryDequeue(out string backendIdentifier)) { if (this.backendEndpoints.TryGetValue(backendIdentifier, out RegisteredBackend candidateBackend)) { this.backendEndpointIds.Enqueue(backendIdentifier); if (candidateBackend.IsConnected) { registeredBackend = this.backendEndpoints[backendIdentifier]; break; } } //if ((DateTime.UtcNow - registeredBackend.RegisteredDate).TotalMilliseconds < 10000) //{ // this.backendEndpointIds.Enqueue(backendIdentifier); // break; //} //else //{ // if (this.backendEndpoints.TryRemove(backendIdentifier, out RegisteredBackend expiredBackend)) // { // Console.WriteLine($"Backend {backendIdentifier} expired"); // expiredBackend.Close().ContinueWith((result) => // { // Console.WriteLine($"Backend {backendIdentifier} closed"); // }); // } //} } if (registeredBackend != null || (DateTime.Now - forwardStart).TotalMilliseconds > 30000) { break; } System.Threading.Thread.Sleep(100); } if (registeredBackend != null) { message.Metadata.Add($"envelope[{this.Identity}]", envelope); registeredBackend.BackendBuffer.Enqueue(message); } else { Console.WriteLine("No backends available!!!"); var nmqm = MessageHelpers.CreateNetMQErrorMessage(envelope, "No backends found", message.Metadata); e.Socket.SendMultipartMessage(nmqm); } } } catch (Exception ex) { Console.WriteLine(ex.Message + ": " + ex.StackTrace); } }; this.frontendBuffer.ReceiveReady += (sender, e) => { try { while (this.frontendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero)) { if (!message.Metadata.TryPluck($"envelope[{this.Identity}]", out var envelope)) { throw new Exception("Message envelope not found"); } this.OnBackendForwarded(message); if (!frontendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope))) { Console.WriteLine("Failed to forward to frontend"); } } } catch (Exception ex) { Console.WriteLine(ex.Message + ": " + ex.StackTrace); } }; monitor.Listening += (sender, e) => { Console.WriteLine($"Frontend router socket listening at {connectionString}"); isListening = true; }; monitor.Closed += (sender, e) => { Console.WriteLine($"Frontend router socket closed on {connectionString}"); isListening = false; }; monitor.Accepted += (sender, e) => { Console.WriteLine($"Frontend router socket connection accepted at {connectionString}"); }; monitor.Disconnected += (sender, e) => { Console.WriteLine($"Frontend router socket disconnected at {connectionString}"); }; Console.WriteLine($"Attempting to bind frontend socket to {connectionString}"); monitor.StartAsync(); monitor.AttachToPoller(poller); var pollerTask = new Task(poller.Run); pollerTask.ContinueWith((Task task) => { var ex = task.Exception; Console.WriteLine(ex.Message + ": " + ex.StackTrace); isListening = false; }, TaskContinuationOptions.OnlyOnFaulted); pollerTask.Start(); frontendSocket.Bind(connectionString); var start = DateTime.Now; while (!isListening) { if ((DateTime.Now - start).TotalMilliseconds > 5000) { throw new Exception($"Frontend socket bind timeout ({connectionString})"); } await Task.Delay(1000); } while (this.IsRunning && isListening) { await Task.Delay(1000); } poller.StopAsync(); frontendSocket.Disconnect(connectionString); monitor.DetachFromPoller(); monitor.Stop(); } } catch (Exception ex) { Console.WriteLine(ex.Message + ": " + ex.StackTrace); } } }
static void Main(string[] args) { var proxy1 = new Proxy(new RouterSocket("@tcp://*:5001"), new DealerSocket("@tcp://*:5002")); Task.Factory.StartNew(proxy1.Start); var dealer = new DealerSocket(">tcp://127.0.0.1:5002"); var queue = new NetMQQueue <NetMQMessage>(); var poller = new NetMQPoller { dealer, queue }; var show = false; dealer.ReceiveReady += (s, e) => { var clientmessage = e.Socket.ReceiveMultipartMessage(); Task.Factory.StartNew((o) => { var cmsg = (NetMQMessage)o; var address = cmsg.First().ConvertToString(); var msg = cmsg.Last().ConvertToString() + "-OK"; var servermessage = new NetMQMessage(3); servermessage.Append(address);//fortest servermessage.AppendEmptyFrame(); servermessage.Append(msg); //var r = random.NextDouble(); //if (r > 0 && r < 0.78) //{ // Thread.Sleep(random.Next(1, 51)); //} //else if (r >= 0.78 & r < 0.78 + 0.21) //{ // Thread.Sleep(random.Next(51, 101)); //} //else //{ // Thread.Sleep(random.Next(101, 300)); //} queue.Enqueue(servermessage); //if (show) // Console.WriteLine(msg); }, clientmessage); if (show) { Console.WriteLine(1); } }; queue.ReceiveReady += (s, e) => { var msg = e.Queue.Dequeue(); dealer.SendMultipartMessage(msg); }; poller.RunAsync(); //for (var i = 0; i < 5; i++) //{ // Task.Factory.StartNew(() => // { // while (true) // { // var servermessage = new NetMQMessage(3); // servermessage.Append(Encoding.UTF8.GetBytes("dealerclient")); //for test // servermessage.AppendEmptyFrame(); // servermessage.Append($"================={DateTime.Now.ToString()}======================"); // queue.Enqueue(servermessage); // Thread.Sleep(1000); // } // }); //} Console.WriteLine("Press any key to stop!"); Console.Read(); show = true; Console.Read(); Console.Read(); Console.Read(); }
public XplaneConnectionManager(IEventBroker broker, IAppConfig config, IFsdManger fsdManager) : base(broker) { DealerSocket visualDealerSocket = null; mVisualDealerSockets = null; mConfig = config; mFsdManager = fsdManager; if (mConfig.VisualClientIPs.Count > 0) { foreach (string mIP in mConfig.VisualClientIPs) { visualDealerSocket = new DealerSocket(); visualDealerSocket.Options.Identity = Encoding.UTF8.GetBytes("CLIENT"); visualDealerSocket.Options.TcpKeepalive = true; try { visualDealerSocket.Connect("tcp://" + mIP + ":" + mConfig.TcpPort); if (mVisualDealerSockets == null) { mVisualDealerSockets = new List <DealerSocket>(); } mVisualDealerSockets.Add(visualDealerSocket); } catch (AddressAlreadyInUseException) { NotificationPosted?.Invoke(this, new NotificationPostedEventArgs(NotificationType.Error, "Plugin port already in use. Please choose a different TCP port.")); } } } if (!string.IsNullOrEmpty(mConfig.SimClientIP)) { mSimulatorIP = mConfig.SimClientIP; } mMessageQueue = new NetMQQueue <string>(); mDealerSocket = new DealerSocket(); mDealerSocket.Options.TcpKeepalive = true; mDealerSocket.Options.Identity = Encoding.UTF8.GetBytes("CLIENT"); mDealerSocket.ReceiveReady += DealerSocket_ReceiveReady; try { mDealerSocket.Connect("tcp://" + mSimulatorIP + ":" + mConfig.TcpPort); } catch (AddressAlreadyInUseException) { NotificationPosted?.Invoke(this, new NotificationPostedEventArgs(NotificationType.Error, "Plugin port already in use. Please choose a different TCP port.")); } mPoller = new NetMQPoller { mDealerSocket, mMessageQueue }; if (!mPoller.IsRunning) { mPoller.RunAsync(); } mMessageQueue.ReceiveReady += (s, e) => { if (mMessageQueue.TryDequeue(out string msg, TimeSpan.FromMilliseconds(100))) { if (mDealerSocket != null) { mDealerSocket.SendFrame(msg); } if (mVisualDealerSockets != null && mVisualDealerSockets.Count > 0) { foreach (DealerSocket socket in mVisualDealerSockets) { socket.SendFrame(msg); } } } }; mXplaneConnector = new XPlaneConnector.XPlaneConnector(mSimulatorIP); mUserAircraftData = new UserAircraftData(); mRadioStackState = new UserAircraftRadioStack(); mGetXplaneDataTimer = new Timer { Interval = 10 }; mGetXplaneDataTimer.Tick += GetXplaneDataTimer_Tick; mGetXplaneDataTimer.Start(); mConnectionTimer = new Timer { Interval = 50 }; mConnectionTimer.Tick += ConnectionTimer_Tick; mConnectionTimer.Start(); mRetryConnectionTimer = new Timer { Interval = 1000 }; mRetryConnectionTimer.Tick += RetryConnectionTimer_Tick; mRetryConnectionTimer.Start(); mWhosOnlineListRefresh = new Timer { Interval = 5000 }; mWhosOnlineListRefresh.Tick += WhosOnlineListRefresh_Tick; SetupSubscribers(); if (!Directory.Exists(Path.Combine(mConfig.AppPath, "PluginLogs"))) { Directory.CreateDirectory(Path.Combine(mConfig.AppPath, "PluginLogs")); } var directory = new DirectoryInfo(Path.Combine(mConfig.AppPath, "PluginLogs")); var query = directory.GetFiles("*", SearchOption.AllDirectories); foreach (var file in query.OrderByDescending(file => file.CreationTime).Skip(10)) { file.Delete(); } mRawDataStream = new StreamWriter(Path.Combine(mConfig.AppPath, string.Format($"PluginLogs/PluginLog-{DateTime.UtcNow:yyyyMMddHHmmss}.log")), false); }
private async Task BackendHandler() { while (this.IsRunning) { try { while (this.RegisteredBackendIdentifiers.TryDequeue(out string identifier)) { } bool isListening = false; var connectionString = this.BackendEndpoint.ToConnectionString(); using (var backendSocket = new RouterSocket()) using (this.AltBackendBuffer = new NetMQQueue <TransportMessage>()) using (var poller = new NetMQPoller() { backendSocket, this.AltBackendBuffer }) using (var monitor = new NetMQ.Monitoring.NetMQMonitor(backendSocket, $"inproc://monitor.routerdevice.backend.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Disconnected | SocketEvents.Closed | SocketEvents.BindFailed)) { backendSocket.ReceiveReady += (sender, e) => { try { //Console.WriteLine("Backend message received"); //Console.WriteLine($"RECEIVED BACKEND ({this.BackendSocket.HasIn}) ({this.BackendSocket.HasOut})"); var netmqMessage = new NetMQMessage(); while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage)) { var message = netmqMessage.ToMessage(out var envelope); this.OnBackendReceived(message); //this.BackendBuffer.Enqueue(message); if (message.Metadata.TryPluck("Greeting", out var encodedGreeting)) { var identifier = BitConverter.ToString(envelope); if (this.RegisteredBackends.TryAdd(identifier, new RegisteredBackend(envelope, DateTime.UtcNow))) { Console.WriteLine($"Backend registered [ {identifier} ]"); this.RegisteredBackendIdentifiers.Enqueue(identifier); } else { this.RegisteredBackends[identifier].RegsiteredDate = DateTime.UtcNow; } } else { this.AltFrontendBuffer.Enqueue(message); } } } catch (Exception ex) { Console.WriteLine(ex.Message + ": " + ex.StackTrace); } }; //var lastFlushed = DateTime.UtcNow; //backendSocket.SendReady += (sender, e) => //{ // try // { // if (!this.FrontendBuffer.IsEmpty) // { // while (this.FrontendBuffer.TryDequeue(out Message message)) // { // Console.WriteLine("Frontend forwarding"); // if (!e.Socket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(true))) // { // Console.WriteLine("Failed to forward to backend"); // //var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope); // //this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true)); // } // } // lastFlushed = DateTime.UtcNow; // } // if ((DateTime.UtcNow - lastFlushed).TotalSeconds > 1) // Task.Delay(1).Wait(); // } // catch (Exception ex) // { // Console.WriteLine(ex.Message + ": " + ex.StackTrace); // } //}; this.AltBackendBuffer.ReceiveReady += (sender, e) => { try { while (this.AltBackendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero)) { if (!message.Metadata.TryPluck($"backendEnvelope[{this.Identity}]", out var envelope)) { throw new Exception("Message backend envelope not found"); } this.OnFrontendForwarded(message); if (!backendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope))) { Console.WriteLine("Failed to forward to backend"); //var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope); //this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true)); } } } catch (Exception ex) { Console.WriteLine(ex.Message + ": " + ex.StackTrace); } }; monitor.Listening += (sender, e) => { Console.WriteLine($"Backend router socket listening at {connectionString}"); isListening = true; }; monitor.Closed += (sender, e) => { Console.WriteLine($"Backend router socket accepted connection on {connectionString}"); isListening = false; }; monitor.Disconnected += (sender, e) => { Console.WriteLine($"Backend router socket disconnected at {connectionString}"); }; monitor.BindFailed += (sender, e) => { Console.WriteLine($"Backend router bind failed {connectionString}"); }; Console.WriteLine($"Attempting to bind backend socket to {connectionString}"); monitor.StartAsync(); monitor.AttachToPoller(poller); var pollerTask = new Task(poller.Run); pollerTask.ContinueWith((Task task) => { var ex = task.Exception; Console.WriteLine(ex.Message + ": " + ex.StackTrace); isListening = false; }, TaskContinuationOptions.OnlyOnFaulted); pollerTask.Start(); backendSocket.Bind(connectionString); var start = DateTime.Now; while (!isListening) { if ((DateTime.Now - start).TotalMilliseconds > 5000) { throw new Exception($"Backend socket bind timeout ({connectionString})"); } await Task.Delay(1000); } while (this.IsRunning && isListening) { if (this.BackendAnnouncer != null) { //Console.WriteLine("Registering backend"); await this.BackendAnnouncer.Register(this.BackendEndpoint); } await Task.Delay(1000); } poller.StopAsync(); backendSocket.Disconnect(connectionString); monitor.DetachFromPoller(); monitor.Stop(); } } catch (Exception ex) { Console.WriteLine(ex.Message + ": " + ex.StackTrace); } } }