private void OnShimReady(object sender, NetMQSocketEventArgs e)
{
var command = _shim.ReceiveFrameString();
switch (command)
{
case NetMQActor.EndShimMessage:
{
_poll.Stop();
break;
}
case PublishCommand:
{
_publisher.SendMultipartMessage(_shim.ReceiveMultipartMessage());
break;
}
case GetHostAddressCommand:
{
_shim.SendFrame($"{_beacon.BoundTo}:{_port}");
break;
}
}
}
private void _querySocket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
try
{
if (e.IsReadyToReceive)
{
NetMQMessage msg = e.Socket.ReceiveMultipartMessage();
if (null != msg && msg.FrameCount >= 3)
{
string queryType = msg[1].ReadString();
string stationId = msg[2].ReadString();
switch (queryType)
{
case QUERY_CMD_PCLIENT:
string param = msg[3].ReadString();
Console.WriteLine("[Progress]:[3] Request Received");
//do something
ReceiveOptionFromServer(stationId, param);
break;
default:
break;
}
}
else if (null != msg && msg.FrameCount == 2)
{
string str = msg[1].ReadString();
Console.WriteLine("req received:" + str);
}
}
}
catch (Exception ex)
{
}
}
private void ReceiveFromRemote(object sender, NetMQSocketEventArgs e)
{
NetMQMessage msg = e.Socket.ReceiveMultipartMessage();
Guid remoteId = new Guid(msg[1].Buffer);
string name = msg[2].ConvertToString();
switch (msg[0].ConvertToString())
{
case "ENTER":
Console.WriteLine("New endpoint found");
RemoteEndpoint remote = new RemoteEndpoint(name, this, remoteId, (c) => { Console.WriteLine("REMOTE: " + c); });
remote.RequestRemoteGraph(remoteId);
if (!_remoteEndpoints.ContainsKey(remoteId))
{
_remoteEndpoints.Add(remoteId, remote);
}
else
{
_remoteEndpoints[remoteId] = remote;
}
break;
case "WHISPER":
HandleWhisperMessage(msg);
break;
case "SHOUT":
HandleShoutMessage(msg);
break;
default:
break;
}
}
/// <summary>
/// 消息接收事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Response_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
NetMQMessage mqMsg = null;
if (e.Socket.TryReceiveMultipartMessage(Timeout, ref mqMsg))
{
if (mqMsg.FrameCount < 3)
{
Logger.Error($"TryReceive Exceptrion : Not the correct message frame");
return;
}
var messageType = (ProtoEnum)mqMsg[0].ConvertToInt32();
var HeaderBytes = mqMsg[1].Buffer;
var BodyBytes = mqMsg[2].Buffer;
Header header;
using (var ms = new System.IO.MemoryStream(HeaderBytes))
header = ProtoBuf.Serializer.Deserialize <Header>(ms);
header.MessageType = messageType;
this.Service_ReceiveMessage(header, BodyBytes, e.Socket);
}
else
{
Logger.Error($"TryReceive Exceptrion : Message Receive Fail!");
}
}
/// <summary>
/// handle the incoming messages
/// if a message is received timeout timer is reseted
/// </summary>
/// <remarks>
/// socket strips [client adr][e] from message // TODO remove this?!
/// message ->
/// [empty frame][protocol header][service name][reply]
/// [empty frame][protocol header][service name][result code of service lookup]
/// </remarks>
private void OnProcessReceiveReady(object sender, NetMQSocketEventArgs e)
{
Exception exception = null;
NetMQMessage reply = null;
try
{
reply = m_client.ReceiveMultipartMessage();
if (ReferenceEquals(reply, null))
{
throw new ApplicationException("Unexpected behavior");
}
m_timer.EnableAndReset(); // reset timeout timer because a message was received
Log($"[CLIENT INFO] received a reply with '{reply.FrameCount}' frames");
ExtractFrames(reply);
}
catch (Exception ex)
{
exception = ex;
}
finally
{
ReturnReply(reply, exception);
}
}
/// <summary>
/// Handling replies to a data push, a historical data request, or an available data request
/// </summary>
private void HistoricalDataSocketReceiveReady(object sender, NetMQSocketEventArgs e)
{
lock (_historicalDataSocketLock)
{
if (_historicalDataSocket == null)
{
return;
}
// 1st message part: what kind of stuff we're receiving
var type = _historicalDataSocket.ReceiveFrameString();
if (type.Equals(MessageType.HistPushReply, StringComparison.InvariantCultureIgnoreCase))
{
HandleDataPushReply();
}
else if (type.Equals(MessageType.HistReply, StringComparison.InvariantCultureIgnoreCase))
{
HandleHistoricalDataRequestReply();
}
else if (type.Equals(MessageType.AvailableDataReply, StringComparison.InvariantCultureIgnoreCase))
{
HandleAvailabledataReply();
}
else if (type.Equals(MessageType.Error, StringComparison.InvariantCultureIgnoreCase))
{
HandleErrorReply();
}
}
}
private void OnSocketReady(object sender, NetMQSocketEventArgs e)
{
Codec.Receive(m_clientSocket);
UInt64 relatedMessageId = Codec.Id == Codec.MessageId.Message ? Codec.Message.RelatedMessageId : Codec.Error.RelatedMessageId;
PendingMessage pendingMessage;
if (m_pendingRequests.TryGetValue(relatedMessageId, out pendingMessage))
{
if (Codec.Id == Codec.MessageId.Message)
{
var body = m_serializer.Deserialize(Codec.Message.Subject, Codec.Message.Body, 0,
Codec.Message.Body.Length);
pendingMessage.TaslCompletionSource.SetResult(body);
}
else
{
// TODO: we should pass more meaningful exceptions
pendingMessage.TaslCompletionSource.SetException(new Exception());
}
}
else
{
// TOOD: how to handle messages that don't exist or probably expired
}
}
private void OnReceiveReady(object sender, NetMQSocketEventArgs e)
{
var data = e.Socket.ReceiveFrameBytes();
var reply = _backend.RequestResponse(data).Result;
e.Socket.SendFrame(reply);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Server_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
NetMQMessage mqmessage = null;
if (!e.Socket.TryReceiveMultipartMessage(ref mqmessage))
{
return;
}
var identity = mqmessage.First.Buffer;
var clientId = BitConverter.ToInt32(identity, 1);
var message = NetMessage.Deserialize(mqmessage.Last.Buffer);
Slave slave;
if (!m_slaveById.ContainsKey(clientId))
{
m_slaveById.Add(clientId, slave = new Slave(identity, clientId));
}
else
{
slave = m_slaveById[clientId];
}
FireSlaveIncommingMessage(slave, message);
}
//处理订阅收到的数据,然后发送给指定的Client
protected virtual void ProcessSubscribe(object o, NetMQSocketEventArgs e)
{
//TODO https://netmq.readthedocs.io/en/latest/poller/ #Performance
if (Logger.IsTraceEnabled)
{
Logger.Trace($"ProcessSubscribe -> ThreadID = {Thread.CurrentThread.ManagedThreadId}");
}
var topic = e.Socket.ReceiveFrameBytes();//TryReceiveMultipartMessage();
var msg = e.Socket.ReceiveFrameBytes();
var dout = msg.FromProtobuf <Out>();
var protocolPackage = NetSend.GetProtocolPackage(dout.Id);
if (protocolPackage == null)
{
return;
}
var response = new PirateXResponsePackage()
{
HeaderBytes = dout.HeaderBytes,
ContentBytes = dout.BodyBytes
};
var bytes = protocolPackage.PackPacketToBytes(response);
protocolPackage.Send(bytes);
}
/// <summary>
/// This is called when a new historical data request or data push request is made.
/// </summary>
private void SocketReceiveReady(object sender, NetMQSocketEventArgs e)
{
string requesterIdentity;
string text;
lock (_socketLock)
{
// Here we process the first two message parts: first, the identity string of the client
requesterIdentity = _socket?.ReceiveFrameString() ?? string.Empty;
// Second: the string specifying the type of request
text = _socket?.ReceiveFrameString() ?? string.Empty;
}
if (text.Equals(MessageType.HistRequest, StringComparison.InvariantCultureIgnoreCase)) // The client wants to request some data
{
AcceptHistoricalDataRequest(requesterIdentity);
}
else if (text.Equals(MessageType.HistPush, StringComparison.InvariantCultureIgnoreCase)) // The client wants to push some data into the db
{
AcceptDataAdditionRequest(requesterIdentity);
}
else if (text.Equals(MessageType.AvailableDataRequest, StringComparison.InvariantCultureIgnoreCase)) // Client wants to know what kind of data we have stored locally
{
AcceptAvailableDataRequest(requesterIdentity);
}
else
{
_logger.Info($"Unrecognized request to historical data broker: {text}");
}
}
private void OnBackendReady(object sender, NetMQSocketEventArgs e)
{
Codec.Receive(m_backend);
if (Codec.Id == Codec.MessageId.ServiceRegister)
{
Service service;
if (!m_services.TryGetValue(Codec.ServiceRegister.Service, out service))
{
service = new Service(Codec.ServiceRegister.Service);
m_services.Add(Codec.ServiceRegister.Service, service);
}
// register the new service
service.Add(Codec.RoutingId);
}
else if (Codec.Id == Codec.MessageId.Message)
{
// route the message to the client id
Codec.RoutingId = RouterUtility.ConvertConnectionIdToRoutingId(Codec.Message.ConnectionId);
Codec.Message.ConnectionId = 0;
Codec.Send(m_frontend);
}
else if (Codec.Id == Codec.MessageId.Error)
{
// route the message to the client id
Codec.RoutingId = RouterUtility.ConvertConnectionIdToRoutingId(Codec.Error.ConnectionId);
Codec.Error.ConnectionId = 0;
Codec.Send(m_frontend);
}
}
/// <summary>
/// 客户端路由请求接入
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void Router_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
try
{
//前两个字节是路由的信息
var msg = e.Socket.ReceiveMultipartMessage();
//索引[2]才是协议ID
var protocolID = msg[2].ConvertToInt32();
var service = ServiceManager.FillService(protocolID);
if (service == null)
{
_response_exception(msg, e, 800001, $"消息请求：{protocolID}，找不到模块！");
return;
}
var res = service.Dealer.TrySendMultipartMessage(msg);
Console.WriteLine($"路由 接入 : {protocolID} >> {service.ServiceName} 转发 : {res}");
if (res)
{
ProxyBetween(service.Dealer, e.Socket, null);
}
else
{
ServiceManager.Uninstall(service);
_response_exception(msg, e, 800002, $"消息请求：{protocolID}，找不到模块！");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
private void _Subscire_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
var msg = subscriber.ReceiveMultipartMessage();
if (msg.FrameCount == 0)
{
return;
}
MarketData data = MarketData.Parser.ParseFrom(msg.Pop().ToByteArray());
var type = data.Type;
if (type == MarketData.Types.Type.Stock)
{
OnStockQuoteUpdated?.Invoke(Transfer(data.StockData));
}
else if (type == MarketData.Types.Type.Transaction)
{
OnTransactionUpdated?.Invoke(Transfer(data.TransactionData));
}
else if (type == MarketData.Types.Type.Order)
{
OnOrderUpdated?.Invoke(Transfer(data.OrderData));
}
else if (type == MarketData.Types.Type.Queue)
{
OnOrderQueueUpdated?.Invoke(Transfer(data.QueueData));
}
}
private void OnShimReady(object sender, NetMQSocketEventArgs e)
{
string command = e.Socket.ReceiveFrameString();
switch (command)
{
case NetMQActor.EndShimMessage:
Log.Information("Actor received EndShimMessage");
poller.Stop();
break;
case "AmendAccount":
Log.Information("Actor received AmendAccount message");
string accountJson = e.Socket.ReceiveFrameString();
Account account
= JsonConvert.DeserializeObject <Account>(accountJson);
string accountActionJson = e.Socket.ReceiveFrameString();
AccountAction accountAction
= JsonConvert.DeserializeObject <AccountAction>(
accountActionJson);
Log.Information("Incoming Account details: {Account}", account);
AmendAccount(account, accountAction);
shim.SendFrame(JsonConvert.SerializeObject(account));
break;
}
}
private static void BackendOnReceiveReady(object sender, NetMQSocketEventArgs socket)
{
// Queue worker address for LRU routing
byte[] workerAddress = socket.Socket.Receive();
// Use worker address for LRU routing
workerQueue.Enqueue(workerAddress);
// Second frame is empty
byte[] empty = socket.Socket.Receive();
// Third frame is READY or else a client reply address
byte[] clientAddress = socket.Socket.Receive();
// If client reply, send rest back to frontend
// Forward message to client if it's not a READY
if (Encoding.Unicode.GetString(clientAddress) != LRU_READY)
{
empty = socket.Socket.Receive();
byte[] reply = socket.Socket.Receive();
frontend.SendMore(clientAddress);
frontend.SendMore("");
frontend.Send(reply);
}
}
private void RequestSocketReceiveReady(object sender, NetMQSocketEventArgs e)
{
lock (_requestConnectionString)
{
if (_requestSocket != null)
{
var requestType = _requestSocket.ReceiveFrameString();
if (requestType == null)
{
return;
}
// Handle ping requests
if (requestType.Equals(MessageType.Ping, StringComparison.InvariantCultureIgnoreCase))
{
_requestSocket.SendFrame(MessageType.Pong);
return;
}
// Handle real time data requests
if (requestType.Equals(MessageType.RTDRequest, StringComparison.InvariantCultureIgnoreCase)) // Two part message: first, "RTD" string. Then the RealTimeDataRequest object.
{
HandleRealTimeDataRequest();
}
// Manage cancellation requests
// Three part message: first: MessageType.CancelRTD. Second: the instrument ID. Third: frequency.
if (requestType.Equals(MessageType.CancelRTD, StringComparison.InvariantCultureIgnoreCase))
{
HandleRealTtimeDataCancelRequest();
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ClientReceive(object sender, NetMQSocketEventArgs e)
{
UpdateLastReceived();
SetConnected();
var frames = m_client.ReceiveMultipartMessage();
var message = NetMessage.Deserialize(frames[0].Buffer);
message.Match()
.With <DoYourDutyMessage>(DoYourDuty)
.With <PingMessage>(m => Send(new PongMessage()))
.With <NavigateToFolderMessage>(NavigateToFolder)
.With <DownloadFilePartMessage>(DownloadFilePart)
.With <UploadFileMessage>(UploadFile)
.With <DeleteFileMessage>(DeleteFile)
.With <StartScreenCaptureMessage>(ScreenCapture.Instance.StartScreenCapture)
.With <StopScreenCaptureMessage>(ScreenCapture.Instance.StopScreenCapture)
.With <ExecuteFileMessage>(ExecuteFile)
.With <StartCredentialsMessage>(DumpCredentials)
.With <StartWebcamCaptureMessage>(Webcam.Instance.StartScreenCapture)
.With <StopWebcamCaptureMessage>(Webcam.Instance.StopScreenCapture)
.Default(m => SendFailedStatus(message.WindowId, "Message parsing", $"Unknow message {m.GetType().Name}"));
#if DEBUG
if (message.GetType() != typeof(PingMessage))
{
Console.WriteLine(message.GetType().Name);
}
#endif
}
private void OnShimReady(object sender, NetMQSocketEventArgs e)
{
string command = e.Socket.ReceiveString();
if (command == WSSocket.BindCommand)
{
string address = e.Socket.ReceiveString();
int errorCode = 0;
try
{
m_stream.Bind(address.Replace("ws://", "tcp://"));
}
catch (NetMQException ex)
{
errorCode = (int)ex.ErrorCode;
}
byte[] bytes = BitConverter.GetBytes(errorCode);
e.Socket.Send(bytes);
}
else if (command == ActorKnownMessages.END_PIPE)
{
m_poller.Stop(false);
}
}
/// <summary>
/// Handling replies to a data push, a historical data request, or an available data request
/// </summary>
private void _dealerSocket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
lock (_dealerSocketLock)
{
//1st message part: what kind of stuff we're receiving
string type = _dealerSocket.ReceiveString();
switch (type)
{
case "PUSHREP":
HandleDataPushReply();
break;
case "HISTREQREP":
HandleHistoricalDataRequestReply();
break;
case "AVAILABLEDATAREP":
HandleAvailabledataReply();
break;
case "ERROR":
HandleErrorReply();
break;
}
}
}
private void SubOnReceiveReady(object sender, NetMQSocketEventArgs e)
{
NetMQSocket socket = e.Socket;
bool hasMore;
try
{
string msg = Encoding.UTF8.GetString(socket.Receive(SendReceiveOptions.DontWait, out hasMore));
if (msg.Length > 0)
{
string topic, body, serviceName;
if (SpliteMsg(msg, out topic, out body))
{
serviceName = GetServiceName(_sub_links, Encoding.UTF8.GetString(socket.Options.Identity));
MsgHandler h = this.GetTopicSubscriber(serviceName, topic);
if (h != null)
{
h(msg);
}
}
}
}
catch (Exception ce)
{
Console.WriteLine("onsubscribe Error: {0}", ce.Message);
log.Error("onsubscribe message error: ", ce);
}
}
/// <summary>
/// expect from
/// CLIENT -> [sender adr][e][protocol header][service name][request]
/// WORKER -> [sender adr][e][protocol header][mdp command][reply]
/// </summary>
private void ProcessReceivedMessage(object sender, NetMQSocketEventArgs e)
{
var msg = e.Socket.ReceiveMultipartMessage();
DebugLog($"Received: {msg}");
var senderFrame = msg.Pop(); // [e][protocol header][service or command][data]
var empty = msg.Pop(); // [protocol header][service or command][data]
var headerFrame = msg.Pop(); // [service or command][data]
var header = headerFrame.ConvertToString();
if (header == MDPClientHeader)
{
ProcessClientMessage(senderFrame, msg);
}
else
if (header == MDPWorkerHeader)
{
ProcessWorkerMessage(senderFrame, msg);
}
else
{
Log(string.Format("ERROR - message with invalid protocol header!"));
}
}
private static void OnWorkerReceiveReady(object sender, NetMQSocketEventArgs e)
{
// upon receiving a message this event handler is called
// read the message, randomly simulate failure/problem
// process message or heartbeat or crash
var msg = e.Socket.ReceiveMultipartMessage();
// message is a NetMQMessage (!)
// - 3 part envelope + content -> request
// - 1 part HEARTBEAT -> heartbeat
if (msg.FrameCount > 3)
{
// in order to test the robustness we simulate a couple of typical problems
// e.g. worker crushing or running very slow
// that is initiated after multiple cycles to give everything time to stabilize first
cycles++;
if (cycles > 3 && rnd.Next(5) == 0)
{
Console.WriteLine("[WORKER] simulating crashing!");
crash = true;
return;
}
if (cycles > 3 && rnd.Next(3) == 0)
{
Console.WriteLine("[WORKER] Simulating CPU overload!");
Thread.Sleep(500);
}
if (verbose)
{
Console.Write("[WORKER] working ...!");
}
// simulate high workload
Thread.Sleep(10);
if (verbose)
{
Console.WriteLine("[WORKER] sending {0}", msg.ToString());
}
// answer
e.Socket.SendMultipartMessage(msg);
// reset liveliness
liveliness = Commons.HeartbeatLiveliness;
}
else if (IsHeartbeatMessage(msg))
{
liveliness = Commons.HeartbeatLiveliness;
}
else
{
Console.WriteLine("[WORKER] Received invalid message!");
}
interval = Commons.IntervalInit;
}
private static void Pull_ReceiveReady1(object sender, NetMQSocketEventArgs e)
{
var fileByte = e.Socket.ReceiveFrameBytes();
var md5Str = Encoding.UTF8.GetString(fileByte.Take(128).ToArray());
var time = Encoding.UTF8.GetString(fileByte.Skip(md5Str.Length).Take(17).ToArray());
DateTime sendTime = DateTime.ParseExact(time, "yyyyMMddHHmmssfff", null);
int takeSize = md5Str.Length + time.Length;
var bodyBytes = fileByte.Skip(takeSize).TakeLast(fileByte.Length - takeSize).ToArray();
DateTime reciveDateTime = System.DateTime.Now;
string md5 = MD5(bodyBytes);
if (!string.Equals(md5Str, md5))
{
Console.Out.WriteLine($"上传文件不合法， {System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss fff")}");
}
else
{
Console.Out.WriteLine($"接收文件成功，文件大小为{bodyBytes.Length}， {reciveDateTime.ToString("yyyy-MM-dd HH:mm:ss fff")},发送时间为{sendTime.ToString("yyyy-MM-dd HH:mm:ss fff")},耗时：{(reciveDateTime - sendTime).TotalMilliseconds}");
}
string addr = @$ "{e.Socket.Options.LastEndpoint}";
publisherSocket.SendMoreFrame(addr).SendFrame("test");
}
static void Client_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
bool more = false;
string result = e.Socket.ReceiveFrameString(out more);
Console.WriteLine("REPLY {0}", result);
}
private void OnSubscriberMessage(object sender, NetMQSocketEventArgs e)
{
// we just forward the message to the actor
var message = _subscriber.ReceiveMultipartMessage();
Debug.WriteLine(message);
var topic = message[0].ConvertToString();
if (topic == WelcomeMessage)
{
SubscriberAddress = e.Socket.Options.LastEndpoint;
Debug.WriteLine($"Subsciber Address: {SubscriberAddress}");
_welcomeMessageHandler?.Invoke();
}
else if (topic == HeartbeatMessage)
{
// we got a heartbeat, lets postponed the timer
_timeoutTimer.EnableAndReset();
}
else
{
_shim.SendMultipartMessage(message);
}
}
private static void FrontendOnReceiveReady(object sender, NetMQSocketEventArgs socket)
{
// Now get next client request, route to next worker
// Dequeue and drop the next worker address
// Now get next client request, route to LRU worker
// Client request is [address][empty][request]
byte[] clientAddr = socket.Socket.Receive();
byte[] empty = socket.Socket.Receive();
byte[] request = socket.Socket.Receive();
byte[] deq;
try
{
deq = workerQueue.Dequeue();
backend.SendMore(deq);
backend.SendMore(Encoding.Unicode.GetBytes(""));
backend.SendMore(clientAddr);
backend.SendMore(Encoding.Unicode.GetBytes(""));
backend.Send(request);
}
catch (Exception exc)
{
Console.WriteLine("Q: [FrontendOnReceiveReady] Dequeue exc: {0}", exc.ToString());
}
}
void _reqSocket_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
string requestType = _reqSocket.ReceiveString();
if (requestType == null)
{
return;
}
//handle ping requests
if (requestType == "PING")
{
_reqSocket.Send("PONG");
return;
}
//Handle real time data requests
if (requestType == "RTD") //Two part message: first, "RTD" string. Then the RealTimeDataRequest object.
{
HandleRTDataRequest();
}
//manage cancellation requests
//two part message: first: "CANCEL". Second: the instrument
if (requestType == "CANCEL")
{
HandleRTDataCancelRequest();
}
}
/// <summary>
/// handle the incoming messages
/// </summary>
/// <remarks>
/// socket strips [client adr][e] from message
/// message -> [protocol header][service name][reply]
/// [protocol header][service name][result code of service lookup]
/// </remarks>
private void ProcessReceiveReady(object sender, NetMQSocketEventArgs e)
{
// a message is available within the timeout period
var reply = m_client.ReceiveMultipartMessage();
Log($"\n[CLIENT INFO] received the reply {reply}\n");
// in production code malformed messages should be handled smarter
if (reply.FrameCount < 2)
{
throw new ApplicationException("[CLIENT ERROR] received a malformed reply");
}
var header = reply.Pop(); // [MDPHeader] <- [service name][reply] OR ['mmi.service'][return code]
if (header.ConvertToString() != m_mdpClient)
{
throw new ApplicationException($"[CLIENT INFO] MDP Version mismatch: {header}");
}
var service = reply.Pop(); // [service name or 'mmi.service'] <- [reply] OR [return code]
if (service.ConvertToString() != m_serviceName)
{
throw new ApplicationException($"[CLIENT INFO] answered by wrong service: {service.ConvertToString()}");
}
// now set the value for the reply of the send method!
m_reply = reply; // [reply] OR [return code]
}
private void BackendReceiveReady(object sender, NetMQSocketEventArgs e)
{
// 将worker的地址入队
var address = e.Socket.ReceiveFrameBytes();
workerQueue.Enqueue(address);
// 跳过空帧
e.Socket.ReceiveFrameBytes();
// 第三帧是“READY”或是一个client的地址
var clientAddress = e.Socket.ReceiveFrameBytes();
// 如果是一个应答消息，则转发给client
if (clientAddress.Length > 1)
{
//空帧
e.Socket.ReceiveFrameBytes();
var replay = e.Socket.ReceiveFrameBytes();
_frontend.SendMoreFrame(clientAddress);
_frontend.SendMoreFrame("");
_frontend.SendFrame(replay);
}
else
{
Console.WriteLine($"backend[{Encoding.UTF8.GetString(address)}] receive ready");
}
}
private void OnSubscriberMessage(object sender, NetMQSocketEventArgs e)
{
var topic = e.Socket.ReceiveFrameString();
switch (topic)
{
case "WM":
// welcome message, print and reset timeout timer
Console.WriteLine("Connection drop recongnized");
m_timeoutTimer.Enable = false;
m_timeoutTimer.Enable = true;
Console.WriteLine("Message received. Topic: {0}", topic);
break;
case "HB":
// heartbeat, we reset timeout timer
m_timeoutTimer.Enable = false;
m_timeoutTimer.Enable = true;
Console.WriteLine("Message received. Topic: {0}", topic);
break;
default:
// its a message, reset timeout timer, notify the client, for the example we just print it
m_timeoutTimer.Enable = false;
m_timeoutTimer.Enable = true;
string message = e.Socket.ReceiveFrameString();
Console.WriteLine("Message received. Topic: {0}, Message: {1}", topic, message);
break;
}
}
private void OnMessagePipeReceiveReady(object sender, NetMQSocketEventArgs e)
{
var temp = ReceiveReady;
if (temp != null)
{
temp(this, new WSSocketEventArgs(this));
}
}
protected void OnShimReady(object sender, NetMQSocketEventArgs e)
{
string command = Shim.ReceiveFrameString();
if (command == NetMQActor.EndShimMessage)
Poller.Stop();
else
OnShimCommand(command);
}
/// <summary>
/// This Override of FrontendHandler receives data from the socket contained within args,
/// and sends it to BackendSocket.
/// </summary>
/// <param name="sender">unused</param>
/// <param name="args">a NetMQSocketEventArgs that contains a NetMqSocket for receiving data from</param>
protected override void FrontendHandler(object sender, NetMQSocketEventArgs args)
{
bool more;
do
{
var data = args.Socket.ReceiveFrameBytes(out more);
if (more)
BackendSocket.SendMoreFrame(data);
else
BackendSocket.SendFrame(data);
} while (more);
}
protected override void FrontendHandler(object sender, NetMQSocketEventArgs args)
{
bool more;
do {
var data = args.Socket.Receive(out more) ?? new byte[] { };
if (more)
BackendSocket.SendMore(data);
else {
BackendSocket.Send(data);
}
} while (more);
}
private void OnWorkerReady(object sender, NetMQSocketEventArgs e)
{
Codec.Receive(m_workerSocket);
if (Codec.Id == Codec.MessageId.Message)
{
bool oneway = Codec.Message.OneWay == 1;
object message = m_serializer.Deserialize(Codec.Message.Subject, Codec.Message.Body, 0, Codec.Message.Body.Length);
ulong messageId = Codec.Message.MessageId;
string service = Codec.Message.Service;
uint connectionId = Codec.Message.ConnectionId;
if (oneway)
{
// TODO: this should run on user provided task scheduler
HandleOneWay(connectionId, messageId, service, message);
}
else
{
try
{
object reply = HandleRequest(connectionId, messageId, service, message);
string subject = m_serializer.GetObjectSubject(reply);
// TODO: Zproto should support ArraySegment to improve performance
var bodySegment = m_serializer.Serialize(reply);
byte[] body = new byte[bodySegment.Count];
Buffer.BlockCopy(bodySegment.Array, bodySegment.Offset, body, 0, bodySegment.Count);
Codec.Id = Codec.MessageId.Message;
Codec.Message.MessageId = ++m_nextMessageId;
Codec.Message.Subject = subject;
Codec.Message.Body = body;
Codec.Message.RelatedMessageId = messageId;
Codec.Send(m_workerSocket);
}
catch (Exception)
{
Codec.Id = Codec.MessageId.Error;
Codec.Error.RelatedMessageId = messageId;
Codec.Error.ConnectionId = Codec.Message.ConnectionId;
Codec.Send(m_workerSocket);
}
}
}
}
/// <summary>
/// This override of FrontendHandler receives data from the socket contained within args,
/// and Sends it to BackendSocket.
/// </summary>
/// <param name="sender">unused</param>
/// <param name="args">a NetMQSocketEventArgs that contains a Socket for receiving data from</param>
protected override void FrontendHandler(object sender, NetMQSocketEventArgs args)
{
// TODO reuse a Msg instance here for performance
bool more;
do
{
var data = args.Socket.ReceiveFrameBytes(out more);
if (more)
BackendSocket.SendMore(data);
else
BackendSocket.Send(data);
} while (more);
}
private static void ForwardTo(NetMQSocketEventArgs args, IOutgoingSocket toSocket)
{
var msg = new Msg();
msg.InitEmpty();
bool more;
do
{
args.Socket.Receive(ref msg);
more = msg.HasMore;
toSocket.Send(ref msg, more);
}
while (more);
msg.Close();
}
/// <summary>
/// This override of FrontendHandler receives data from the socket contained within args,
/// and Sends it to BackendSocket.
/// </summary>
/// <param name="sender">unused</param>
/// <param name="args">a NetMQSocketEventArgs that contains a NetMQSocket for receiving data from</param>
protected override void FrontendHandler(object sender, NetMQSocketEventArgs args)
{
ForwardTo(args, BackendSocket);
}
private void OnPipeReceiveReady(object sender, NetMQSocketEventArgs e)
{
ReceiveApi();
}
private void OnInboxReady(object sender, NetMQSocketEventArgs e)
{
ReceivePeer();
}
void Client_ReceiveReady(object sender, NetMQSocketEventArgs e)
{
bool hasmore = false;
e.Socket.Receive(out hasmore);
if (hasmore)
{
string result = e.Socket.ReceiveFrameString(out hasmore);
Console.WriteLine("REPLY {0}", result);
}
}
private void OnFrontendReady(object sender, NetMQSocketEventArgs e)
{
Codec.Receive(m_frontend);
if (Codec.Id == Codec.MessageId.Message)
{
Service service;
if (!m_services.TryGetValue(Codec.Message.Service, out service))
{
// TODO: we should return error or save the message until a service become available
}
else
{
// Add the routing id as the client id and send to correct service
Codec.Message.ConnectionId = RouterUtility.ConvertRoutingIdToConnectionId(Codec.RoutingId);
Codec.RoutingId = service.GetNextRoutingId();
Codec.Send(m_backend);
}
}
}
// These events offer similar functionality to zeromq/zyre/zyre_event.c
/// <summary>
/// This receives a message relayed by ZyreNode.ReceivePeer()
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void InboxReceiveReady(object sender, NetMQSocketEventArgs e)
{
var msg = _inbox.ReceiveMultipartMessage();
if (msg.FrameCount < 3)
{
return;
}
var msgType = msg.Pop().ConvertToString();
var senderBytes = msg.Pop().Buffer;
Debug.Assert(senderBytes.Length == 16);
var senderUuid = new Guid(senderBytes);
var name = msg.Pop().ConvertToString();
string groupName;
switch (msgType)
{
case "ENTER":
var headersBuffer = msg.Pop().Buffer;
var headers = Serialization.BinaryDeserialize<Dictionary<string, string>>(headersBuffer);
var address = msg.Pop().ConvertToString();
var enterEvent = new ZyreEventEnter(senderUuid, name, headers, address);
OnEnterEvent(enterEvent);
break;
case "WHISPER":
var whisperEvent = new ZyreEventWhisper(senderUuid, name, msg);
OnWhisperEvent(whisperEvent);
break;
case "SHOUT":
groupName = msg.Pop().ConvertToString();
var shoutEvent = new ZyreEventShout(senderUuid, name, groupName, msg);
OnShoutEvent(shoutEvent);
break;
case "JOIN":
groupName = msg.Pop().ConvertToString();
var joinEvent = new ZyreEventJoin(senderUuid, name, groupName);
OnJoinEvent(joinEvent);
break;
case "LEAVE":
groupName = msg.Pop().ConvertToString();
var leaveEvent = new ZyreEventLeave(senderUuid, name, groupName);
OnLeaveEvent(leaveEvent);
break;
case "EXIT":
OnExitEvent(new ZyreEventExit(senderUuid, name));
break;
case "STOP":
OnStopEvent(new ZyreEventStop(senderUuid, name));
break;
case "EVASIVE":
OnEvasiveEvent(new ZyreEventEvasive(senderUuid, name));
break;
default:
throw new ArgumentException(msgType);
}
}
private void OnInboxReady(object sender, NetMQSocketEventArgs e)
{
try
{
ReceivePeer();
}
catch (Exception ex)
{
_loggerDelegate?.Invoke(ex.ToString());
}
}
/// <summary> /// Invoked when a message has been received by the frontend socket. /// </summary> /// <param name="sender">the object that raised the ReceiveReady event</param> /// <param name="args">a NetMQSocketEventArgs that contains a Socket for receiving data from</param> protected abstract void FrontendHandler(object sender, NetMQSocketEventArgs args);
/// <summary>
/// Invoked when a message has been received by the backend socket.
/// </summary>
/// <param name="sender">the object that raised the ReceiveReady event</param>
/// <param name="args">a NetMQSocketEventArgs that contains a Socket for receiving data from</param>
protected virtual void BackendHandler(object sender, NetMQSocketEventArgs args) { }
