private void ProxyThread()
{
if (_disposeCount != 0)
{
_traces.Debug("IpcEventProxy: disposed before start.");
return;
}
XSubscriberSocket xsub = null;
XPublisherSocket xpub = null;
try
{
xsub = _context.CreateXSubscriberSocket();
xpub = _context.CreateXPublisherSocket();
xsub.Bind(_xSubscriberAddress);
xpub.Bind(_xPublisherAddress);
var xproxy = new Proxy(xpub, xsub, null);
_traces.Debug("IpcEventProxy: started (pub->xsub {0} <=> {1} xpub<-sub)", _xSubscriberAddress, _xPublisherAddress);
xproxy.Start();
_traces.Debug("IpcEventProxy: stopped.");
}
catch (NetMQException ex)
{
if (_disposeCount == 0 && !(ex is TerminatingException))
{
_isFaultedState = true;
_traces.Error(ex, "Error while IpcEventProxy starting or during operation.");
var handler = FaultedState;
if (handler != null)
{
try
{
handler(this, EventArgs.Empty);
}
catch (Exception ex2)
{
_traces.Error(ex2);
}
}
}
}
finally
{
if (xsub != null)
{
_traces.CaptureMqExceptions(xsub.Dispose);
}
if (xpub != null)
{
_traces.CaptureMqExceptions(xpub.Dispose);
}
}
}
internal bool Terminate()
{
if (Interlocked.Increment(ref _terminateCount) != 1)
{
return(false);
}
_traces.CaptureMqExceptions(() => _socket.Options.Linger = TimeSpan.Zero);
if (_traces.CaptureMqExceptions(_socket.Dispose))
{
_traces.Debug("Publisher({0:x}) disposed.", _instanceHashCode);
}
return(true);
}
public void Dispose()
{
if (Interlocked.Increment(ref _disposeCount) != 1)
{
return;
}
_traces.CaptureMqExceptions(_context.Dispose);
}
private void ListenSocket(object state)
{
var cancellationToken = (CancellationToken)state;
var socket = _context.CreateSubscriberSocket();
try
{
socket.Options.ReceiveTimeout = _recTimeout;
socket.Options.ReceiveHighWatermark = 100000;
socket.Connect(_address);
if (_topicsToSubscribe.Length != 0)
{
foreach (var filter in _topicsToSubscribe)
{
socket.Subscribe(filter);
}
}
else
{
socket.Subscribe(string.Empty);
}
_traces.Debug("Subscriber({0:x}) created ({1}).", _instanceHashCode, _address);
byte[] buffer;
while (_terminateCount == 0 && !cancellationToken.IsCancellationRequested)
{
buffer = _traces.CaptureMqExceptions <AgainException, byte[]>(socket.Receive);
if (buffer == null)
{
continue;
}
byte[] eventTopic = buffer.ToArray();
buffer = _traces.CaptureMqExceptions <AgainException, byte[]>(socket.Receive);
if (buffer == null)
{
continue;
}
if (Internals.SyncEvent.EventPrefix.SequenceEqual(eventTopic))
{
if (_synced)
{
continue;
}
using (var ms = new MemoryStream(buffer, 0, buffer.Length, false))
{
var data = Serializer.Deserialize <Internals.SyncEvent>(ms);
if (data.SubscriberInstanceId == _instanceHashCode)
{
if (_verboseLog)
{
_traces.Debug("Subscriber({0:x}): sync event received.", _instanceHashCode);
}
_synced = true;
}
}
}
else
{
long eventCode = BitConverter.ToInt64(eventTopic, 0);
if (_verboseLog)
{
_traces.Debug("Subscriber({0:x}): event {1} received.", _instanceHashCode, eventCode);
}
var eventHandler = OnMessage;
if (eventHandler != null)
{
try
{
eventHandler(this, new MessageEventArgs(eventCode, buffer));
}
catch (Exception ex)
{
_traces.Error(ex, "Subscriber({0:x}): Error on receiving event {0}.", _instanceHashCode, eventCode);
}
}
}
}
}
catch (TerminatingException)
{
// ZMQ context is in terminating phase...
}
catch (Exception ex)
{
_traces.Error(ex);
}
finally
{
if (_traces.CaptureMqExceptions(socket.Dispose))
{
_traces.Debug("Subscriber({0:x}) disposed.", _instanceHashCode);
}
}
}
