private void OnDestroy() { Debug.Log("ZMQ Destroy: Teardown socket"); if (_pubSocket != null) { try { _pubSocket.Unbind("tcp://127.0.0.1:12345"); _pubSocket.Dispose(); } catch (ObjectDisposedException e) { Debug.LogWarning("PubSocket already disposed"); } } }
public void RunPipeline(PairSocket shim) { publisherSocket = context.CreatePublisherSocket(); publisherSocket.Bind("tcp://*:" + StreamingProtocol.Port); snapshotSocket = context.CreateResponseSocket(); snapshotSocket.Bind("tcp://*:" + SnapshotProtocol.Port); snapshotSocket.ReceiveReady += OnSnapshotReady; shim.ReceiveReady += OnShimReady; heartbeatTimer = new NetMQTimer(StreamingProtocol.HeartbeatInterval); heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed; shim.SignalOK(); poller = new Poller(); poller.AddSocket(shim); poller.AddSocket(snapshotSocket); poller.AddTimer(heartbeatTimer); poller.Start(); publisherSocket.Dispose(); snapshotSocket.Dispose(); }
public async Task <XtResult <TMessage> > PublishAsync <TMessage>(TMessage message) where TMessage : class, new() { PublisherSocket publisherSocket = null; try { publisherSocket = new PublisherSocket(); publisherSocket.Connect(_configuration.Address()); return(await Task.Run(() => { try { var msg = new PubSubMessage <TMessage>(_configuration, message); publisherSocket.SendMultipartMessage(msg); } catch (System.Exception ex) { return XtResult <TMessage> .Failed(ex, "publish"); } return XtResult <TMessage> .Success(message, "publish"); })); } catch (System.Exception ex) { return(XtResult <TMessage> .Failed(ex, "publish")); } finally { publisherSocket?.Dispose(); } }
public void Stop() { _subscribeThreadCancellation.Cancel(); _pingThreadCancellation.Cancel(); _subscribeThread.Join(); _pingThread.Join(); _subscribeThreadCancellation.Dispose(); _pingThreadCancellation.Dispose(); lock (_publishSocketLocker) { _publishSocket?.Disconnect(_publishAddress); } _subscribeSocket?.Disconnect(_subscribeAddress); lock (_publishSocketLocker) { _publishSocket?.Dispose(); } _subscribeSocket?.Dispose(); _messageHost?.Stop(); }
/// <summary> /// <para>Constructs a publisher socket.</para> /// </summary> /// <param name="address">Address to which to connect (for example: tcp://localhost:9001).</param> /// <param name="context">ZMQ Context.</param> /// <param name="verboseLog">Enable tracing of each event published.</param> /// <param name="traceWriter">Traces</param> internal Publisher(string address, NetMQContext context, bool verboseLog, ITraceWriter traceWriter) { if (context == null) { throw new ArgumentNullException("context"); } if (string.IsNullOrEmpty(address)) { throw new ArgumentNullException("address"); } if (traceWriter == null) { throw new ArgumentNullException("traceWriter"); } _traces = traceWriter; _verboseLog = verboseLog; _instanceHashCode = this.GetHashCode(); _socket = context.CreatePublisherSocket(); _socket.Options.SendHighWatermark = 100000; try { _socket.Connect(address); _traces.Debug("Publisher({0:x}) created ({1}).", _instanceHashCode, address); } catch (Exception ex) { _traces.Error(ex); _socket.Dispose(); throw; } }
public void Dispose() { lock (_lockObj) { try { if (SendEndOfFlag) { // 发送结束标志 foreach (string topic in strTopics) { _publisher.SendMoreFrame(topic).SendFrame(MyFuncOfFlag.EndOfFlag); } foreach (string topic in dataTopics) { _publisher.SendMoreFrame(topic).SendFrame(MyFuncOfFlag.EncodeFlag()); } } _publisher.Close(); _publisher.Dispose(); dataTopics.Clear(); strTopics.Clear(); } catch { } } }
/// <summary> /// Dispose managed resources. /// </summary> /// <param name="disposing">Is desposing.</param> protected virtual void Dispose(bool disposing) { if (!disposed) { if (disposing) { CancelPolling(); if (pubSocket != null) { pubSocket.Disconnect(PublisherAddress); pubSocket.Dispose(); pubSocket = null; } if (poller != null) { poller.Dispose(); poller = null; } if (context != null) { context.Terminate(); context.Dispose(); context = null; } if (source != null) { source.Dispose(); source = null; } } // Shared cleanup logic. disposed = true; } }
public void Stop() { if (!_feederSocket.IsDisposed) { _feederSocket.Close(); _feederSocket.Dispose(); } }
public void Disconnect() { PublisherSocket?.Close(); PublisherSocket?.Dispose(); SubscriberSocket?.Close(); SubscriberSocket?.Dispose(); }
public void Dispose() { _actor?.Dispose(); _publisher?.Dispose(); _subscriber?.Dispose(); _beacon?.Dispose(); _poll?.Dispose(); _shim?.Dispose(); }
/// <summary> /// Stops MQ Publisher once and for all /// </summary> public void Stop() { if (Publisher != null) { Publisher.Unbind("tcp://" + IP + ":" + Port.ToString()); Publisher.Close(); Publisher.Dispose(); Publisher = null; } }
public async Task Stop() { _isConnected.OnCompleted(); _disconnected.Dispose(); _publishMarketUpdates.Close(); _publishMarketUpdates.Dispose(); await Cleanup(); }
public void Stop() { _cancel.Cancel(); _heartbeatSocket.Close(); _heartbeatSocket.Dispose(); _publisherSocket.Close(); _publisherSocket.Dispose(); }
public void Stop() { logger.Info(() => "Stopping .."); pubSocket.Dispose(); queueSub?.Dispose(); queueSub = null; logger.Info(() => "Stopped"); }
protected override Task DestroyInternal() { _cancel.Cancel(); _state.OnCompleted(); _state.Dispose(); _publisherSocket.Close(); _publisherSocket.Dispose(); return(Task.CompletedTask); }
protected override void disconnectClose() { if (sender != null) { // TODO: check first if closed sender.Disconnect("tcp://" + IP + ":" + Port); sender.Close(); sender.Dispose(); sender = null; } //NetMQConfig.Cleanup(); }
protected override void Dispose() { if (!disposed) { poller.Cancel(); clientR.Dispose(); clientS.Dispose(); context.Dispose(); disposed = true; } }
protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { shellSocket?.Dispose(); controlSocket?.Dispose(); ioPubSocket?.Dispose(); } disposedValue = true; } }
void IDisposable.Dispose() { if (Interlocked.Increment(ref _disposeCount) != 1) { return; } Debug.WriteLine(string.Format("Disposing {0}...", this.GetType().Name)); new Action(() => _socket.Options.Linger = TimeSpan.Zero).CaptureMqExceptions <TerminatingException>(); new Action(() => _socket.Dispose()).CaptureMqExceptions(); new Action(() => _context.Dispose()).CaptureMqExceptions(); Console.WriteLine(string.Format("{0} disposed.", this.GetType().Name)); }
/// <summary> /// Cleans up resources /// </summary> private void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { TerminateConnection(); socket?.Dispose(); socket = null; } disposedValue = true; } }
private bool disposedValue = false; // To detect redundant calls protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { _poller?.Dispose(); _responseSocket?.Dispose(); _publisherSocket?.Dispose(); } disposedValue = true; } }
public void NetMQPublisher_WithNullSerializer_ThrowsArgumentNullException() { // Assert var socket = new PublisherSocket(); // Act TestDelegate construct = () => new NetMQPublisher(socket, null); // Assert Assert.That(construct, Throws.ArgumentNullException); // Cleanup socket.Dispose(); }
protected async override Task DestroyInternal() { _cancel.Cancel(); _state.OnCompleted(); _state.Dispose(); _publisherSocket.Close(); _publisherSocket.Dispose(); _heartbeatPoller.Stop(); await WaitForWorkProceduresToComplete(_heartbeatProc); }
protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { publisherSocket.Dispose(); if (cleanUpNetMq) { NetMQConfig.Cleanup(true); } } disposedValue = true; } }
void IDisposable.Dispose() { tokenSource.Cancel(); if (publisher != null) { publisher.Dispose(); } if (receiver != null) { receiver.Dispose(); } if (context != null) { context.Dispose(); } }
/// <summary> /// Dispose /// </summary> /// <returns>Returns void.</returns> public void Dispose() { m_PublisherThread.Abort(); m_SubscriberThread.Abort(); m_ResponseThread.Abort(); m_PublisherSocket.Dispose(); m_SubscriberSocket.Dispose(); m_ResponseSocket.Dispose(); m_PublisherSignal.Dispose(); m_SubAPIResponse.Clear(); m_SubAPITypeResponse.Clear(); m_RepAPIResponse.Clear(); m_RepAPITypeResponse.Clear(); }
public void Stop() { try { _poller.Stop(); _publisherSocket.Disconnect(_publisherAddress); _dealerSocket.Disconnect(_dealerAddress); _poller.Dispose(); _publisherSocket.Dispose(); _dealerSocket.Dispose(); } finally { NetMQConfig.Cleanup(); } }
public void Addresses_WhenDisposed_ThrowsInvalidOperationException() { // Arrange var socket = new PublisherSocket(); var publisher = new NetMQPublisher(socket, messageFactory); var address = TcpAddress.Wildcard(5555); publisher.Dispose(); // Act void AddAddress() => publisher.AddAddress(address); // Assert Assert.That(AddAddress, Throws.TypeOf <InvalidOperationException>()); // Cleanup socket.Dispose(); }
public void Stop() { _cancel.Cancel(); _poller.Stop(); _heartbeat.Close(); _heartbeat.Dispose(); _publishStateUpdate.Close(); _publishStateUpdate.Dispose(); _subscribeToUpdates.Close(); _subscribeToUpdates.Dispose(); _stateRequest.Close(); _stateRequest.Dispose(); }
public void Dispose() { Publisher.Dispose(); NetMQConfig.Cleanup(block: false); }