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) { }