private PublisherSocket GetNewPublisherSocket(string addressZeroMq)
{
PublisherSocket publisherSocket;
{
_loggerDelegate?.Invoke(string.Format("Publisher socket binding to: {0}\n", addressZeroMq));
publisherSocket = new PublisherSocket();
// Corner case: wait until publisher socket is ready (see code below that waits for
// "_publisherReadySignal").
NetMQMonitor monitor;
{
// Must ensure that we have a unique monitor name for every instance of this class.
string endPoint = string.Format("inproc://#SubjectNetMQ#Publisher#{0}#{1}", addressZeroMq, Guid.NewGuid().ToString());
monitor = new NetMQMonitor(publisherSocket,
endPoint,
SocketEvents.Accepted | SocketEvents.Listening
);
monitor.Accepted += Publisher_Event_Accepted;
monitor.Listening += Publisher_Event_Listening;
monitor.StartAsync();
}
publisherSocket.Options.SendHighWatermark = this.HighwaterMark;
try
{
publisherSocket.Bind(addressZeroMq);
}
catch (NetMQException ex)
{
// This is usually because the address is in use.
throw new Exception(string.Format("Error E56874. Cannot bind publisher to '{0}'. 95% probability that this is caused by trying to bind a publisher to a port already in use by another process. To fix, choose a unique publisher port for this process. For more on this error, see 'Readme.md' (or the GitHub homepage for NetMQ.ReactiveExtensions).", addressZeroMq), ex);
}
// Corner case: wait until publisher socket is ready (see code below that sets "_publisherReadySignal").
{
Stopwatch sw = Stopwatch.StartNew();
_publisherReadySignal.WaitOne(TimeSpan.FromMilliseconds(3000));
_loggerDelegate?.Invoke(string.Format("Publisher: Waited {0} ms for binding.\n", sw.ElapsedMilliseconds));
}
{
monitor.Accepted -= Publisher_Event_Accepted;
monitor.Listening -= Publisher_Event_Listening;
// Current issue with NegMQ: Cannot stop or dispose monitor, or else it stops the parent socket.
//monitor.Stop();
//monitor.Dispose();
}
}
// Otherwise, the first item we publish may get missed by the subscriber. 500 milliseconds consistently works
// locally, but occasionally fails on the AppVeyor build server. 650 milliseconds is optimal.
using (EventWaitHandle wait = new ManualResetEvent(false))
{
// Cannot use Thread.Sleep() here, as this is incompatible with .NET Core 1.0, Windows 8.0, 8.1, and 10.
wait.WaitOne(TimeSpan.FromMilliseconds(650));
}
return(publisherSocket);
}
public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()
{
// The bug:
// Given we monitor a netmq tcp socket
// Given we disposed of the monitored socket first
// When we dispose of the monitor
// Then our monitor is Faulted with a EndpointNotFoundException
// And monitor can't be stopped or disposed
using (var context = NetMQContext.Create())
using (var res = context.CreateResponseSocket())
{
NetMQMonitor monitor;
using (var req = context.CreateRequestSocket())
{
monitor = new NetMQMonitor(context, req, "inproc://#monitor", SocketEvents.All);
Task.Factory.StartNew(monitor.Start);
// Bug only occurs when monitoring a tcp socket
var port = res.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
req.Send("question");
Assert.That(res.ReceiveFrameString(), Is.EqualTo("question"));
res.Send("response");
Assert.That(req.ReceiveFrameString(), Is.EqualTo("response"));
}
Thread.Sleep(100);
// Monitor.Dispose should complete
var completed = Task.Factory.StartNew(() => monitor.Dispose()).Wait(1000);
Assert.That(completed, Is.True);
}
// NOTE If this test fails, it will hang because context.Dispose will block
}
public void MonitorDisposeProperlyWhenDisposedAfterMonitoredTcpSocket()
{
// The bug:
// Given we monitor a netmq tcp socket
// Given we disposed of the monitored socket first
// When we dispose of the monitor
// Then our monitor is Faulted with a EndpointNotFoundException
// And monitor can't be stopped or disposed
using (var context = NetMQContext.Create())
using (var res = context.CreateResponseSocket())
{
NetMQMonitor monitor;
using (var req = context.CreateRequestSocket())
{
monitor = new NetMQMonitor(context, req, "inproc://#monitor", SocketEvents.All);
Task.Factory.StartNew(monitor.Start);
// Bug only occurs when monitoring a tcp socket
var port = res.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
req.Send("question");
Assert.That(res.ReceiveFrameString(), Is.EqualTo("question"));
res.Send("response");
Assert.That(req.ReceiveFrameString(), Is.EqualTo("response"));
}
Thread.Sleep(100);
// Monitor.Dispose should complete
var completed = Task.Factory.StartNew(() => monitor.Dispose()).Wait(1000);
Assert.That(completed, Is.True);
}
// NOTE If this test fails, it will hang because context.Dispose will block
}
public void ErrorCodeTest()
{
using (var req = new RequestSocket())
using (var rep = new ResponseSocket())
using (var monitor = new NetMQMonitor(req, "inproc://rep.inproc", SocketEvents.ConnectDelayed))
{
var eventArrived = false;
monitor.ConnectDelayed += (s, a) => { eventArrived = true; };
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var monitorTask = Task.Factory.StartNew(monitor.Start);
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
req.SendFrame("a");
rep.SkipFrame();
rep.SendFrame("b");
req.SkipFrame();
Thread.Sleep(200);
Assert.IsTrue(eventArrived);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(monitorTask.IsCompleted);
}
}
protected override void ProducerAction()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (SubscriberSocket socket = ctx.CreateSubscriberSocket())
{
using (
var monitor = new NetMQMonitor(ctx, socket, "inproc://monitor.sub/" + Guid.NewGuid(),
SocketEvent.Connected | SocketEvent.Disconnected))
{
monitor.Connected += monitor_Connected;
monitor.Disconnected += monitor_Disconnected;
monitor.Timeout = TimeSpan.FromMilliseconds(100);
Task.Factory.StartNew(monitor.Start);
socket.Connect(Address);
socket.Subscribe(string.Empty);
while (true)
{
_commandProcessor.ExecuteAll(socket);
NetMQMessage message = socket.ReceiveMessage();
if (message != null && !IsEmpty)
{
Queue.Add(message);
}
}
}
}
}
}
protected override void _SocketBuilder()
{
if (info == null)
{
info = GetAddress(name);
if (info == null)
{
Thread.Sleep(900);
return;
}
}
reportLog("Starting Dealer for ip " + info.Address + " and port " + info.Port, LogType.INFO, section);
string path = "tcp://" + info.Address + ":" + info.Port;
socket = new DealerSocket();
socket.Options.TcpKeepalive = true;
socket.Options.TcpKeepaliveIdle = TimeSpan.FromMilliseconds(100);
socket.Options.TcpKeepaliveInterval = TimeSpan.FromMilliseconds(100);
monitor = new NetMQMonitor(socket, "inproc://dealer" + Net2.GetAddressIndex(), SocketEvents.All);
monitor.Disconnected += Monitor_Disconnected;
monitor.Connected += Monitor_Connected;
monitor.Timeout = TimeSpan.FromMilliseconds(100);
task = Task.Factory.StartNew(monitor.Start);
setState(Net2State.STARTED);
start_time = GetTime().sec;
socket.Connect(path);
reportLog("Dealer is connected to " + path, LogType.INFO, section);
}
public void SubsriberCleanupOnUnbind(string address)
{
for (var i = 0; i < 10; i++)
{
using (var sub = new SubscriberSocket())
{
sub.Bind(address);
using (var monitor = new NetMQMonitor(sub, String.Format("inproc://cleanup.test{0}", Guid.NewGuid()), SocketEvents.Closed))
{
var monitorTask = Task.Factory.StartNew(monitor.Start);
var closed = new ManualResetEventSlim();
monitor.Closed += (sender, args) => closed.Set();
var time = DateTime.Now;
sub.Unbind(address);
Assert.That(closed.Wait(1000), Is.True, "Unbind failed to report Closed event to the Monitor");
var duration = DateTime.Now - time;
Console.WriteLine("Run {0}: {1} ms", i, duration.TotalMilliseconds);
monitor.Stop();
monitorTask.Wait();
}
}
}
}
private void DisposeMonitor()
{
_monitor.Connected -= Monitor_Connected;
_monitor.Disconnected -= Monitor_Disconnected;
_monitor.ConnectRetried -= Monitor_ConnectRetried;
_monitor.Dispose();
_monitor = null;
}
private void DisposeMonitor()
{
_monitor.Connected -= Monitor_Connected;
_monitor.Disconnected -= Monitor_Disconnected;
_monitor.ConnectRetried -= Monitor_ConnectRetried;
_monitor.Dispose();
_monitor = null;
}
public void Monitoring()
{
ManualResetEvent listeningEvent = new ManualResetEvent(false);
ManualResetEvent acceptedEvent = new ManualResetEvent(false);
ManualResetEvent connectedEvent = new ManualResetEvent(false);
using (NetMQContext contex = NetMQContext.Create())
{
Poller poller = new Poller();
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) => acceptedEvent.Set();
monitor.Listening += (s, a) => listeningEvent.Set();
monitor.AttachToPoller(poller);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
using (NetMQMonitor reqMonitor = new NetMQMonitor(contex, req, "inproc://req.inproc", SocketEvent.Connected))
{
reqMonitor.Connected += (s, a) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
try
{
var pollerTask = Task.Factory.StartNew(poller.Start);
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
}
finally
{
poller.Stop();
}
}
}
}
}
}
}
public void Monitoring()
{
bool listening = false;
bool accepted = false;
using (NetMQContext contex = NetMQContext.Create())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) =>
{
accepted = true;
//Console.WriteLine(a.Socket.LocalEndPoint.ToString());
};
monitor.Listening += (s, a) =>
{
listening = true;
Console.WriteLine(a.Socket.LocalEndPoint.ToString());
};
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Thread.Sleep(200);
Assert.IsTrue(listening);
Assert.IsTrue(accepted);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
}
public void Monitoring()
{
bool listening = false;
bool accepted = false;
using (NetMQContext contex = NetMQContext.Create())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) =>
{
accepted = true;
Console.WriteLine(a.Socket.RemoteEndPoint.ToString());
};
monitor.Listening += (s, a) =>
{
listening = true;
Console.WriteLine(a.Socket.LocalEndPoint.ToString());
};
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Thread.Sleep(200);
Assert.IsTrue(listening);
Assert.IsTrue(accepted);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
}
public void AddSubscriber_BeforeRunning_DoesNotBindReceiver()
{
// Arrange
var monitor = new NetMQMonitor(poller);
// Act
monitor.AddSubscriber(subscriber);
// Assert
mockSubscriber.Verify(m => m.InitializeConnection(), Times.Never);
}
public void AddSender_WithNullReceiver_DoesNotThrow()
{
// Arrange
var monitor = new NetMQMonitor(poller);
// Act
TestDelegate add = () => monitor.AddSender(null);
// Assert
Assert.That(add, Throws.Nothing);
}
public void StartMonitoring_BeforeStarted_RunsPoller()
{
// Arrange
var monitor = new NetMQMonitor(poller);
// Act
monitor.StartMonitoring();
// Assert
mockPoller.Verify(m => m.RunAsync(), Times.Once);
}
public void AddSubscriber_WithReceiver_AddsPollableSocketToPoller()
{
// Arrange
var monitor = new NetMQMonitor(poller);
// Act
monitor.AddSubscriber(subscriber);
// Assert
mockPoller.Verify(m => m.Add(It.IsIn(pollableSocket)), Times.Once);
}
public void StartAsync()
{
using (var rep = new ResponseSocket())
using (var monitor = new NetMQMonitor(rep, "inproc://foo", SocketEvents.Closed))
{
var task = monitor.StartAsync();
Thread.Sleep(200);
Assert.AreEqual(TaskStatus.Running, task.Status);
monitor.Stop();
Assert.True(task.Wait(TimeSpan.FromMilliseconds(1000)));
}
}
public void StartAsync()
{
using (var rep = new ResponseSocket())
using (var monitor = new NetMQMonitor(rep, "inproc://foo", SocketEvents.Closed))
{
var task = monitor.StartAsync();
Thread.Sleep(200);
Assert.AreEqual(TaskStatus.Running, task.Status);
monitor.Stop();
Assert.True(task.Wait(TimeSpan.FromMilliseconds(1000)));
}
}
public void StartMonitor_WithPublisherAdded_BindsReceiver()
{
// Arrange
var monitor = new NetMQMonitor(poller);
monitor.AddPublisher(publisher);
// Act
monitor.StartMonitoring();
// Assert
mockPublisher.Verify(m => m.InitializeConnection(), Times.Once);
}
public void StartMonitor_WithSubscriberAdded_ConnectsReceiver()
{
// Arrange
var monitor = new NetMQMonitor(poller);
monitor.AddSubscriber(subscriber);
// Act
monitor.StartMonitoring();
// Assert
mockSubscriber.Verify(m => m.InitializeConnection(), Times.Once);
}
public void StopMonitoring_WhenRunning_StopsPoller()
{
// Arrange
var monitor = new NetMQMonitor(poller);
monitor.StartMonitoring();
// Act
monitor.StopMonitoring();
// Assert
mockPoller.Verify(m => m.StopAsync(), Times.Once);
}
private NetMQMonitor CreateMonitor(NetMQContext context, NetMQSocket socket, Poller poller)
{
var monitor = new NetMQMonitor(context, socket, $"inproc://{Guid.NewGuid()}.inproc",
SocketEvents.Connected | SocketEvents.Disconnected | SocketEvents.ConnectRetried);
monitor.Connected += Monitor_Connected;
monitor.Disconnected += Monitor_Disconnected;
monitor.ConnectRetried += Monitor_ConnectRetried;
monitor.AttachToPoller(poller);
return monitor;
}
private NetMQMonitor CreateMonitor(NetMQSocket socket, NetMQPoller poller)
{
var monitor = new NetMQMonitor(socket, $"inproc://{Guid.NewGuid()}.inproc",
SocketEvents.Connected | SocketEvents.Disconnected | SocketEvents.ConnectRetried);
monitor.Connected += Monitor_Connected;
monitor.Disconnected += Monitor_Disconnected;
monitor.ConnectRetried += Monitor_ConnectRetried;
monitor.AttachToPoller(poller);
return(monitor);
}
public void AddReceiver_AfterStarted_BindsReceiver()
{
// Arrange
var monitor = new NetMQMonitor(poller);
monitor.StartMonitoring();
// Act
monitor.AddReceiver(receiver);
// Assert
mockReceiver.Verify(m => m.InitializeConnection(), Times.Once);
}
public void StopMonitoring_WithSubscriberAdded_UnbindsReceiver()
{
// Arrange
var monitor = new NetMQMonitor(poller);
monitor.AddSubscriber(subscriber);
monitor.StartMonitoring();
// Act
monitor.StopMonitoring();
// Assert
mockSubscriber.Verify(m => m.TerminateConnection(), Times.Once);
}
public void ErrorCodeTest()
{
bool eventArrived = false;
using (NetMQContext contex = NetMQContext.Create())
{
using (var req = contex.CreateRequestSocket())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor =
new NetMQMonitor(contex, req, "inproc://rep.inproc", SocketEvent.ConnectDelayed))
{
monitor.ConnectDelayed += (s, a) =>
{
eventArrived = true;
};
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
rep.Bind("tcp://127.0.0.1:5002");
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Thread.Sleep(200);
Assert.IsTrue(eventArrived);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
}
public void StopMonitoring_WithSenderAdded_DisconnectsSender()
{
// Arrange
var monitor = new NetMQMonitor(poller);
monitor.AddSender(sender);
monitor.StartMonitoring();
// Act
monitor.StopMonitoring();
// Assert
mockSender.Verify(m => m.TerminateConnection(), Times.Once);
}
public void AddSubscriber_AfterStopped_DoesNotBindReceiver()
{
// Arrange
var monitor = new NetMQMonitor(poller);
monitor.StartMonitoring();
monitor.StopMonitoring();
// Act
monitor.AddSubscriber(subscriber);
// Assert
mockSubscriber.Verify(m => m.InitializeConnection(), Times.Never);
}
private void InitializePublisherOnFirstUse()
{
if (m_initializePublisherDone == false) // Double checked locking.
{
lock (m_initializePublisherLock)
{
if (m_initializePublisherDone == false)
{
Console.WriteLine("Publisher socket binding to: {0}", ZeroMqAddress);
m_publisherSocket = new PublisherSocket();
// Corner case: wait until publisher socket is ready (see code below that waits for
// "_publisherReadySignal").
NetMQMonitor monitor;
{
// Must ensure that we have a unique monitor name for every instance of this class.
string endPoint = string.Format("inproc://#SubjectNetMQ#Publisher#{0}#{1}", this.QueueName, this.ZeroMqAddress);
monitor = new NetMQMonitor(m_publisherSocket, endPoint,
SocketEvents.Accepted | SocketEvents.Listening
);
monitor.Accepted += Publisher_Event_Accepted;
monitor.Listening += Publisher_Event_Listening;
monitor.StartAsync();
}
m_publisherSocket.Options.SendHighWatermark = 2000 * 1000;
m_publisherSocket.Bind(this.ZeroMqAddress);
// Corner case: wait until publisher socket is ready (see code below that sets
// "_publisherReadySignal").
{
Stopwatch sw = Stopwatch.StartNew();
m_publisherReadySignal.WaitOne(TimeSpan.FromMilliseconds(3000));
Console.Write("Publisher: Waited {0} ms for binding.\n", sw.ElapsedMilliseconds);
}
{
monitor.Accepted -= Publisher_Event_Accepted;
monitor.Listening -= Publisher_Event_Listening;
// Current issue with NegMQ: Cannot stop or dispose monitor, or else it stops the parent socket.
//monitor.Stop();
//monitor.Dispose();
}
m_initializePublisherDone = true;
}
} // lock
Thread.Sleep(500); // Otherwise, the first item we publish may get missed by the subscriber.
}
}
public void ErrorCodeTest()
{
bool eventArrived = false;
using (NetMQContext contex = NetMQContext.Create())
{
using (var req = contex.CreateRequestSocket())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor =
new NetMQMonitor(contex, req, "inproc://rep.inproc", SocketEvent.ConnectDelayed))
{
monitor.ConnectDelayed += (s, a) =>
{
eventArrived = true;
};
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
rep.Bind("tcp://127.0.0.1:5002");
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Thread.Sleep(200);
Assert.IsTrue(eventArrived);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
}
private static async Task CreatePushSocket()
{
var poller = new NetMQPoller();
push = new PushSocket();
push.BindRandomPort("tcp://127.0.0.1");
NetMQMonitor monitor = new NetMQMonitor(push, "inproc://req.inproc", SocketEvents.All);
monitor.Connected += Monitor_Connected;
monitor.EventReceived += Monitor_EventReceived;
//monitor.AttachToPoller(poller);
queue.ReceiveReady += Queue_ReceiveReady;;
push.Connect(address);
poller.Add(push);
poller.Add(queue);
poller.RunAsync();
await monitor.StartAsync();
}
public void Monitoring()
{
var listeningEvent = new ManualResetEvent(false);
var acceptedEvent = new ManualResetEvent(false);
var connectedEvent = new ManualResetEvent(false);
using (var context = NetMQContext.Create())
using (var rep = context.CreateResponseSocket())
using (var req = context.CreateRequestSocket())
using (var poller = new Poller {
PollTimeout = TestPollTimeoutMillis
})
using (var repMonitor = new NetMQMonitor(context, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
using (var reqMonitor = new NetMQMonitor(context, req, "inproc://req.inproc", SocketEvent.Connected))
{
repMonitor.Accepted += (s, e) => acceptedEvent.Set();
repMonitor.Listening += (s, e) => listeningEvent.Set();
repMonitor.AttachToPoller(poller);
int port = rep.BindRandomPort("tcp://127.0.0.1");
reqMonitor.Connected += (s, e) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
poller.PollTillCancelledNonBlocking();
req.Connect("tcp://127.0.0.1:" + port);
req.Send("a");
rep.SkipFrame();
rep.Send("b");
req.SkipFrame();
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
poller.CancelAndJoin();
}
}
public void NoHangWhenMonitoringUnboundInprocAddress()
{
using (var monitor = new NetMQMonitor(new PairSocket(), "inproc://unbound-inproc-address", ownsSocket: true))
{
var task = Task.Factory.StartNew(monitor.Start);
monitor.Stop();
try
{
task.Wait(TimeSpan.FromMilliseconds(1000));
Assert.Fail("Exception expected");
}
catch (AggregateException ex)
{
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsTrue(ex.InnerExceptions.Single() is EndpointNotFoundException);
}
}
}
public void NoHangWhenMonitoringUnboundInprocAddress()
{
using (var monitor = new NetMQMonitor(new PairSocket(), "inproc://unbound-inproc-address", ownsSocket: true))
{
var task = Task.Factory.StartNew(monitor.Start);
monitor.Stop();
try
{
task.Wait(TimeSpan.FromMilliseconds(1000));
Assert.Fail("Exception expected");
}
catch (AggregateException ex)
{
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsTrue(ex.InnerExceptions.Single() is EndpointNotFoundException);
}
}
}
private static void CreatePullSocket()
{
try
{
var poller = new NetMQPoller();
NetMQMonitor monitor = new NetMQMonitor(pull, "inproc://req.inproc", SocketEvents.All);
monitor.Accepted += Monitor_Accepted;
monitor.EventReceived += Monitor_EventReceived;
pull.ReceiveReady += Pull_ReceiveReady1;
pull.Bind(address);
//monitor.AttachToPoller(poller);
poller.Add(pull);
poller.RunAsync();
monitor.StartAsync();
}
catch (Exception ex)
{
}
}
/// <summary>
/// Unbind the socket from last endpoint and wait until the underlaying socket was unbound and disposed.
/// It will also dispose the NetMQSocket
/// </summary>
/// <param name="sub"></param>
public static void Unbind(this NetMQSocket sub)
{
using (var monitor = new NetMQMonitor(sub, $"inproc://unbind.wait.{Counter++}", SocketEvents.Closed))
{
var monitorTask = Task.Factory.StartNew(monitor.Start);
var closed = new ManualResetEventSlim();
monitor.Closed += (sender, args) => closed.Set();
Assert.IsNotNull(sub.Options.LastEndpoint);
sub.Unbind(sub.Options.LastEndpoint);
closed.Wait(1000);
monitor.Stop();
monitorTask.Wait();
}
}
public bool TryConnectAndMonitorSocket(NetMQSocket socket, string address, NetMQPoller poller = null, Action <IConnectionMonitor, bool> onConnectionStateChanged = null)
{
_onConnectionStateChanged = onConnectionStateChanged;
_monitor = new NetMQMonitor(socket, $"inproc://monitor.socket/{Guid.NewGuid()}", SocketEvents.Connected | SocketEvents.Disconnected);
_monitor.Connected += MonitorConnected;
_monitor.Disconnected += MonitorDisconnected;
if (poller == null)
{
_monitorTask = _monitor.StartAsync();
}
else
{
_monitor.AttachToPoller(poller);
}
socket.Connect(address);
return(WaitForConnection());
}
/// <summary>
/// Unbind the socket from last endpoint and wait until the underlaying socket was unbound and disposed.
/// It will also dispose the NetMQSocket
/// </summary>
/// <param name="sub"></param>
public static void Unbind(this NetMQSocket sub)
{
using (var monitor = new NetMQMonitor(sub, $"inproc://unbind.wait.{Counter++}", SocketEvents.Closed))
{
var monitorTask = Task.Factory.StartNew(monitor.Start);
var closed = new ManualResetEventSlim();
monitor.Closed += (sender, args) => closed.Set();
Assert.IsNotNull(sub.Options.LastEndpoint);
sub.Unbind(sub.Options.LastEndpoint);
closed.Wait(1000);
monitor.Stop();
monitorTask.Wait();
}
}
public void Monitoring()
{
var listeningEvent = new ManualResetEvent(false);
var acceptedEvent = new ManualResetEvent(false);
var connectedEvent = new ManualResetEvent(false);
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
using (var poller = new NetMQPoller())
using (var repMonitor = new NetMQMonitor(rep, "inproc://rep.inproc", SocketEvents.Accepted | SocketEvents.Listening))
using (var reqMonitor = new NetMQMonitor(req, "inproc://req.inproc", SocketEvents.Connected))
{
repMonitor.Accepted += (s, e) => acceptedEvent.Set();
repMonitor.Listening += (s, e) => listeningEvent.Set();
repMonitor.AttachToPoller(poller);
int port = rep.BindRandomPort("tcp://127.0.0.1");
reqMonitor.Connected += (s, e) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
poller.RunAsync();
req.Connect("tcp://127.0.0.1:" + port);
req.SendFrame("a");
rep.SkipFrame();
rep.SendFrame("b");
req.SkipFrame();
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
poller.Stop();
}
}
public void Monitoring()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
using (var monitor = new NetMQMonitor(rep, $"inproc://rep.inproc", SocketEvents.Accepted | SocketEvents.Listening))
{
var listening = false;
var accepted = false;
monitor.Accepted += (s, a) => { accepted = true; };
monitor.Listening += (s, a) => { listening = true; };
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var monitorTask = Task.Factory.StartNew(monitor.Start);
Thread.Sleep(10);
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
req.SendFrame("a");
rep.SkipFrame();
rep.SendFrame("b");
req.SkipFrame();
Thread.Sleep(200);
Assert.IsTrue(listening);
Assert.IsTrue(accepted);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(monitorTask.IsCompleted);
}
}
public void ErrorCodeTest()
{
using (var context = NetMQContext.Create())
using (var req = context.CreateRequestSocket())
using (var rep = context.CreateResponseSocket())
using (var monitor = new NetMQMonitor(context, req, "inproc://rep.inproc", SocketEvents.ConnectDelayed))
{
var eventArrived = false;
monitor.ConnectDelayed += (s, a) => { eventArrived = true; };
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var monitorTask = Task.Factory.StartNew(monitor.Start);
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
req.Send("a");
rep.SkipFrame();
rep.Send("b");
req.SkipFrame();
Thread.Sleep(200);
Assert.IsTrue(eventArrived);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(monitorTask.IsCompleted);
}
}
public NetMQMonitorIntervalEventArgs(NetMQMonitor monitor, string address, int interval)
: base(monitor, address)
{
Interval = interval;
}
public ConnectionMonitor(NetMQContext context, NetMQSocket monitoredSocket, Poller poller)
{
_monitor = CreateMonitor(context, monitoredSocket, poller);
}
/// <summary>
/// Create a new NetMQMonitorSocketEventArgs that contains the given monitor, address, and socket.
/// </summary>
/// <param name="monitor">The <see cref="NetMQMonitor"/> that raised this event.</param>
/// <param name="address">The address of the event.</param>
/// <param name="socketEvent">The type of socket event that occurred.</param>
/// <param name="socket">The socket upon which this event occurred.</param>
public NetMQMonitorSocketEventArgs( NetMQMonitor monitor, string address, AsyncSocket socket, SocketEvents socketEvent)
: base(monitor, address, socketEvent)
{
Socket = socket;
}
/// <summary>
/// Create a new NetMQMonitorErrorEventArgs that contains the given monitor, address, and error-code.
/// </summary>
/// <param name="monitor">The <see cref="NetMQMonitor"/> that raised this event.</param>
/// <param name="address">The address of the event.</param>
/// <param name="socketEvent">The type of socket event that occurred.</param>
/// <param name="errorCode">The error code associated with this event.</param>
public NetMQMonitorErrorEventArgs( NetMQMonitor monitor, string address, ErrorCode errorCode, SocketEvents socketEvent)
: base(monitor, address, socketEvent)
{
ErrorCode = errorCode;
}
public void Monitoring()
{
ManualResetEvent listeningEvent = new ManualResetEvent(false);
ManualResetEvent acceptedEvent = new ManualResetEvent(false);
ManualResetEvent connectedEvent = new ManualResetEvent(false);
using (NetMQContext contex = NetMQContext.Create())
using (Poller poller = new Poller())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) => acceptedEvent.Set();
monitor.Listening += (s, a) => listeningEvent.Set();
monitor.AttachToPoller(poller);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
using (NetMQMonitor reqMonitor = new NetMQMonitor(contex, req, "inproc://req.inproc", SocketEvent.Connected))
{
reqMonitor.Connected += (s, a) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
try
{
var pollerTask = Task.Factory.StartNew(poller.Start);
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
}
finally
{
poller.Stop();
}
}
}
}
}
}
}
private PublisherSocket GetNewPublisherSocket(string addressZeroMq)
{
PublisherSocket publisherSocket;
{
_loggerDelegate?.Invoke(string.Format("Publisher socket binding to: {0}\n", addressZeroMq));
publisherSocket = new PublisherSocket();
// Corner case: wait until publisher socket is ready (see code below that waits for
// "_publisherReadySignal").
NetMQMonitor monitor;
{
// Must ensure that we have a unique monitor name for every instance of this class.
string endPoint = string.Format("inproc://#SubjectNetMQ#Publisher#{0}#{1}", addressZeroMq, Guid.NewGuid().ToString());
monitor = new NetMQMonitor(publisherSocket,
endPoint,
SocketEvents.Accepted | SocketEvents.Listening
);
monitor.Accepted += Publisher_Event_Accepted;
monitor.Listening += Publisher_Event_Listening;
monitor.StartAsync();
}
publisherSocket.Options.SendHighWatermark = this.HighwaterMark;
try
{
publisherSocket.Bind(addressZeroMq);
}
catch (NetMQException ex)
{
// This is usually because the address is in use.
throw new Exception(string.Format("Error E56874. Cannot bind publisher to '{0}'. 95% probability that this is caused by trying to bind a publisher to a port already in use by another process. To fix, choose a unique publisher port for this process. For more on this error, see 'Readme.md' (or the GitHub homepage for NetMQ.ReactiveExtensions).", addressZeroMq), ex);
}
// Corner case: wait until publisher socket is ready (see code below that sets "_publisherReadySignal").
{
Stopwatch sw = Stopwatch.StartNew();
_publisherReadySignal.WaitOne(TimeSpan.FromMilliseconds(3000));
_loggerDelegate?.Invoke(string.Format("Publisher: Waited {0} ms for binding.\n", sw.ElapsedMilliseconds));
}
{
monitor.Accepted -= Publisher_Event_Accepted;
monitor.Listening -= Publisher_Event_Listening;
// Current issue with NegMQ: Cannot stop or dispose monitor, or else it stops the parent socket.
//monitor.Stop();
//monitor.Dispose();
}
}
// Otherwise, the first item we publish may get missed by the subscriber. 500 milliseconds consistently works
// locally, but occasionally fails on the AppVeyor build server. 650 milliseconds is optimal.
using (EventWaitHandle wait = new ManualResetEvent(false))
{
// Cannot use Thread.Sleep() here, as this is incompatible with .NET Core 1.0, Windows 8.0, 8.1, and 10.
wait.WaitOne(TimeSpan.FromMilliseconds(650));
}
return publisherSocket;
}
public void Monitoring()
{
var listeningEvent = new ManualResetEvent(false);
var acceptedEvent = new ManualResetEvent(false);
var connectedEvent = new ManualResetEvent(false);
using (var context = NetMQContext.Create())
using (var rep = context.CreateResponseSocket())
using (var req = context.CreateRequestSocket())
using (var poller = new Poller { PollTimeout = TestPollTimeoutMillis })
using (var repMonitor = new NetMQMonitor(context, rep, "inproc://rep.inproc", SocketEvents.Accepted | SocketEvents.Listening))
using (var reqMonitor = new NetMQMonitor(context, req, "inproc://req.inproc", SocketEvents.Connected))
{
repMonitor.Accepted += (s, e) => acceptedEvent.Set();
repMonitor.Listening += (s, e) => listeningEvent.Set();
repMonitor.AttachToPoller(poller);
int port = rep.BindRandomPort("tcp://127.0.0.1");
reqMonitor.Connected += (s, e) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
poller.PollTillCancelledNonBlocking();
req.Connect("tcp://127.0.0.1:" + port);
req.SendFrame("a");
rep.SkipFrame();
rep.SendFrame("b");
req.SkipFrame();
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
poller.CancelAndJoin();
}
}
public NetMQMonitorErrorEventArgs(NetMQMonitor monitor, string address, ErrorCode errorCode)
: base(monitor, address)
{
ErrorCode = errorCode;
}
public void SubsriberCleanupOnUnbind(string address)
{
for (var i = 0; i < 10; i++)
{
using (var sub = new SubscriberSocket())
{
sub.Bind(address);
using (var monitor = new NetMQMonitor(sub, String.Format("inproc://cleanup.test{0}", Guid.NewGuid()), SocketEvents.Closed))
{
var monitorTask = Task.Factory.StartNew(monitor.Start);
var closed = new ManualResetEventSlim();
monitor.Closed += (sender, args) => closed.Set();
var time = DateTime.Now;
sub.Unbind(address);
Assert.That(closed.Wait(1000), Is.True, "Unbind failed to report Closed event to the Monitor");
var duration = DateTime.Now - time;
monitor.Stop();
monitorTask.Wait();
}
}
}
}
public void Monitoring()
{
using (var context = NetMQContext.Create())
using (var rep = context.CreateResponseSocket())
using (var req = context.CreateRequestSocket())
using (var monitor = new NetMQMonitor(context, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
bool listening = false;
bool accepted = false;
monitor.Accepted += (s, a) => { accepted = true; };
monitor.Listening += (s, a) => { listening = true; };
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
req.Send("a");
rep.ReceiveString();
rep.Send("b");
req.ReceiveString();
Thread.Sleep(200);
Assert.IsTrue(listening);
Assert.IsTrue(accepted);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
public NetMQMonitorEventArgs(NetMQMonitor monitor, string address)
{
Monitor = monitor;
Address = address;
}
/// <summary>
/// Create a new NetMQMonitorIntervalEventArgs containing the given NetMQMonitor, address, and interval.
/// </summary>
/// <param name="monitor">the NetMQMonitor</param>
/// <param name="address">The a string denoting the address</param>
/// <param name="interval">The interval, in milliseconds.</param>
/// <param name="socketEvent">The type of socket event that occurred.</param>
public NetMQMonitorIntervalEventArgs( NetMQMonitor monitor, string address, int interval, SocketEvents socketEvent)
: base(monitor, address, socketEvent)
{
Interval = interval;
}
public NetMQMonitorSocketEventArgs(NetMQMonitor monitor, string address, Socket socket)
: base(monitor, address)
{
Socket = socket;
}
/// <summary>
/// Create a new NetMQMonitorEventArgs that contains the given monitor and address.
/// </summary>
/// <param name="monitor">The <see cref="NetMQMonitor"/> that raised this event.</param>
/// <param name="address">The address of the event.</param>
/// <param name="socketEvent">The type of socket event that occurred.</param>
protected NetMQMonitorEventArgs( NetMQMonitor monitor, string address, SocketEvents socketEvent)
{
Monitor = monitor;
Address = address;
SocketEvent = socketEvent;
}
