public NetMQScheduler(NetMQContext context, Poller poller = null) { m_context = context; if (poller == null) { m_ownPoller = true; m_poller = new Poller(); } else { m_ownPoller = false; m_poller = poller; } m_clientSockets = new ConcurrentBag <NetMQSocket>(); m_schedulerId = Interlocked.Increment(ref s_schedulerCounter); m_address = string.Format("{0}://scheduler-{1}", NetMQ.zmq.Address.InProcProtocol, m_schedulerId); m_serverSocket = context.CreatePullSocket(); m_serverSocket.Options.Linger = TimeSpan.Zero; m_serverSocket.Bind(m_address); m_currentMessageHandler = OnMessageFirstTime; m_serverSocket.ReceiveReady += m_currentMessageHandler; m_poller.AddSocket(m_serverSocket); m_clientSocket = new ThreadLocal <NetMQSocket>(() => { var socket = m_context.CreatePushSocket(); socket.Connect(m_address); m_clientSockets.Add(socket); return(socket); }); m_schedulerThread = new ThreadLocal <bool>(() => false); if (m_ownPoller) { Task.Factory.StartNew(m_poller.Start, TaskCreationOptions.LongRunning); } }
public static Task <(string, bool)> ReceiveFrameStringAsync( [NotNull] this NetMQSocket socket, [NotNull] Encoding encoding, CancellationToken cancellationToken = default(CancellationToken)) { if (NetMQRuntime.Current == null) { throw new InvalidOperationException("NetMQRuntime must be created before calling async functions"); } socket.AttachToRuntime(); var msg = new Msg(); msg.InitEmpty(); if (socket.TryReceive(ref msg, TimeSpan.Zero)) { var str = msg.Size > 0 ? encoding.GetString(msg.Data, msg.Offset, msg.Size) : string.Empty; msg.Close(); return(Task.FromResult((str, msg.HasMore))); } TaskCompletionSource <(string, bool)> source = new TaskCompletionSource <(string, bool)>(); cancellationToken.Register(() => source.SetCanceled()); void Listener(object sender, NetMQSocketEventArgs args) { if (socket.TryReceive(ref msg, TimeSpan.Zero)) { var str = msg.Size > 0 ? encoding.GetString(msg.Data, msg.Offset, msg.Size) : string.Empty; bool more = msg.HasMore; msg.Close(); socket.ReceiveReady -= Listener; source.SetResult((str, more)); } } socket.ReceiveReady += Listener; return(source.Task); }
public void RunPipeline(Sockets.PairSocket shim) { m_pipe = shim; shim.SignalOK(); while (!m_terminated) { PollItem[] pollItems = new PollItem[] { new PollItem(m_pipe.SocketHandle, PollEvents.PollIn), new PollItem(m_udpSocket, PollEvents.PollIn), }; long timeout = -1; if (m_transmit != null) { timeout = m_pingAt - Clock.NowMs(); if (timeout < 0) { timeout = 0; } } ZMQ.Poll(pollItems, m_udpSocket != null ? 2 : 1, (int)timeout); if (pollItems[0].ResultEvent.HasFlag(PollEvents.PollIn)) { HandlePipe(); } if (pollItems[1].ResultEvent.HasFlag(PollEvents.PollIn)) { HandleUdp(); } if (m_transmit != null && Clock.NowMs() > m_pingAt) { SendUdpFrame(m_transmit); m_pingAt = Clock.NowMs() + m_interval; } } m_udpSocket.Dispose(); }
public void RemoveSocket(NetMQSocket socket) { if (socket == null) { throw new ArgumentNullException("stock"); } if (m_disposed) { throw new ObjectDisposedException("Poller is disposed"); } socket.EventsChanged -= OnSocketEventsChanged; m_sockets.Remove(socket); m_isDirty = true; }
/// <summary> /// Receive a single frame from <paramref name="socket"/>, asynchronously. /// </summary> /// <param name="socket">The socket to receive from.</param> /// <param name="cancellationToken">The token used to propagate notification that this operation should be canceled.</param> /// <returns>The content of the received message frame and boolean indicate if another frame of the same message follows.</returns> public static Task <(byte[], bool)> ReceiveFrameBytesAsync( this NetMQSocket socket, CancellationToken cancellationToken = default(CancellationToken) ) { if (NetMQRuntime.Current == null) { throw new InvalidOperationException("NetMQRuntime must be created before calling async functions"); } socket.AttachToRuntime(); var msg = new Msg(); msg.InitEmpty(); if (socket.TryReceive(ref msg, TimeSpan.Zero)) { var data = msg.CloneData(); bool more = msg.HasMore; msg.Close(); return(Task.FromResult((data, more))); } TaskCompletionSource <(byte[], bool)> source = new TaskCompletionSource <(byte[], bool)>(); cancellationToken.Register(() => source.SetCanceled()); void Listener(object sender, NetMQSocketEventArgs args) { if (socket.TryReceive(ref msg, TimeSpan.Zero)) { var data = msg.CloneData(); bool more = msg.HasMore; msg.Close(); socket.ReceiveReady -= Listener; source.SetResult((data, more)); } } socket.ReceiveReady += Listener; return(source.Task); }
/// <summary> /// Create a new instance of a Proxy (NetMQ.Proxy) /// with the given sockets to serve as a front-end, a back-end, and a control socket. /// </summary> /// <param name="frontend">the socket that messages will be forwarded from</param> /// <param name="backend">the socket that messages will be forwarded to</param> /// <param name="control">this socket will have messages also sent to it - you can set this to null if not needed</param> /// <param name="poller">an optional external poller to use within this proxy</param> /// <exception cref="InvalidOperationException"><paramref name="poller"/> is not <c>null</c> and either <paramref name="frontend"/> or <paramref name="backend"/> are not contained within it.</exception> public Proxy([NotNull] NetMQSocket frontend, [NotNull] NetMQSocket backend, [CanBeNull] NetMQSocket control = null, Poller poller = null) { if (poller != null) { if (!poller.ContainsSocket(backend) || !poller.ContainsSocket(frontend)) { throw new InvalidOperationException("When using an external poller, both the frontend and backend sockets must be added to it."); } m_externalPoller = true; m_poller = poller; } m_frontend = frontend; m_backend = backend; m_control = control; }
public static Task SendFrameAsync( this NetMQSocket socket, byte[] data, bool more = false, CancellationToken cancellationToken = default(CancellationToken) ) { if (NetMQRuntime.Current == null) { throw new InvalidOperationException("NetMQRuntime must be created before calling async functions"); } if (data == null) { throw new ArgumentNullException(nameof(data)); } socket.AttachToRuntime(); if (socket.TrySendFrame(TimeSpan.Zero, data, more)) { return(Task.CompletedTask); } TaskCompletionSource <object> source = new TaskCompletionSource <object>(); cancellationToken.Register(() => { socket.SendReady -= Listener; source.TrySetCanceled(); }); void Listener(object sender, NetMQSocketEventArgs args) { if (socket.TrySendFrame(TimeSpan.Zero, data, more)) { socket.SendReady -= Listener; source.TrySetResult(null); } } socket.SendReady += Listener; return(source.Task); }
public NetMQScheduler(NetMQContext context, Poller poller = null) { m_context = context; if (poller == null) { m_ownPoller = true; m_poller = new Poller(); } else { m_ownPoller = false; m_poller = poller; } m_tasksQueue = new ConcurrentQueue <Task>(); m_syncObject = new object(); m_schedulerId = Interlocked.Increment(ref s_schedulerCounter); m_address = string.Format("{0}://scheduler-{1}", NetMQ.zmq.Address.InProcProtocol, m_schedulerId); m_serverSocket = context.CreatePullSocket(); m_serverSocket.Options.Linger = TimeSpan.Zero; m_serverSocket.Bind(m_address); m_currentMessageHandler = OnMessageFirstTime; m_serverSocket.ReceiveReady += m_currentMessageHandler; m_poller.AddSocket(m_serverSocket); m_clientSocket = m_context.CreatePushSocket(); m_clientSocket.Connect(m_address); m_schedulerThread = new ThreadLocal <bool>(() => false); if (m_ownPoller) { m_poller.PollTillCancelledNonBlocking(); } }
/// <summary> /// Receive a single frame from <paramref name="socket"/>, asynchronously. /// </summary> /// <param name="socket">The socket to receive from.</param> /// <param name="expectedFrameCount">Specifies the initial capacity of the <see cref="List{T}"/> used /// to buffer results. If the number of frames is known, set it here. If more frames arrive than expected, /// an extra allocation will occur, but the result will still be correct.</param> /// <param name="cancellationToken">The token used to propagate notification that this operation should be canceled.</param> /// <returns>The content of the received message.</returns> public static async Task <NetMQMessage> ReceiveMultipartMessageAsync( this NetMQSocket socket, int expectedFrameCount = 4, CancellationToken cancellationToken = default(CancellationToken)) { var message = new NetMQMessage(expectedFrameCount); while (true) { (byte[] bytes, bool more) = await socket.ReceiveFrameBytesAsync(cancellationToken); message.Append(bytes); if (!more) { break; } } return(message); }
public void Run(PairSocket shim) { m_pipe = shim; shim.SignalOK(); m_pipe.ReceiveReady += OnPipeReady; m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero); m_pingTimer.Elapsed += PingElapsed; m_pingTimer.Enable = false; m_poller = new NetMQPoller { m_pipe, m_pingTimer }; m_poller.Run(); // the beacon might never been configured m_udpSocket?.Close(); }
public static NetMQMessage ReceiveMessage(this NetMQSocket socket, TimeSpan timeout) { var item = new PollItem(socket.SocketHandle, PollEvents.PollIn); var items = new[] { item }; ZMQ.Poll(items, (int)timeout.TotalMilliseconds); if (item.ResultEvent.HasFlag(PollEvents.PollError) && !socket.IgnoreErrors) { throw new ErrorPollingException("Error while polling", socket); } if (!item.ResultEvent.HasFlag(PollEvents.PollIn)) { return(null); } var msg = socket.ReceiveMessage(); return(msg); }
/// <summary> /// Receive a single frame from <paramref name="socket"/>, asynchronously, then ignore its content. /// </summary> /// <param name="socket">The socket to receive from.</param> /// <returns>Boolean indicate if another frame of the same message follows</returns> public static Task <bool> SkipFrameAsync([NotNull] this NetMQSocket socket) { if (NetMQRuntime.Current == null) { throw new InvalidOperationException("NetMQRuntime must be created before calling async functions"); } socket.AttachToRuntime(); var msg = new Msg(); msg.InitEmpty(); if (socket.TryReceive(ref msg, TimeSpan.Zero)) { bool more = msg.HasMore; msg.Close(); return(more ? s_trueTask : s_falseTask); } TaskCompletionSource <bool> source = new TaskCompletionSource <bool>(); void Listener(object sender, NetMQSocketEventArgs args) { if (socket.TryReceive(ref msg, TimeSpan.Zero)) { bool more = msg.HasMore; msg.Close(); socket.ReceiveReady -= Listener; source.SetResult(more); } } socket.ReceiveReady += Listener; return(source.Task); }
public void AddSocket(NetMQSocket socket) { if (socket == null) { throw new ArgumentNullException("stock"); } if (m_sockets.Contains(socket)) { throw new ArgumentException("Socket already added to poller"); } if (m_disposed) { throw new ObjectDisposedException("Poller is disposed"); } m_sockets.Add(socket); socket.EventsChanged += OnSocketEventsChanged; m_isDirty = true; }
private NetMQScheduler(Poller poller, PushSocket pushSocket, PullSocket pullSocket) { if (poller == null) { m_ownPoller = true; m_poller = new Poller(); } else { m_ownPoller = false; m_poller = poller; } var address = string.Format("{0}://scheduler-{1}", Address.InProcProtocol, Interlocked.Increment(ref s_schedulerCounter)); m_serverSocket = pullSocket; m_serverSocket.Options.Linger = TimeSpan.Zero; m_serverSocket.Bind(address); m_currentMessageHandler = OnMessageFirstTime; m_serverSocket.ReceiveReady += m_currentMessageHandler; m_poller.AddSocket(m_serverSocket); m_clientSocket = pushSocket; m_clientSocket.Connect(address); m_isSchedulerThread = new ThreadLocal <bool>(() => false); if (m_ownPoller) { m_poller.PollTillCancelledNonBlocking(); } }
public void Run(PairSocket shim) { m_pipe = shim; shim.SignalOK(); m_pipe.ReceiveReady += OnPipeReady; m_pingTimer = new NetMQTimer(0); m_pingTimer.Elapsed += PingElapsed; m_pingTimer.Enable = false; m_poller = new Poller(); m_poller.AddSocket(m_pipe); m_poller.AddTimer(m_pingTimer); m_poller.PollTillCancelled(); // the beacon might never been configured if (m_udpSocket != null) { m_udpSocket.Close(); } }
/// <summary> /// Runs the poller on the caller's thread. Only returns when <see cref="Stop"/> or <see cref="StopAsync"/> are called from another thread. /// </summary> private void RunPoller() { try { // Recalculate all timers now foreach (var timer in m_timers) { if (timer.Enable) { timer.When = Clock.NowMs() + timer.Interval; } } // Run until stop is requested while (!m_stopSignaler.IsStopRequested) { if (m_isPollSetDirty) { RebuildPollset(); } var pollStart = Clock.NowMs(); // Set tickless to "infinity" long tickless = pollStart + int.MaxValue; // Find the When-value of the earliest timer.. foreach (var timer in m_timers) { // If it is enabled but no When is set yet, if (timer.When == -1 && timer.Enable) { // Set this timer's When to now plus it's Interval. timer.When = pollStart + timer.Interval; } // If it has a When and that is earlier than the earliest found thus far, if (timer.When != -1 && tickless > timer.When) { // save that value. tickless = timer.When; } } // Compute a timeout value - how many milliseconds from now that the earliest-timer will expire. var timeout = tickless - pollStart; // Use zero to indicate it has already expired. if (timeout < 0) { timeout = 0; } var isItemAvailable = false; if (m_pollSet.Length != 0) { isItemAvailable = m_netMqSelector.Select(m_pollSet, m_pollSet.Length, timeout); } else if (timeout > 0) { //TODO: Do we really want to simply sleep and return, doing nothing during this interval? //TODO: Should a large value be passed it will sleep for a month literally. // Solution should be different, but sleep is more natural here than in selector (timers are not selector concern). Debug.Assert(timeout <= int.MaxValue); Thread.Sleep((int)timeout); } // Get the expected end time in case we time out. This looks redundant but, unfortunately, // it happens that Poll takes slightly less than the requested time and 'Clock.NowMs() >= timer.When' // may not true, even if it is supposed to be. In other words, even when Poll times out, it happens // that 'Clock.NowMs() < pollStart + timeout' var expectedPollEnd = !isItemAvailable ? pollStart + timeout : -1L; // that way we make sure we can continue the loop if new timers are added. // timers cannot be removed foreach (var timer in m_timers) { if ((Clock.NowMs() >= timer.When || expectedPollEnd >= timer.When) && timer.When != -1) { timer.InvokeElapsed(this); if (timer.Enable) { timer.When = Clock.NowMs() + timer.Interval; } } } for (var i = 0; i < m_pollSet.Length; i++) { NetMQSelector.Item item = m_pollSet[i]; if (item.Socket != null) { NetMQSocket socket = m_pollact[i]; if (item.ResultEvent.HasError()) { if (++socket.Errors > 1) { Remove(socket); item.ResultEvent = PollEvents.None; } } else { socket.Errors = 0; } if (item.ResultEvent != PollEvents.None) { socket.InvokeEvents(this, item.ResultEvent); } } else if (item.ResultEvent.HasError() || item.ResultEvent.HasIn()) { if (m_pollinSockets.TryGetValue(item.FileDescriptor, out Action <Socket> action)) { action(item.FileDescriptor); } } } } #if !NET35 // Try to dequeue and execute all pending tasks before stopping poller while (m_tasksQueue.TryDequeue(out Task task, TimeSpan.Zero)) { TryExecuteTask(task); } #endif } finally { foreach (var socket in m_sockets.ToList()) { Remove(socket); } } }
/// <summary> /// Poll as long as the given Func evaluates to true. /// </summary> /// <param name="condition">a Func that returns a boolean value, to evaluate on each poll-iteration to decide when to exit the loop</param> /// <exception cref="ObjectDisposedException">This poller must not have already been disposed.</exception> /// <exception cref="InvalidOperationException">This poller must not have already been started.</exception> private void PollWhile([NotNull, InstantHandle] Func <bool> condition) { if (m_disposed) { throw new ObjectDisposedException("Poller is disposed"); } if (m_isStarted) { throw new InvalidOperationException("Poller is started"); } if (Thread.CurrentThread.Name == null) { Thread.CurrentThread.Name = "NetMQPollerThread"; } m_isStoppedEvent.Reset(); m_isStarted = true; try { // the sockets may have been created in another thread, to make sure we can fully use them we do full memory barrier // at the beginning of the loop Thread.MemoryBarrier(); // Recalculate all timers now foreach (var timer in m_timers) { if (timer.Enable) { timer.When = Clock.NowMs() + timer.Interval; } } // Do this until the given Func evaluates to false... while (condition()) { if (m_isDirty) { RebuildPollset(); } var pollStart = Clock.NowMs(); var timeout = TicklessTimer(); var isItemsAvailable = false; if (m_pollSize > 0) { isItemsAvailable = m_selector.Select(m_pollset, m_pollSize, timeout); } else { // Don't pass anything less than 0 to sleep or risk an out of range exception or worse - infinity. Do not sleep on 0 from orginal code. if (timeout > 0) { //TODO: Do we really want to simply sleep and return, doing nothing during this interval? //TODO: Should a large value be passed it will sleep for a month literaly. // Solution should be different, but sleep is more natural here than in selector (timers are not selector concern). Thread.Sleep(timeout); } } // Get the expected end time in case we time out. This looks redundant but, unfortunately, // it happens that Poll takes slightly less than the requested time and 'Clock.NowMs() >= timer.When' // may not true, even if it is supposed to be. In other words, even when Poll times out, it happens // that 'Clock.NowMs() < pollStart + timeout' var expectedPollEnd = !isItemsAvailable ? pollStart + timeout : -1; // that way we make sure we can continue the loop if new timers are added. // timers cannot be removed int timersCount = m_timers.Count; for (int i = 0; i < timersCount; i++) { var timer = m_timers[i]; if ((Clock.NowMs() >= timer.When || expectedPollEnd >= timer.When) && timer.When != -1) { timer.InvokeElapsed(this); if (timer.Enable) { timer.When = timer.Interval + Clock.NowMs(); } } } for (int itemNbr = 0; itemNbr < m_pollSize; itemNbr++) { SelectItem item = m_pollset[itemNbr]; if (item.Socket != null) { NetMQSocket socket = m_pollact[itemNbr]; if (item.ResultEvent.HasError()) { socket.Errors++; if (socket.Errors > 1) { RemoveSocket(socket); item.ResultEvent = PollEvents.None; } } else { socket.Errors = 0; } if (item.ResultEvent != PollEvents.None) { socket.InvokeEvents(this, item.ResultEvent); } } else { if (item.ResultEvent.HasError() || item.ResultEvent.HasIn()) { Action <Socket> action; if (m_pollinSockets.TryGetValue(item.FileDescriptor, out action)) { action(item.FileDescriptor); } } } } if (m_zombies.Count > 0) { // Now handle any timer zombies // This is going to be slow if we have many zombies foreach (var netMQTimer in m_zombies) { m_timers.Remove(netMQTimer); } m_zombies.Clear(); } } } finally { try { foreach (var socket in m_sockets.ToList()) { RemoveSocket(socket); } } finally { m_isStarted = false; m_isStoppedEvent.Set(); } } }
public void Add(NetMQSocket socket) { m_poller.Add(socket); m_sockets.Add(socket); }
public void Remove(NetMQSocket socket) { m_poller.Remove(socket); m_sockets.Remove(socket); }
/// <summary> /// Create a new instance of a Proxy (NetMQ.Proxy) /// with the given sockets to serve as a front-end, a back-end, and a control socket. /// </summary> /// <param name="frontend">the socket that messages will be forwarded from</param> /// <param name="backend">the socket that messages will be forwarded to</param> /// <param name="controlIn">this socket will have incoming messages also sent to it - you can set this to null if not needed</param> /// <param name="controlOut">this socket will have outgoing messages also sent to it - you can set this to null if not needed</param> /// <param name="poller">an optional external poller to use within this proxy</param> public Proxy([NotNull] NetMQSocket frontend, [NotNull] NetMQSocket backend, [CanBeNull] NetMQSocket controlIn, [CanBeNull] NetMQSocket controlOut, [CanBeNull] INetMQPoller poller = null) { if (poller != null) { m_externalPoller = true; m_poller = poller; } m_frontend = frontend; m_backend = backend; m_controlIn = controlIn; m_controlOut = controlOut ?? controlIn; }
/// <summary> /// Create a new instance of a Proxy (NetMQ.Proxy) /// with the given sockets to serve as a front-end, a back-end, and a control socket. /// </summary> /// <param name="frontend">the socket that messages will be forwarded from</param> /// <param name="backend">the socket that messages will be forwarded to</param> /// <param name="control">this socket will have messages also sent to it - you can set this to null if not needed</param> /// <param name="poller">an optional external poller to use within this proxy</param> /// <exception cref="InvalidOperationException"><paramref name="poller"/> is not <c>null</c> and either <paramref name="frontend"/> or <paramref name="backend"/> are not contained within it.</exception> public Proxy([NotNull] NetMQSocket frontend, [NotNull] NetMQSocket backend, [CanBeNull] NetMQSocket control = null, [CanBeNull] INetMQPoller poller = null) : this(frontend, backend, control, null, poller) { }
public SocketOptions([NotNull] NetMQSocket socket) { m_socket = socket; }
/// <summary> /// Create a new SocketOptions that references the given NetMQSocket. /// </summary> /// <param name="socket">the NetMQSocket for this SocketOptions to hold a reference to</param> public SocketOptions(NetMQSocket socket) { m_socket = socket; }
/// <summary> /// Create a new NetMQSocketEventArgs referencing the given socket. /// </summary> /// <param name="socket">the NetMQSocket that this is about</param> public NetMQSocketEventArgs([NotNull] NetMQSocket socket) { Socket = socket; }
public Proxy(NetMQSocket frontend, NetMQSocket backend, NetMQSocket control) { m_frontend = frontend; m_backend = backend; m_control = control; }
internal static Context CreateContext(Model.IUser user, Header header, Model.Model dbContext, NetMQ.NetMQSocket socket) { return(new Context() { Header = header, User = user, Socket = socket, DbContext = dbContext }); }
private void PollWhile(Func <bool> condition) { if (m_disposed) { throw new ObjectDisposedException("Poller is disposed"); } if (m_isStarted) { throw new InvalidOperationException("Poller is started"); } if (Thread.CurrentThread.Name == null) { Thread.CurrentThread.Name = "NetMQPollerThread"; } m_isStoppedEvent.Reset(); m_isStarted = true; try { // the sockets may have been created in another thread, to make sure we can fully use them we do full memory barried // at the begining of the loop Thread.MemoryBarrier(); // Recalculate all timers now foreach (NetMQTimer netMQTimer in m_timers) { if (netMQTimer.Enable) { netMQTimer.When = Clock.NowMs() + netMQTimer.Interval; } } while (condition()) { if (m_isDirty) { RebuildPollset(); } var pollStart = Clock.NowMs(); var timeout = TicklessTimer(); var nbEvents = ZMQ.Poll(m_pollset, m_pollSize, timeout); // Get the expected end time in case we time out. This looks redundant but, unfortunately, // it happens that Poll takes slightly less than the requested time and 'Clock.NowMs() >= timer.When' // may not true, even if it is supposed to be. In other words, even when Poll times out, it happens // that 'Clock.NowMs() < pollStart + timeout' var expectedPollEnd = nbEvents == 0 ? pollStart + timeout : -1; // that way we make sure we can continue the loop if new timers are added. // timers cannot be removed int timersCount = m_timers.Count; for (int i = 0; i < timersCount; i++) { var timer = m_timers[i]; if ((Clock.NowMs() >= timer.When || expectedPollEnd >= timer.When) && timer.When != -1) { timer.InvokeElapsed(this); if (timer.Enable) { timer.When = timer.Interval + Clock.NowMs(); } } } for (int itemNbr = 0; itemNbr < m_pollSize; itemNbr++) { PollItem item = m_pollset[itemNbr]; if (item.Socket != null) { NetMQSocket socket = m_pollact[itemNbr] as NetMQSocket; if (item.ResultEvent.HasFlag(PollEvents.PollError) && !socket.IgnoreErrors) { socket.Errors++; if (socket.Errors > 1) { RemoveSocket(socket); item.ResultEvent = PollEvents.None; } } else { socket.Errors = 0; } if (item.ResultEvent != PollEvents.None) { socket.InvokeEvents(this, item.ResultEvent); } } else { if (item.ResultEvent.HasFlag(PollEvents.PollError) || item.ResultEvent.HasFlag(PollEvents.PollIn)) { Action <Socket> action; if (m_pollinSockets.TryGetValue(item.FileDescriptor, out action)) { action(item.FileDescriptor); } } } } if (m_zombies.Any()) { // Now handle any timer zombies // This is going to be slow if we have many zombies foreach (NetMQTimer netMQTimer in m_zombies) { m_timers.Remove(netMQTimer); } m_zombies.Clear(); } } } finally { m_isStoppedEvent.Set(); foreach (var socket in m_sockets.ToList()) { RemoveSocket(socket); } } }
/// <summary> /// Create a new ErrorPollingException containing the given message and a reference to the given socket. /// </summary> /// <param name="message">the textual description of what gave rise to this exception, to be exposed as the Message property</param> /// <param name="socket">a reference to the socket, to be exposed via the Socket property</param> public ErrorPollingException(string message, NetMQSocket socket) : base(message) { Socket = socket; }
public PollerPollItem(NetMQSocket socket, PollEvents events) : base(socket.SocketHandle, events) { m_socket = socket; }
/// <summary> /// Gets whether <paramref name="socket"/> has been added to this <see cref="Poller"/>. /// </summary> public bool ContainsSocket(NetMQSocket socket) { return(m_sockets.Contains(socket)); }