public void SendAndReceive()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back);
Task.Factory.StartNew(proxy.Start);
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
}
proxy.Stop();
}
}
public void ResponsePoll()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
using (var poller = new NetMQPoller { rep })
{
int port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
rep.ReceiveReady += (s, e) =>
{
bool more;
Assert.AreEqual("Hello", e.Socket.ReceiveFrameString(out more));
Assert.False(more);
e.Socket.SendFrame("World");
};
poller.RunAsync();
req.SendFrame("Hello");
bool more2;
Assert.AreEqual("World", req.ReceiveFrameString(out more2));
Assert.IsFalse(more2);
poller.Stop();
}
}
/// <summary>
/// Try to send request message and return the response as a message, or return null if not successful
/// </summary>
/// <param name="address">a string denoting the address to connect to</param>
/// <param name="requestMessage">The request message</param>
/// <param name="numTries">The number of times to try</param>
/// <param name="requestTimeout">The timeout for each request</param>
/// <param name="progressPublisher">Report topics: Failure, Retry, Send, Success</param>
/// <returns>the response message, or null if not successful</returns>
public static NetMQMessage RequestResponseMultipartMessageWithRetry([NotNull] string address, [NotNull] NetMQMessage requestMessage,
int numTries, TimeSpan requestTimeout, PublisherSocket progressPublisher = null)
{
var responseMessage = new NetMQMessage();
while (numTries-- > 0)
{
using (var requestSocket = new RequestSocket(address))
{
progressPublisher?.SendFrame(ProgressTopic.Send.ToString());
requestSocket.SendMultipartMessage(requestMessage);
if (requestSocket.TryReceiveMultipartMessage(requestTimeout, ref responseMessage))
{
progressPublisher?.SendFrame(ProgressTopic.Success.ToString());
return responseMessage;
}
progressPublisher?.SendFrame(ProgressTopic.Retry.ToString());
}
}
progressPublisher?.SendFrame(ProgressTopic.Failure.ToString());
return null;
}
public void ResponsePoll()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
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, e) =>
{
bool more;
Assert.AreEqual("Hello", e.Socket.ReceiveFrameString(out more));
Assert.False(more);
e.Socket.SendFrame("World");
};
poller.PollTillCancelledNonBlocking();
req.SendFrame("Hello");
bool more2;
Assert.AreEqual("World", req.ReceiveFrameString(out more2));
Assert.IsFalse(more2);
poller.CancelAndJoin();
}
}
public ZSocketManager(string connString)
{
bf = new BinaryFormatter();
connectionString = connString;
client = new NetMQ.Sockets.RequestSocket();
client.Connect(connectionString);
}
public void ReceiveBeforeSending()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
var port = rep.BindRandomPort("tcp://localhost");
req.Connect("tcp://localhost:" + port);
Assert.Throws<FiniteStateMachineException>(() => req.ReceiveFrameBytes());
}
}
public void SendMessageInResponeBeforeReceiving()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
var port = rep.BindRandomPort("tcp://localhost");
req.Connect("tcp://localhost:" + port);
Assert.Throws<FiniteStateMachineException>(() => rep.SendFrame("1"));
}
}
public void SendingTwoRequestsInaRow()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
var port = rep.BindRandomPort("tcp://localhost");
req.Connect("tcp://localhost:" + port);
req.SendFrame("Hi");
rep.SkipFrame();
Assert.Throws<FiniteStateMachineException>(() => req.SendFrame("Hi2"));
}
}
public void SimpleReqRep(string address)
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
var port = rep.BindRandomPort(address);
req.Connect(address + ":" + port);
req.SendFrame("Hi");
CollectionAssert.AreEqual(new[] { "Hi" }, rep.ReceiveMultipartStrings());
rep.SendFrame("Hi2");
CollectionAssert.AreEqual(new[] { "Hi2" }, req.ReceiveMultipartStrings());
}
}
public void SendMultipartMessage()
{
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
var port = rep.BindRandomPort("tcp://localhost");
req.Connect("tcp://localhost:" + port);
req.SendMoreFrame("Hello").SendFrame("World");
CollectionAssert.AreEqual(new[] { "Hello", "World" }, rep.ReceiveMultipartStrings());
rep.SendMoreFrame("Hello").SendFrame("Back");
CollectionAssert.AreEqual(new[] { "Hello", "Back" }, req.ReceiveMultipartStrings());
}
}
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 ControlSocketObservedMessages()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
using (var controlPush = new PushSocket())
using (var controlPull = new PullSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
controlPush.Bind("inproc://control");
controlPull.Connect("inproc://control");
var proxy = new Proxy(front, back, controlPush);
Task.Factory.StartNew(proxy.Start);
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
}
Assert.IsNotNull(controlPull.ReceiveFrameBytes()); // receive identity
Assert.IsEmpty(controlPull.ReceiveFrameString()); // pull terminator
Assert.AreEqual("hello", controlPull.ReceiveFrameString());
Assert.IsNotNull(controlPull.ReceiveFrameBytes()); // receive identity
Assert.IsEmpty(controlPull.ReceiveFrameString()); // pull terminator
Assert.AreEqual("reply", controlPull.ReceiveFrameString());
proxy.Stop();
}
}
/// <summary>
/// Try to send request string and return the response string, or return null if not successful
/// </summary>
/// <param name="address">a string denoting the address to connect to</param>
/// <param name="requestString">The request string</param>
/// <param name="numTries">The number of times to try</param>
/// <param name="requestTimeout">The timeout for each request</param>
/// <param name="progressPublisher">Report topics: Failure, Retry, Send, Success</param>
/// <returns>the response message, or null if not successful</returns>
public static string RequestResponseStringWithRetry(string address, string requestString,
int numTries, TimeSpan requestTimeout, PublisherSocket progressPublisher = null)
{
while (numTries-- > 0)
{
using (var requestSocket = new RequestSocket(address))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Send.ToString());
}
requestSocket.SendFrame(requestString);
string frameString;
if (requestSocket.TryReceiveFrameString(requestTimeout, out frameString))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Success.ToString());
}
return(frameString);
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Retry.ToString());
}
}
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Failure.ToString());
}
return(null);
}
public void CycleCreateTerminate()
{
NetMQConfig.ContextCreate(true);
var isTerminated = VerifyTermination();
Assert.AreEqual(false, isTerminated);
// We use the Poller Test code.
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
using (var poller = new NetMQPoller { rep })
{
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
rep.ReceiveReady += (s, e) =>
{
bool more;
Assert.AreEqual("Hello", e.Socket.ReceiveFrameString(out more));
Assert.False(more);
e.Socket.SendFrame("World");
};
poller.RunAsync();
req.SendFrame("Hello");
bool more2;
Assert.AreEqual("World", req.ReceiveFrameString(out more2));
Assert.IsFalse(more2);
poller.Stop();
}
NetMQConfig.ContextTerminate();
isTerminated = VerifyTermination();
Assert.AreEqual(true, isTerminated);
}
public void StartAgainAfterStop()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back);
Task.Factory.StartNew(proxy.Start);
// Send a message through to ensure the proxy has started
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
}
proxy.Stop(); // blocks until stopped
// Start it again
Task.Factory.StartNew(proxy.Start);
// Send a message through to ensure the proxy has started
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
}
proxy.Stop(); // blocks until stopped
}
}
public void Issue52_ReqToRouterBug()
{
using (var router = new RouterSocket())
using (var req = new RequestSocket())
{
router.Bind("inproc://example");
req.Connect("inproc://example");
const string testmessage = "Simple Messaging Test";
req.SendFrame(testmessage);
var msg = router.ReceiveMultipartMessage();
Assert.AreEqual(3, msg.FrameCount);
Assert.AreEqual(msg[2].ConvertToString(), testmessage);
}
}
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 res = new ResponseSocket())
{
NetMQMonitor monitor;
using (var req = new RequestSocket())
{
monitor = new NetMQMonitor(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.SendFrame("question");
Assert.That(res.ReceiveFrameString(), Is.EqualTo("question"));
res.SendFrame("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
}
/// <summary>
/// Try to send request string and return the response string, or return null if not successful
/// </summary>
/// <param name="address">a string denoting the address to connect to</param>
/// <param name="requestString">The request string</param>
/// <param name="numTries">The number of times to try</param>
/// <param name="requestTimeout">The timeout for each request</param>
/// <param name="progressPublisher">Report topics: Failure, Retry, Send, Success</param>
/// <returns>the response message, or null if not successful</returns>
public static string RequestResponseStringWithRetry([NotNull] string address, [NotNull] string requestString,
int numTries, TimeSpan requestTimeout, PublisherSocket progressPublisher = null)
{
while (numTries-- > 0)
{
using (var requestSocket = new RequestSocket(address))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Send.ToString());
}
requestSocket.SendFrame(requestString);
string frameString;
if (requestSocket.TryReceiveFrameString(requestTimeout, out frameString))
{
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Success.ToString());
}
return frameString;
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Retry.ToString());
}
}
}
if (progressPublisher != null)
{
progressPublisher.SendFrame(ProgressTopic.Failure.ToString());
}
return null;
}
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);
}
}
public void StartAndStopStateValidation()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back);
Task.Factory.StartNew(proxy.Start);
// Send a message through to ensure the proxy has started
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
}
Assert.Throws<InvalidOperationException>(proxy.Start);
Assert.Throws<InvalidOperationException>(proxy.Start);
Assert.Throws<InvalidOperationException>(proxy.Start);
proxy.Stop(); // blocks until stopped
Assert.Throws<InvalidOperationException>(proxy.Stop);
}
}
public void ConnectionStringSpecifyNonDefault()
{
using (ResponseSocket response = new ResponseSocket(">tcp://127.0.0.1:5555"))
{
using (RequestSocket request = new RequestSocket("@tcp://127.0.0.1:5555"))
{
request.SendFrame("Hello");
Assert.AreEqual("Hello", response.ReceiveFrameString());
}
}
}
public void TestKeepAlive()
{
// there is no way to test tcp keep alive without disconnect the cable, we just testing that is not crashing the system
using (var rep = new ResponseSocket())
using (var req = new RequestSocket())
{
rep.Options.TcpKeepalive = true;
rep.Options.TcpKeepaliveIdle = TimeSpan.FromSeconds(5);
rep.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(1);
req.Options.TcpKeepalive = true;
req.Options.TcpKeepaliveIdle = TimeSpan.FromSeconds(5);
req.Options.TcpKeepaliveInterval = TimeSpan.FromSeconds(1);
var port = rep.BindRandomPort("tcp://127.0.0.1");
req.Connect("tcp://127.0.0.1:" + port);
bool more;
req.SendFrame("1");
Assert.AreEqual("1", rep.ReceiveFrameString(out more));
Assert.IsFalse(more);
rep.SendFrame("2");
Assert.AreEqual("2", req.ReceiveFrameString(out more));
Assert.IsFalse(more);
Assert.IsTrue(req.Options.TcpKeepalive);
Assert.AreEqual(TimeSpan.FromSeconds(5), req.Options.TcpKeepaliveIdle);
Assert.AreEqual(TimeSpan.FromSeconds(1), req.Options.TcpKeepaliveInterval);
Assert.IsTrue(rep.Options.TcpKeepalive);
Assert.AreEqual(TimeSpan.FromSeconds(5), rep.Options.TcpKeepaliveIdle);
Assert.AreEqual(TimeSpan.FromSeconds(1), rep.Options.TcpKeepaliveInterval);
}
}
public void StoppingProxyDisengagesFunctionality()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back);
Task.Factory.StartNew(proxy.Start);
// Send a message through to ensure the proxy has started
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
proxy.Stop(); // blocks until stopped
using (var poller = new NetMQPoller { front, back })
{
poller.RunAsync();
client.SendFrame("anyone there?");
// Should no longer receive any messages
Assert.IsFalse(server.TrySkipFrame(TimeSpan.FromMilliseconds(50)));
}
}
}
}
public void ConnectionStringWithWhiteSpace()
{
using (ResponseSocket response = new ResponseSocket(" >tcp://127.0.0.1:5555 "))
{
using (RequestSocket request = new RequestSocket("@tcp://127.0.0.1:5555, "))
{
request.SendFrame("Hello");
Assert.AreEqual("Hello", response.ReceiveFrameString());
}
}
}
public void TestProxySendAndReceiveWithExternalPoller()
{
using (var front = new RouterSocket())
using (var back = new DealerSocket())
using (var poller = new NetMQPoller { front, back })
{
front.Bind("inproc://frontend");
back.Bind("inproc://backend");
var proxy = new Proxy(front, back, null, poller);
proxy.Start();
poller.RunAsync();
using (var client = new RequestSocket())
using (var server = new ResponseSocket())
{
client.Connect("inproc://frontend");
server.Connect("inproc://backend");
client.SendFrame("hello");
Assert.AreEqual("hello", server.ReceiveFrameString());
server.SendFrame("reply");
Assert.AreEqual("reply", client.ReceiveFrameString());
// Now stop the external poller
poller.Stop();
client.SendFrame("anyone there?");
// Should no longer receive any messages
Assert.IsFalse(server.TrySkipFrame(TimeSpan.FromMilliseconds(50)));
}
}
}
