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);
}
