public void AddSocketDuringWork()
{
using (var context = NetMQContext.Create())
using (var router1 = context.CreateRouterSocket())
using (var router2 = context.CreateRouterSocket())
using (var dealer1 = context.CreateDealerSocket())
using (var dealer2 = context.CreateDealerSocket())
using (var poller = new Poller(router1) { PollTimeout = TestPollTimeoutMillis })
{
int port1 = router1.BindRandomPort("tcp://127.0.0.1");
int port2 = router2.BindRandomPort("tcp://127.0.0.1");
dealer1.Connect("tcp://127.0.0.1:" + port1);
dealer2.Connect("tcp://127.0.0.1:" + port2);
bool router1arrived = false;
bool router2arrived = false;
var signal1 = new ManualResetEvent(false);
var signal2 = new ManualResetEvent(false);
router1.ReceiveReady += (s, a) =>
{
router1.Receive();
router1.Receive();
router1arrived = true;
poller.AddSocket(router2);
signal1.Set();
};
router2.ReceiveReady += (s, a) =>
{
router2.Receive();
router2.Receive();
router2arrived = true;
signal2.Set();
};
poller.PollTillCancelledNonBlocking();
dealer1.Send("1");
Assert.IsTrue(signal1.WaitOne(300));
dealer2.Send("2");
Assert.IsTrue(signal1.WaitOne(300));
poller.CancelAndJoin();
Assert.IsTrue(router1arrived);
Assert.IsTrue(router2arrived);
}
}
public void TestPollerDispose()
{
const int timerIntervalMillis = 10;
var timer = new NetMQTimer(TimeSpan.FromMilliseconds(timerIntervalMillis));
var signal = new ManualResetEvent(false);
var count = 0;
timer.Elapsed += (a, s) =>
{
if (count++ == 5)
signal.Set();
};
Poller poller;
using (poller = new Poller(timer) { PollTimeout = TestPollTimeoutMillis })
{
poller.PollTillCancelledNonBlocking();
Assert.IsTrue(signal.WaitOne(500));
Assert.IsTrue(poller.IsStarted);
Assert.Throws<InvalidOperationException>(() => poller.PollTillCancelled());
}
Assert.IsFalse(poller.IsStarted);
Assert.Throws<ObjectDisposedException>(() => poller.PollTillCancelled());
Assert.Throws<ObjectDisposedException>(() => poller.CancelAndJoin());
Assert.Throws<ObjectDisposedException>(() => poller.AddTimer(timer));
Assert.Throws<ObjectDisposedException>(() => poller.RemoveTimer(timer));
}
public void TwoTimers()
{
var timer1 = new NetMQTimer(TimeSpan.FromMilliseconds(52));
var timer2 = new NetMQTimer(TimeSpan.FromMilliseconds(40));
int count = 0;
int count2 = 0;
var signal1 = new ManualResetEvent(false);
var signal2 = new ManualResetEvent(false);
timer1.Elapsed += (a, s) =>
{
count++;
timer1.Enable = false;
timer2.Enable = false;
signal1.Set();
};
timer2.Elapsed += (s, a) =>
{
count2++;
signal2.Set();
};
using (var poller = new Poller(timer1, timer2) { PollTimeout = TestPollTimeoutMillis })
{
poller.PollTillCancelledNonBlocking();
Assert.IsTrue(signal1.WaitOne(300));
Assert.IsTrue(signal2.WaitOne(300));
poller.CancelAndJoin();
}
Assert.AreEqual(1, count);
Assert.AreEqual(1, count2);
}
public void RunMultipleTimes()
{
int count = 0;
const int timerIntervalMillis = 20;
var timer = new NetMQTimer(TimeSpan.FromMilliseconds(timerIntervalMillis));
timer.Elapsed += (a, s) =>
{
count++;
if (count == 3)
{
timer.Enable = false;
}
};
using (var poller = new Poller(timer) { PollTimeout = TestPollTimeoutMillis })
{
poller.PollTillCancelledNonBlocking();
Thread.Sleep(timerIntervalMillis * 6);
poller.CancelAndJoin();
Assert.AreEqual(3, count);
}
}
public void SimpleTimer()
{
// TODO it is not really clear what this test is actually testing -- maybe split it into a few smaller tests
using (var context = NetMQContext.Create())
using (var router = context.CreateRouterSocket())
using (var dealer = context.CreateDealerSocket())
using (var poller = new Poller(router) { PollTimeout = TestPollTimeoutMillis })
{
int port = router.BindRandomPort("tcp://127.0.0.1");
dealer.Connect("tcp://127.0.0.1:" + port);
bool messageArrived = false;
router.ReceiveReady += (s, a) =>
{
Assert.IsFalse(messageArrived);
router.Receive();
router.Receive();
messageArrived = true;
};
bool timerTriggered = false;
int count = 0;
const int timerIntervalMillis = 100;
var timer = new NetMQTimer(TimeSpan.FromMilliseconds(timerIntervalMillis));
timer.Elapsed += (a, s) =>
{
// the timer should jump before the message
Assert.IsFalse(messageArrived);
timerTriggered = true;
timer.Enable = false;
count++;
};
poller.AddTimer(timer);
poller.PollTillCancelledNonBlocking();
Thread.Sleep(150);
dealer.Send("hello");
Thread.Sleep(300);
poller.CancelAndJoin();
Assert.IsTrue(messageArrived);
Assert.IsTrue(timerTriggered);
Assert.AreEqual(1, count);
}
}
public void RemoveTimer()
{
using (var context = NetMQContext.Create())
using (var router = context.CreateRouterSocket())
using (var dealer = context.CreateDealerSocket())
using (var poller = new Poller(router) { PollTimeout = TestPollTimeoutMillis })
{
int port = router.BindRandomPort("tcp://127.0.0.1");
dealer.Connect("tcp://127.0.0.1:" + port);
bool timerTriggered = false;
var timer = new NetMQTimer(TimeSpan.FromMilliseconds(100));
timer.Elapsed += (a, s) => { timerTriggered = true; };
// the timer will jump after 100ms
poller.AddTimer(timer);
bool messageArrived = false;
router.ReceiveReady += (s, a) =>
{
bool isMore;
router.Receive(out isMore);
router.Receive(out isMore);
messageArrived = true;
poller.RemoveTimer(timer);
};
poller.PollTillCancelledNonBlocking();
Thread.Sleep(20);
dealer.Send("hello");
Thread.Sleep(300);
poller.CancelAndJoin();
Assert.IsTrue(messageArrived);
Assert.IsFalse(timerTriggered);
}
}
public void ResponsePoll()
{
using (var context = NetMQContext.Create())
using (var rep = context.CreateResponseSocket())
using (var req = context.CreateRequestSocket())
using (var poller = new Poller(rep) { PollTimeout = TestPollTimeoutMillis })
{
int port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
rep.ReceiveReady += (s, a) =>
{
bool more;
Assert.AreEqual("Hello", a.Socket.ReceiveString(out more));
Assert.False(more);
a.Socket.Send("World");
};
poller.PollTillCancelledNonBlocking();
req.Send("Hello");
bool more2;
Assert.AreEqual("World", req.ReceiveString(out more2));
Assert.IsFalse(more2);
poller.CancelAndJoin();
}
}
public void NativeSocket()
{
using (var context = NetMQContext.Create())
using (var streamServer = context.CreateStreamSocket())
using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
int port = streamServer.BindRandomPort("tcp://*");
socket.Connect("127.0.0.1", port);
var buffer = new byte[] { 1 };
socket.Send(buffer);
byte[] identity = streamServer.Receive();
byte[] message = streamServer.Receive();
Assert.AreEqual(buffer[0], message[0]);
var socketSignal = new ManualResetEvent(false);
var poller = new Poller { PollTimeout = TestPollTimeoutMillis };
poller.AddPollInSocket(socket, s =>
{
socket.Receive(buffer);
socketSignal.Set();
// removing the socket
poller.RemovePollInSocket(socket);
});
poller.PollTillCancelledNonBlocking();
// no message is waiting for the socket so it should fail
Assert.IsFalse(socketSignal.WaitOne(100));
// sending a message back to the socket
streamServer.SendMore(identity).Send("a");
Assert.IsTrue(socketSignal.WaitOne(100));
socketSignal.Reset();
// sending a message back to the socket
streamServer.SendMore(identity).Send("a");
// we remove the native socket so it should fail
Assert.IsFalse(socketSignal.WaitOne(100));
poller.CancelAndJoin();
}
}
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, a) => acceptedEvent.Set();
repMonitor.Listening += (s, a) => listeningEvent.Set();
repMonitor.AttachToPoller(poller);
int port = rep.BindRandomPort("tcp://127.0.0.1");
reqMonitor.Connected += (s, a) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
poller.PollTillCancelledNonBlocking();
req.Connect("tcp://127.0.0.1:" + port);
req.Send("a");
rep.ReceiveString();
rep.Send("b");
req.ReceiveString();
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
poller.CancelAndJoin();
}
}
public void EnableTimer()
{
const int timerIntervalMillis = 20;
var timer1 = new NetMQTimer(TimeSpan.FromMilliseconds(timerIntervalMillis));
var timer2 = new NetMQTimer(TimeSpan.FromMilliseconds(timerIntervalMillis)) { Enable = false};
int count = 0;
int count2 = 0;
timer1.Elapsed += (a, s) =>
{
count++;
if (count == 1)
{
timer2.Enable = true;
timer1.Enable = false;
}
else if (count == 2)
{
timer1.Enable = false;
}
};
timer2.Elapsed += (s, a) =>
{
timer1.Enable = true;
timer2.Enable = false;
count2++;
};
using (var poller = new Poller(timer1, timer2) { PollTimeout = TestPollTimeoutMillis })
{
poller.PollTillCancelledNonBlocking();
Thread.Sleep(timerIntervalMillis * 6);
poller.CancelAndJoin();
}
Assert.AreEqual(2, count);
Assert.AreEqual(1, count2);
}
public void ChangeTimerInterval()
{
int count = 0;
const int timerIntervalMillis = 10;
var timer = new NetMQTimer(TimeSpan.FromMilliseconds(timerIntervalMillis));
var stopwatch = new Stopwatch();
long length1 = 0;
long length2 = 0;
timer.Elapsed += (a, s) =>
{
count++;
if (count == 1)
{
stopwatch.Start();
}
else if (count == 2)
{
length1 = stopwatch.ElapsedMilliseconds;
timer.Interval = 20;
stopwatch.Restart();
}
else if (count == 3)
{
length2 = stopwatch.ElapsedMilliseconds;
stopwatch.Stop();
timer.Enable = false;
}
};
using (var poller = new Poller(timer) { PollTimeout = TestPollTimeoutMillis })
{
poller.PollTillCancelledNonBlocking();
Thread.Sleep(timerIntervalMillis * 6);
poller.CancelAndJoin();
}
Assert.AreEqual(3, count);
Assert.AreEqual(10.0, length1, 2.0);
Assert.AreEqual(20.0, length2, 2.0);
}
public void AddTwoSocketAfterRemoving()
{
using (var context = NetMQContext.Create())
using (var router1 = context.CreateRouterSocket())
using (var router2 = context.CreateRouterSocket())
using (var router3 = context.CreateRouterSocket())
using (var router4 = context.CreateRouterSocket())
using (var dealer1 = context.CreateDealerSocket())
using (var dealer2 = context.CreateDealerSocket())
using (var dealer3 = context.CreateDealerSocket())
using (var dealer4 = context.CreateDealerSocket())
using (var poller = new Poller(router1, router2) { PollTimeout = TestPollTimeoutMillis })
{
int port1 = router1.BindRandomPort("tcp://127.0.0.1");
int port2 = router2.BindRandomPort("tcp://127.0.0.1");
int port3 = router3.BindRandomPort("tcp://127.0.0.1");
int port4 = router4.BindRandomPort("tcp://127.0.0.1");
dealer1.Connect("tcp://127.0.0.1:" + port1);
dealer2.Connect("tcp://127.0.0.1:" + port2);
dealer3.Connect("tcp://127.0.0.1:" + port3);
dealer4.Connect("tcp://127.0.0.1:" + port4);
int router1arrived = 0;
int router2arrived = 0;
bool router3arrived = false;
bool router4arrived = false;
var signal1 = new ManualResetEvent(false);
var signal2 = new ManualResetEvent(false);
var signal3 = new ManualResetEvent(false);
var signal4 = new ManualResetEvent(false);
router1.ReceiveReady += (s, a) =>
{
router1arrived++;
router1.Receive();
router1.Receive();
poller.RemoveSocket(router1);
signal1.Set();
};
router2.ReceiveReady += (s, a) =>
{
router2arrived++;
router2.Receive();
router2.Receive();
if (router2arrived == 1)
{
poller.AddSocket(router3);
poller.AddSocket(router4);
signal2.Set();
}
};
router3.ReceiveReady += (s, a) =>
{
router3.Receive();
router3.Receive();
router3arrived = true;
signal3.Set();
};
router4.ReceiveReady += (s, a) =>
{
router4.Receive();
router4.Receive();
router4arrived = true;
signal4.Set();
};
poller.PollTillCancelledNonBlocking();
dealer1.Send("1");
Assert.IsTrue(signal1.WaitOne(300));
dealer2.Send("2");
Assert.IsTrue(signal2.WaitOne(300));
dealer3.Send("3");
dealer4.Send("4");
dealer2.Send("2");
dealer1.Send("1");
Assert.IsTrue(signal3.WaitOne(300));
Assert.IsTrue(signal4.WaitOne(300));
poller.CancelAndJoin();
bool more;
router1.Receive(true, out more);
Assert.IsTrue(more);
router1.Receive(true, out more);
Assert.IsFalse(more);
Assert.AreEqual(1, router1arrived);
Assert.AreEqual(2, router2arrived);
Assert.IsTrue(router3arrived);
Assert.IsTrue(router4arrived);
}
}
