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 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()); } }
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 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 virtual void Setup(INetManager netManager) { if (string.IsNullOrEmpty(PushsocketString)) { throw new ArgumentNullException(nameof(PushsocketString)); } if (string.IsNullOrEmpty(PullSocketString)) { throw new ArgumentNullException(nameof(PullSocketString)); } if (netManager == null) { throw new ArgumentNullException(nameof(netManager)); } if (!string.IsNullOrEmpty(XPubSocketString) && !string.IsNullOrEmpty(XSubSocketString)) { var PublisherSocket = new XPublisherSocket(XPubSocketString); var SubscriberSocket = new XSubscriberSocket(XSubSocketString); GlobalServerProxy = new Proxy(SubscriberSocket, PublisherSocket); } sender = new PushSocket(PushsocketString); responseSocket = new PullSocket(PullSocketString); Poller = new NetMQPoller() { sender, responseSocket, PushQueue }; NetSend = netManager; PushQueue.ReceiveReady += (o, args) => { var msg = PushQueue.Dequeue(); sender.SendMultipartMessage(msg); }; responseSocket.ReceiveReady += ProcessResponse; IsSetuped = 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)); } }
private void OnOutgoingQueueReady(object sender, NetMQQueueEventArgs <OutgoingMessage> e) { var outgoingMessage = m_outgoingQueue.Dequeue(); //var bodySegment = m_serializer.Serialize(outgoingMessage.Message); //byte[] body = new byte[bodySegment.Count]; //Buffer.BlockCopy(bodySegment.Array, bodySegment.Offset, body, 0, bodySegment.Count); UInt64 messageId = ++m_nextMessageId; m_nextMessageId = messageId; //string subject = m_serializer.GetObjectSubject(outgoingMessage.Message); //Console.WriteLine("Codec.Message.RelatedMessageId: " + messageId + " ; " + Codec.Error.RelatedMessageId); Codec.Id = Codec.MessageId.Message; Codec.Message.MessageId = messageId; Codec.Message.Service = outgoingMessage.Service; Codec.Message.Subject = ""; Codec.Message.Body = outgoingMessage.Message; Codec.Message.RelatedMessageId = 0; // one way message if (outgoingMessage.Oneway) { Codec.Message.OneWay = 1; } else { Codec.Message.OneWay = 0; // add to pending requests dictionary // TODO: we might want to create a pending message structure that will not hold reference to the message (can lead to GC second generation) var msg = new PendingMessage(messageId, outgoingMessage.TaskCompletionSource); m_pendingRequests.Add(messageId, msg); GC.KeepAlive(msg); GC.KeepAlive(outgoingMessage); } Codec.Send(m_clientSocket); }
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)); } }
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(); } }