private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: remote_thr <connect-to> <message-size> <message-count>");
return 1;
}
string connectTo = args[0];
int messageSize = int.Parse(args[1]);
int messageCount = int.Parse(args[2]);
using (var push = new PushSocket())
{
push.Connect(connectTo);
for (int i = 0; i != messageCount; i++)
{
var msg = new Msg();
msg.InitPool(messageSize);
push.Send(ref msg, more: false);
msg.Close();
}
}
return 0;
}
private static int Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("usage: remote_thr <connect-to> <message-size> <message-count>");
return(1);
}
string connectTo = args[0];
int messageSize = int.Parse(args[1]);
int messageCount = int.Parse(args[2]);
using (var push = new PushSocket())
{
push.Connect(connectTo);
for (int i = 0; i != messageCount; i++)
{
var msg = new Msg();
msg.InitPool(messageSize);
push.Send(ref msg, more: false);
msg.Close();
}
}
return(0);
}
public Sender(IOptions <ConnectionSettings> settings, ILogger <Sender> logger)
{
_settings = settings.Value;
_logger = logger;
Socket = new PushSocket();
}
public override void Publisher()
{
AsyncIO.ForceDotNet.Force();
sender = new PushSocket();
sender.Connect("tcp://" + IP + ":" + Port);
Debug.Log("Connect ObjectSender to: " + "tcp://" + IP + ":" + Port);
while (IsRunning)
{
Thread.Sleep(50);
if (sendMessageQueue.Count > 3)
{
sendMessageQueue.RemoveRange(0, sendMessageQueue.Count - 3);
}
if (sendMessageQueue.Count > 0)
{
// Debug.Log("Send: " + sendMessageQueue[0]);
try
{
sender.SendFrame(sendMessageQueue[0], false); // true not wait
sendMessageQueue.RemoveAt(0);
}
catch { }
}
}
// disconnectClose();
}
private static void Main()
{
Console.WriteLine("Creating socket..");
using (var pushSocket = new PushSocket(">tcp://localhost:5556")
{
/* So apparently this is needed to prevent the socket from being immediately disposed
* after the last instruction of the using block.
* With this setting, the socket shall be disposed only after the message has been sent.
* This is equivalent to say "wait forever", but someone may arguably want to set a finite
* amount of time when in production.
*/
Options = { Linger = TimeSpan.FromSeconds(-1) }
})
{
Console.WriteLine("Creating message..");
var message = new Message
{
Text = "test message",
TimeStamp = DateTime.Now,
Type = "test",
ValueCode = 0
};
Console.WriteLine("Serializing message..");
using (var memoryStream = new MemoryStream())
{
var binaryFormatter = new BinaryFormatter();
binaryFormatter.Serialize(memoryStream, message);
var serializedMessage = memoryStream.ToArray();
Console.WriteLine("Sending message..");
pushSocket.SendFrame(serializedMessage);
}
}
Console.WriteLine("Performing cleanup..");
NetMQConfig.Cleanup();
}
public static void Main(string[] args)
{
Console.WriteLine("====== VENTILATOR ======");
Console.WriteLine("Press enter when all is set up");
Console.ReadLine();
using (var sender = new PushSocket("@tcp://*:80"))
{
Console.WriteLine("Sending tasks to workers");
int step = 10;
int height = 200; //400 hier kann height geändert werden
int width = 200; // hier kann width geändert werden
for (int start = 0; start < height; start += 10)
{
Thread.Sleep(100);
sender.SendFrame(start + "," + step + "," + width);
Console.WriteLine("asked for " + start + " to " + step);
step = step + 10;
}
Console.WriteLine("Press any key to quit");
Console.ReadLine();
}
}
public NetMQWorker(int id, string pushAddress, string pullAddress, NetMQContext context) : base(id)
{
_pullSocket = context.CreatePullSocket();
_pushSocket = context.CreatePushSocket();
_pushSocket.Connect(pushAddress);
_pullSocket.Bind(pullAddress+id);
}
static void Main(string[] args)
{
bool started = false;
while (true)
{
if (started)
{
Console.WriteLine("Please Press Enter to Stop...");
Console.ReadLine();
using (var server = new PushSocket())
{
server.Connect("tcp://127.0.0.1:5489");
server.SendFrame("false");
started = false;
}
}
else
{
Console.WriteLine("Please Press Enter to Start...");
Console.ReadLine();
using (var send = new PushSocket())
{
send.Connect("tcp://127.0.0.1:5488");
send.SendFrame("true");
started = true;
}
}
}
}
static void Main(string[] args)
{
/// Task Ventilator
// Binds PUSH socket to tcp://localhost:5557
// Sends batch of tasks to workers via that socket
Console.WriteLine("====== VENTILATOR ======");
using (var sender = new PushSocket("@tcp://*:5557"))
using (var sink = new PushSocket(">tcp://localhost:5558"))
{
Console.WriteLine("Press enter when worker are ready");
Console.ReadLine();
//the first message it "0" and signals start of batch
//see the Sink.csproj Program.cs file for where this is used
Console.WriteLine("Sending start of batch to Sink");
sink.SendFrame("0");
Console.WriteLine("Sending tasks to workers");
//initialise random number generator
Random rand = new Random(0);
//expected costs in Ms
int totalMs = 0;
//send 100 tasks (workload for tasks, is just some random sleep time that
//the workers can perform, in real life each work would do more than sleep
for (int taskNumber = 0; taskNumber < 100; taskNumber++)
{
//Random workload from 1 to 100 msec
int workload = rand.Next(0, 100);
totalMs += workload;
Console.WriteLine("Workload : {0}", workload);
sender.SendFrame(workload.ToString());
}
Console.WriteLine("Total expected cost : {0} msec", totalMs);
Console.WriteLine("Press Enter to quit");
Console.ReadLine();
}
}
public ZeroNotificationEnqueue(ZeroConfiguration configuration)
{
_poller = new NetMQPoller();
_client = new PushSocket();
_client.Connect(configuration.ZeroMqAddress);
_poller.RunAsync();
}
static void Main(string[] args)
{
Console.WriteLine("====== WORKER ======");
var sinkPort = ConfigurationManager.AppSettings.Get("sinkPort") ?? "8088";
var ventilatorPort = ConfigurationManager.AppSettings.Get("ventilatorPort") ?? "400";
using (var receiver = new PullSocket($">tcp://localhost:{sinkPort}"))
using (var sender = new PushSocket($">tcp://localhost:{ventilatorPort}"))
{
while (true)
{
string workload = receiver.ReceiveFrameString();
// the protocoll is as follows: [0] -> lower, [1] -> upper, [2] -> height
string[] workLoadArray = workload.Split(',');
var calculator = new MandelbrotCalculator();
var result = calculator.Calculate(Convert.ToInt32(workLoadArray[2]), 400, Convert.ToInt32(workLoadArray[0]), Convert.ToInt32(workLoadArray[1]));
byte[] data;
BinaryFormatter binaryFormatter = new BinaryFormatter();
using (var memoryStream = new MemoryStream())
{
binaryFormatter.Serialize(memoryStream, result);
data = memoryStream.ToArray();
}
Console.WriteLine("Sending");
sender.SendFrame(data);
}
}
}
private bool _disposedValue = false; // Для определения избыточных вызовов
#endregion Fields
#region Constructors
public FanBrocker(NetMQContext context, string ventAddress, string sinkAddress, int workersCnt)
{
_logger.Trace("Brocker created");
_ventAddress = ventAddress;
_sinkAddress = sinkAddress;
_sinkSocket = context.CreatePullSocket();
_sinkSocket.Options.ReceiveBuffer = 1;
_sinkSocket.Bind(sinkAddress);
_ventSocket = context.CreatePushSocket();
_ventSocket.Options.SendBuffer = 1;
_ventSocket.Bind(ventAddress);
Task.Run(() =>
{
try
{
while (true)
{
var ba = _sinkSocket.ReceiveFrameString();
_logger.Trace("Brocker received data {0}", ba);
var data = JsonConvert.DeserializeObject<ProcessedEventArgs>(ba);
OnFramesProcessed(data);
}
}
catch (Exception)
{
_logger.Error("EXCEPTION");
}
});
}
static void Main(string[] args)
{
// Console.WriteLine("Connecting to hello world server…");
// using (var requester = new RequestSocket())
// {
// requester.Connect("tcp://localhost:5555");
// int requestNumber;
// for (requestNumber = 0; requestNumber != 100; requestNumber++)
// {
// Console.WriteLine("Sending Hello {0}...", requestNumber);
// requester.SendFrame("Hello");
// string str = requester.ReceiveFrameString();
// Console.WriteLine("Received World {0}", requestNumber);
// }
// }
using (var responder = new PushSocket())
{
responder.Bind("tcp://*:5555");
while (true)
{
//string str = responder.ReceiveFrameString();
string str = "hellllllo";
Console.WriteLine(str);
Thread.Sleep(50); // Do some 'work'
responder.SendFrame(str);
}
}
}
public void DesktopClient_WillAccept_SinglePartMessages()
{
Queue<Packet> packets = new Queue<Packet>();
// Mock the the message handler processor
var messageHandler = new Mock<IDesktopMessageHandler>();
messageHandler.Setup(mh => mh.DisplayLogPacket(It.IsAny<LogPacket>())).Callback(
(LogPacket packet) =>
{
packets.Enqueue(packet);
}).Verifiable();
// Setup Client
StartClientThread(messageHandler.Object);
using (PushSocket server = new PushSocket("@tcp://*:" + _port))
{
var message = new NetMQMessage();
message.Append(JsonConvert.SerializeObject(new LogPacket()));
server.SendMultipartMessage(message);
}
// Give NetMQ time to send the message
Thread.Sleep(500);
Assert.IsTrue(packets.Count == 1);
}
public void DesktopClient_WillNotAccept_MoreThanOnePartMessages()
{
Queue <Packet> packets = new Queue <Packet>();
// Mock the the message handler processor
var messageHandler = new Mock <IDesktopMessageHandler>();
messageHandler.Setup(mh => mh.DisplayLogPacket(It.IsAny <LogPacket>()))
.Callback((LogPacket packet) =>
{
packets.Enqueue(packet);
})
.Verifiable();
// Setup Client
StartClientThread(messageHandler.Object);
using (PushSocket server = new PushSocket("@tcp://*:" + _port))
{
var message = new NetMQMessage();
message.Append(typeof(LogPacket).Name);
message.Append(JsonConvert.SerializeObject(new LogPacket()));
message.Append("hello!");
server.SendMultipartMessage(message);
}
// Give NetMQ time to send the message
Thread.Sleep(500);
Assert.IsTrue(packets.Count == 0);
}
public void Start(string serverIpAddress, int serverPort)
{
string serverAddress = string.Format("tcp://{0}:{1}", serverIpAddress, serverPort);
pushSocket = new PushSocket();
pushSocket.Connect(serverAddress);
}
static void Main(string[] args)
{
string connectionString = args[0];
using (var send = new PushSocket(">tcp://127.0.0.1:9999"))
using (var receive = new ResponseSocket(connectionString))
{
while (true)
{
// Block for request
var message = receive.ReceiveFrameString();
var msgId = Guid.NewGuid().ToString();
// Acknowledge
receive.SendFrame("200, ACK");
// Do Work ...
Thread.Sleep(2000);
// Send response
send.SendFrame(string.Format("Handler {0} completed task {1}",
connectionString, msgId));
// Exit handler
break;
}
}
}
public void Start()
{
if (!ServerSpecified)
{
return;
}
if (context == null)
{
context = NetMQContext.Create();
subscriber = context.CreateSubscriberSocket();
subscriber.Connect("tcp://127.0.0.1:5252");
subscriber.Subscribe(String.Empty);
sender = context.CreatePushSocket();
sender.Connect("tcp://127.0.0.1:5253");
// Start listening..
Task.Run(() =>
{
while (!tokenSource.IsCancellationRequested)
{
var message = subscriber.ReceiveString();
var eventObject = Serialization.DeserializeEnvelope <ContractMarker>(message);
eventReceivedSubject.OnNext(eventObject);
}
});
}
}
public virtual NetMQSocket Rent()
{
if (_pool.TryDequeue(out var _sender))
{
Interlocked.Decrement(ref _count);
Debug.Assert(_count >= 0);
return(_sender);
}
try
{
switch (_options.Pattern)
{
case NetMQPattern.PushPull:
_sender = new PushSocket();
break;
case NetMQPattern.PubSub:
_sender = new PublisherSocket();
break;
default:
break;
}
_sender.Connect(HostAddress);
}
catch (Exception e)
{
_logger.LogError(e, "ZeroMQ channel model create failed!");
throw;
}
return(_sender);
}
private void CreateRemoteNode()
{
if (NodeAddressNumber >= RemoteAddressesList.Count)
{
throw new Exception("Node number is not correct, ");
}
NodeAddress = RemoteAddressesList[this.NodeAddressNumber];
if (NodeAddressNumber == 0)
{
MainNode = true;
}
WorkingRemoteServersCount = RemoteAddressesList.Count;
RemoteAddressesList.RemoveAt(NodeAddressNumber);
NodePort = NodeAddress.Split(new[] { ":" }, StringSplitOptions.None)[1];
foreach (var remoteServer in RemoteAddressesList)
{
var remotePushSocket = new PushSocket();
RemoteServerSockets[remoteServer] = remotePushSocket;
remotePushSocket.Connect("tcp://" + remoteServer);
}
}
private void Main()
{
using (this.pushSocket = new PushSocket(this.connectionString))
{
Volatile.Write(ref this.currentState, RUNNING);
var spin = new SpinWait();
var msg = new Msg();
msg.InitPool(this.maxFrameSize);
while (Volatile.Read(ref this.currentState) == RUNNING)
{
try
{
if (this.buffer.TryPoll(out var send))
{
send.Send(
this.pushSocket,
this.envelopFactory,
this.encoder,
msg,
this.maxFrameSize);
}
else
{
spin.SpinOnce();
}
}
catch (Exception ex)
{
log.Error(ex, ex.Message);
}
}
}
}
static void Main(string[] args)
{
Console.WriteLine("====== VENTILATOR ======");
using (var push = new PushSocket())
using (var sink = new DealerSocket())
{
push.Bind("tcp://127.0.0.1:8888");
sink.Connect("tcp://127.0.0.1:7777");
Console.WriteLine("Press enter when worker are ready");
Console.ReadLine();
Console.WriteLine("Sending start of batch to Sink");
sink.SendFrame("0");
Console.WriteLine("Sending tasks to workers");
var rnd = new Random();
var totalMs = 0;
for (int taskNumber = 0; taskNumber < 100; taskNumber++)
{
int workload = rnd.Next(0, 100);
totalMs += workload;
Console.WriteLine("Workload : {0}", workload);
push.SendFrame(workload.ToString());
}
Console.WriteLine($"Total expected cost : {totalMs} msec");
Console.WriteLine("Press Enter to quit");
Console.ReadLine();
}
}
static void Main(string[] args)
{
// Task Ventilator
// Binds PUSH socket to tcp://localhost:5557
// Sends batch of tasks to workers via that socket
Console.WriteLine("====== VENTILATOR ======");
using (var sender = new PushSocket("@tcp://*:80"))
using (var sink = new PullSocket(">tcp://localhost:8080"))
{
Thread.Sleep(1000);
//the first message it "0" and signals start of batch
//see the Sink.csproj Program.cs file for where this is used
Console.WriteLine("Sending start of batch to Sink");
//sink.SendFrame("0");
Console.WriteLine("Sending tasks to workers");
//initialise random number generator
Random rand = new Random(0);
//expected costs in Ms
int totalMs = 0;
//send 100 tasks (workload for tasks, is just some random sleep time that
//the workers can perform, in real life each work would do more than sleep
int upper = 10;
int height = 400;
for (int lower = 0; lower < height; lower += 10)
{
sender.SendFrame(lower + "," + upper + "," + height);
upper += 10;
}
Console.WriteLine("Total expected cost : {0} msec", totalMs);
Console.WriteLine("Press Enter to quit");
Console.ReadLine();
}
}
//static void SetSocketOpt(NetMQSocket socket)
//{
// socket.Options.TcpKeepalive = true;
// socket.Options.ReconnectIntervalMax = TimeSpan.FromMilliseconds(30000);
// socket.Options.Linger = TimeSpan.FromMilliseconds(0);
// //socket.KeepAlive = true;
// //socket.ReconnectIntervalMax = TimeSpan.FromMilliseconds(30000);
// //socket.Linger = TimeSpan.FromMilliseconds(0);
//}
static public Socket_NanoMsg Create(SocketType socketType)
{
NanomsgSocketBase socket;
switch (socketType)
{
case SocketType.Pub:
socket = new PublishSocket();
return(new Socket_NanoMsg(socket));
case SocketType.Pull:
socket = new PullSocket();
return(new Socket_NanoMsg(socket));
case SocketType.Push:
socket = new PushSocket();
return(new Socket_NanoMsg(socket));
case SocketType.Sub:
socket = new SubscribeSocket();
return(new Socket_NanoMsg(socket));
default:
throw new Exception("Non support SocketType.");
}
}
public static void Main(string[] args)
{
// Task Worker
// Connects PULL socket to tcp://localhost:5557
// collects workload for socket from Ventilator via that socket
// Connects PUSH socket to tcp://localhost:5558
// Sends results to Sink via that socket
Console.WriteLine("====== WORKER ======");
using (var receiver = new PullSocket(">tcp://127.0.0.1:5557"))
using (var sender = new PushSocket(">tcp://127.0.0.1:5558"))
{
//process tasks forever
while (true)
{
//workload from the vetilator is a simple delay
//to simulate some work being done, see
//Ventilator.csproj Proram.cs for the workload sent
//In real life some more meaningful work would be done
string workload = receiver.ReceiveFrameString();
//simulate some work being done
Thread.Sleep(int.Parse(workload));
//send results to sink, sink just needs to know worker
//is done, message content is not important, just the presence of
//a message means worker is done.
//See Sink.csproj Proram.cs
Console.WriteLine("Sending to Sink");
sender.SendFrame(string.Empty);
}
}
}
public RegisterClusterSuccesful(uint clusterId, bool succesful, PushSocket socket)
{
OutgoingInterserverPacket packet = new OutgoingInterserverPacket(OpCodes.REGISTER_CLUSTER_REQUEST_SUCCESFUL);
packet.Write(clusterId);
packet.Write(succesful);
packet.Send(socket);
}
public RegisterChannelRequestSuccesful(bool accepted, uint channelId, PushSocket socket)
{
OutgoingInterserverPacket packet = new OutgoingInterserverPacket(OpCodes.REGISTER_CHANNEL_REQUEST_SUCCESFUL);
packet.Write(accepted);
packet.Write(channelId);
packet.Send(socket);
}
public void Start(string serverIpAddress, int serverPort)
{
ctx = NetMQContext.Create();
pushSocket = ctx.CreatePushSocket();
string serverAddress = string.Format("tcp://{0}:{1}", serverIpAddress, serverPort);
pushSocket.Connect(serverAddress);
}
public RegisterNewChannelSuccesful(uint channelId, bool succesful, PushSocket socket)
{
OutgoingInterserverPacket packet = new OutgoingInterserverPacket(OpCodes.REGISTER_NEW_CHANNEL_SUCCESFUL);
packet.Write(channelId);
packet.Write(succesful);
packet.Send(socket);
}
static void Main(string[] args)
{
Console.WriteLine("====== Back Queue STARTED ======");
using var fromWorkerForPosion = new PullSocket($"@{ThreadSafeFactory.BackPosionQueue}");
using var fromWorkerForUrl = new PullSocket($"@{ThreadSafeFactory.BackUrlQueue}");
using var forFrontForUrl = new PushSocket($"@{ThreadSafeFactory.BackQueue}");
Console.WriteLine("Socket initialized");
var fromWorkerProcessorForFrontQueue = Task.Run(() =>
{
do
{
try
{
Console.WriteLine($"Waiting for worker link");
var queueItem = fromWorkerForUrl.ReceiveFrameString();
Console.WriteLine($"Received [{queueItem}] from worker");
Console.WriteLine($"Sending to front queue");
forFrontForUrl.SendFrame(queueItem);
Console.WriteLine($"Sent to front queue");
}
catch (Exception ex)
{
Console.WriteLine($"Error in Front Queue Processor {ex.Message}");
}
} while (true);
});
var fromWorkerProcessorForPoison = Task.Run(() =>
{
do
{
Console.WriteLine($"Waiting for poison items");
var workload = fromWorkerForPosion.ReceiveFrameString();
UrlPosionQueueItem queueItem = workload.FromJson <UrlPosionQueueItem>();
_posionQueue.Enqueue(queueItem);
Console.WriteLine($"Received poison [{queueItem.ToJson()}] from worker");
} while (true);
});
var poisonQueueProcessor = Task.Run(() =>
{
do
{
//while (_posionQueue.IsEmpty)
//{
// Task.Delay(5000).Wait();
//}
if (_posionQueue.TryDequeue(out UrlPosionQueueItem queueItem))
{
Console.WriteLine($"Processing poison {queueItem.ToJson()}");
}
// TODO: Persist all posion queue items with failure reasons in db
} while (true);
});
Task.WaitAll(fromWorkerProcessorForFrontQueue, /* fromWorkerProcessorForPoison,*/ poisonQueueProcessor);
Console.WriteLine("====== FRONT QUEUE ======");
}
private void createSSocket()
{
clientS = context.CreatePushSocket();
string[] srAddrs = cfg.ServerR.Split(',');
foreach (string addr in srAddrs)
{
clientS.Connect(addr);
}
}
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 Sender(string addr)
{
StringNullOrEmptyException.Assert(addr, nameof(addr));
_socket = new PushSocket();
_socket.Options.SendTimeout = TimeSpan.FromMilliseconds(100);
_socket.Options.ReconnectInterval = TimeSpan.FromMilliseconds(150);
_socket.Connect(addr.ToLower());
}
public void Start(string serverIpAddress, int serverPort)
{
ctx = NetMQContext.Create();
pushSocket = ctx.CreatePushSocket();
string serverAddress = string.Format("tcp://{0}:{1}", serverIpAddress, serverPort);
pushSocket.Connect(serverAddress);
}
protected override void Produce(PushSocket socket, int messageSize)
{
var msg = new byte[messageSize];
msg[messageSize / 2] = 0x42;
for (int i = 0; i < MsgCount; i++)
{
socket.SendFrame(msg);
}
}
public CommandListener (int port, Dictionary<int, Job> jobs)
{
this.Port = port;
this.Jobs = jobs;
this.Context = NetMQContext.Create ();
this.RequestSock = Context.CreateResponseSocket ();
this.RequestSock.Bind ("tcp://0.0.0.0:" + Port);
logger.Info ("Bound to TCP port {0}", Port);
this.ResponseSock = Context.CreatePushSocket ();
this.ResponseSock.Bind ("tcp://0.0.0.0:" + (Port + 1));
logger.Info ("Bound callback to TCP port {0}", (Port + 1));
}
private bool _disposedValue = false; // Для определения избыточных вызовов
#endregion Fields
#region Constructors
public NetMQBrocker(NetMQContext context, string pushAddress, string pullAddress, int workersCnt)
{
_logger.Trace("Brocker created");
_pushAddress = pushAddress;
_pullAddress = pullAddress;
//_pushSocket.Bind(pushAddress);
_pullSocket = context.CreatePullSocket();
_pullSocket.Bind(pullAddress);
_pushSocket = context.CreatePushSocket();
Task.Run(() =>
{
try
{
while (true)
{
var ba = _pullSocket.ReceiveFrameBytes();
if (ba != null)
{
using (var ms = new MemoryStream())
{
ms.Write(ba, 0, ba.Length);
ms.Position = 0;
var data = (ProcessedEventArgs)_formatter.Deserialize(ms);
_logger.Trace("Brocker received result queue {0}", data.QueueId);
OnFramesProcessed(data);
}
}
else
{
_logger.Trace("Brocker not received");
Thread.Sleep(200);
}
}
}
catch (Exception)
{
_logger.Error("EXCEPTION");
}
});
}
private NetMQScheduler(Poller poller, PushSocket pushSocket, PullSocket pullSocket)
{
if (poller == null)
{
m_ownPoller = true;
m_poller = new Poller();
}
else
{
m_ownPoller = false;
m_poller = poller;
}
var address = string.Format("{0}://scheduler-{1}",
Address.InProcProtocol,
Interlocked.Increment(ref s_schedulerCounter));
m_serverSocket = pullSocket;
m_serverSocket.Options.Linger = TimeSpan.Zero;
m_serverSocket.Bind(address);
m_currentMessageHandler = OnMessageFirstTime;
m_serverSocket.ReceiveReady += m_currentMessageHandler;
m_poller.AddSocket(m_serverSocket);
m_clientSocket = pushSocket;
m_clientSocket.Connect(address);
m_isSchedulerThread = new ThreadLocal<bool>(() => false);
if (m_ownPoller)
{
m_poller.PollTillCancelledNonBlocking();
}
}
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 NetMQPoller())
using (var client = new RequestSocket())
using (var monitor = new PushSocket())
{
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.SendFrame(msg);
// if poller is started than stop it
if (clientPoller.IsRunning)
clientPoller.Stop();
// 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.SendFrame(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.SendFrame(string.Format("[CLIENT {0}] Received answer {1}",
m_id,
sb.ToString()));
}
};
// add socket & timer to poller
clientPoller.Add(client);
clientPoller.Add(timer);
// start poller in another thread to allow the continued processing
clientPoller.RunAsync();
// 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.SendMultipartMessage(msg);
}
}
// stop poller if needed
if (clientPoller.IsRunning)
clientPoller.Stop();
}
}
/// <summary>
/// Initialize the messaging system
/// </summary>
public void Initialize()
{
_port = Config.Get("desktop-http-port");
CheckPort();
_server = new PushSocket("@tcp://*:" + _port);
}
public void DesktopClient_WillShutDown_WhenStopServerIsCalled_FromAnotherThread()
{
Queue<Packet> packets = new Queue<Packet>();
var messageHandler = new Mock<IDesktopMessageHandler>();
messageHandler.Setup(mh => mh.DisplayLogPacket(It.IsAny<LogPacket>()))
.Callback((LogPacket packet) =>
{
packets.Enqueue(packet);
})
.Verifiable();
StartClientThread(messageHandler.Object);
// Try to send a message when the DesktopClient is listening
using (PushSocket server = new PushSocket("@tcp://*:" + _port))
{
var message = new NetMQMessage();
message.Append(JsonConvert.SerializeObject(new LogPacket()));
server.SendMultipartMessage(message);
}
// Give NetMQ time to send the message
Thread.Sleep(2000);
Assert.IsTrue(packets.Count == 1);
// Shut down the server
_desktopMessageHandler.StopServer();
Thread.Sleep(2000);
// Try to send another message when the DesktopClient is not listening
using (PushSocket server = new PushSocket("@tcp://*:" + _port))
{
var message = new NetMQMessage();
message.Append(JsonConvert.SerializeObject(new LogPacket()));
server.SendMultipartMessage(message);
}
// Give NetMQ time to send the message
Thread.Sleep(2000);
// Nothing should have made it so the count should be the same
Assert.IsTrue(packets.Count == 1);
}
