public void Run(params string[] addresses)
{
using (m_context = NetMQContext.Create())
{
var subscriber = Connect(addresses);
if (subscriber == null)
throw new Exception("cannot connect to eny of the endpoints");
// timeout timer, when heartbeat was not arrived for 5 seconds
m_timeoutTimer = new NetMQTimer(TimeSpan.FromSeconds(5));
m_timeoutTimer.Elapsed += (sender, args) =>
{
// timeout happend, first dispose existing subscriber
subscriber.Dispose();
m_poller.RemoveSocket(subscriber);
// connect again
subscriber = Connect(addresses);
if (subscriber == null)
throw new Exception("cannot connect to eny of the endpoints");
m_poller.AddSocket(subscriber);
};
m_poller = new Poller(subscriber);
m_poller.AddTimer(m_timeoutTimer);
m_poller.PollTillCancelled();
}
}
public static void Run()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var publisherSocket = context.CreateXPublisherSocket())
{
publisherSocket.SetWelcomeMessage("WM");
publisherSocket.Bind("tcp://*:6669");
// we just drop subscriptions
publisherSocket.ReceiveReady += (sender, eventArgs) => publisherSocket.SkipMultipartMessage();
Poller poller = new Poller(publisherSocket);
// send a message every second
NetMQTimer sendMessageTimer = new NetMQTimer(1000);
poller.AddTimer(sendMessageTimer);
sendMessageTimer.Elapsed +=
(sender, eventArgs) =>
publisherSocket.SendMoreFrame("A").SendFrame(new Random().Next().ToString());
// send heartbeat every two seconds
NetMQTimer heartbeatTimer = new NetMQTimer(2000);
poller.AddTimer(heartbeatTimer);
heartbeatTimer.Elapsed += (sender, eventArgs) => publisherSocket.SendFrame("HB");
poller.PollTillCancelled();
}
}
}
/// <summary>
/// setup the client with standard values
/// verbose == false
/// Connect the client to broker
/// </summary>
private MDPClientAsync()
{
m_client = null;
m_connected = false;
m_poller = new NetMQPoller();
Timeout = m_defaultTimeOut;
m_timer = new NetMQTimer(Timeout);
m_timer.Enable = false;
m_poller.Add(m_timer);
m_timer.Elapsed += (s, e) => OnProcessTimeOut();
m_poller.RunAsync();
}
public void RemoveTimer(NetMQTimer timer)
{
if (timer == null)
{
throw new ArgumentNullException("timer");
}
if (m_disposed)
{
throw new ObjectDisposedException("Poller is disposed");
}
timer.When = -1;
m_zombies.Add(timer);
}
void IShimHandler.Run(PairSocket shim)
{
_pipe = shim;
_pipe.SignalOK();
_pipe.ReceiveReady += OnPipeReady;
_timer = new NetMQTimer(TimeSpan.FromSeconds(1));
_timer.Elapsed += OnPingPeer;
_inbox = _context.CreateRouterSocket();
_inbox.ReceiveReady += OnInboxReady;
_poller = new Poller(_pipe);
_poller.AddTimer(_timer);
_poller.PollTillCancelled();
}
static void Main(string[] args)
{
using (var context = NetMQContext.Create())
{
string[] topics = new string[] { "A", "B", "C" };
Random random = new Random();
using (var publisher = context.CreateXPublisherSocket())
{
// Set publisher to manual subscriptions mode
publisher.Options.ManualPublisher = true;
publisher.Bind("tcp://*:5556");
publisher.ReceiveReady += (sender, eventArgs) =>
{
var message = publisher.ReceiveString();
// we only handle subscription requests, unsubscription and any
// other type of messages will be dropped
if (message[0] == (char)1)
{
// calling Subscribe to add subscription to the last subscriber
publisher.Subscribe(message.Substring(1));
}
};
NetMQTimer sendTimer = new NetMQTimer(1000);
sendTimer.Elapsed += (sender, eventArgs) =>
{
// sends a message every second with random topic and current time
publisher.
SendMore(topics[random.Next(3)]).
Send(DateTime.Now.ToString());
};
Poller poller = new Poller();
poller.AddSocket(publisher);
poller.AddTimer(sendTimer);
poller.PollTillCancelled();
}
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new NetMQPoller {
m_pipe, m_pingTimer
};
m_poller.Run();
// the beacon might never been configured
m_udpSocket?.Close();
}
/// <summary>
/// create worker with standard parameter
/// HeartbeatDelay == 2500 milliseconds
/// ReconnectDelay == 2500 milliseconds
/// ConnectionRetries == 3
/// Verbose == false
/// </summary>
private MDPWorker()
{
HeartbeatDelay = TimeSpan.FromMilliseconds(2500);
ReconnectDelay = TimeSpan.FromMilliseconds(2500);
m_timer = new NetMQTimer(HeartbeatDelay);
m_timer.Enable = false;
m_timer.Elapsed += (s, e) => OnHeartbeat();
m_pollerQueue = new NetMQQueue<Action>();
m_pollerQueue.ReceiveReady += (sender, args) =>
{
var action = args.Queue.Dequeue();
action.Invoke();
};
m_poller = new NetMQPoller();
m_poller.Add(m_pollerQueue);
m_poller.Add(m_timer);
m_poller.RunAsync();
}
/// <summary>
/// Create a new instance of a Proxy (NetMQ.Proxy)
/// with the given sockets to serve as a front-end, a back-end, and a control socket.
/// </summary>
/// <param name="publisherAddress">the address that messages will be forwarded from</param>
/// <param name="subscriberAddress">the address that messages should be sent to</param>
/// <param name="heartbeat">the timespan at which to send HEARTBEAT messages (in milliseconds) - you can set this to zero if not needed</param>
/// <param name="control">this socket will have messages also sent to it - you can set this to null if not needed</param>
public ZeroMqHub(string publisherAddress, string subscriberAddress, int heartbeat = 0, NetMQSocket control = null)
{
_subscriberAddress = subscriberAddress;
_publisherAddress = publisherAddress;
var context = NetMQContext.Create();
_subscriber = context.CreateXSubscriberSocket();
_publisher = context.CreateXPublisherSocket();
_control = control;
if (heartbeat > 0)
{
_heartbeat = new NetMQTimer(heartbeat);
_heartbeat.Elapsed += (s, a) => _publisher.Send("HEARTBEAT");
}
Name = "XPub-XSub";
PSJobTypeName = typeof(ZeroMqHub).Name;
_subscriber.Bind(subscriberAddress);
_publisher.Bind(publisherAddress);
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(0);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new Poller();
m_poller.AddSocket(m_pipe);
m_poller.AddTimer(m_pingTimer);
m_poller.PollTillCancelled();
// the beacon might never been configured
if (m_udpSocket != null)
{
m_udpSocket.Close();
}
}
/// <summary>
/// Create a new NetMQTimerEventArgs that contains a reference to the given NetMQTimer.
/// </summary>
/// <param name="timer">the NetMQTimer to hold a reference to</param>
public NetMQTimerEventArgs([NotNull] NetMQTimer timer)
{
Timer = timer;
}
/// <summary>
/// ParanoidPirate.Queue [-v]
///
/// Does load-balancing with heartbeating on worker tasks to detect
/// crashed, blocked or slow running worker tasks .
/// </summary>
private static void Main(string[] args)
{
Console.Title = "NetMQ ParanoidPirate Queue";
// serves as flag for exiting the program
var exit = false;
// catch CTRL+C as exit command
Console.CancelKeyPress += (s, e) =>
{
e.Cancel = true;
exit = true;
};
var verbose = args.Length > 0 && args[0] == "-v";
using (var frontend = new RouterSocket())
using (var backend = new RouterSocket())
using (var poller = new NetMQPoller())
{
frontend.Bind(Commons.QueueFrontend);
backend.Bind(Commons.QueueBackend);
var workers = new Workers();
// client sends to this socket
frontend.ReceiveReady += (s, e) =>
{
// only process incoming client requests
// if we have workers available handle client requests as long as we have workers
// storage capability of the socket otherwise and pick up later
if (workers.Available)
{
// get all message frames!
var request = frontend.ReceiveMultipartMessage();
if (verbose)
Console.WriteLine("[QUEUE] received {0}", request);
// get next available worker
var worker = workers.Next();
// wrap message with worker's address
var msg = Wrap(worker, request);
if (verbose)
Console.WriteLine("[QUEUE -> WORKER] sending {0}", msg);
backend.SendMultipartMessage(msg);
}
};
// worker sends to this socket
backend.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveMultipartMessage();
if (verbose)
Console.WriteLine("[QUEUE <- WORKER] received {0}", msg);
// use workers identity for load-balancing
var workerIdentity = Unwrap(msg);
var worker = new Worker(workerIdentity);
workers.Ready(worker);
// just convenience
var readableWorkerId = workerIdentity.ConvertToString();
if (msg.FrameCount == 1)
{
var data = msg[0].ConvertToString();
// the message is either READY or HEARTBEAT or corrupted
switch (data)
{
case Commons.PPPHeartbeat:
Console.WriteLine("[QUEUE <- WORKER] Received a Heartbeat from {0}",
readableWorkerId);
break;
case Commons.PPPReady:
Console.WriteLine("[QUEUE <- WORKER] Received a READY form {0}",
readableWorkerId);
break;
default:
Console.WriteLine("[QUEUE <- WORKER] ERROR received an invalid message!");
break;
}
}
else
{
if (verbose)
Console.WriteLine("[QUEUE -> CLIENT] sending {0}", msg);
frontend.SendMultipartMessage(msg);
}
};
var timer = new NetMQTimer(Commons.HeartbeatInterval);
// every specified ms QUEUE shall send a heartbeat to all connected workers
timer.Elapsed += (s, e) =>
{
// send heartbeat to every worker
foreach (var worker in workers)
{
var heartbeat = new NetMQMessage();
heartbeat.Push(new NetMQFrame(Commons.PPPHeartbeat));
heartbeat.Push(worker.Identity);
Console.WriteLine("[QUEUE -> WORKER] sending heartbeat!");
backend.SendMultipartMessage(heartbeat);
}
// restart timer
e.Timer.Enable = true;
// remove all dead or expired workers
workers.Purge();
};
if (verbose)
Console.WriteLine("[QUEUE] Start listening!");
poller.Add(frontend);
poller.Add(backend);
poller.RunAsync();
// hit CRTL+C to stop the while loop
while (!exit)
Thread.Sleep(100);
}
}
public void SendWrongMDPVersionFromBrokerNoLoggingShouldThrowApplicationException()
{
const string hostAddress = "tcp://localhost:5555";
// setup the counter socket for communication
using (var broker = new RouterSocket())
using (var poller = new NetMQPoller())
using (var session = new MDPClientAsync(hostAddress))
{
broker.Bind(hostAddress);
// we need to pick up any message in order to avoid errors
broker.ReceiveReady += (s, e) =>
{
// return empty reply
var msg = e.Socket.ReceiveMultipartMessage();
// we expect to receive a 4 Frame message
// [REQ ADR][EMPTY]["MDPC01"]["echo"]["REQUEST"][requestId]
if (msg.FrameCount != 6)
Assert.Fail("Message with wrong count of frames {0}", msg.FrameCount);
// REQUEST socket will strip the his address + empty frame
// ROUTER has to add the address prelude in order to identify the correct socket(!)
// [REQ ADR][EMPTY]["MDPC00"]["echo"]["REQUEST"][requestId]
var clientAddress = msg.Pop();
msg.Pop(); // forget empty frame
msg.Pop(); // drop the MDP Version Frame
msg.Push("MDPC00"); // insert wrong MDP version
msg.Push(NetMQFrame.Empty);
msg.Push(clientAddress); // reinsert the client's address
e.Socket.SendMultipartMessage(msg);
};
int timeOutInMillis = 10000;
var timer = new NetMQTimer(timeOutInMillis); // Used so it doesn't block if something goes wrong!
timer.Elapsed += (s, e) =>
{
Assert.Fail($"Waited {timeOutInMillis} and had no response from broker");
poller.Stop();
};
poller.Add(broker);
poller.Add(timer);
session.ReplyReady += (s, e) =>
{
Assert.True(e.HasError());
Assert.That(e.Exception.Message, Is.StringContaining("MDP Version mismatch"));
poller.Stop(); // To unlock the Task.Wait()
};
session.FailedRequest += (s, e) =>
{
Assert.True(e.HasError());
Assert.That(e.Exception.Message, Is.StringContaining("MDP Version mismatch"));
poller.Stop(); // To unlock the Task.Wait()
};
var task = Task.Factory.StartNew(() => poller.Run());
var requestMessage = new NetMQMessage(new[] { new NetMQFrame("REQUEST") });
session.Send("echo", requestMessage);
task.Wait();
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(0);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new Poller();
m_poller.AddSocket(m_pipe);
m_poller.AddTimer(m_pingTimer);
m_poller.PollTillCancelled();
// the beacon might never been configured
if (m_udpSocket != null)
{
m_udpSocket.Close();
}
}
private void Run(PairSocket shim)
{
m_shim = shim;
shim.ReceiveReady += OnShimMessage;
m_timeoutTimer = new NetMQTimer(TimeOut);
m_timeoutTimer.Elapsed += OnTimeoutTimer;
m_reconnectTimer = new NetMQTimer(ReconnectTimer);
m_reconnectTimer.Elapsed += OnReconnectTimer;
m_poller = new Poller(shim);
m_poller.AddTimer(m_timeoutTimer);
m_poller.AddTimer(m_reconnectTimer);
shim.SignalOK();
Connect();
m_poller.PollTillCancelled();
if (m_subscriber != null)
m_subscriber.Dispose();
}
public void Remove( NetMQTimer timer)
{
if (timer == null)
throw new ArgumentNullException("timer");
CheckDisposed();
timer.When = -1;
Run(() => m_timers.Remove(timer));
}
public void SendEmptyReplyFromBrokerWithLoggingShouldThrowApplicationException()
{
const string hostAddress = "tcp://localhost:5555";
var loggingMessages = new List<string>();
// setup the counter socket for communication
using (var broker = new RouterSocket())
using (var poller = new NetMQPoller())
using (var session = new MDPClientAsync(hostAddress))
{
broker.Bind(hostAddress);
// we need to pick up any message in order to avoid errors
broker.ReceiveReady += (s, e) =>
{
// return empty reply
var msg = e.Socket.ReceiveMultipartMessage();
// we expect to receive a 4 Frame message
// [REQ ADR][EMPTY]["MDPC01"]["echo"]["REQUEST"][requestId]
if (msg.FrameCount != 6)
Assert.Fail("Message with wrong count of frames {0}", msg.FrameCount);
// REQUEST socket will strip the his address + empty frame
// ROUTER has to add the address prelude in order to identify the correct socket(!)
// [REQ ADR][EMPTY]["MDPC01"]["echo"]["REQUEST"][requestId]
e.Socket.SendMultipartMessage(msg);
};
session.LogInfoReady += (s, e) => loggingMessages.Add(e.Info);
session.ReplyReady += (s, e) =>
{
Assert.That(loggingMessages.Count, Is.EqualTo(3));
Assert.That(loggingMessages[0], Is.EqualTo("[CLIENT] connecting to broker at tcp://localhost:5555"));
Assert.That(loggingMessages[1].Contains("[CLIENT INFO] sending"), Is.True);
Assert.That(loggingMessages[2].Contains("[CLIENT INFO] received"), Is.True);
poller.Stop(); // To unlock the Task.Wait()
};
poller.Add(broker);
var task = Task.Factory.StartNew(() => poller.Run());
// well formed message
var requestMessage = new NetMQMessage(new[] { new NetMQFrame("REQUEST") });
// correct call
session.Send("echo", requestMessage);
int timeOutInMillis = 10000;
var timer = new NetMQTimer(timeOutInMillis); // Used so it doesn't block if something goes wrong!
timer.Elapsed += (s, e) =>
{
Assert.Fail($"Waited {timeOutInMillis} and had no response from broker");
poller.Stop();
};
poller.Add(timer);
task.Wait();
}
}
private void Run(PairSocket shim)
{
using (m_publisherSocket = m_context.CreateXPublisherSocket())
{
m_publisherSocket.SetWelcomeMessage(WelcomeMessage);
m_publisherSocket.Bind(m_address);
m_publisherSocket.ReceiveReady += DropPublisherSubscriptions;
m_heartbeatTimer = new NetMQTimer(HeartbeatInterval);
m_heartbeatTimer.Elapsed += OnHeartbeatTimerElapsed;
shim.ReceiveReady += OnShimMessage;
// signal the actor that the shim is ready to work
shim.SignalOK();
m_poller = new Poller(m_publisherSocket, shim);
m_poller.AddTimer(m_heartbeatTimer);
// Polling until poller is cancelled
m_poller.PollTillCancelled();
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
using (m_poller = new NetMQPoller { m_pipe, m_pingTimer })
{
m_poller.Run();
}
// the beacon might never been configured
#if NET35
m_udpSocket?.Close();
#else
m_udpSocket?.Dispose();
#endif
}
public void RemoveTimer(NetMQTimer timer)
{
timer.When = -1;
m_zombies.Add(timer);
}
public void AddTimer(NetMQTimer timer)
{
m_timers.Add(timer);
}
private SubscriberSocket Connect(string[] addresses)
{
List<SubscriberSocket> sockets = new List<SubscriberSocket>();
Poller poller = new Poller();
SubscriberSocket connectedSocket = null;
// event handler to handle message from socket
EventHandler<NetMQSocketEventArgs> handleMessage = (sender, args) =>
{
if (connectedSocket == null)
{
connectedSocket = (SubscriberSocket) args.Socket;
poller.Cancel();
}
};
// If timeout elapsed just cancel the poller without seting the connected socket
NetMQTimer timeoutTimer = new NetMQTimer(TimeSpan.FromSeconds(5));
timeoutTimer.Elapsed += (sender, args) => poller.Cancel();
poller.AddTimer(timeoutTimer);
foreach (var address in addresses)
{
var socket = m_context.CreateSubscriberSocket();
sockets.Add(socket);
socket.ReceiveReady += handleMessage;
poller.AddSocket(socket);
// Subscribe to welcome message
socket.Subscribe("WM");
socket.Connect(address);
}
poller.PollTillCancelled();
// if we a connected socket the connection attempt succeed
if (connectedSocket != null)
{
// remove the connected socket form the list
sockets.Remove(connectedSocket);
// close all existing sockets
CloseSockets(sockets);
// drop the welcome message
connectedSocket.SkipMultipartMessage();
// subscribe to heartbeat
connectedSocket.Subscribe("HB");
// subscribe to our only topic
connectedSocket.Subscribe("A");
connectedSocket.ReceiveReady -= handleMessage;
connectedSocket.ReceiveReady += OnSubscriberMessage;
return connectedSocket;
}
else
{
// close all existing sockets
CloseSockets(sockets);
return null;
}
}
/// <summary>
/// the broker setting up the cluster
///
///
/// State 2 ---+ +--- State n
/// | |
/// +----+----+
/// client 1 ---| | |--- worker 1
/// client 2 ---+---- BROKER 1 ----+--- worker 2
/// : | | | :
/// client n ---+ +----+----+ +--- worker n
/// | |
/// BROKER 2 BROKER n
///
/// BROKER 2 and n are not included and must be setup separately
///
/// A minimum of two address must be supplied
/// </summary>
/// <param name="args">[0] = this broker's address
/// [1] = 1st peer's address
/// :
/// [n] = nth peer address</param>
/// <remarks>
/// since "inproc://" is not working in NetMQ we use "tcp://"
/// for each broker we need 5 ports which for this example are
/// assigned as follows (in true life it should be configurable whether
/// they are ports or tcp/ip addresses)
///
/// this brokers address => local frontend binds to tcp://127.0.0.1:5555
/// cloud frontend binds to :5556
/// local backend binds to :5557
/// state backend binds to :5558
/// monitor PULL binds to :5559
///
/// the sockets are connected as follows
///
/// this broker's monitor PUSH connects to tcp://127.0.0.1:5559
///
/// (if peer's address and port is tcp://127.0.0.1:5575)
///
/// this broker's cloud backend connects to :5576
/// this broker's state frontend connects to :5578
///
/// this scheme is fix in this example
/// </remarks>
public static void Main(string[] args)
{
Console.Title = "NetMQ Inter-Broker Router";
const string baseAddress = "tcp://127.0.0.1:";
if (args.Length < 2)
{
Console.WriteLine("usage: program me peer1 [peer]*");
Console.WriteLine("each broker needs 5 port for his sockets!");
Console.WriteLine("place enough distance between multiple broker addresses!");
Environment.Exit(-1);
}
// trapping Ctrl+C as exit signal!
Console.CancelKeyPress += (s, e) =>
{
e.Cancel = true;
s_keepRunning = false;
};
// get random generator for later use
var rnd = new Random();
// get list for registering the clients
var clients = new List<byte[]>(NbrClients);
// get a list of peer addresses
var peers = new List<byte[]>();
// get all peer addresses - first is this broker!
for (var i = 1; i < args.Length; i++)
peers.Add(Encoding.UTF8.GetBytes(args[i]));
// build this broker's address
var me = baseAddress + args[0];
// get the port as integer for later use
var myPort = int.Parse(args[0]);
Console.WriteLine("[BROKER] The broker can be stopped by using CTRL+C!");
Console.WriteLine("[BROKER] setting up sockets ...");
// set up all the addresses needed in the due course
var localFrontendAddress = me;
var cloudFrontendAddress = baseAddress + (myPort + 1);
var localBackendAddress = baseAddress + (myPort + 2);
var stateBackendAddress = baseAddress + (myPort + 3);
var monitorAddress = baseAddress + (myPort + 4);
// create the context and all the sockets
using (var context = NetMQContext.Create())
using (var localFrontend = context.CreateRouterSocket())
using (var localBackend = context.CreateRouterSocket())
using (var cloudFrontend = context.CreateRouterSocket())
using (var cloudBackend = context.CreateRouterSocket())
using (var stateBackend = context.CreatePublisherSocket())
using (var stateFrontend = context.CreateSubscriberSocket())
using (var monitor = context.CreatePullSocket())
{
// give every socket an unique identity, e.g. LocalFrontend[Port]
SetIdentities(myPort,
localFrontend,
cloudFrontend,
localBackend,
stateBackend,
monitor,
cloudBackend, stateFrontend);
// subscribe to any message on the stateFrontend socket!
stateFrontend.Subscribe("");
// bind the serving sockets
localFrontend.Bind(localFrontendAddress);
cloudFrontend.Bind(cloudFrontendAddress);
localBackend.Bind(localBackendAddress);
stateBackend.Bind(stateBackendAddress);
monitor.Bind(monitorAddress);
// connect sockets to peers
for (var i = 1; i < args.Length; i++)
{
// build the cloud back end address
var peerPort = int.Parse(args[i]);
var address = baseAddress + (peerPort + 1);
Console.WriteLine("[BROKER] connect to cloud peer {0}", address);
// this cloudBackend connects to all peer cloudFrontends
cloudBackend.Connect(address);
// build the state front end address
address = baseAddress + (peerPort + 3);
Console.WriteLine("[BROKER] subscribe to state peer {0}", address);
// this stateFrontend to all peer stateBackends
stateFrontend.Connect(address);
}
// setup the local worker queue for LRU and monitor cloud capacity
var workerQueue = new Queue<byte[]>();
int previousLocalCapacity = 0;
// receive the capacity available from other peer(s)
stateFrontend.ReceiveReady += (s, e) =>
{
// the message should contain the available cloud capacity
var capacity = e.Socket.ReceiveFrameString();
Debug.Assert(string.IsNullOrWhiteSpace(capacity), "StateFrontend: message was empty!");
int couldCapacity;
Debug.Assert(int.TryParse(capacity, out couldCapacity), "StateFrontend: message did not contain a number!");
};
// get the status message and print it
monitor.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveFrameString();
Console.WriteLine("[MONITOR] {0}", msg);
};
// all local clients are connecting to this socket
// they send a REQ and get a REPLY
localFrontend.ReceiveReady += (s, e) =>
{
// [client adr][empty][message id]
var request = e.Socket.ReceiveMultipartMessage();
// register the local client for later identification if not known
if (!clients.Any(n => AreSame(n, request[0])))
clients.Add(request[0].Buffer);
// if we have local capacity send worker else send to cloud
if (workerQueue.Count > 0)
{
// get the LRU worker adr
var worker = workerQueue.Dequeue();
// wrap message with workers address
var msg = Wrap(worker, request);
// send message to the worker
// [worker adr][empty][client adr][empty][data]
localBackend.SendMessage(msg);
}
else
{
// get an random index for peers
var peerIdx = rnd.Next(peers.Count - 2) + 2;
// get peers address
var peer = peers[peerIdx];
// wrap message with peer's address
var msg = Wrap(peer, request);
// [peer adr][empty][client adr][empty][data]
cloudBackend.SendMessage(msg);
}
};
// the workers are connected to this socket
// we get a REPLY either for a cloud client [worker adr][empty][peer adr][empty][peer client adr][empty][data]
// or local client [worker adr][empty][client adr][empty][data]
// or a READY message [worker adr][empty][WORKER_READY]
localBackend.ReceiveReady += (s, e) =>
{
// a worker can send "READY" or a request
// or an REPLAY
var msg = e.Socket.ReceiveMultipartMessage();
// just to make sure we received a proper message
Debug.Assert(msg != null && msg.FrameCount > 0, "[LocalBackend] message was empty or frame count == 0!");
// get the workers identity
var id = Unwrap(msg);
// this worker done in either way so add it to available workers
workerQueue.Enqueue(id);
// if it is NOT a ready message we need to route the message
// it could be a reply to a peer or a local client
// [WORKER_READY] or [client adr][empty][data] or [peer adr][empty][peer client adr][empty][data]
if (msg[0].Buffer[0] != WorkerReady)
{
Debug.Assert(msg.FrameCount > 2, "[LocalBackend] None READY message malformed");
// if the adr (first frame) is any of the clients send the REPLY there
// and send it to the peer otherwise
if (clients.Any(n => AreSame(n, msg.First)))
localFrontend.SendMessage(msg);
else
cloudFrontend.SendMessage(msg);
}
};
// this socket is connected to all peers
// we receive either a REQ or a REPLY form a peer
// REQ [peer adr][empty][peer client adr][empty][message id] -> send to peer for processing
// REP [peer adr][empty][client adr][empty][message id] -> send to local client
cloudBackend.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveMultipartMessage();
// just to make sure we received a message
Debug.Assert(msg != null && msg.FrameCount > 0, "[CloudBackend] message was empty or frame count == 0!");
// we need the peers address for proper addressing
var peerAdr = Unwrap(msg);
// the remaining message must be at least 3 frames!
Debug.Assert(msg.FrameCount > 2, "[CloudBackend] message malformed");
// if the id is any of the local clients it is a REPLY
// and a REQ otherwise
if (clients.Any(n => AreSame(n, msg.First)))
{
// [client adr][empty][message id]
localFrontend.SendMessage(msg);
}
else
{
// add the peers address to the request
var request = Wrap(peerAdr, msg);
// [peer adr][empty][peer client adr][empty][message id]
cloudFrontend.SendMessage(request);
}
};
// all peers are binding to this socket
// we receive REPLY or REQ from peers
// REQ [peer adr][empty][peer client adr][empty][data] -> send to local worker for processing
// REP [peer adr][empty][client adr][empty][data] -> send to local client
cloudFrontend.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveMultipartMessage();
// just to make sure we received a message
Debug.Assert(msg != null && msg.FrameCount > 0, "[CloudFrontend] message was empty or frame count == 0!");
// we may need need the peers address for proper addressing
var peerAdr = Unwrap(msg);
// the remaining message must be at least 3 frames!
Debug.Assert(msg.FrameCount > 2, "[CloudFrontend] message malformed");
// if the address is any of the local clients it is a REPLY
// and a REQ otherwise
if (clients.Any(n => AreSame(n, msg.First)))
localFrontend.SendMessage(msg);
else
{
// in order to know which per to send back the peers adr must be added again
var original = Wrap(peerAdr, msg);
// reduce the capacity to reflect the use of a worker by a cloud request
previousLocalCapacity = workerQueue.Count;
// get the LRU worker
var workerAdr = workerQueue.Dequeue();
// wrap the message with the worker address and send
var request = Wrap(workerAdr, original);
localBackend.SendMessage(request);
}
};
// in order to reduce chatter we only check to see if we have local capacity to provide to cloud
// periodically every 2 seconds with a timer
var timer = new NetMQTimer((int)TimeSpan.FromSeconds(2).TotalMilliseconds);
timer.Elapsed += (t, e) =>
{
// send message only if the previous send information changed
if (previousLocalCapacity != workerQueue.Count)
{
// set the information
previousLocalCapacity = workerQueue.Count;
// generate the message
var msg = new NetMQMessage();
var data = new NetMQFrame(previousLocalCapacity.ToString());
msg.Append(data);
var stateMessage = Wrap(Encoding.UTF8.GetBytes(me), msg);
// publish info
stateBackend.SendMessage(stateMessage);
}
// restart the timer
e.Timer.Enable = true;
};
// start all clients and workers as threads
var clientTasks = new Thread[NbrClients];
var workerTasks = new Thread[NbrWorker];
for (var i = 0; i < NbrClients; i++)
{
var client = new Client(localFrontendAddress, monitorAddress, (byte)i);
clientTasks[i] = new Thread(client.Run) { Name = string.Format("Client_{0}", i) };
clientTasks[i].Start();
}
for (var i = 0; i < NbrWorker; i++)
{
var worker = new Worker(localBackendAddress, (byte)i);
workerTasks[i] = new Thread(worker.Run) { Name = string.Format("Worker_{0}", i) };
workerTasks[i].Start();
}
var sockets = new NetMQSocket[]
{
localFrontend,
localBackend,
cloudFrontend,
cloudBackend,
stateFrontend,
stateBackend,
monitor
};
// create poller and add sockets & timer
var poller = new Poller(sockets);
poller.AddTimer(timer);
// start monitoring the sockets
Task.Factory.StartNew(poller.PollTillCancelled);
// we wait for a CTRL+C to exit
while (s_keepRunning)
{}
Console.WriteLine("Ctrl-C encountered! Exiting the program!");
if (poller.IsStarted)
poller.CancelAndJoin();
poller.Dispose();
}
}
public NetMQTimerEventArgs(NetMQTimer timer)
{
Timer = timer;
}
static void Main(string[] args)
{
// this key should be shared between authorization server and publisher
const string Key = "SecretKey";
string[] symbols = new[] {"EURUSD", "GBPUSD", "EURJPY",
"USDJPY", "EURGBP", "GBPJPY"};
Random random = new Random();
using (var context = NetMQContext.Create())
{
using (var publisher = context.CreateXPublisherSocket())
{
publisher.Options.ManualPublisher = true;
publisher.Bind("tcp://*:5558");
publisher.ReceiveReady += (sender, eventArgs) =>
{
byte[] subscriptionBytes = publisher.Receive();
if (subscriptionBytes[0] == 1 || subscriptionBytes[0] == 0)
{
// the rest of the bytes is the token, convert them to string
string serializedToken = Encoding.ASCII.GetString(
subscriptionBytes, 1, subscriptionBytes.Length - 1);
// deserialize the token
Token token;
if (Token.TryDeserialize(serializedToken, out token))
{
// Check if the token is valid
if (token.Validate(Key))
{
// first byte indicate if it a subscription or unsubscription
if (subscriptionBytes[0] == 1)
{
Console.WriteLine("Subscription request {0}",
token.Subscription);
publisher.Subscribe(token.Subscription);
}
else
{
publisher.Unsubscribe(token.Subscription);
}
}
else
{
Console.WriteLine("Invalid token {0}",
serializedToken);
}
}
}
};
// Some fake publishing
NetMQTimer publishTimer = new NetMQTimer(100);
publishTimer.Elapsed += (sender, eventArgs) =>
{
publisher.
SendMore(symbols[random.Next(symbols.Length)]).
Send(random.Next().ToString());
};
Poller poller = new Poller();
poller.AddSocket(publisher);
poller.AddTimer(publishTimer);
poller.PollTillCancelled();
}
}
}
public void Add( NetMQTimer timer)
{
if (timer == null)
throw new ArgumentNullException("timer");
CheckDisposed();
Run(() => m_timers.Add(timer));
}
public void RemoveTimer(NetMQTimer timer)
{
timer.When = -1;
m_zombies.Add(timer);
}
public void SendCorrectInputWithLoggingShouldReturnCorrectReply()
{
const string hostAddress = "tcp://localhost:5555";
var loggingMessages = new List<string>();
var serviceName = "echo";
using (var broker = new RouterSocket())
using (var poller = new NetMQPoller())
using (var session = new MDPClientAsync(hostAddress))
{
broker.Bind(hostAddress);
// we need to pick up any message in order to avoid errors
broker.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveMultipartMessage();
// we expect to receive a 4 Frame message
// [client adrR][e][mdp header][service][request]
if (msg.FrameCount != 6)
Assert.Fail("Message with wrong count of frames {0}", msg.FrameCount);
// REQUEST socket will strip the his address + empty frame
// ROUTER has to add the address prelude in order to identify the correct socket(!)
// [client adr][e][mdp header][service][reply][requestId]
var requestId = msg.Last.ConvertToString(); // get the requestId string
msg.RemoveFrame(msg.Last); // remove the request frame
var request = msg.Last.ConvertToString(); // get the request string
msg.RemoveFrame(msg.Last); // remove the request frame
msg.Append(new NetMQFrame(request + " OK")); // append the reply frame
msg.Append(requestId);
e.Socket.SendMultipartMessage(msg);
};
session.LogInfoReady += (s, e) => loggingMessages.Add(e.Info);
session.ReplyReady += (s, e) =>
{
var reply = e.Reply;
Assert.That(reply.FrameCount, Is.EqualTo(1));
Assert.That(reply.First.ConvertToString(), Is.EqualTo("REQUEST OK"));
poller.Stop();
};
int timeOutInMillis = 10000;
var timer = new NetMQTimer(timeOutInMillis); // Used so it doesn't block if something goes wrong!
timer.Elapsed += (s, e) =>
{
Assert.Fail($"Waited {timeOutInMillis} and had no response from broker");
poller.Stop();
};
poller.Add(broker);
poller.Add(timer);
var task = Task.Factory.StartNew(() => poller.Run());
var requestMessage = new NetMQMessage(new[] { new NetMQFrame("REQUEST") });
session.Send(serviceName, requestMessage);
task.Wait();
Assert.That(loggingMessages.Count, Is.EqualTo(3));
Assert.That(loggingMessages[0], Is.EqualTo("[CLIENT] connecting to broker at tcp://localhost:5555"));
Assert.That(loggingMessages[1].Contains("[CLIENT INFO] sending"), Is.True);
Assert.That(loggingMessages[2].Contains("[CLIENT INFO] received"), Is.True);
}
}
public void RemoveTimer(NetMQTimer timer)
{
if (timer == null)
{
throw new ArgumentNullException("timer");
}
if (m_disposed)
{
throw new ObjectDisposedException("Poller is disposed");
}
timer.When = -1;
m_zombies.Add(timer);
}
private void Connect()
{
List<SubscriberSocket> sockets = new List<SubscriberSocket>();
Poller poller = new Poller();
SubscriberSocket connectedSocket = null;
// event handler to handle message from socket
EventHandler<NetMQSocketEventArgs> handleMessage = (sender, args) =>
{
connectedSocket = (SubscriberSocket)args.Socket;
poller.Cancel();
};
NetMQTimer timeoutTimer = new NetMQTimer(TimeOut);
// just cancel the poller without seting the connected socket
timeoutTimer.Elapsed += (sender, args) => poller.Cancel();
poller.AddTimer(timeoutTimer);
foreach (var address in m_addresses)
{
var socket = m_context.CreateSubscriberSocket();
sockets.Add(socket);
socket.ReceiveReady += handleMessage;
poller.AddSocket(socket);
// Subscribe to welcome message
socket.Subscribe(WelcomeMessage);
socket.Connect(address);
}
poller.PollTillCancelled();
// if we a connected socket the connection attempt succeed
if (connectedSocket != null)
{
// remove the connected socket form the list
sockets.Remove(connectedSocket);
// close all exsiting connections
foreach (var socket in sockets)
{
// to close them immediatly we set the linger to zero
socket.Options.Linger = TimeSpan.Zero;
socket.Dispose();
}
// set the socket
m_subscriber = connectedSocket;
// drop the welcome message
m_subscriber.SkipMultipartMessage();
// subscribe to heartbeat
m_subscriber.Subscribe(HeartbeatMessage);
// subscribe to all subscriptions
foreach (string subscription in m_subscriptions)
{
m_subscriber.Subscribe(subscription);
}
m_subscriber.ReceiveReady -= handleMessage;
m_subscriber.ReceiveReady += OnSubscriberMessage;
m_poller.AddSocket(m_subscriber);
m_timeoutTimer.Enable = true;
m_reconnectTimer.Enable = false;
}
else
{
// close all exsiting connections
foreach (var socket in sockets)
{
// to close them immediatly we set the linger to zero
socket.Options.Linger = TimeSpan.Zero;
socket.Dispose();
}
m_reconnectTimer.Enable = true;
m_timeoutTimer.Enable = false;
}
}
public void Run(PairSocket shim)
{
m_pipe = shim;
shim.SignalOK();
m_pipe.ReceiveReady += OnPipeReady;
m_pingTimer = new NetMQTimer(interval: TimeSpan.Zero);
m_pingTimer.Elapsed += PingElapsed;
m_pingTimer.Enable = false;
m_poller = new NetMQPoller { m_pipe, m_pingTimer };
m_poller.Run();
// the beacon might never been configured
if (m_udpSocket != null)
m_udpSocket.Close();
}
/// <summary>
/// run the broker - if not bound to endpoint automatically binds to known endpoint
/// </summary>
/// <param name="token">CancellationToken to cancel the method</param>
/// <exception cref="InvalidOperationException">Can't start same broker more than once!</exception>
public void RunSynchronous (CancellationToken token)
{
if (m_isRunning)
throw new InvalidOperationException ("Can't start same broker more than once!");
if (!m_isBound)
Bind ();
m_isRunning = true;
using (var poller = new Poller ())
{
Socket.ReceiveReady += ProcessReceivedMessage;
// get timer for scheduling heartbeat
var timer = new NetMQTimer (HeartbeatInterval);
// send every 'HeartbeatInterval' a heartbeat to all not expired workers
timer.Elapsed += (s, e) => SendHeartbeat ();
poller.AddSocket (Socket);
poller.AddTimer (timer);
Log ("Starting to listen for incoming messages ...");
// start the poller and wait for the return, which will happen once token is
// signalling Cancel(!)
Task.Factory.StartNew (poller.PollTillCancelled, token).Wait ();
Log ("... Stopped!");
// clean up
poller.RemoveTimer (timer);
poller.RemoveSocket (Socket);
// unregister event handler
Socket.ReceiveReady -= ProcessReceivedMessage;
}
m_isRunning = false;
}
public void ReconnectToBrokerIfIsNotReplying()
{
const string hostAddress = "tcp://localhost:5555";
const int timeOutToReconnectInMillis = 7500;
var loggingMessages = new List<string>();
var serviceName = "echo";
var messagesReceivedOnBroker = 0;
// setup the counter socket for communication
using (var broker = new RouterSocket())
using (var poller = new NetMQPoller())
using (var session = new MDPClientAsync(hostAddress))
{
session.Timeout = TimeSpan.FromMilliseconds(timeOutToReconnectInMillis);
broker.Bind(hostAddress);
broker.ReceiveReady += (s, e) =>
{
var msg = e.Socket.ReceiveMultipartMessage();
if (messagesReceivedOnBroker != 0) // doesn't respond if is the first message received!
{
// we expect to receive a 4 Frame message
// [client adrR][e][mdp header][service][request]
if (msg.FrameCount != 6)
Assert.Fail("Message with wrong count of frames {0}", msg.FrameCount);
// REQUEST socket will strip the his address + empty frame
// ROUTER has to add the address prelude in order to identify the correct socket(!)
var requestId = msg.Last.ConvertToString(); // get the requestId string
msg.RemoveFrame(msg.Last); // remove the request frame
var request = msg.Last.ConvertToString(); // get the request string
msg.RemoveFrame(msg.Last); // remove the request frame
msg.Append(new NetMQFrame(request + " OK")); // append the reply frame
msg.Append(requestId);
e.Socket.SendMultipartMessage(msg);
}
messagesReceivedOnBroker++;
};
session.LogInfoReady += (s, e) => loggingMessages.Add(e.Info);
session.ReplyReady += (s, e) =>
{
var reply = e.Reply;
Assert.That(reply.FrameCount, Is.EqualTo(1));
Assert.That(reply.First.ConvertToString(), Is.EqualTo("REQUEST OK"));
poller.Stop();
};
var requestMessage = new NetMQMessage(new[] { new NetMQFrame("REQUEST") });
int timeOutInMillis = timeOutToReconnectInMillis + 3000; // Waits for the timeOut on the client
var timer = new NetMQTimer(timeOutInMillis);
timer.Elapsed += (s, e) =>
{
session.Send(serviceName, requestMessage); // resends the request after timeout
};
poller.Add(timer);
poller.Add(broker);
var task = Task.Factory.StartNew(() => poller.Run());
session.Send(serviceName, requestMessage);
var result = task.Wait(timeOutToReconnectInMillis * 2);
var numberOfConnects = loggingMessages.FindAll(x => x.Contains("[CLIENT] connecting to broker")).Count;
Assert.IsTrue(numberOfConnects > 1);
}
}
public NetMQTimerEventArgs(NetMQTimer timer)
{
Timer = timer;
}
private void RunActor(PairSocket shim)
{
// save the shim to the class to use later
m_shim = shim;
// create all subscriber, publisher and beacon
using (m_subscriber = new SubscriberSocket())
using (m_publisher = new PublisherSocket())
using (m_beacon = new NetMQBeacon())
{
// listen to actor commands
m_shim.ReceiveReady += OnShimReady;
// subscribe to all messages
m_subscriber.Subscribe("");
// we bind to a random port, we will later publish this port
// using the beacon
m_randomPort = m_subscriber.BindRandomPort("tcp://*");
Console.WriteLine("Bus subscriber is bound to {0}", m_subscriber.Options.LastEndpoint);
// listen to incoming messages from other publishers, forward them to the shim
m_subscriber.ReceiveReady += OnSubscriberReady;
// configure the beacon to listen on the broadcast port
Console.WriteLine("Beacon is being configured to UDP port {0}", m_broadcastPort);
m_beacon.Configure(m_broadcastPort);
// publishing the random port to all other nodes
Console.WriteLine("Beacon is publishing the Bus subscriber port {0}", m_randomPort);
m_beacon.Publish(m_randomPort.ToString(), TimeSpan.FromSeconds(1));
// Subscribe to all beacon on the port
Console.WriteLine("Beacon is subscribing to all beacons on UDP port {0}", m_broadcastPort);
m_beacon.Subscribe("");
// listen to incoming beacons
m_beacon.ReceiveReady += OnBeaconReady;
// Create a timer to clear dead nodes
NetMQTimer timer = new NetMQTimer(TimeSpan.FromSeconds(1));
timer.Elapsed += ClearDeadNodes;
// Create and configure the poller with all sockets and the timer
m_poller = new NetMQPoller { m_shim, m_subscriber, m_beacon, timer };
// signal the actor that we finished with configuration and
// ready to work
m_shim.SignalOK();
// polling until cancelled
m_poller.Run();
}
}
public void Run()
{
Console.WriteLine("[CLIENT {0}] Starting", m_id);
var rnd = new Random(m_id);
// each request shall have an unique id in order to recognize an reply for a request
var messageId = new byte[5];
// create clientId for messages
var clientId = new[] { m_id };
// a flag to signal that an answer has arrived
bool messageAnswered = false;
// we use a poller because we have a socket and a timer to monitor
using (var clientPoller = new Poller())
using (var context = NetMQContext.Create())
using (var client = context.CreateRequestSocket())
using (var monitor = context.CreatePushSocket())
{
client.Connect(m_localFrontendAddress);
monitor.Connect(m_monitorAddress);
client.Options.Identity = new[] { m_id };
var timer = new NetMQTimer((int)TimeSpan.FromSeconds(10).TotalMilliseconds);
// use as flag to indicate exit
var exit = false;
// every 10 s check if message has been received, if not then send error message and ext
// and restart timer otherwise
timer.Elapsed += (s, e) =>
{
if (messageAnswered)
{
e.Timer.Enable = true;
}
else
{
var msg = string.Format("[CLIENT {0}] ERR - EXIT - lost message {1}", m_id, messageId);
// send an error message
monitor.Send(msg);
// if poller is started than stop it
if (clientPoller.IsStarted)
clientPoller.CancelAndJoin();
// mark the required exit
exit = true;
}
};
// process arriving answers
client.ReceiveReady += (s, e) =>
{
// mark the arrival of an answer
messageAnswered = true;
// worker is supposed to answer with our request id
var reply = e.Socket.ReceiveMultipartMessage();
if (reply.FrameCount == 0)
{
// something went wrong
monitor.Send(string.Format("[CLIENT {0}] Received an empty message!", m_id));
// mark the exit flag to ensure the exit
exit = true;
}
else
{
var sb = new StringBuilder();
// create success message
foreach (var frame in reply)
sb.Append("[" + frame.ConvertToString() + "]");
// send the success message
monitor.Send(string.Format("[CLIENT {0}] Received answer {1}",
m_id,
sb.ToString()));
}
};
// add socket & timer to poller
clientPoller.AddSocket(client);
clientPoller.AddTimer(timer);
// start poller in another thread to allow the continued processing
clientPoller.PollTillCancelledNonBlocking();
// if true the message has been answered
// the 0th message is always answered
messageAnswered = true;
while (!exit)
{
// simulate sporadic activity by randomly delaying
Thread.Sleep((int)TimeSpan.FromSeconds(rnd.Next(5)).TotalMilliseconds);
// only send next message if the previous one has been replied to
if (messageAnswered)
{
// generate random 5 byte as identity for for the message
rnd.NextBytes(messageId);
messageAnswered = false;
// create message [client adr][empty][message id] and send it
var msg = new NetMQMessage();
msg.Push(messageId);
msg.Push(NetMQFrame.Empty);
msg.Push(clientId);
client.SendMessage(msg);
}
}
// stop poller if needed
if (clientPoller.IsStarted)
clientPoller.CancelAndJoin();
}
}
public void AddTimer(NetMQTimer timer)
{
if (timer == null)
{
throw new ArgumentNullException("timer");
}
if (m_disposed)
{
throw new ObjectDisposedException("Poller is disposed");
}
m_timers.Add(timer);
}
