private void ReceivingMain()
{
log.Info("Started the receive thread.");
Volatile.Write(ref this.receivingState, RUNNING);
var msg = new Msg();
msg.InitPool(this.maxFrameSize);
using (var pullSocket = new PullSocket(this.incomingConnection))
{
while (Volatile.Read(ref this.receivingState) == RUNNING)
{
try
{
if (pullSocket.TryReceive(ref msg, new TimeSpan(0, 0, 5)))
{
var body = msg.Data;
if (this.encoder.Decode(body, out var envelope))
{
this.subject.OnNext(envelope);
}
}
msg.InitPool(this.maxFrameSize);
}
catch (Exception ex)
{
log.Error(ex, ex.Message);
}
}
}
Volatile.Write(ref this.receivingState, STOPPED);
log.Info("Receiving thread has stopped.");
}
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("====== 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);
}
}
}
public void Run()
{
var subAddress = _settings.SubAddress;
var pullAddress = _settings.PullAddress;
var topic = _settings.SubTopic;
using (var subscriber = new SubscriberSocket())
using (var puller = new PullSocket())
{
subscriber.Connect(subAddress);
subscriber.Subscribe(topic);
_logger.LogInformation($"Sub socket on {subAddress} topic {topic}");
puller.Connect(pullAddress);
_logger.LogInformation($"Pull socket on {pullAddress}");
using (var poller = new NetMQPoller {
subscriber, puller
})
{
subscriber.ReceiveReady += SubReceiveReady;
puller.ReceiveReady += PullReceiveReady;
poller.Run();
}
}
}
static void Main(string[] args)
{
// Task Sink
// Bindd PULL socket to tcp://localhost:5558
// Collects results from workers via that socket
Console.WriteLine("====== SINK ======");
//socket to receive messages on
using (var receiver = new PullSocket("@tcp://localhost:400"))
{
//wait for start of batch (see Ventilator.csproj Program.cs)
// var startOfBatchTrigger = receiver.ReceiveFrameString();
Console.WriteLine("Seen start of batch");
//Start our clock now
var watch = Stopwatch.StartNew();
for (int taskNumber = 0; taskNumber < 400; taskNumber = taskNumber + 10)
{
var workerDoneTrigger = receiver.ReceiveFrameBytes();
List <(int, int, int)> gameField = null;
BinaryFormatter binaryFormatter2 = new BinaryFormatter();
using (var memoryStream2 = new MemoryStream(workerDoneTrigger))
{
gameField = (List <(int, int, int)>)binaryFormatter2.Deserialize(memoryStream2);
}
}
watch.Stop();
//Calculate and report duration of batch
Console.WriteLine();
Console.WriteLine("Total elapsed time {0} msec", watch.ElapsedMilliseconds);
Console.ReadLine();
}
}
public void Start()
{
if (context == null)
{
context = NetMQContext.Create();
publisher = context.CreatePublisherSocket();
publisher.Bind("tcp://*:5252");
receiver = context.CreatePullSocket();
receiver.Bind("tcp://*:5253");
// Start listening..
Task.Run(() =>
{
try
{
while (!tokenSource.IsCancellationRequested)
{
var message = receiver.ReceiveString();
var command = Serialization.DeserializeEnvelope <ContractMarker>(message);
commandReceivedSubject.OnNext(command);
}
}
catch (Exception ex)
{
Tracer.Error(ex);
throw;
}
});
}
}
public static void Main(string[] args)
{
using (var client = new PullSocket())
{
client.Bind("tcp://127.0.0.1:5488");
while (true)
{
string a = client.ReceiveFrameString(); // To receive a flag from external programs to start the service
if (bool.Parse(a))
{
Console.WriteLine("START");
// Added Begin
CancellationTokenSource source = new CancellationTokenSource();
CancellationToken token = source.Token;
// Added End
Thread t = new Thread(new ParameterizedThreadStart(ThreadProc));
//t.Start(args);
t.Start(source);
//CreateHostBuilder(args).Build().RunAsync(token).Wait(); // This works at the first start
// ATTENTION! CreateHostBuilder(args).Build().Run() will return an error about args.Length < 0
CreateHostBuilder(args).Build().RunAsync(token);
Console.WriteLine("DONE Start");
}
}
}
}
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 Main(string[] args)
{
using (var server = new ResponseSocket())
using (var comm = new PullSocket("@tcp://*:9999"))
using (var poller = new NetMQPoller {
comm
})
{
comm.ReceiveReady += (s, a) =>
{
//bool more;
//string messageIn = a.Socket.ReceiveFrameString(out more);
string message = a.Socket.ReceiveFrameString();
Console.WriteLine("Poller ==> Received: {0}", message);
// TODO: When receiving a message send response to caller
};
// Start polling
poller.RunAsync();
Console.WriteLine("Server waiting for requests. " +
"Press <Spacebar> to generate test data. " +
"Press <Enter> to send. " +
"Press <Esc> to quit.");
List <int> freePorts = Enumerable.Range(4000, 5999).ToList();
// TODO: Handle data and model transfer ...
string model = "<Here goes the serialized model (protobuf?)";
string data = Guid.NewGuid().ToString();
var cki = new ConsoleKeyInfo();
while (true)
{
cki = Console.ReadKey();
if (cki.Key == ConsoleKey.Spacebar)
{
Console.Write("Generating test data ... ");
var filename = data + ".dat";
Data.GenerateDataFile(filename, 40000, 4200);
Console.WriteLine("Done!");
}
if (cki.Key == ConsoleKey.Enter)
{
Console.WriteLine("Request received. Delegating ...");
var port = freePorts.TakeFirst();
Task.Factory.StartNew(() =>
HandleCalibration(port, model, data));
}
if (cki.Key == ConsoleKey.Escape)
{
break;
}
}
}
}
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 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 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.");
}
}
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 ======");
}
protected override void Consume(PullSocket socket, int messageSize)
{
for (int i = 0; i < MsgCount; i++)
{
var message = socket.ReceiveFrameBytes();
Debug.Assert(message.Length == messageSize, "Message length was different from expected size.");
Debug.Assert(message[messageSize / 2] == 0x42, "Message did not contain verification data.");
}
}
public void MessageHandler_SendsCorrectPackets_ToCorrectRoutes()
{
//Allow proper decoding of orders.
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Converters = { new OrderJsonConverter() }
};
// Create list of packets to test
var debug = new DebugPacket();
var log = new LogPacket();
var backtest = new BacktestResultPacket();
var handled = new HandledErrorPacket();
var error = new RuntimeErrorPacket();
var packetList = new List<Packet>
{
log,
debug,
backtest,
handled,
error
};
using (var pullSocket = new PullSocket(">tcp://localhost:" + _port))
{
var count = 0;
while (count < packetList.Count)
{
_messageHandler.Send(packetList[count]);
var message = pullSocket.ReceiveMultipartMessage();
var payload = message[0].ConvertToString();
var packet = JsonConvert.DeserializeObject<Packet>(payload);
Assert.IsTrue(message.FrameCount == 1);
if (PacketType.Debug == packet.Type)
Assert.IsTrue(payload == JsonConvert.SerializeObject(debug));
if (PacketType.HandledError == packet.Type)
Assert.IsTrue(payload == JsonConvert.SerializeObject(handled));
if (PacketType.BacktestResult == packet.Type)
Assert.IsTrue(payload == JsonConvert.SerializeObject(backtest));
if (PacketType.RuntimeError == packet.Type)
Assert.IsTrue(payload == JsonConvert.SerializeObject(error));
if (PacketType.Log == packet.Type)
Assert.IsTrue(payload == JsonConvert.SerializeObject(log));
count++;
}
}
}
public Scheduler ()
{
Context = NetMQContext.Create ();
ReceiverSocket = Context.CreatePullSocket ();
ReceiverSocket.Bind ("tcp://0.0.0.0:10000");
new Thread (this.catchAck).Start ();
logger.Info ("Scheduler started");
}
/// <summary>
/// This 0MQ Pull socket accepts certain messages from a 0MQ Push socket
/// </summary>
/// <param name="port">The port on which to listen</param>
/// <param name="handler">The handler which will display the repsonses</param>
public void Run(string port, IDesktopMessageHandler handler)
{
//Allow proper decoding of orders.
JsonConvert.DefaultSettings = () => new JsonSerializerSettings
{
Converters = { new OrderJsonConverter() }
};
using (var pullSocket = new PullSocket(">tcp://localhost:" + port))
{
while (!_stopServer)
{
var message = pullSocket.ReceiveMultipartMessage();
// There should only be 1 part messages
if (message.FrameCount != 1) continue;
var payload = message[0].ConvertToString();
var packet = JsonConvert.DeserializeObject<Packet>(payload);
switch (packet.Type)
{
case PacketType.BacktestNode:
var backtestJobModel = JsonConvert.DeserializeObject<BacktestNodePacket>(payload);
handler.Initialize(backtestJobModel);
break;
case PacketType.LiveNode:
var liveJobModel = JsonConvert.DeserializeObject<LiveNodePacket>(payload);
handler.Initialize(liveJobModel);
break;
case PacketType.Debug:
var debugEventModel = JsonConvert.DeserializeObject<DebugPacket>(payload);
handler.DisplayDebugPacket(debugEventModel);
break;
case PacketType.HandledError:
var handleErrorEventModel = JsonConvert.DeserializeObject<HandledErrorPacket>(payload);
handler.DisplayHandledErrorPacket(handleErrorEventModel);
break;
case PacketType.BacktestResult:
var backtestResultEventModel = JsonConvert.DeserializeObject<BacktestResultPacket>(payload);
handler.DisplayBacktestResultsPacket(backtestResultEventModel);
break;
case PacketType.RuntimeError:
var runtimeErrorEventModel = JsonConvert.DeserializeObject<RuntimeErrorPacket>(payload);
handler.DisplayRuntimeErrorPacket(runtimeErrorEventModel);
break;
case PacketType.Log:
var logEventModel = JsonConvert.DeserializeObject<LogPacket>(payload);
handler.DisplayLogPacket(logEventModel);
break;
}
}
}
}
public Server(string address)
{
_mainThread = new TaskThread("执行", MainLoop);
_sendThread = new TaskThread("发送", OnSend);
_receThread = new TaskThread("接收", OnReceive);
Address = address;
_netMqContext = NetMQContext.Create();
_pullSocket = _netMqContext.CreatePullSocket();
_pushSocket = _netMqContext.CreatePushSocket();
Current = this;
}
public void Connect(string endpoint)
{
if (_owner.bypassPrediction || _zmqPredictedMotion != null)
{
return;
}
_zmqPredictedMotion = new PullSocket();
_zmqPredictedMotion.Connect(endpoint);
_msgRecv = new NetMQ.Msg();
_msgRecv.InitPool(8 + 4 * 4);
}
public void ServerAsync()
{
using var server = new PullSocket();
var url = ConnectionUrl.Replace("127.0.0.1", "*");
server.Bind($"tcp://{url}");
while (server.TryReceiveFrameString(timeout: TimeSpan.FromMinutes(5), out string responseMessage))
{
_networkAdapter.Receive(responseMessage);
// server.TrySignalOK();
}
}
public virtual void SetUp()
{
PullSocket = new PullSocket(config.PullSocketString);
PullSocket.ReceiveReady += ProcessTaskPullSocket;
PushSocket = new PushSocket(config.PushsocketString);
Poller = new NetMQPoller()
{
PullSocket, PushSocket, MessageQueue
};
MessageQueue.ReceiveReady += (sender, args) => { PushSocket.SendMultipartMessage(args.Queue.Dequeue()); };
}
public void EmptyMessage()
{
using (var pullSocket = new PullSocket())
using (var pushSocket = new PushSocket())
{
var port = pullSocket.BindRandomPort("tcp://127.0.0.1");
pushSocket.Connect("tcp://127.0.0.1:" + port);
pushSocket.SendFrame(new byte[300]);
Assert.AreEqual(300, pullSocket.ReceiveFrameString().Length);
}
}
public void Close()
{
if (_zmqPredictedMotion == null)
{
return;
}
_zmqPredictedMotion.Close();
_msgRecv.Close();
_zmqPredictedMotion.Dispose();
_zmqPredictedMotion = null;
}
public PushPullSocketPortSpecs()
{
Context1 = NetMQContext.Create();
Context2 = NetMQContext.Create();
RcvdSignal = new ManualResetEvent(false);
ClientFiber = PoolFiber.StartNew();
Pull = new PullSocket <string>(Context1, "tcp://localhost:6002", x => Encoding.Unicode.GetString(x), Channel);
Push = new SendSocket <string>(Context2,
"tcp://localhost:6002",
s => Encoding.Unicode.GetBytes(s),
ZmqSocketType.Push,
false);
}
public void Start(int listenPort)
{
ctx = NetMQContext.Create();
responseSocket = ctx.CreatePullSocket();
responseSocket.Bind("tcp://*:" + listenPort);
isRunning = true;
listenThread = new Thread(ListenForMessages);
listenThread.Name = "ClientMessageListenThread";
listenThread.Start();
logger.Info("Client message puller has started listening on port " + listenPort);
}
public override void OnUnregistered()
{
base.OnUnregistered();
Debug.Assert(_zmqPredictedMotion != null);
_zmqPredictedMotion.Close();
_msgRecv.Close();
_zmqPredictedMotion.Dispose();
_zmqPredictedMotion = null;
_lastCenterEyePosition = Vector3.zero;
}
public void Start(int listenPort)
{
ctx = NetMQContext.Create();
responseSocket = ctx.CreatePullSocket();
responseSocket.Bind("tcp://*:" + listenPort);
isRunning = true;
listenThread = new Thread(ListenForMessages);
listenThread.Name = "ClientMessageListenThread";
listenThread.Start();
logger.Info("Client message puller has started listening on port " + listenPort);
}
public void SimplePushPull()
{
using (var pullSocket = new PullSocket())
using (var pushSocket = new PushSocket())
{
var port = pullSocket.BindRandomPort("tcp://127.0.0.1");
pushSocket.Connect("tcp://127.0.0.1:" + port);
pushSocket.SendFrame("hello");
Assert.AreEqual("hello", pullSocket.ReceiveFrameString());
}
}
protected override void Consume(PullSocket socket, int messageSize)
{
var msg = new Msg();
msg.InitEmpty();
for (int i = 0; i < MsgCount; i++)
{
socket.Receive(ref msg);
Debug.Assert(msg.Data.Length == messageSize, "Message length was different from expected size.");
Debug.Assert(msg.Data[msg.Size / 2] == 0x42, "Message did not contain verification data.");
}
}
public void Start()
{
if (this.cts != null && !this.cts.IsCancellationRequested)
{
throw new InvalidOperationException("The handler has already been started");
}
this.logger.LogDebug("Starting the message handler");
this.cts = new CancellationTokenSource();
this.socket = new PullSocket();
this.socket.Connect(this.options.Address);
this.process = Task.Run(this.Process, this.cts.Token);
}
private 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]);
using (var pullSocket = new PullSocket())
{
pullSocket.Bind(bindTo);
var msg = new Msg();
msg.InitEmpty();
pullSocket.Receive(ref msg);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i != messageCount - 1; i++)
{
pullSocket.Receive(ref msg);
if (msg.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: " + msg.Size + " Expected: " + messageSize);
return(-1);
}
}
stopWatch.Stop();
var millisecondsElapsed = stopWatch.ElapsedMilliseconds;
if (millisecondsElapsed == 0)
{
millisecondsElapsed = 1;
}
msg.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);
}
return(0);
}
private void FanInEntry(object n)
{
FansInRun f;
string name = (string)n;
if (FunInRM.ContainsKey(name))
{
f = FunInRM[name];
}
else
{
Logging.logger.Error("FunInEntry get name failed " + name);
return;
}
PullSocket p = new PullSocket();
string e = "tcp://" + f.point.ip + ":" + f.point.port;
try
{
p.Bind(e);
f.pullsock = p;
}
catch (Exception err)
{
Logging.logger.Error(ModName + " bind funin socket failed " + e + " " + err.Message);
throw (err);
}
string str;
string outdata;
bool result;
f.Working = true;
while (f.Running)
{
str = string.Empty;
result = f.pullsock.TryReceiveFrameString(out str);
outdata = string.Empty;
if (result == true)
{
outdata = Entry4FanInData(name, str);
}
DelayTime();
}
f.Working = false;
p.Close();
return;
}
/// <summary>
/// 三经典模式：推拉模式(管道模式)
/// 一个消息只能被消费一次
/// </summary>
static void PushPull()
{
using (var pullSocket = new PullSocket())
using (var pushSocket = new PushSocket())
{
var port = pullSocket.BindRandomPort($"{address}");
pushSocket.Connect($"{address}:" + port);
pushSocket.SendMoreFrame("hello").SendFrame("hello world");
var s = pullSocket.ReceiveFrameString();
s += pullSocket.ReceiveFrameString();
Console.WriteLine(s);//hellohello world
}
}
public async Task Start()
{
_nodeSocket = new PushSocket(_localConnectionString);
_poller.Add(_nodeSocket);
_poller.RunAsync();
_active = true;
foreach (var connStr in _peerConnectionStrings)
{
PullSocket peer = new PullSocket(connStr);
peer.ReceiveReady += Peer_ReceiveReady;
_poller.Add(peer);
_peerSockets.Add(peer);
}
}
/// <summary>
///
/// </summary>
public OrionSource(string tag)
{
Socket = new PullSocket();
this.Tag = tag;
_pinger = new NetMQTimer(TimeSpan.FromSeconds(2));
_poller = new NetMQPoller {
Socket, _pinger
};
Socket.ReceiveReady += OnDataAvailable;
_pinger.Elapsed += (s, a) =>
{
//Console.WriteLine($"{Tag} Pinger - " + DateTime.Now.ToString());
};
}
public void SetUp()
{
PushSocket = new PushSocket("@tcp://*:4556");
PullSocket = new PullSocket("@tcp://*:4557");
Poller = new NetMQPoller()
{
PushSocket,
PullSocket
};
Poller.RunAsync();
//var mockContainer = new Mock<DistrictContainer>(new ContainerSetting(), new ServerSetting
//{
// Id = "PirateX.VS-DEV",
// RedisHost = "localhost:6379"
//});
//mockContainer.Setup(x => x.GetDistrictConfig(It.IsAny<int>()))
// .Returns(DistrictConfig);
//mockContainer.Setup(x => x.LoadDistrictConfigs())
// .Returns(new []{ DistrictConfig });
//mockContainer.Setup(x => x.GetDistrictDatabaseFactory(DistrictConfig))
// .Returns(new ServiceStackDatabaseFactory(DistrictConfig.ConnectionString));
//mockContainer.Setup(x => x.GetConfigDatabaseFactory(DistrictConfig))
// .Returns(new ServiceStackDatabaseFactory(DistrictConfig.ConfigConnectionString));
_actorService = new TestActorService(new ActorConfig()
{
}, ServerContainer);
var districtConfig = ServerContainer.GetDistrictConfig(1);
Token.Sign = Utils.GetMd5($"{Token.Did}{Token.Rid}{Token.Ts}{districtConfig.SecretKey}");
_actorService.Start();
Logger.Debug("debug");
Logger.Info("debug");
Logger.Warn("debug");
//var mock = new Mock<IFoo>();
//mock.Setup(foo => foo.DoSomething("ping")).Returns(true);
}
private 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]);
using (var pullSocket = new PullSocket())
{
pullSocket.Bind(bindTo);
var msg = new Msg();
msg.InitEmpty();
pullSocket.Receive(ref msg);
var stopWatch = Stopwatch.StartNew();
for (int i = 0; i != messageCount - 1; i++)
{
pullSocket.Receive(ref msg);
if (msg.Size != messageSize)
{
Console.WriteLine("message of incorrect size received. Received: " + msg.Size + " Expected: " + messageSize);
return -1;
}
}
stopWatch.Stop();
var millisecondsElapsed = stopWatch.ElapsedMilliseconds;
if (millisecondsElapsed == 0)
millisecondsElapsed = 1;
msg.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);
}
return 0;
}
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");
}
});
}
public void MessageHandler_WillSend_MultipartMessage()
{
using (var pullSocket = new PullSocket(">tcp://localhost:" + _port))
{
var logPacket = new LogPacket
{
Message = "1"
};
var tx = JsonConvert.SerializeObject(logPacket);
_messageHandler.Transmit(logPacket);
var message = pullSocket.ReceiveMultipartMessage();
Assert.IsTrue(message.FrameCount == 1);
Assert.IsTrue(message[0].ConvertToString() == tx);
}
}
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();
}
}
/// <summary>
/// sets unique identities for all sockets
/// </summary>
private static void SetIdentities(
int myPort,
RouterSocket localFrontend,
RouterSocket cloudFrontend,
RouterSocket localBackend,
PublisherSocket stateBackend,
PullSocket monitor,
RouterSocket cloudBackend,
SubscriberSocket stateFrontend)
{
localFrontend.Options.Identity = Encoding.UTF8.GetBytes("LocalFrontend[" + myPort + "]");
cloudFrontend.Options.Identity = Encoding.UTF8.GetBytes("CloudFrontend[" + (myPort + 1) + "]");
localBackend.Options.Identity = Encoding.UTF8.GetBytes("LocalBackend[" + (myPort + 2) + "]");
stateBackend.Options.Identity = Encoding.UTF8.GetBytes("StateBackend[" + (myPort + 3) + "]");
monitor.Options.Identity = Encoding.UTF8.GetBytes("Monitor[" + (myPort + 4) + "]");
cloudBackend.Options.Identity = Encoding.UTF8.GetBytes("CloudBackend");
stateFrontend.Options.Identity = Encoding.UTF8.GetBytes("StateFrontend");
}
/// <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 localFrontend = new RouterSocket())
using (var localBackend = new RouterSocket())
using (var cloudFrontend = new RouterSocket())
using (var cloudBackend = new RouterSocket())
using (var stateBackend = new PublisherSocket())
using (var stateFrontend = new SubscriberSocket())
using (var monitor = new PullSocket())
{
// 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.SendMultipartMessage(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.SendMultipartMessage(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.SendMultipartMessage(msg);
else
cloudFrontend.SendMultipartMessage(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.SendMultipartMessage(msg);
}
else
{
// add the peers address to the request
var request = Wrap(peerAdr, msg);
// [peer adr][empty][peer client adr][empty][message id]
cloudFrontend.SendMultipartMessage(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 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.SendMultipartMessage(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.SendMultipartMessage(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.SendMultipartMessage(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();
}
// create poller and add sockets & timer
var poller = new NetMQPoller
{
localFrontend,
localBackend,
cloudFrontend,
cloudBackend,
stateFrontend,
stateBackend,
monitor,
timer
};
// start monitoring the sockets
poller.RunAsync();
// we wait for a CTRL+C to exit
while (s_keepRunning)
Thread.Sleep(100);
Console.WriteLine("Ctrl-C encountered! Exiting the program!");
if (poller.IsRunning)
poller.Stop();
poller.Dispose();
}
}
public void MessageHandler_WillSend_NewLiveJob_ToCorrectRoute()
{
using (var pullSocket = new PullSocket(">tcp://localhost:" + _port))
{
_messageHandler.SetAuthentication(new LiveNodePacket());
var message = pullSocket.ReceiveMultipartMessage();
var payload = message[0].ConvertToString();
var packet = JsonConvert.DeserializeObject<Packet>(payload);
Assert.IsTrue(message.FrameCount == 1);
Assert.IsTrue(PacketType.LiveNode == packet.Type);
Assert.IsTrue(payload == JsonConvert.SerializeObject(new LiveNodePacket()));
}
}
