public Task Send(ArraySegment <byte> data, params object[] connectionIDs) { var task = new Task(() => { var msg = new NetMQMessage(); if (_socket is RouterSocket) { msg.Append(new byte[0]); msg.AppendEmptyFrame(); } msg.Append(data.Count == data.Array.Length ? data.Array : data.ToArray()); if (connectionIDs.Length <= 0) { _socket.SendMultipartMessage(msg); } else { foreach (var connection in connectionIDs) { if (_socket is RouterSocket && connection is byte[]) { msg.Pop(); msg.Push(((byte[])connection)); } _socket.SendMultipartMessage(msg); } } }); task.Start(_scheduler); return(task); }
public bool sendAndReceive(ref NetMQMessage req_msg, ref NetMQ.Msg resp_msg) { if (socket == null) { reconnect(); } bool ok = false; NetMQMessage copy = new NetMQMessage(req_msg); socket.SendMultipartMessage(copy); // receive if (socket.TryReceive(ref resp_msg, timeout)) { ok = true; //UnityEngine.Debug.Log("ReliableExternalClient: response received " // + new StdMessage(resp_msg.Data[1], resp_msg.Data[2]).to_string()); } copy.Clear(); socket.Dispose(); socket.Close(); socket = null; if (socket == null) { UnityEngine.Debug.Log("ReliableExternalClient: socket closed and null"); } return(ok); }
/// <summary> /// Send a message to broker /// if no message provided create a new empty one /// prepend the message with the MDP prologue /// </summary> /// <param name="mdpCommand">MDP command</param> /// <param name="data">data to be sent</param> /// <param name="message">the message to send</param> private void Send(MDPCommand mdpCommand, string data, NetMQMessage message) { // cmd, null, message -> [REPLY],<null>,[client adr][e][reply] // cmd, string, null -> [READY],[service name] // cmd, null, null -> [HEARTBEAT] var msg = ReferenceEquals(message, null) ? new NetMQMessage() : message; // protocol envelope according to MDP // last frame is the data if available if (!ReferenceEquals(data, null)) { // data could be multiple whitespaces or even empty(!) msg.Push(data); } // set MDP command ([client adr][e][reply] OR [service]) => [data] msg.Push(new[] { (byte)mdpCommand }); // [command][header][data] // set MDP Header msg.Push(m_mdpWorker); // [header][data] // set MDP empty frame as separator msg.Push(NetMQFrame.Empty); // [e][command][header][data] //Log ($"[WORKER] sending msg to broker / Command {mdpCommand}"); m_worker.SendMultipartMessage(msg); }
public static void SendError(byte[] destination, NetMQSocket socket, ErrorCode errorCode) { var response = ResponseCreator.Create(new NoEncryption(), destination, MessageType.Error, JsonConvert.SerializeObject(errorCode)); socket.SendMultipartMessage(response); }
/// <summary> /// send a request to a broker for a specific service and receive the reply /// /// if the reply is not available within a specified time /// the client deems the connection as lost and reconnects /// for a specified number of times. if no reply is available /// throughout this procedure the client abandons /// the reply is checked for validity and returns the reply /// according to the verbose flag it reports about its activities /// </summary> /// <param name="serviceName">the name of the service requested</param> /// <param name="request">the request message to process by service</param> /// <returns>the reply from service</returns> /// <exception cref="ApplicationException">malformed message received</exception> /// <exception cref="ApplicationException">malformed header received</exception> /// <exception cref="ApplicationException">reply received from wrong service</exception> public NetMQMessage Send(string serviceName, NetMQMessage request) { if (string.IsNullOrWhiteSpace(serviceName)) { throw new ApplicationException("serviceName must not be empty or null."); } if (ReferenceEquals(request, null)) { throw new ApplicationException("the request must not be null"); } // memorize it for the event handler m_serviceName = serviceName; // if for any reason the socket is NOT connected -> connect it! if (!m_connected) { Connect(); } var message = new NetMQMessage(request); // prefix the request according to MDP specs // Frame 1: "MDPCxy" (six bytes MDP/Client x.y) // Frame 2: service name as printable string // Frame 3: request message.Push(serviceName); message.Push(m_mdpClient); Log(string.Format("[CLIENT INFO] sending {0} to service {1}", message, serviceName)); var retiesLeft = Retries; while (retiesLeft > 0) { // beware of an exception if broker has not picked up the message at all // because one can not send multiple times! it is strict REQ -> REP -> REQ ... m_client.SendMultipartMessage(message); // Poll -> see ReceiveReady for event handling if (m_client.Poll(Timeout)) { // set by event handler return(m_reply); } // if it failed assume communication dead and re-connect if (--retiesLeft > 0) { Log("[CLIENT WARNING] no reply, reconnecting ..."); Connect(); } } Log("[CLIENT ERROR] permanent error, abandoning!"); m_client.Dispose(); return(null); }
public override void Response(TResponse response) { try { #region Sending Response // Preparing response. var messageToClient = new NetMQMessage(); messageToClient.Append(clientAddress); messageToClient.AppendEmptyFrame(); messageToClient.Append(MessageQueueCommonItems.SerializeToJson(response)); // Sending response. responseChannel.SendMultipartMessage(messageToClient); #endregion } catch (QueueException queueException) { #region Logging - Error logger.Error(queueException, queueException.Message); #endregion throw; } catch (Exception ex) { throw MessageQueueCommonItems.PrepareAndLogQueueException( errorCode: QueueErrorCode.FailedToSendResponseMessage, message: ErrorMessages.FailedToSendResponseMessage, innerException: ex, queueContext: CommonItems.ZeroMqName, logger: logger); } }
public void Start() { while (true) { var msg = frontend.ReceiveMultipartMessage(); backend.SendMultipartMessage(msg); frontend.SendFrame("Success"); } }
/// <summary> /// Sends an object to the Server /// </summary> /// <typeparam name="T">Type of object to be sent</typeparam> /// <param name="objectToSend">The object to send to the server</param> public void Send <T>(T objectToSend) { byte[] data = BsonMagic.SerializeObject <T>(objectToSend); NetMQMessage messageToServer = new NetMQMessage(); messageToServer.AppendEmptyFrame(); messageToServer.Append(typeof(T).AssemblyQualifiedName); messageToServer.Append(data); clientSocket.SendMultipartMessage(messageToServer); }
public Action<NetMQMessage> Send(NetMQSocket socket, PendingResRequest pendingRequest, Guid requestId) { var pending = (PendingResRequest<QueryEventsForStreamResponse>) pendingRequest; var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(ResCommands.QueryEventsByStream); msg.Append(requestId.ToByteArray()); msg.Append(_context); msg.Append(_stream); msg.Append(_fromVersion.ToNetMqFrame()); msg.Append(_maxVersion.ToNetMqFrame()); socket.SendMultipartMessage(msg); return m => { var command = m.Pop().ConvertToString(); if (command == ResCommands.Error) { var errorCode = m.Pop().ConvertToString(); var errorDetails = m.Pop().ConvertToString(); ErrorResolver.RaiseException(errorCode, errorDetails, pending.SetException); return; } if (command != ResCommands.QueryEventsByStreamResponse) pending.SetException(new UnsupportedCommandException(command)); var count = m.PopInt32(); var events = new EventInStorage[count]; for (var i = 0; i < count; i++) { var id = new Guid(m.Pop().ToByteArray()); var streamId = m.Pop().ConvertToString(); var context = m.Pop().ConvertToString(); var sequence = m.PopInt64(); var timestamp = m.PopDateTime();; var type = m.PopString(); var headers = m.PopStringOrNull(); var body = m.PopString(); events[i] = new EventInStorage(context, streamId, sequence, type, id, headers, body, timestamp); } var result = new QueryEventsForStreamResponse(_context, _stream, events); pending.SetResult(result); }; }
/// <summary> /// Send an object to a specified client /// </summary> /// <typeparam name="T">The type of the object being sent</typeparam> /// <param name="objectToSend">The object to send to the client</param> /// <param name="clientId">ID of the client to whom the object will be sent</param> public void Send <T>(T objectToSend, Guid clientId) { byte[] data = BsonMagic.SerializeObject <T>(objectToSend); NetMQMessage msgToSend = new NetMQMessage(); msgToSend.Append(clientId.ToByteArray()); msgToSend.AppendEmptyFrame(); msgToSend.Append(typeof(T).AssemblyQualifiedName); msgToSend.Append(data); netMqSocket.SendMultipartMessage(msgToSend); }
private void ProcessMessage(object sender, NetMQSocketEventArgs eventArgs) { try { NetMQMessage raw = eventArgs.Socket.ReceiveMultipartMessage(); NetMQSocket client = eventArgs.Socket; Message message = Message.Parse(raw); Message reply = null; switch (message) { case GetBlock getBlock: var block = _chain[getBlock.BlockHash]; var payload = block.Serialize(); reply = new Block(payload); break; case GetTip getTip: var tip = _chain.Tip; reply = new Tip(tip.Index, tip.Hash); break; case GetState getState: var state = _chain.GetState( getState.Address, getState.BlockHash) ?? default(Null); var codec = new Codec(); reply = new State(codec.Encode(state)); break; case GetBlockHash getBlockHash: var blockHash = _chain[getBlockHash.BlockIndex].Hash; reply = new BlockHash(blockHash); break; default: throw new InvalidMessageException( $"Unhandled message [type: {message.GetType()}]."); } client.SendMultipartMessage(reply.ToNetMQMessage()); } catch (Exception e) { Log.Error("Error occurred.", e); } }
public void ProcessMessage(NetMQMessage message, NetMQSocket socket) { var sender = new List<NetMQFrame>(message.FrameCount); for (int i = 0; i < message.FrameCount; i++) { var frame = message[i]; if (frame.BufferSize == 0) break; sender.Add(frame); } var protocolFrame = message[sender.Count + 1]; var commandFrame = message[sender.Count + 2]; var requestId = message[sender.Count + 3]; try { _processor.ProcessMessage(message, socket); } catch (Exception e) { Log.Warn("[EHMessageProcessor] Error processing message.", e); var entry = _errorResolver.GetError(e); if (entry != null) { var msg = new NetMQMessage(); foreach (var frame in sender) { msg.Append(frame); } msg.AppendEmptyFrame(); msg.Append(protocolFrame); msg.Append(requestId); msg.Append(ResCommands.Error); msg.Append(entry.ErrorCode.ToString(CultureInfo.InvariantCulture)); msg.Append(entry.Message); socket.SendMultipartMessage(msg); } } }
public Action<NetMQMessage> Send(NetMQSocket socket, PendingResRequest pendingRequest, Guid requestId) { var pending = (PendingResRequest<CommitResponse>) pendingRequest; var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(ResCommands.AppendCommit); msg.Append(requestId.ToByteArray()); msg.Append(Context); msg.Append(Stream); msg.Append(ExpectedVersion.ToNetMqFrame()); msg.Append(Events.Length.ToNetMqFrame()); foreach (var e in Events) { msg.Append(e.EventId.ToByteArray()); msg.Append(e.Timestamp.ToNetMqFrame()); msg.Append(e.TypeTag); msg.Append(e.Headers.ToNetMqFrame()); msg.Append(e.Body); } socket.SendMultipartMessage(msg); return m => { var command = m.Pop().ConvertToString(); if (command == ResCommands.Error) { var errorCode = m.Pop().ConvertToString(); var errorDetails = m.Pop().ConvertToString(); ErrorResolver.RaiseException(errorCode, errorDetails, pending.SetException); return; } if (command != ResCommands.CommitResult) pending.SetException(new UnsupportedCommandException(command)); var commitId = new Guid(m.Pop().ToByteArray()); var result = new CommitResponse(commitId); pending.SetResult(result); }; }
protected override Task SendAsync(WampMessage <object> message) { var task = new Task(() => { var msg = new NetMQMessage(); if (_socket is RouterSocket) { msg.Append(new byte[0]); msg.AppendEmptyFrame(); } var bytes = _binding.Format(message); msg.Append(bytes); _socket.SendMultipartMessage(msg); }); task.Start(_scheduler); return(task); }
public void Send(NetMQSocket socket) { var msg = new NetMQMessage(); msg.Append(_context.Sender); msg.AppendEmptyFrame(); msg.Append(_protocol); msg.Append(_context.RequestId); if (_error == null) { msg.Append(ResCommands.CommitResult); msg.Append(_context.CommitId.ToByteArray()); } else { msg.Append(ResCommands.Error); msg.Append(_error.ErrorCode.ToString(CultureInfo.InvariantCulture)); msg.Append(_error.Message); } socket.SendMultipartMessage(msg); }
/// <summary> /// send a asyncronous request to a broker for a specific service without receiving a reply /// /// there is no retry logic /// according to the verbose flag it reports about its activities /// </summary> /// <param name="serviceName">the name of the service requested</param> /// <param name="request">the request message to process by service</param> /// <exception cref="ApplicationException">serviceName must not be empty or null.</exception> /// <exception cref="ApplicationException">the request must not be null</exception> public void Send([NotNull] string serviceName, NetMQMessage request) { // TODO criar tabela de pedidos ongoing if (string.IsNullOrWhiteSpace(serviceName)) { throw new ApplicationException("serviceName must not be empty or null."); } if (ReferenceEquals(request, null)) { throw new ApplicationException("the request must not be null"); } // memorize it for the event handler m_serviceName = serviceName; // if for any reason the socket is NOT connected -> connect it! if (!m_connected) { Connect(); } var message = new NetMQMessage(request); // prefix the request according to MDP specs // Frame 1: Empty Frame, because DEALER socket needs to emulate a REQUEST socket to comunicate with ROUTER socket // Frame 2: "MDPCxy" (six bytes MDP/Client x.y) // Frame 3: service name as printable string // Frame 4: request message.Push(serviceName); message.Push(m_mdpClient); message.PushEmptyFrame(); Log($"[CLIENT INFO] sending message to service {serviceName}"); m_client.SendMultipartMessage(message); // Or TrySend!? ErrorHandling!? }
public Task <OperateResult> SendAsync(TransportMessage message) { NetMQSocket channel = null; try { channel = _connectionChannelPool.Rent(); NetMQMessage msg = new NetMQMessage(); msg.Append(message.GetName()); msg.Append(System.Text.Json.JsonSerializer.Serialize(message.Headers.ToDictionary(x => x.Key, x => (object)x.Value))); msg.Append(message.Body); channel.SendMultipartMessage(msg); _logger.LogDebug($"ZeroMQ topic message [{message.GetName()}] has been published."); return(Task.FromResult(OperateResult.Success)); } catch (Exception ex) { var wrapperEx = new PublisherSentFailedException(ex.Message, ex); var errors = new OperateError { Code = ex.HResult.ToString(), Description = ex.Message }; return(Task.FromResult(OperateResult.Failed(wrapperEx, errors))); } finally { if (channel != null) { var returned = _connectionChannelPool.Return(channel); if (!returned) { channel.Dispose(); } } } }
public void sendMessage(NetMQSocket socket, KernelMessage envelope, string messageType, object content) { var header = createHeader(messageType, envelope); var msg = new NetMQMessage(); foreach (var ident in envelope.Identifiers) { msg.Append(ident); } var _header = serialize(header); var _parent_header = serialize(envelope.Header); var _meta = "{}"; var _content = serialize(content); var _signature = sign(new string[] { _header, _parent_header, _meta, _content }); msg.Append(encode("<IDS|MSG>")); msg.Append(encode(_signature)); msg.Append(encode(_header)); msg.Append(encode(_parent_header)); msg.Append(encode(_meta)); msg.Append(encode(_content)); socket.SendMultipartMessage(msg); }
private void RouterSocket_ReceiveReady(object sender, NetMQSocketEventArgs e) { NetMQMessage message = e.Socket.ReceiveMultipartMessage(); _dealerSocket.SendMultipartMessage(message); }
public void Send(NetMQSocket socket) { socket.SendMultipartMessage(_msg); }
/// <summary> /// New non blocking queue, using Thread events for smart control. /// </summary> private void MessageSenderLoop() { _logger.Debug("Starting dequeue loop..."); if (Thread.CurrentThread.Name == null) { Thread.CurrentThread.Name = "Nyx Borg Message Queue"; } Thread.CurrentThread.Priority = ThreadPriority.Highest; while (!_messageLoopToken.IsCancellationRequested) { if (_messageQueue.Count == 0) { _messageSendResetEvent.WaitOne(); } else if (!_isConnected) { if (_messageLoopCancelation.IsCancellationRequested) { _messageReplyReceived.OnError(new EndOfStreamException("Message queue is stopping.")); } _messageLoopToken.ThrowIfCancellationRequested(); _messageSendResetEvent.WaitOne(TimeSpan.FromSeconds(_timeOut)); continue; } // Check if we have messages or if our hub is alive if (_messageQueue.Count == 0) { continue; } if (_reqSocket == null) { continue; } // Dequeues message if dequeue on fail is on, else leave this to a later stage var dequeueOnFail = _dequeueOnFail; MessageHelper msg; lock (MessageQueueSync) msg = dequeueOnFail ? _messageQueue.Dequeue() : _messageQueue.Peek(); var readonlyMsg = msg.Message.AsReadOnly(); _logger.Trace("{0} message {1}", dequeueOnFail ? "Dequeued" : "Peeked", msg.Message); var abort = FilterMessage(msg.Message); if (abort) { _logger.Debug("Message {0} was not sent.", msg.Message); if (!dequeueOnFail || msg.Retries > _maxFailedRetries) { lock (MessageQueueSync) _messageQueue.Dequeue(); } else { msg.Retries++; } if (_messageQueue.Count == 0) { _messageSendResetEvent.Reset(); } continue; } // Reply control NetMQMessage mqMessage = null; var retries = _timeOutRetries; var timeout = Debugger.IsAttached ? 120000 : _timeOut; try { _reqSocket.SendMultipartMessage(msg.Message.ToNetMQMessage()); var received = false; while (!received && retries > 0) { received = _reqSocket.TryReceiveMultipartMessage(TimeSpan.FromMilliseconds(timeout), ref mqMessage); retries--; } } catch (Exception ex) { _logger.Error("Error sending message. REQ-REP Socket state problem.", ex); } if (mqMessage == null) { _logger.Error("Message with id={0}, failed, due to timeout of {1}ms reached, hub maybe busy.", msg.Message.ShortId(), timeout * retries); NotifyMessageFailedOut(readonlyMsg, "No reply or invalid data return by the hub."); // Here we restart all over again... if (!dequeueOnFail && msg.Retries <= _maxFailedRetries) { _logger.Debug("Requeue message with id={0}.", msg.Message.ShortId()); msg.Retries++; } else if (msg.Retries > _maxFailedRetries) { if (!dequeueOnFail) { lock (MessageQueueSync) _messageQueue.Dequeue(); } } if (_clearQueueOnFail) { lock (MessageQueueSync) _messageQueue.Clear(); } CreateServerSocket(); continue; } // Everything went well lets dequeue if we didn't do that before if (!dequeueOnFail) { lock (MessageQueueSync) _messageQueue.Dequeue(); } NotifyMessageSentOut(readonlyMsg, true); var data = mqMessage.FrameCount > 1 ? mqMessage[2].ConvertToString() : mqMessage.First.ConvertToString(); _logger.Trace("We did get a reply {0}...", data); if (_messageQueue.Count == 0) { _messageSendResetEvent.Reset(); } } _messageReplyReceived.OnError(new EndOfStreamException("Message queue is stopping.")); _logger.Debug("Stopping dequeue loop..."); }
public Action<NetMQMessage> Send(NetMQSocket socket, PendingResRequest pendingRequest, Guid requestId) { var pending = (PendingResRequest<QueuedEventsResponse>) pendingRequest; var msg = new NetMQMessage(); msg.AppendEmptyFrame(); msg.Append(ResProtocol.ResClient01); msg.Append(ResCommands.AcknowledgeQueue); msg.Append(requestId.ToByteArray()); msg.Append(_context); msg.Append(_queueId); msg.Append(_subscriberId); msg.Append(_allocationId.ToNetMqFrame()); msg.Append(_allocationBatchSize.ToNetMqFrame()); msg.Append(_allocationTimeoutInMilliseconds.ToNetMqFrame()); socket.SendMultipartMessage(msg); return m => { var command = m.Pop().ConvertToString(); if (command == ResCommands.Error) { var errorCode = m.Pop().ConvertToString(); var errorDetails = m.Pop().ConvertToString(); ErrorResolver.RaiseException(errorCode, errorDetails, pending.SetException); return; } if (command != ResCommands.QueuedEvents) pending.SetException(new UnsupportedCommandException(command)); var queueContext = m.Pop().ConvertToString(); var queueId = m.Pop().ConvertToString(); var subscriberId = m.Pop().ConvertToString(); var time = m.PopDateTime(); var allocationId = m.PopNullableInt64(); var count = m.PopInt32(); var events = new EventInStorage[count]; for (var i = 0; i < count; i++) { var id = new Guid(m.Pop().ToByteArray()); var streamId = m.Pop().ConvertToString(); var context = m.Pop().ConvertToString(); var sequence = m.PopInt64(); var timestamp = m.PopDateTime(); var type = m.PopString(); var headers = m.PopStringOrNull(); var body = m.PopString(); events[i] = new EventInStorage(context, streamId, sequence, type, id, headers, body, timestamp); } var result = new QueuedEventsResponse(queueContext, queueId, subscriberId, time, allocationId, events); pending.SetResult(result); }; }