/// <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 ZmqService(YahooFinancialDataProvider primitiveQuoteService)
{
this.primitiveQuoteService = primitiveQuoteService;
subscribedTickerList.AddRange(MarketDataSettings.StartupTickers);
refreshInterval = MarketDataSettings.ServerRefreshMillis;
socketFactory = NetMQContext.Create();
}
static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: local_thr <bind-to> <message-size> <message-count>");
return(1);
}
string bindTo = args[0];
int messageSize = int.Parse(args[1]);
int messageCount = int.Parse(args[2]);
var context = NetMQContext.Create();
var pullSocket = context.CreatePullSocket();
pullSocket.Bind(bindTo);
var message = new Msg();
message.InitEmpty();
pullSocket.Receive(ref message, SendReceiveOptions.None);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i != messageCount - 1; i++)
{
pullSocket.Receive(ref message, SendReceiveOptions.None);
if (message.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: " + message.Size + " Expected: " + messageSize);
return(-1);
}
}
stopWatch.Stop();
var millisecondsElapsed = stopWatch.ElapsedMilliseconds;
if (millisecondsElapsed == 0)
{
millisecondsElapsed = 1;
}
message.Close();
double messagesPerSecond = (double)messageCount / millisecondsElapsed * 1000;
double megabits = messagesPerSecond * messageSize * 8 / 1000000;
Console.WriteLine("message size: {0} [B]", messageSize);
Console.WriteLine("message count: {0}", messageCount);
Console.WriteLine("mean throughput: {0:0.000} [msg/s]", messagesPerSecond);
Console.WriteLine("mean throughput: {0:0.000} [Mb/s]", megabits);
pullSocket.Close();
context.Terminate();
return(0);
}
/// <summary>
/// create worker with standard parameter
/// HeartbeatDelay == 2500 milliseconds
/// ReconnectDelay == 2500 milliseconds
/// ConnectionRetries == 3
/// Verbose == false
/// </summary>
private MDPWorker()
{
m_ctx = NetMQContext.Create();
HeartbeatDelay = TimeSpan.FromMilliseconds(2500);
ReconnectDelay = TimeSpan.FromMilliseconds(2500);
m_exit = false;
m_connected = false;
}
public void Monitoring()
{
ManualResetEvent listeningEvent = new ManualResetEvent(false);
ManualResetEvent acceptedEvent = new ManualResetEvent(false);
ManualResetEvent connectedEvent = new ManualResetEvent(false);
using (NetMQContext contex = NetMQContext.Create())
using (Poller poller = new Poller())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) => acceptedEvent.Set();
monitor.Listening += (s, a) => listeningEvent.Set();
monitor.AttachToPoller(poller);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
using (NetMQMonitor reqMonitor = new NetMQMonitor(contex, req, "inproc://req.inproc", SocketEvent.Connected))
{
reqMonitor.Connected += (s, a) => connectedEvent.Set();
reqMonitor.AttachToPoller(poller);
try
{
poller.PollTillCancelledNonBlocking();
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Assert.IsTrue(listeningEvent.WaitOne(300));
Assert.IsTrue(connectedEvent.WaitOne(300));
Assert.IsTrue(acceptedEvent.WaitOne(300));
}
finally
{
poller.CancelAndJoin();
}
}
}
}
}
}
}
public void Receive_RequestWithWrongFirstFrame_ShouldThrowApplicationException()
{
const string hostAddress = "tcp://localhost:5555";
// setup the counter socket for communication
using (var context = NetMQContext.Create())
using (var broker = context.CreateRouterSocket())
using (var poller = new Poller())
using (var session = new MDPWorker(hostAddress, "test"))
{
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 5 Frame message
// [WORKER ADR][EMPTY]["MDPW01"]["READY"]["test"]
if (msg.FrameCount != 5)
{
Assert.Fail("Message with wrong count of frames {0}", msg.FrameCount);
}
// make sure the frames are as expected
Assert.That(msg[1], Is.EqualTo(NetMQFrame.Empty));
Assert.That(msg[2].ConvertToString(), Is.EqualTo("MDPW01"));
Assert.That(msg[3].BufferSize, Is.EqualTo(1));
Assert.That(msg[3].Buffer[0], Is.EqualTo((byte)MDPCommand.Ready));
Assert.That(msg[4].ConvertToString(), Is.EqualTo("test"));
// tell worker to stop gracefully
var reply = new NetMQMessage();
reply.Push(new[] { (byte)MDPCommand.Kill });
// push MDP Version
reply.Push("MDPW01");
// push separator
reply.Push("Should be empty");
// push worker address
reply.Push(msg[0]);
// send reply which is a request for the worker
e.Socket.SendMessage(reply);
};
poller.AddSocket(broker);
Task.Factory.StartNew(poller.PollTillCancelled);
try
{
session.Receive(null);
}
catch (ApplicationException ex)
{
Assert.That(ex.Message, Is.EqualTo("First frame must be an empty frame!"));
}
poller.CancelAndJoin();
poller.RemoveSocket(broker);
}
}
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 Start(int publishPort)
{
ctx = NetMQContext.Create();
publishSocket = ctx.CreatePublisherSocket();
publishSocket.Bind("tcp://*:" + publishPort);
logger.Info("Message publisher started on port " + publishPort);
}
public void NeverConfigured()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQBeacon speaker = new NetMQBeacon(context))
{
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NmqMessageServer"/> class.
/// </summary>
/// <param name="messageReceiver">The message receiver.</param>
/// <param name="port">The port.</param>
internal NmqMessageServer(IMessageReceiver messageReceiver, int port)
{
tokenSource = new CancellationTokenSource();
this.port = port;
this.messageReceiver = messageReceiver;
context = NetMQContext.Create();
responseQueue = new NmqResponseQueue(context, port);
}
public ZeroNotificationEnqueue()
{
_context = NetMQContext.Create();
_poller = new Poller();
_client = _context.CreatePushSocket();
_client.Connect(QueueAddress);
_scheduler = new NetMQScheduler(_context, _poller);
Task.Factory.StartNew(_poller.PollTillCancelled, TaskCreationOptions.LongRunning);
}
public void HelloWorldTest()
{
// context must be created to create sockets, one context per application
using (NetMQContext context = NetMQContext.Create())
{
Task.Factory.StartNew(() => Server(context));
Client(context);
}
}
public void Init(string ip, int port, MQClientType type)
{
_type = type;
_ip = ip;
_port = port;
_isStart = true;
_context = NetMQContext.Create();
CreateClient();
}
public static void StartServer(IDistributedApp app, string url, int expectedClients = 0, Action <Exception> connected = null)
{
Task.Run(() =>
{
using (var context = NetMQContext.Create())
using (var input = context.CreateDealerSocket())
{
Dictionary <string, DealerSocket> clients = null;
try
{
input.Bind(url);
if (expectedClients > 0)
{
clients = new Dictionary <string, DealerSocket>();
awaitClients(input, expectedClients, clients, context, app);
app.SendToClient = (client, msg) => writeMessage(clients[client], msg);
}
connected(null);
}
catch (Exception ex)
{
connected(ex);
return;
}
//loop
var message = new NetMQMessage(expectedFrameCount: 7);
var appMessage = new DistributedAppMessage();
for (;;)
{
message = input.ReceiveMultipartMessage(expectedFrameCount: 7);
try
{
if (!readMessage(message, appMessage))
{
continue;
}
app.Receive(appMessage);
}
catch
{
//td: log?
}
finally
{
message.Clear();
}
}
}
});
}
public static void Main()
{
var workers = new List <Thread>(WorkersCount);
using (var context = NetMQContext.Create())
using (var client = context.CreateRouterSocket())
{
string cnn = string.Format("tcp://localhost:{0}", PortNumber);
client.Bind(cnn);
Console.WriteLine("[B] Connect to {0}", cnn);
for (int workerNumber = 0; workerNumber < WorkersCount; workerNumber++)
{
workers.Add(new Thread(WorkerTask));
workers[workerNumber].Start(PortNumber);
}
for (int taskNumber = 0; taskNumber < WorkersCount * 10; taskNumber++)
{
// LRU worker is next waiting in queue
string address = client.ReceiveFrameString();
//Console.WriteLine("[B] Message received: {0}", address);
string empty = client.ReceiveFrameString();
//Console.WriteLine("[B] Message received: {0}", empty);
string ready = client.ReceiveFrameString();
//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 < WorkersCount; taskNbr++)
{
string address = client.ReceiveFrameString();
//Console.WriteLine("[B] Message received: {0}", address);
string empty = client.ReceiveFrameString();
//Console.WriteLine("[B] Message received: {0}", empty);
string ready = client.ReceiveFrameString();
//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();
}
public void Send_WrongHeaderFromBrokerNoLogging_ShouldThrowApplicationException()
{
const string hostAddress = "tcp://localhost:5555";
// setup the counter socket for communication
using (var context = NetMQContext.Create())
using (var broker = context.CreateRouterSocket())
using (var poller = new Poller())
using (var session = new MDPClient(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"]
if (msg.FrameCount != 5)
{
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"]
var clientAddress = msg.Pop();
msg.Pop(); // forget empty frame
var mdpVersion = msg.Pop();
msg.Pop(); // drop service name version
msg.Push("NoService");
msg.Push(mdpVersion);
msg.Push(NetMQFrame.Empty);
msg.Push(clientAddress); // reinsert the client's address
e.Socket.SendMessage(msg);
};
poller.AddSocket(broker);
Task.Factory.StartNew(poller.PollTillCancelled);
// well formed message
var requestMessage = new NetMQMessage(new[] { new NetMQFrame("REQUEST") });
try
{
session.Send("echo", requestMessage);
}
catch (ApplicationException ex)
{
Assert.That(ex.Message, Is.EqualTo("[CLIENT INFO] answered by wrong service: NoService"));
}
poller.CancelAndJoin();
poller.RemoveSocket(broker);
}
}
public void Monitoring()
{
bool listening = false;
bool accepted = false;
using (NetMQContext contex = NetMQContext.Create())
{
using (var rep = contex.CreateResponseSocket())
{
using (NetMQMonitor monitor = new NetMQMonitor(contex, rep, "inproc://rep.inproc", SocketEvent.Accepted | SocketEvent.Listening))
{
monitor.Accepted += (s, a) =>
{
accepted = true;
//Console.WriteLine(a.Socket.LocalEndPoint.ToString());
};
monitor.Listening += (s, a) =>
{
listening = true;
Console.WriteLine(a.Socket.LocalEndPoint.ToString());
};
monitor.Timeout = TimeSpan.FromMilliseconds(100);
var pollerTask = Task.Factory.StartNew(monitor.Start);
rep.Bind("tcp://127.0.0.1:5002");
using (var req = contex.CreateRequestSocket())
{
req.Connect("tcp://127.0.0.1:5002");
req.Send("a");
bool more;
string m = rep.ReceiveString(out more);
rep.Send("b");
string m2 = req.ReceiveString(out more);
Thread.Sleep(200);
Assert.IsTrue(listening);
Assert.IsTrue(accepted);
monitor.Stop();
Thread.Sleep(200);
Assert.IsTrue(pollerTask.IsCompleted);
}
}
}
}
}
public void 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);
}
}
}
}
public void NativeSocket()
{
using (NetMQContext context = NetMQContext.Create())
{
using (var streamServer = context.CreateStreamSocket())
{
streamServer.Bind("tcp://*:5557");
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
socket.Connect("127.0.0.1", 5557);
byte[] buffer = new byte[] { 1 };
socket.Send(buffer);
byte[] identity = streamServer.Receive();
byte[] message = streamServer.Receive();
Assert.AreEqual(buffer[0], message[0]);
ManualResetEvent socketSignal = new ManualResetEvent(false);
Poller poller = new Poller();
poller.AddPollInSocket(socket, s =>
{
socket.Receive(buffer);
socketSignal.Set();
// removing the socket
poller.RemovePollInSocket(socket);
});
poller.PollTillCancelledNonBlocking();
// no message is waiting for the socket so it should fail
Assert.IsFalse(socketSignal.WaitOne(200));
// sending a message back to the socket
streamServer.SendMore(identity).Send("a");
Assert.IsTrue(socketSignal.WaitOne(200));
socketSignal.Reset();
// sending a message back to the socket
streamServer.SendMore(identity).Send("a");
// we remove the native socket so it should fail
Assert.IsFalse(socketSignal.WaitOne(200));
poller.Stop(true);
}
}
}
}
public void EnqueueDequeue()
{
using (NetMQContext context = NetMQContext.Create())
using (NetMQQueue <int> queue = new NetMQQueue <int>(context))
{
queue.Enqueue(1);
Assert.AreEqual(1, queue.Dequeue());
}
}
public void CheckReceiveAgainException()
{
using (var context = NetMQContext.Create())
using (var router = context.CreateRouterSocket())
{
router.BindRandomPort("tcp://127.0.0.1");
router.Receive(SendReceiveOptions.DontWait);
}
}
public virtual void OnImportsSatisfied()
{
var context = NetMQContext.Create();
FPort.Changed += UpdatePort;
FProtocol.Changed += UpdateProtocol;
FAddress.Changed += UpdateAddress;
FContext.Changed += UpdateContext;
}
public static string ZMQRequest(string endpoint, string requestText)
{
string answer = "";
using (NetMQContext context = NetMQContext.Create())
{
answer = Client(context, endpoint, requestText);
}
return(answer);
}
public void DefaultValues()
{
using (var context = NetMQContext.Create())
using (var socket = context.CreateRouterSocket())
{
Assert.IsNull(socket.Options.Identity);
// Assert.IsNull(socket.Options.TcpAcceptFilter);
Assert.AreEqual(false, socket.Options.ReceiveMore);
}
}
/// <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;
}
/// <summary>
/// Default ctor.
/// </summary>
public FeedMuxMessageBroker()
{
context = NetMQContext.Create();
pubSocket = context.CreatePublisherSocket();
pubSocket.Connect(PublisherAddress);
pollerCancelled = new ManualResetEvent(false);
source = new CancellationTokenSource();
token = source.Token;
StartPolling();
}
public void DisposeImmediatly()
{
using (NetMQContext context = NetMQContext.Create())
{
using (NetMQSocket server = context.CreateDealerSocket())
{
server.Bind("tcp://*:5557");
}
}
}
public void Mandatory()
{
using (var context = NetMQContext.Create())
using (var router = context.CreateRouterSocket()) {
router.Options.RouterMandatory = true;
router.BindRandomPort("tcp://*");
Assert.Throws <HostUnreachableException>(() => router.SendMoreFrame("UNKNOWN").SendFrame("Hello"));
}
}
static void Main(string[] args)
{
string username = args[0];
string password = args[1];
string subscription = args[2].ToUpper();
using (var context = NetMQContext.Create())
{
string token;
// first we try to get a token
using (var request = context.CreateRequestSocket())
{
request.Connect("tcp://localhost:" + AuthorizationProtocol.Port);
// send token request
request.
SendMore(AuthorizationProtocol.GetTokenCommand).
SendMore(username).
SendMore(password).
Send(subscription);
string result = request.ReceiveString();
if (result == AuthorizationProtocol.SuccessReply)
{
token = request.ReceiveString();
}
else
{
throw new Exception("Invalid username or password");
}
}
// we must use XSUB because
using (var subscriber = context.CreateXSubscriberSocket())
{
subscriber.Connect("tcp://localhost:" + StreamingProtocol.Port);
// create the subscription message
byte[] subscriptionMessage = new byte[token.Length + 1];
subscriptionMessage[0] = 1;
Encoding.ASCII.GetBytes(token, 0, token.Length, subscriptionMessage, 1);
subscriber.Send(subscriptionMessage);
while (true)
{
string symbol = subscriber.ReceiveString();
string price = subscriber.ReceiveString();
Console.WriteLine("{0} {1}", symbol, price);
}
}
}
}
public void Sending1000Messages()
{
// creating two different context and sending 1000 messages
int count = 0;
var subReady = new ManualResetEvent(false);
Task subTask = Task.Factory.StartNew(() =>
{
using (var context = NetMQContext.Create())
using (var sub = context.CreateSubscriberSocket())
{
sub.Bind("pgm://224.0.0.1:5555");
sub.Subscribe("");
subReady.Set();
while (count < 1000)
{
bool more;
Assert.AreEqual(count, BitConverter.ToInt32(sub.ReceiveFrameBytes(out more), 0));
Assert.IsFalse(more);
count++;
}
}
});
subReady.WaitOne();
Task pubTask = Task.Factory.StartNew(() =>
{
using (var context = NetMQContext.Create())
using (var pub = context.CreatePublisherSocket())
{
pub.Connect("pgm://224.0.0.1:5555");
for (int i = 0; i < 1000; i++)
{
pub.Send(BitConverter.GetBytes(i));
}
// if we close the socket before the subscriber receives all messages subscriber
// might miss messages, lets wait another second
Thread.Sleep(1000);
}
});
pubTask.Wait();
subTask.Wait();
Thread.MemoryBarrier();
Assert.AreEqual(1000, count);
}
