private void HandleInstrumentAdditionRequest() { using (var ms = new MemoryStream()) { var buffer = _socket.ReceiveFrameBytes(); var instrument = MyUtils.ProtoBufDeserialize <Instrument>(buffer, ms); _logger.Info($"Instruments Server: Received instrument addition request. Instrument: {instrument}"); Instrument addedInstrument; try { addedInstrument = _instrumentManager.AddInstrument(instrument); } catch (Exception ex) { addedInstrument = null; _logger.Error($"Instruments Server: Instrument addition error: {ex.Message}"); } _socket.SendMoreFrame(addedInstrument != null ? MessageType.Success : MessageType.Error); _socket.SendFrame(MyUtils.ProtoBufSerialize(addedInstrument, ms)); } }
private void handleMessage(string msg, NetMQSocket socket) { JObject req = JObject.Parse(msg); string tickerId = (string)req["ticker"]; TickerInfo info; bool found = false; lock (symbols) { found = symbols.TryGetValue(tickerId, out info); } if (found) { JObject resp = new JObject(); resp["ticker"] = info.TickerId; resp["lot_size"] = info.LotSize; resp["tick_size"] = info.TickSize; resp["tick_price"] = info.TickPrice; socket.SendMoreFrame("OK"); socket.SendFrame(resp.ToString()); } else { socket.SendMoreFrame("ERROR"); socket.SendFrame("Unknown ticker"); } }
/// <summary> /// Given a historical data request and the data that fill it, /// send the reply to the client who made the request. /// </summary> private void SendFilledHistoricalRequest(HistoricalDataRequest request, List <OHLCBar> data) { lock (_socketLock) { if (_socket != null) { using (var ms = new MemoryStream()) { // This is a 5 part message // 1st message part: the identity string of the client that we're routing the data to var clientIdentity = request.RequesterIdentity; _socket.SendMoreFrame(clientIdentity ?? string.Empty); // 2nd message part: the type of reply we're sending _socket.SendMoreFrame(MessageType.HistReply); // 3rd message part: the HistoricalDataRequest object that was used to make the request _socket.SendMoreFrame(MyUtils.ProtoBufSerialize(request, ms)); // 4th message part: the size of the uncompressed, serialized data. Necessary for decompression on the client end. var uncompressed = MyUtils.ProtoBufSerialize(data, ms); _socket.SendMoreFrame(BitConverter.GetBytes(uncompressed.Length)); // 5th message part: the compressed serialized data. var compressed = new byte[LZ4Codec.MaximumOutputSize(uncompressed.Length)]; var targetSpan = new Span <byte>(compressed); int compressedLength = LZ4Codec.Encode(new Span <byte>(uncompressed), targetSpan, LZ4Level.L03_HC); //var compressed = LZ4Codec.EncodeHC(uncompressed, 0, uncompressed.Length); // compress _socket.SendFrame(targetSpan.Slice(0, compressedLength).ToArray()); } } } }
// Accept a real time data request private void HandleRealTimeDataRequest() { using (var ms = new MemoryStream()) { bool hasMore; var buffer = _requestSocket.ReceiveFrameBytes(out hasMore); var request = MyUtils.ProtoBufDeserialize <RealTimeDataRequest>(buffer, ms); // Make sure the ID and data sources are set if (!request.Instrument.ID.HasValue) { SendErrorReply("Instrument had no ID set.", buffer); _logger.Error("Instrument with no ID requested."); return; } if (request.Instrument.Datasource == null) { SendErrorReply("Instrument had no data source set.", buffer); _logger.Error("Instrument with no data source requested."); return; } // With the current approach we can't handle multiple real time data streams from // the same symbol and data source, but at different frequencies // Forward the request to the broker try { if (_broker.RequestRealTimeData(request)) { // And report success back to the requesting client _requestSocket.SendMoreFrame(MessageType.Success); // Along with the request _requestSocket.SendFrame(MyUtils.ProtoBufSerialize(request, ms)); } else { throw new Exception("Unknown error."); } } catch (Exception ex) { SendErrorReply(ex.Message, buffer); _logger.Error($"RTDS: Error handling RTD request {request.Instrument.Symbol} @ {request.Instrument.Datasource} ({request.Frequency}): {ex.Message}"); } } }
/// <summary> /// When data arrives from an external data source to the broker, this event is fired. /// </summary> private void BrokerRealTimeDataArrived(object sender, RealTimeDataEventArgs e) { lock (_publisherSocketLock) { if (_publisherSocket == null) { return; } using (var ms = new MemoryStream()) { Serializer.Serialize(ms, e); _publisherSocket.SendMoreFrame(BitConverter.GetBytes(e.InstrumentID)); // Start by sending the ticker before the data _publisherSocket.SendMoreFrame(MessageType.RealTimeBars); _publisherSocket.SendFrame(ms.ToArray()); // Then send the serialized bar } } }
/// <summary> /// When data arrives from an external data source to the broker, this event is fired. /// </summary> private void BrokerRealTimeDataArrived(object sender, RealTimeDataEventArgs e) { lock (_publisherSocketLock) { if (_publisherSocket == null) { return; } using (var ms = new MemoryStream()) { Serializer.Serialize(ms, e); _publisherSocket.SendMoreFrame(Encoding.UTF8.GetBytes($"{e.InstrumentID}~{(int)e.Frequency}")); // Start by sending the id+freq before the data _publisherSocket.SendMoreFrame(MessageType.RealTimeBars); _publisherSocket.SendFrame(ms.ToArray()); // Then send the serialized bar } } }
protected override void DoClient(int id, NetMQSocket socket) { const string value = "Hello World"; var expected = value + " " + id; Console.WriteLine("Client: {0} Publishing: {1}", id, expected); socket.SendMoreFrame(Topic); socket.SendFrame(expected); }
private void sendResponse(List <Bar> data, NetMQSocket sock) { try { MemoryStream stream = new MemoryStream(); foreach (Bar b in data) { BarSerializer.WriteToStream(stream, b); } sock.SendMoreFrame("OK"); sock.SendFrame(stream.ToArray()); } catch (Exception e) { sock.SendMoreFrame("ERROR"); sock.SendFrame(e.ToString()); } }
private void SendTicks(string ticker, List <Tick> ticks, NetMQSocket sock) { var stream = new MemoryStream(); foreach (var tick in ticks) { TickSerializer.WriteToStream(stream, tick); } sock.SendMoreFrame(ticker); sock.SendFrame(stream.ToArray()); }
protected override void DoWork(NetMQSocket socket) { var received = socket.ReceiveMultipartStrings(); for (var i = 0; i < received.Count; i++) { if (i == received.Count - 1) { socket.SendFrame(received[i]); } else { socket.SendMoreFrame(received[i]); } } }
public bool Send(byte[] message, bool dontWait, bool more) { int frameSize = 2 + 1 + message.Length; int payloadStartIndex = 2; int payloadLength = message.Length + 1; if (payloadLength > 125) { frameSize += 2; payloadStartIndex += 2; if (payloadLength > ushort.MaxValue) { frameSize += 6; payloadStartIndex += 6; } } byte[] frame = new byte[frameSize]; frame[0] = (byte)0x81; // Text and Final // No mask frame[1] = 0x00; if (payloadLength <= 125) { frame[1] |= (byte)(payloadLength & 127); } else { // TODO: implement } // more byte frame[payloadStartIndex] = (byte)(more ? '1' : '0'); payloadStartIndex++; // payload Buffer.BlockCopy(message, 0, frame, payloadStartIndex, message.Length); try { if (dontWait) { return(m_streamSocket.TrySendFrame(Identity, Identity.Length, true) && m_streamSocket.TrySendFrame(frame, frame.Length)); } else { m_streamSocket.SendMoreFrame(Identity, Identity.Length); m_streamSocket.SendFrame(frame, frame.Length); return(true); } } catch (NetMQException exception) { m_state = WebSocketClientState.Closed; throw exception; } }
private void SocketReceiveReady(object sender, NetMQSocketEventArgs e) { var hasMore = false; var request = string.Empty; lock (_socketLock) { var receiveResult = _socket?.TryReceiveFrameString(out request, out hasMore); if (!receiveResult.HasValue || !receiveResult.Value || string.IsNullOrEmpty(request)) { return; } } var instruments = new List <Instrument>(); using (var ms = new MemoryStream()) { // If the request is for a search, receive the instrument w/ the search parameters and pass it to the searcher if (request == "SEARCH" && hasMore) { var buffer = _socket.ReceiveFrameBytes(); var searchInstrument = MyUtils.ProtoBufDeserialize <Instrument>(buffer, ms); _logger.Info($"Instruments Server: Received search request: {searchInstrument}"); try { instruments = _instrumentManager.FindInstruments(null, searchInstrument); } catch (Exception ex) { _logger.Error($"Instruments Server: Instrument search error: {ex.Message}"); } } else if (request == "ALL") // If the request is for all the instruments, we don't need to receive anything else { _logger.Info("Instruments Server: received request for list of all instruments."); try { instruments = _instrumentManager.FindInstruments(); } catch (Exception ex) { _logger.Error($"Instruments Server: Instrument search error: {ex.Message}"); } } else if (request == "ADD" && hasMore) // Request to add instrument { var buffer = _socket.ReceiveFrameBytes(); var instrument = MyUtils.ProtoBufDeserialize <Instrument>(buffer, ms); _logger.Info($"Instruments Server: Received instrument addition request. Instrument: {instrument}"); Instrument addedInstrument; try { addedInstrument = _instrumentManager.AddInstrument(instrument); } catch (Exception ex) { addedInstrument = null; _logger.Error($"Instruments Server: Instrument addition error: {ex.Message}"); } _socket.SendMoreFrame(addedInstrument != null ? "SUCCESS" : "FAILURE"); _socket.SendFrame(MyUtils.ProtoBufSerialize(addedInstrument, ms)); return; } else // No request = loop again { return; } var uncompressed = MyUtils.ProtoBufSerialize(instruments, ms); // Serialize the list of instruments ms.Read(uncompressed, 0, (int)ms.Length); // Get the uncompressed data var result = LZ4Codec.Encode(uncompressed, 0, (int)ms.Length); // Compress it // Before we send the result we must send the length of the uncompressed array, because it's needed for decompression _socket.SendMoreFrame(BitConverter.GetBytes(uncompressed.Length)); // Then finally send the results _socket.SendFrame(result); } }
public void SendMessage <T>(string topic, T message) { var serializedMessage = _serializer.Serialize(message); _socket.SendMoreFrame(topic).SendFrame(serializedMessage); }
private void TransactionDelete() { byte[] transactionIdBytes = m_serverSocket.ReceiveFrameBytes(); int transactionId = BitConverter.ToInt32(transactionIdBytes, 0); byte[] documentIdBytes = m_serverSocket.ReceiveFrameBytes(); DocumentId documentId = new DocumentId(documentIdBytes); try { m_db.TransactionDelete(transactionId, documentId); // sending success m_serverSocket.SendFrame(Protocol.Success); } catch (TransactionNotExistException ex) { m_serverSocket.SendMoreFrame(Protocol.Failed).SendFrame("Transaction doesn't exist"); } catch (DocumentLockedException) { m_serverSocket.SendMoreFrame(Protocol.Failed).SendFrame("Document locked by another transaction"); } }
/// <summary> /// Given a historical data request and the data that fill it, /// send the reply to the client who made the request. /// </summary> private void SendFilledHistoricalRequest(HistoricalDataRequest request, List <OHLCBar> data) { lock (socketLock) { if (socket != null) { using (var ms = new MemoryStream()) { // This is a 5 part message // 1st message part: the identity string of the client that we're routing the data to var clientIdentity = request.RequesterIdentity; socket.SendMoreFrame(clientIdentity ?? string.Empty); // 2nd message part: the type of reply we're sending socket.SendMoreFrame(BitConverter.GetBytes((byte)DataRequestMessageType.HistReply)); // 3rd message part: the HistoricalDataRequest object that was used to make the request socket.SendMoreFrame(MyUtils.ProtoBufSerialize(request, ms)); // 4th message part: the size of the uncompressed, serialized data. Necessary for decompression on the client end. var uncompressed = MyUtils.ProtoBufSerialize(data, ms); socket.SendMoreFrame(BitConverter.GetBytes(uncompressed.Length)); // 5th message part: the compressed serialized data. var compressed = LZ4Codec.EncodeHC(uncompressed, 0, uncompressed.Length); // compress socket.SendFrame(compressed); } } } }