public void Start()
{
_context = NetMQContext.Create();
_frontend = _context.CreateRouterSocket();
_backend = _context.CreateRouterSocket();
_frontend.Bind("tcp://localhost:5555"); // For Clients
_backend.Bind("tcp://localhost:5556"); // For Workers
_frontend.ReceiveReady += _frontEnd_ReceiveReady;
_backend.ReceiveReady += _backEnd_ReceiveReady;
var heartbeatTimer = new NetMQTimer(Paranoid.HEARTBEAT_INTERVAL_MS);
heartbeatTimer.Elapsed += heartbeatTimer_Elapsed;
_poller = new Poller();
_poller.AddSocket(_frontend);
_poller.AddSocket(_backend);
_poller.AddTimer(heartbeatTimer);
_nextHeartbeatAt = DateTime.Now.AddMilliseconds(Paranoid.HEARTBEAT_INTERVAL_MS);
Task.Factory.StartNew(t => Run(t), _tokenSource.Token, TaskCreationOptions.LongRunning);
Task.Factory.StartNew(_poller.Start, TaskCreationOptions.LongRunning);
}
public void AddSocketDuringWork()
{
using (NetMQContext contex = NetMQContext.Create())
{
// we are using three responses to make sure we actually move the correct socket and other sockets still work
using (var router = contex.CreateRouterSocket())
using (var router2 = contex.CreateRouterSocket())
{
router.Bind("tcp://127.0.0.1:5002");
router2.Bind("tcp://127.0.0.1:5003");
using (var dealer = contex.CreateDealerSocket())
using (var dealer2 = contex.CreateDealerSocket())
using (Poller poller = new Poller())
{
dealer.Connect("tcp://127.0.0.1:5002");
dealer2.Connect("tcp://127.0.0.1:5003");
bool router1arrived = false;
bool router2arrived = false;
bool more;
router2.ReceiveReady += (s, a) =>
{
router2.Receive(out more);
router2.Receive(out more);
router2arrived = true;
};
router.ReceiveReady += (s, a) =>
{
router1arrived = true;
router.Receive(out more);
router.Receive(out more);
poller.AddSocket(router2);
};
poller.AddSocket(router);
Task task = Task.Factory.StartNew(poller.Start);
dealer.Send("1");
Thread.Sleep(300);
dealer2.Send("2");
Thread.Sleep(300);
poller.Stop(true);
task.Wait();
Assert.IsTrue(router1arrived);
Assert.IsTrue(router2arrived);
}
}
}
}
void CreateServer()
{
switch (_type)
{
case ServerType.Response:
_serverSocket = _context.CreateResponseSocket(); break;
case ServerType.Pub:
_serverSocket = _context.CreatePushSocket(); break;
case ServerType.Router:
_serverSocket = _context.CreateRouterSocket(); break;
case ServerType.Stream:
_serverSocket = _context.CreateStreamSocket(); break;
case ServerType.Push:
_serverSocket = _context.CreatePushSocket(); break;
case ServerType.XPub:
_serverSocket = _context.CreateXPublisherSocket(); break;
default:
_serverSocket = _context.CreateResponseSocket(); break;
}
_serverSocket.Bind("tcp://*:" + _port);
Task.Factory.StartNew(() =>
AsyncRead(_serverSocket), TaskCreationOptions.LongRunning);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueDevice"/> class.
/// </summary>
/// <param name="context">The <see cref="NetMQContext"/> to use when creating the sockets.</param>
/// <param name="poller">The <see cref="Poller"/> to use.</param>
/// <param name="frontendBindAddress">The endpoint used to bind the frontend socket.</param>
/// <param name="backendBindAddress">The endpoint used to bind the backend socket.</param>
/// <param name="mode">The <see cref="DeviceMode"/> for the device.</param>
public QueueDevice(NetMQContext context, Poller poller, string frontendBindAddress, string backendBindAddress,
DeviceMode mode = DeviceMode.Threaded)
: base(poller, context.CreateRouterSocket(), context.CreateDealerSocket(), mode)
{
FrontendSetup.Bind(frontendBindAddress);
BackendSetup.Bind(backendBindAddress);
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueDevice"/> class.
/// </summary>
/// <param name="context">The <see cref="NetMQContext"/> to use when creating the sockets.</param>
/// <param name="poller">The <see cref="Poller"/> to use.</param>
/// <param name="frontendBindAddress">The endpoint used to bind the frontend socket.</param>
/// <param name="backendBindAddress">The endpoint used to bind the backend socket.</param>
/// <param name="mode">The <see cref="DeviceMode"/> for the device.</param>
public QueueDevice(NetMQContext context, Poller poller, string frontendBindAddress, string backendBindAddress,
DeviceMode mode = DeviceMode.Threaded)
: base(poller, context.CreateRouterSocket(), context.CreateDealerSocket(), mode)
{
FrontendSetup.Bind(frontendBindAddress);
BackendSetup.Bind(backendBindAddress);
}
protected void CreateServer()
{
switch (_type)
{
case MQServerType.Response:
_serverSocket = _context.CreateResponseSocket(); break;
case MQServerType.Publisher:
_serverSocket = _context.CreatePublisherSocket(); break;
case MQServerType.Router:
_serverSocket = _context.CreateRouterSocket(); break;
case MQServerType.Stream:
_serverSocket = _context.CreateStreamSocket(); break;
case MQServerType.Push:
_serverSocket = _context.CreatePushSocket(); break;
case MQServerType.XPublisher:
_serverSocket = _context.CreateXPublisherSocket(); break;
default:
_serverSocket = _context.CreateResponseSocket(); break;
}
_serverSocket.Bind("tcp://*:" + _port);
}
/// <summary>
/// Initializes a new instance of the Server class
/// </summary>
/// <param name="connectionString">How the server should be set up, to listen on TCP port 7954 to all incoming connections: "tcp://*:7954"</param>
public Server(string connectionString)
{
serverConnectionString = connectionString;
NetMQContext context = NetMQContext.Create();
netMqSocket = context.CreateRouterSocket();
netMqSocket.Bind(serverConnectionString);
}
public static void Main(string[] args)
{
var workers = new List <Thread>(WORKERS_COUNT);
using (NetMQContext context = NetMQContext.Create())
{
using (RouterSocket client = context.CreateRouterSocket())
{
string cnn = string.Format("tcp://localhost:{0}", PORT_NUMBER);
client.Bind(cnn);
Console.WriteLine("[B] Connect to {0}", cnn);
for (int workerNumber = 0; workerNumber < WORKERS_COUNT; workerNumber++)
{
workers.Add(new Thread(WorkerTask));
workers[workerNumber].Start(PORT_NUMBER);
}
for (int taskNumber = 0; taskNumber < WORKERS_COUNT * 10; taskNumber++)
{
// LRU worker is next waiting in queue
string address = client.ReceiveString();
//Console.WriteLine("[B] Message received: {0}", address);
string empty = client.ReceiveString();
//Console.WriteLine("[B] Message received: {0}", empty);
string ready = client.ReceiveString();
//Console.WriteLine("[B] Message received: {0}", ready);
client.SendMore(address);
//Console.WriteLine("[B] Message sent: {0}", address);
client.SendMore("");
//Console.WriteLine("[B] Message sent: {0}", "");
client.Send("This is the workload");
//Console.WriteLine("[B] Message sent: {0}", "This is the workload");
}
// Now ask mamas to shut down and report their results
for (int taskNbr = 0; taskNbr < WORKERS_COUNT; taskNbr++)
{
string address = client.ReceiveString();
//Console.WriteLine("[B] Message received: {0}", address);
string empty = client.ReceiveString();
//Console.WriteLine("[B] Message received: {0}", empty);
string ready = client.ReceiveString();
//Console.WriteLine("[B] Message received: {0}", ready);
client.SendMore(address);
//Console.WriteLine("[B] Message sent: {0}", address);
client.SendMore("");
//Console.WriteLine("[B] Message sent: {0}", "");
client.Send("END");
//Console.WriteLine("[B] Message sent: {0}", "END");
}
}
}
Console.ReadLine();
}
/// <summary>
/// ctor initializing all local variables
/// </summary>
private MDPBroker()
{
m_ctx = NetMQContext.Create();
Socket = m_ctx.CreateRouterSocket();
m_services = new List <Service> ();
m_knownWorkers = new List <Worker> ();
HeartbeatLiveliness = 3;
m_isBound = false;
}
public void BinaryTest()
{
Action <Example> setMessage = m =>
{
m.Id = Example.MessageId.Binary;
m.Binary.Sequence = 123;
FillArray(m.Binary.Flags, 123);
m.Binary.PublicKey = Encoding.ASCII.GetBytes("Captcha Diem");
m.Binary.Identifier = Guid.Parse("DED9D22A-FCE1-488B-8761-84752ACC113E");
};
Action <Example> checkMessage = m =>
{
Assert.That(m.Id, Is.EqualTo(Example.MessageId.Binary));
Assert.That(m.Binary.Sequence, Is.EqualTo(123));
Assert.That(m.Binary.Flags[0], Is.EqualTo(123));
Assert.That(m.Binary.Flags[m.Binary.Flags.Length - 1], Is.EqualTo(123));
Assert.That(m.Binary.PublicKey, Is.EqualTo(Encoding.ASCII.GetBytes("Captcha Diem")));
Assert.That(m.Binary.Identifier, Is.EqualTo(Guid.Parse("DED9D22A-FCE1-488B-8761-84752ACC113E")));
};
using (NetMQContext context = NetMQContext.Create())
using (var client = context.CreateDealerSocket())
using (var server = context.CreateRouterSocket())
{
server.Bind("inproc://zprototest");
client.Connect("inproc://zprototest");
Example clientMessage = new Example();
Example serverMessage = new Example();
for (int i = 0; i < 2; i++)
{
// client send message to server
setMessage(clientMessage);
clientMessage.Send(client);
// server receive the message
serverMessage.Receive(server);
// check that message received ok
Assert.That(serverMessage.RoutingId, Is.Not.Null);
checkMessage(serverMessage);
// reply to client, no need to set the message, using client data
serverMessage.Send(server);
// client receive the message
clientMessage.Receive(client);
// check that message received ok
Assert.That(clientMessage.RoutingId, Is.Null);
checkMessage(clientMessage);
}
}
}
public void CancelTimer()
{
using (NetMQContext contex = NetMQContext.Create())
{
// we are using three responses to make sure we actually move the correct socket and other sockets still work
using (var router = contex.CreateRouterSocket())
{
router.Bind("tcp://127.0.0.1:5002");
using (var dealer = contex.CreateDealerSocket())
using (Poller poller = new Poller())
{
dealer.Connect("tcp://127.0.0.1:5002");
bool timerTriggered = false;
NetMQTimer 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.AddSocket(router);
Task.Factory.StartNew(poller.Start);
Thread.Sleep(20);
dealer.Send("hello");
Thread.Sleep(300);
poller.Stop();
Assert.IsTrue(messageArrived);
Assert.IsFalse(timerTriggered);
}
}
}
}
/// <summary>
/// ctor initializing all local variables
/// <para>DEFAULTS:</para>
/// <para>heartbeat interval 2,500ms</para>
/// <para>max retries for waiting on heartbeats 3 times</para>
/// </summary>
private MDPBroker()
{
m_ctx = NetMQContext.Create();
Socket = m_ctx.CreateRouterSocket();
m_services = new List <Service> ();
m_knownWorkers = new List <Worker> ();
m_heartbeatInterval = TimeSpan.FromMilliseconds(2500); // otherwise the expiry would be 0(!)
HeartbeatLiveliness = 3; // so m_heartbeatExpiry = value * m_heartbeatInterval = 7.500 ms
m_isBound = false;
}
static void Main(string[] args)
{
int count = 1000000;
//BufferPool.SetBufferManagerBufferPool(1024 * 1024 * 10, 1024);
using (NetMQContext context = NetMQContext.Create())
{
using (var router = context.CreateRouterSocket())
{
router.Options.SendHighWatermark = 0;
router.Bind("tcp://*:5555");
List <DealerSocket> dealers = new List <DealerSocket>();
List <byte[]> identities = new List <byte[]>();
Random random = new Random();
for (int i = 0; i < 100; i++)
{
var dealer = context.CreateDealerSocket();
byte[] identity = new byte[50];
random.NextBytes(identity);
dealer.Options.Identity = identity;
dealer.Options.ReceiveHighWatermark = 0;
dealer.Connect("tcp://localhost:5555");
dealers.Add(dealer);
identities.Add(identity);
}
Thread.Sleep(1000);
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = 0; i < count; i++)
{
router.SendMore(identities[i % identities.Count]).Send("E");
}
stopwatch.Stop();
Console.WriteLine("{0:N1} in second", count / stopwatch.Elapsed.TotalSeconds);
Console.ReadLine();
foreach (var dealerSocket in dealers)
{
dealerSocket.Dispose();
}
}
}
}
private void ProxyThread()
{
RouterSocket router = null;
DealerSocket dealer = null;
try
{
router = _ctx.CreateRouterSocket();
dealer = _ctx.CreateDealerSocket();
router.Bind(_frontendAddress);
switch (_backendCxMode)
{
case ConnectionMode.Connect:
dealer.Connect(_backendAddress);
break;
case ConnectionMode.Bind:
dealer.Bind(_backendAddress);
break;
}
router.Options.Linger = TimeSpan.Zero;
dealer.Options.Linger = TimeSpan.Zero;
var xproxy = new Proxy(router, dealer, null);
xproxy.Start();
}
catch (TerminatingException)
{
}
finally
{
if (router != null)
{
try
{
router.Dispose();
}
catch (NetMQException)
{
}
}
if (dealer != null)
{
try
{
dealer.Dispose();
}
catch (NetMQException)
{
}
}
}
}
public void CheckRecvAgainException()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var routerSocket = context.CreateRouterSocket())
{
routerSocket.Bind("tcp://127.0.0.1:5555");
routerSocket.Receive(SendReceiveOptions.DontWait);
}
}
}
public void Mandatory()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var router = context.CreateRouterSocket())
{
router.Options.RouterMandatory = true;
router.Bind("tcp://*:5555");
Assert.Throws <HostUnreachableException>(() => router.SendMore("UNKOWN").Send("Hello"));
}
}
}
public void Run()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (var server = ctx.CreateRouterSocket())
{
server.Bind("tcp://127.0.0.1:5556");
CreateClient(ctx, "A_");
CreateClient(ctx, "B_");
CreateClient(ctx, "C_");
CreateClient(ctx, "D_");
while (true)
{
var clientMessage = server.ReceiveMessage();
Console.WriteLine("========================");
Console.WriteLine(" INCOMING CLIENT MESSAGE ");
Console.WriteLine("========================");
for (int i = 0; i < clientMessage.FrameCount; i++)
{
Console.WriteLine("Frame[{0}] = {1}", i,
clientMessage[i].ConvertToString());
}
var clientAddress = clientMessage[0];
var clientOriginalMessage = clientMessage[2].ConvertToString();
string response = string.Format("{0} back from server",
clientOriginalMessage);
// "B_" client is special
if (clientOriginalMessage.StartsWith("B_"))
{
response = string.Format(
"special Message for 'B' back from server");
}
var messageToClient = new NetMQMessage();
messageToClient.Append(clientAddress);
messageToClient.AppendEmptyFrame();
messageToClient.Append(response);
server.SendMessage(messageToClient);
}
}
}
Console.ReadLine();
}
public void ReceiveReadyDot35Bug()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var server = context.CreateRouterSocket())
{
server.Bind("tcp://127.0.0.1:5555");
server.ReceiveReady += (sender, e) =>
{
//no data receive but every 1s to display ReceiveReady.
Console.WriteLine("ReceiveReady!");
};
Assert.IsFalse(server.Poll(TimeSpan.FromMilliseconds(1000)));
}
}
}
static void Main(string[] args)
{
using (NetMQContext context = NetMQContext.Create())
using (RouterSocket router = context.CreateRouterSocket())
{
router.Bind("tcp://*:33333");
while (true)
{
byte[] identity = router.Receive();
string message = router.ReceiveString();
Console.WriteLine(message);
router.SendMore(identity).Send(message);
}
}
}
protected override void ProducerAction()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (RouterSocket socket = ctx.CreateRouterSocket())
{
socket.Bind(Address);
while (true)
{
NetMQMessage message = socket.ReceiveMessage();
if (!IsEmpty)
{
Queue.Add(message);
}
}
}
}
}
public void CheckSendAgainException()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var routerSocket = context.CreateRouterSocket())
{
routerSocket.Bind("tcp://127.0.0.1:5555");
routerSocket.Options.Linger = TimeSpan.Zero;
using (var dealerSocket = context.CreateDealerSocket())
{
dealerSocket.Options.SendHighWatermark = 1;
dealerSocket.Options.Linger = TimeSpan.Zero;
dealerSocket.Connect("tcp://127.0.0.1:5555");
dealerSocket.Send("1", true, false);
dealerSocket.Send("2", true, false);
}
}
}
}
public void RouterDealerMessaging()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var server = context.CreateRouterSocket())
{
server.Bind("tcp://127.0.0.1:5555");
using (var client = context.CreateDealerSocket())
{
client.Connect("tcp://127.0.0.1:5555");
NetMQMessage clientOutgoingMessage = new NetMQMessage();
clientOutgoingMessage.Append("Hello");
client.SendMessage(clientOutgoingMessage);
NetMQMessage serverIncomingMessage = server.ReceiveMessage();
// number of frames should be one because first message should be identity of client
Assert.AreEqual(2, serverIncomingMessage.FrameCount);
Assert.AreEqual("Hello", serverIncomingMessage[1].ConvertToString());
NetMQMessage serverOutgoingMessage = new NetMQMessage();
// first adding the identity
serverOutgoingMessage.Append(serverIncomingMessage[0]);
serverOutgoingMessage.Append("World");
server.SendMessage(serverOutgoingMessage);
NetMQMessage incomingClientMessage = new NetMQMessage();
client.ReceiveMessage(incomingClientMessage);
Assert.AreEqual(1, incomingClientMessage.FrameCount);
Assert.AreEqual("World", incomingClientMessage[0].ConvertToString());
}
}
}
}
public void HasInTest()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQSocket server = context.CreateRouterSocket())
{
server.Bind("tcp://*:5557");
// no one sent a message so it should be fasle
Assert.IsFalse(server.HasIn);
using (NetMQSocket client = context.CreateDealerSocket())
{
client.Connect("tcp://localhost:5557");
// wait for the client to connect
Thread.Sleep(100);
// now we have one client connected but didn't send a message yet
Assert.IsFalse(server.HasIn);
client.Send("1");
// wait for the message to arrive
Thread.Sleep(100);
// the has in should indicate a message is ready
Assert.IsTrue(server.HasIn);
byte[] identity = server.Receive();
string message = server.ReceiveString();
Assert.AreEqual(message, "1");
// we read the message, it should false again
Assert.IsFalse(server.HasIn);
}
}
}
}
// We have two workers, here we copy the code, normally these would
// run on different boxes…
public static void Main(string[] args)
{
var randomizer = new Random(DateTime.Now.Millisecond);
var workers = new List <Thread>(new[] { new Thread(WorkerTaskA), new Thread(WorkerTaskB) });
using (NetMQContext context = NetMQContext.Create())
{
using (RouterSocket client = context.CreateRouterSocket())
{
client.Bind(string.Format("tcp://localhost:{0}", PORT_NUMBER));
foreach (Thread thread in workers)
{
thread.Start(PORT_NUMBER);
}
// Wait for threads to connect, since otherwise the messages we send won't be routable.
Thread.Sleep(1000);
for (int taskNumber = 0; taskNumber < 1000; taskNumber++)
{
// Send two message parts, first the address…
client.SendMore(randomizer.Next(3) > 0 ? Encoding.Unicode.GetBytes("A") : Encoding.Unicode.GetBytes("B"));
// And then the workload
client.Send("This is the workload");
}
client.SendMore(Encoding.Unicode.GetBytes("A"));
client.Send("END");
client.SendMore(Encoding.Unicode.GetBytes("B"));
client.Send("END");
}
}
Console.ReadKey();
}
public void RawSocket()
{
byte[] message;
byte[] id;
using (NetMQContext context = NetMQContext.Create())
{
using (var routerSocket = context.CreateRouterSocket())
{
routerSocket.Options.RouterRawSocket = true;
routerSocket.Bind("tcp://127.0.0.1:5556");
using (var clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
clientSocket.Connect("127.0.0.1", 5556);
clientSocket.NoDelay = true;
byte[] clientMessage = Encoding.ASCII.GetBytes("HelloRaw");
int bytesSent = clientSocket.Send(clientMessage);
Assert.Greater(bytesSent, 0);
id = routerSocket.Receive();
message = routerSocket.Receive();
routerSocket.SendMore(id).
SendMore(message); // SNDMORE option is ignored
byte[] buffer = new byte[16];
int bytesRead = clientSocket.Receive(buffer);
Assert.Greater(bytesRead, 0);
Assert.AreEqual(Encoding.ASCII.GetString(buffer, 0, bytesRead), "HelloRaw");
}
}
}
}
private void RouterAction()
{
using (NetMQContext ctx = NetMQContext.Create())
{
using (RouterSocket socket = ctx.CreateRouterSocket())
{
socket.Bind(Address);
while (true)
{
NetMQMessage message = socket.ReceiveMessage();
string topic = message.Last.ConvertToString();
byte[] snapshot = _snapshotFactory(topic);
var response = new NetMQMessage();
response.Append(message.First);
response.AppendEmptyFrame();
response.Append(snapshot);
socket.SendMessage(response);
}
}
}
}
public void AddTwoSocketAfterRemoving()
{
using (NetMQContext contex = NetMQContext.Create())
{
// we are using three responses to make sure we actually move the correct socket and other sockets still work
using (var router = contex.CreateRouterSocket())
using (var router2 = contex.CreateRouterSocket())
using (var router3 = contex.CreateRouterSocket())
using (var router4 = contex.CreateRouterSocket())
{
router.Bind("tcp://127.0.0.1:5002");
router2.Bind("tcp://127.0.0.1:5003");
router3.Bind("tcp://127.0.0.1:5004");
router4.Bind("tcp://127.0.0.1:5005");
using (var dealer = contex.CreateDealerSocket())
using (var dealer2 = contex.CreateDealerSocket())
using (var dealer3 = contex.CreateDealerSocket())
using (var dealer4 = contex.CreateDealerSocket())
using (Poller poller = new Poller())
{
dealer.Connect("tcp://127.0.0.1:5002");
dealer2.Connect("tcp://127.0.0.1:5003");
dealer3.Connect("tcp://127.0.0.1:5004");
dealer4.Connect("tcp://127.0.0.1:5005");
int router1arrived = 0;
int router2arrived = 0;
bool router3arrived = false;
bool router4arrived = false;
bool more;
router.ReceiveReady += (s, a) =>
{
router1arrived++;
router.Receive(out more);
router.Receive(out more);
poller.RemoveSocket(router);
};
poller.AddSocket(router);
router3.ReceiveReady += (s, a) =>
{
router3.Receive(out more);
router3.Receive(out more);
router3arrived = true;
};
router4.ReceiveReady += (s, a) =>
{
router4.Receive(out more);
router4.Receive(out more);
router4arrived = true;
};
router2.ReceiveReady += (s, a) =>
{
router2arrived++;
router2.Receive(out more);
router2.Receive(out more);
if (router2arrived == 1)
{
poller.AddSocket(router3);
poller.AddSocket(router4);
}
};
poller.AddSocket(router2);
Task task = Task.Factory.StartNew(poller.Start);
dealer.Send("1");
Thread.Sleep(300);
dealer2.Send("2");
Thread.Sleep(300);
dealer3.Send("3");
dealer4.Send("4");
dealer2.Send("2");
dealer.Send("1");
Thread.Sleep(300);
poller.Stop(true);
task.Wait();
router.Receive(true, out more);
Assert.IsTrue(more);
router.Receive(true, out more);
Assert.IsFalse(more);
Assert.AreEqual(1, router1arrived);
Assert.AreEqual(2, router2arrived);
Assert.IsTrue(router3arrived);
Assert.IsTrue(router4arrived);
}
}
}
}
public void SimpleTimer()
{
using (NetMQContext contex = NetMQContext.Create())
{
// we are using three responses to make sure we actually move the correct socket and other sockets still work
using (var router = contex.CreateRouterSocket())
{
router.Bind("tcp://127.0.0.1:5002");
using (var dealer = contex.CreateDealerSocket())
using (Poller poller = new Poller())
{
dealer.Connect("tcp://127.0.0.1:5002");
bool messageArrived = false;
router.ReceiveReady += (s, a) =>
{
bool isMore;
router.Receive(out isMore);
router.Receive(out isMore);
messageArrived = true;
};
poller.AddSocket(router);
bool timerTriggered = false;
int count = 0;
NetMQTimer timer = new NetMQTimer(TimeSpan.FromMilliseconds(100));
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 CancelSocket()
{
using (NetMQContext contex = NetMQContext.Create())
{
// we are using three responses to make sure we actually move the correct socket and other sockets still work
using (var router = contex.CreateRouterSocket())
using (var router2 = contex.CreateRouterSocket())
using (var router3 = contex.CreateRouterSocket())
{
router.Bind("tcp://127.0.0.1:5002");
router2.Bind("tcp://127.0.0.1:5003");
router3.Bind("tcp://127.0.0.1:5004");
using (var dealer = contex.CreateDealerSocket())
using (var dealer2 = contex.CreateDealerSocket())
using (var dealer3 = contex.CreateDealerSocket())
using (Poller poller = new Poller())
{
dealer.Connect("tcp://127.0.0.1:5002");
dealer2.Connect("tcp://127.0.0.1:5003");
dealer3.Connect("tcp://127.0.0.1:5004");
bool first = true;
router2.ReceiveReady += (s, a) =>
{
bool more;
// identity
byte[] identity = a.Socket.Receive(out more);
// message
a.Socket.Receive(out more);
a.Socket.SendMore(identity);
a.Socket.Send("2");
};
poller.AddSocket(router2);
router.ReceiveReady += (s, a) =>
{
if (!first)
{
Assert.Fail("This should happen because we cancelled the socket");
}
first = false;
bool more;
// identity
a.Socket.Receive(out more);
string m = a.Socket.ReceiveString(out more);
Assert.False(more);
Assert.AreEqual("Hello", m);
// cancellign the socket
poller.RemoveSocket(a.Socket);
};
poller.AddSocket(router);
router3.ReceiveReady += (s, a) =>
{
bool more;
// identity
byte[] identity = a.Socket.Receive(out more);
// message
a.Socket.Receive(out more);
a.Socket.SendMore(identity).Send("3");
};
poller.AddSocket(router3);
Task pollerTask = Task.Factory.StartNew(poller.Start);
dealer.Send("Hello");
// sending this should not arrive on the poller, therefore response for this will never arrive
dealer.Send("Hello2");
Thread.Sleep(100);
// sending this should not arrive on the poller, therefore response for this will never arrive
dealer.Send("Hello3");
Thread.Sleep(500);
bool more2;
// making sure the socket defined before the one cancelled still works
dealer2.Send("1");
string msg = dealer2.ReceiveString(out more2);
Assert.AreEqual("2", msg);
// making sure the socket defined after the one cancelled still works
dealer3.Send("1");
msg = dealer3.ReceiveString(out more2);
Assert.AreEqual("3", msg);
// we have to give this some time if we want to make sure it's really not happening and it not only because of time
Thread.Sleep(300);
poller.Stop();
Thread.Sleep(100);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
public void AddSocketAfterRemoving()
{
using (NetMQContext contex = NetMQContext.Create())
{
// we are using three responses to make sure we actually move the correct socket and other sockets still work
using (var router = contex.CreateRouterSocket())
using (var router2 = contex.CreateRouterSocket())
using (var router3 = contex.CreateRouterSocket())
{
router.Bind("tcp://127.0.0.1:5002");
router2.Bind("tcp://127.0.0.1:5003");
router3.Bind("tcp://127.0.0.1:5004");
using (var dealer = contex.CreateDealerSocket())
using (var dealer2 = contex.CreateDealerSocket())
using (var dealer3 = contex.CreateDealerSocket())
using (Poller poller = new Poller())
{
dealer.Connect("tcp://127.0.0.1:5002");
dealer2.Connect("tcp://127.0.0.1:5003");
dealer3.Connect("tcp://127.0.0.1:5004");
bool router1arrived = false;
bool router2arrived = false;
bool router3arrived = false;
bool more;
router.ReceiveReady += (s, a) =>
{
router1arrived = true;
router.Receive(out more);
router.Receive(out more);
poller.RemoveSocket(router);
};
poller.AddSocket(router);
router3.ReceiveReady += (s, a) =>
{
router3.Receive(out more);
router3.Receive(out more);
router3arrived = true;
};
router2.ReceiveReady += (s, a) =>
{
router2arrived = true;
router2.Receive(out more);
router2.Receive(out more);
poller.AddSocket(router3);
};
poller.AddSocket(router2);
poller.PollTillCancelledNonBlocking();
dealer.Send("1");
Thread.Sleep(300);
dealer2.Send("2");
Thread.Sleep(300);
dealer3.Send("3");
Thread.Sleep(300);
poller.Stop(true);
Assert.IsTrue(router1arrived);
Assert.IsTrue(router2arrived);
Assert.IsTrue(router3arrived);
}
}
}
}
public void StructuresTest()
{
Action <Example> setMessage = m =>
{
m.Id = Example.MessageId.Structures;
m.Sequence = 123;
m.Aliases = new List <string>();
m.Aliases.Add("Name: Brutus");
m.Aliases.Add("Age: 43");
m.Headers = new Dictionary <string, string>();
m.Headers.Add("Name", "Brutus");
m.Headers.Add("Age", "43");
};
Action <Example> checkMessage = m =>
{
Assert.That(m.Id, Is.EqualTo(Example.MessageId.Structures));
Assert.That(m.Sequence, Is.EqualTo(123));
Assert.That(m.Aliases.Count, Is.EqualTo(2));
Assert.That(m.Aliases[0], Is.EqualTo("Name: Brutus"));
Assert.That(m.Aliases[1], Is.EqualTo("Age: 43"));
Assert.That(m.Headers.Count, Is.EqualTo(2));
Assert.That(m.Headers["Name"], Is.EqualTo("Brutus"));
Assert.That(m.Headers["Age"], Is.EqualTo("43"));
};
using (NetMQContext context = NetMQContext.Create())
using (var client = context.CreateDealerSocket())
using (var server = context.CreateRouterSocket())
{
server.Bind("inproc://zprototest");
client.Connect("inproc://zprototest");
Example clientMessage = new Example();
Example serverMessage = new Example();
for (int i = 0; i < 2; i++)
{
// client send message to server
setMessage(clientMessage);
clientMessage.Send(client);
// server receive the message
serverMessage.Receive(server);
// check that message received ok
Assert.That(serverMessage.RoutingId, Is.Not.Null);
checkMessage(serverMessage);
// reply to client, no need to set the message, using client data
serverMessage.Send(server);
// client receive the message
clientMessage.Receive(client);
// check that message received ok
Assert.That(clientMessage.RoutingId, Is.Null);
checkMessage(clientMessage);
}
clientMessage.Dispose();
serverMessage.Dispose();
}
}
