コード例 #1
0
        /// <summary>
        /// Handles requests for information on data that is available in local storage
        /// </summary>
        private void AcceptAvailableDataRequest(string requesterIdentity, NetMQSocket socket)
        {
            //get the instrument
            bool hasMore;
            var  ms = new MemoryStream();

            byte[] buffer = socket.Receive(out hasMore);

            var instrument = MyUtils.ProtoBufDeserialize <Instrument>(buffer, ms);

            //log the request
            Log(LogLevel.Info, string.Format("Received local data storage info request for {0}.",
                                             instrument.Symbol));

            //and send the reply

            var storageInfo = _broker.GetAvailableDataInfo(instrument);

            socket.SendMore(requesterIdentity);
            socket.SendMore("AVAILABLEDATAREP");

            socket.SendMore(MyUtils.ProtoBufSerialize(instrument, ms));

            socket.SendMore(BitConverter.GetBytes(storageInfo.Count));
            foreach (StoredDataInfo sdi in storageInfo)
            {
                socket.SendMore(MyUtils.ProtoBufSerialize(sdi, ms));
            }
            socket.Send("END");
        }
コード例 #2
0
 private void SendReply(byte[] id, byte[] msgId, TReply reply)
 {
     byte[] data = _replyMarshaller(reply);
     _replySocket.SendMore(id);
     _replySocket.SendMore(msgId);
     _replySocket.Send(data);
 }
コード例 #3
0
        /// <summary>
        /// Handles incoming data "push" requests: the client sends data for us to add to local storage.
        /// </summary>
        private void AcceptDataAdditionRequest(string requesterIdentity, NetMQSocket socket)
        {
            //final message part: receive the DataAdditionRequest object
            bool hasMore;
            var  ms = new MemoryStream();

            byte[] buffer = socket.Receive(out hasMore);

            var request = MyUtils.ProtoBufDeserialize <DataAdditionRequest>(buffer, ms);

            //log the request
            Log(LogLevel.Info, string.Format("Received data push request for {0}.",
                                             request.Instrument.Symbol));

            //start building the reply
            socket.SendMore(requesterIdentity);
            socket.SendMore("PUSHREP");
            try
            {
                _broker.AddData(request);
                socket.Send("OK");
            }
            catch (Exception ex)
            {
                socket.SendMore("ERROR");
                socket.Send(ex.Message);
            }
        }
コード例 #4
0
 private void OnRequest(IRequest <TRequest, TReply> obj)
 {
     byte[] msgId = GetId();
     _requests[new Guid(msgId)] = obj;
     _requestSocket.SendMore(_id);
     _requestSocket.SendMore(msgId);
     byte[] requestData = _requestMarshaller(obj.Request);
     _requestSocket.Send(requestData);
 }
コード例 #5
0
ファイル: Program.cs プロジェクト: wbj808178/netmq
        private static void WorkerOnReceiveReady(object sender, NetMQSocketEventArgs socket)
        {
            //  Read and save all frames until we get an empty frame
            //  In this example there is only 1 but it could be more
            byte[] address = worker.Receive();
            byte[] empty   = worker.Receive();
            byte[] request = worker.Receive();

            worker.SendMore(address);
            worker.SendMore(Encoding.Unicode.GetBytes(""));
            worker.Send(Encoding.Unicode.GetBytes(Encoding.Unicode.GetString(request) + " WORLD!"));
        }
コード例 #6
0
        /// <summary>
        /// Pushes data to local storage.
        /// </summary>
        public void PushData(DataAdditionRequest request)
        {
            if (request.Instrument == null || request.Instrument.ID == null)
            {
                RaiseEvent(Error, null, new ErrorArgs(-1, "Instrument must be set and have an ID."));
                return;
            }

            var ms = new MemoryStream();

            lock (_dealerSocketLock)
            {
                _dealerSocket.SendMore("HISTPUSH");
                _dealerSocket.Send(MyUtils.ProtoBufSerialize(request, ms));
            }
        }
コード例 #7
0
 /// <summary>
 /// Request observer
 /// </summary>
 public void Request(Tuple <string, Request> request)
 {
     try
     {
         var data = request.Item2.Serialize();
         if (data == null)
         {
             throw new InvalidDataException("Serialize error");
         }
         var id = Encoding.UTF8.GetBytes(request.Item1);
         router.SendMore(id);
         router.Send(data);
     }
     catch (Exception ex)
     {
         SignalService.Logger.Error("Error: {0}", ex.Message);
     }
 }
コード例 #8
0
ファイル: ForwarderDeviceTests.cs プロジェクト: xuzhe35/netmq
        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.SendMore(Topic);
            socket.Send(expected);
        }
コード例 #9
0
        private void SendEvents(String submissionUri, CancellationToken cancellationToken)
        {
            using (NetMQContext context = NetMQContext.Create())
            {
                using (NetMQSocket pushSocket = context.CreatePushSocket())
                {
                    pushSocket.IgnoreErrors = true;
                    pushSocket.Connect(submissionUri);

                    Logger.Info("ZeroMQCache: Connected to submissionUri \"{0}\".", submissionUri);

                    while (!cancellationToken.IsCancellationRequested)
                    {
                        try
                        {
                            ZeroMQMessage message;

                            if (mQueue.TryTake(out message, TimeSpan.FromSeconds(1)))
                            {
                                Logger.Debug("ZeroMQCache: Sending -> {0}", message.ToString());

                                pushSocket.SendMore(message.Topic);
                                pushSocket.SendMore(message.Client);
                                pushSocket.Send(message.Content);
                            }
                        }
                        catch (OperationCanceledException)
                        {
                            // We have been asked to cancel operation
                            break;
                        }
                        catch (Exception ex)
                        {
                            Logger.Error("ZeroMQCache: Error sending message.", ex);
                        }
                    }

                    // Close socket
                    pushSocket.Close();
                }

                context.Terminate();
            }
        }
コード例 #10
0
        // Accept a request to cancel a real time data stream
        // Obviously we only actually cancel it if
        private void HandleRTDataCancelRequest()
        {
            bool hasMore;

            byte[] buffer = _reqSocket.Receive(out hasMore);

            //receive the instrument
            var ms         = new MemoryStream();
            var instrument = MyUtils.ProtoBufDeserialize <Instrument>(buffer, ms);

            if (instrument.ID != null)
            {
                Broker.CancelRTDStream(instrument.ID.Value);
            }

            //two part message:
            //1: "CANCELED"
            //2: the symbol
            _reqSocket.SendMore("CANCELED");
            _reqSocket.Send(instrument.Symbol);
        }
コード例 #11
0
 /// <summary>
 /// When data arrives from an external data source to the broker, this event is fired.
 /// </summary>
 void _broker_RealTimeDataArrived(object sender, RealTimeDataEventArgs e)
 {
     using (var ms = new MemoryStream())
     {
         Serializer.Serialize(ms, e);
         //this lock is needed because this method will be called from
         //the thread of each DataSource in the broker
         lock (_pubSocketLock)
         {
             _pubSocket.SendMore(BitConverter.GetBytes(e.InstrumentID)); //start by sending the ticker before the data
             _pubSocket.Send(ms.ToArray());                              //then send the serialized bar
         }
     }
 }
コード例 #12
0
        public static void Blow(string song, string notes)
        {
            new Thread(() => {
                using (NetMQSocket request_socket = context.CreateRequestSocket()) {
                    request_socket.Connect(string.Format("tcp://{0}:{1}", Address, RequestPort));
                    request_socket.SendMore("blow").SendMore(song).Send(notes);

                    string response = request_socket.ReceiveString();
                    Console.WriteLine("[request_socket] Response: {0}", response);

                    request_socket.Close();
                    request_socket.Dispose();
                }
            }).Start();
        }
コード例 #13
0
ファイル: QueueDeviceTests.cs プロジェクト: wangkai2014/netmq
        protected override void DoWork(NetMQSocket socket)
        {
            var received = socket.ReceiveMultipartStrings();

            for (var i = 0; i < received.Count; i++)
            {
                if (i == received.Count - 1)
                {
                    socket.Send(received[i]);
                }
                else
                {
                    socket.SendMore(received[i]);
                }
            }
        }
コード例 #14
0
        /// <summary>
        /// Add an instrument to QDMS.
        /// </summary>
        /// <param name="instrument"></param>
        /// <returns>The instrument with its ID set if successful, null otherwise.</returns>
        public Instrument AddInstrument(Instrument instrument)
        {
            if (!Connected)
            {
                RaiseEvent(Error, this, new ErrorArgs(-1, "Could not add instrument - not connected."));
                return(null);
            }

            if (instrument == null)
            {
                RaiseEvent(Error, this, new ErrorArgs(-1, "Could not add instrument - instrument is null."));
                return(null);
            }

            using (NetMQSocket s = _context.CreateSocket(ZmqSocketType.Req))
            {
                s.Connect(string.Format("tcp://{0}:{1}", _host, _instrumentServerPort));
                var ms = new MemoryStream();

                s.SendMore("ADD"); //first we send an "ADD" request

                //then we need to serialize and send the instrument
                s.Send(MyUtils.ProtoBufSerialize(instrument, ms));

                //then get the reply
                string result = s.ReceiveString(TimeSpan.FromSeconds(1));

                if (result != "SUCCESS")
                {
                    RaiseEvent(Error, this, new ErrorArgs(-1, "Instrument addition failed: received no reply."));
                    return(null);
                }

                //Addition was successful, receive the instrument and return it
                byte[] serializedInstrument = s.Receive();

                return(MyUtils.ProtoBufDeserialize <Instrument>(serializedInstrument, ms));
            }
        }
コード例 #15
0
        /// <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)
        {
            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
                string clientIdentity = request.RequesterIdentity;
                _routerSocket.SendMore(clientIdentity);

                //2nd message part: the type of reply we're sending
                _routerSocket.SendMore("HISTREQREP");

                //3rd message part: the HistoricalDataRequest object that was used to make the request
                _routerSocket.SendMore(MyUtils.ProtoBufSerialize(request, ms));

                //4th message part: the size of the uncompressed, serialized data. Necessary for decompression on the client end.
                byte[] uncompressed = MyUtils.ProtoBufSerialize(data, ms);
                _routerSocket.SendMore(BitConverter.GetBytes(uncompressed.Length));

                //5th message part: the compressed serialized data.
                byte[] compressed = LZ4Codec.EncodeHC(uncompressed, 0, uncompressed.Length); //compress
                _routerSocket.Send(compressed);
            }
        }
コード例 #16
0
    // Update is called once per frame
    //
    void Update()
    {
        AsyncIO.ForceDotNet.Force();
        string top;
        string message;

        if (client.TryReceiveFrameString(out top))
        {
            if (client.TryReceiveFrameString(out message))
            {
                Debug.Log(message);
                string[] coord = message.Split();
                transX = int.Parse(coord [0]);
                transY = int.Parse(coord [1]);
            }
        }
        if (Input.GetKeyDown(KeyCode.N))
        {
            calCount++;
        }
        if (Input.GetKeyDown(KeyCode.C))
        {
            if (isVisible)
            {
                isVisible = false;
                targetPrefab.SetActive(false);
            }
            else
            {
                isVisible = true;
                targetPrefab.SetActive(true);
                server.SendMore("coord").Send("1180 564");
            }
        }

        if (calCount != curCount)
        {
            calCount = calCount % 10;
            curCount = calCount;

            gameObject.GetComponent <Image> ().sprite = calImages [calCount];
        }
        tr  = GameObject.FindGameObjectWithTag("RightEyeCamera").transform;
        vec = (tr.forward) + (tr.right * ((transX - 590) / 1000)) + (tr.up * (((-transY) + 282) / 1000));
        //vec = (tr.forward) + (tr.right * (transX)) + (tr.up * ((transY)));
        Vector3    orig = GameObject.FindGameObjectWithTag("RightEyeCamera").transform.position;
        RaycastHit hit;
        Ray        ray = new Ray(orig, vec);

        //Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        if (isVisible)
        {
            if (Physics.Raycast(ray, out hit, 100.0f))
            {
                //Debug.DrawLine (ray.origin, hit.point);
                targetPrefab.transform.position = hit.point;
                targetPrefab.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal);
                targetPrefab.SetActive(true);
            }
            else
            {
                targetPrefab.SetActive(false);
            }
        }
    }
コード例 #17
0
        public void Start()
        {
            using (NetMQSocket response_socket = context.CreateResponseSocket())
                using (NetMQSocket publisher_socket = context.CreateXPublisherSocket()) {
                    string response_address  = string.Format("tcp://{0}:{1}", Address, ResponsePort);
                    string publisher_address = string.Format("tcp://{0}:{1}", Address, PublisherPort);

                    response_socket.Bind(response_address);
                    publisher_socket.Bind(publisher_address);

                    Console.WriteLine("[response_socket] Bound on {0}", response_address);
                    Console.WriteLine("[publisher_socket] Bound on {0}", publisher_address);

                    using (Poller poller = new Poller(response_socket, publisher_socket)) {
                        response_socket.ReceiveReady += delegate(object sender, NetMQSocketEventArgs args) {
                            string message = response_socket.ReceiveString();

                            if (message.StartsWith("blow"))
                            {
                                string song  = "";
                                string notes = "";

                                try {
                                    song  = response_socket.ReceiveString();
                                    notes = response_socket.ReceiveString();

                                    if (song.Length > 64)
                                    {
                                        song = song.Substring(0, 64);
                                    }

                                    if (notes.Length > 64)
                                    {
                                        notes = notes.Substring(0, 64);
                                    }

                                    cache [song] = notes;

                                    Console.WriteLine("[response_socket] Received: song: {0}, notes: {1}", song, notes);
                                } catch (Exception e) {
                                    Console.WriteLine("[response_socket] Invalid request: {0}", e.Message);
                                }

                                response_socket.Send("OK");
                                Console.WriteLine("[response_socket] Sent: OK");

                                publisher_socket.SendMore(song).Send(notes);

                                Console.WriteLine("[publisher_socket] Sent: song: {0}, notes: {1}", song, notes);
                                return;
                            }

                            if (message.Equals("ping"))
                            {
                                Console.WriteLine("[response_socket] Received: {0}", message);

                                int timestamp = (int)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
                                response_socket.Send(timestamp.ToString());

                                Console.WriteLine("[response_socket] Sent: {0}", timestamp);
                                return;
                            }

                            Console.WriteLine("[response_socket] Invalid request: {0}", message);
                            args.Socket.Send("Meow?");
                        };

                        // Send cached notes to new subscribers
                        publisher_socket.ReceiveReady += delegate(object sender, NetMQSocketEventArgs args) {
                            NetMQMessage message = publisher_socket.ReceiveMessage();

                            // Subscribe == 1, Unsubscibe == 0
                            if (message.First.Buffer [0] != 1)
                            {
                                return;
                            }

                            string song         = message.First.ConvertToString().Substring(1);
                            string cached_notes = (string)cache [song];

                            if (cached_notes != null)
                            {
                                publisher_socket.SendMore(song).Send(cached_notes);
                            }
                        };

                        poller.Start();
                    }
                }
        }
コード例 #18
0
        private void TransactionDelete()
        {
            byte[] transactionIdBytes = m_serverSocket.Receive();

            int transactionId = BitConverter.ToInt32(transactionIdBytes, 0);

            byte[] documentIdBytes = m_serverSocket.Receive();

            DocumentId documentId = new DocumentId(documentIdBytes);

            try
            {
                m_db.TransactionDelete(transactionId, documentId);

                // sending success
                m_serverSocket.Send(Protocol.Success);
            }
            catch (TransactionNotExistException ex)
            {
                m_serverSocket.SendMore(Protocol.Failed).Send("Transaction doesn't exist");
            }
            catch (DocumentLockedException)
            {
                m_serverSocket.SendMore(Protocol.Failed).Send("Document locked by another transaction");
            }
        }
コード例 #19
0
ファイル: HistoricalDataServer.cs プロジェクト: ychaim/qdms
        /// <summary>
        /// Handles requests for information on data that is available in local storage
        /// </summary>
        private void AcceptAvailableDataRequest(string requesterIdentity, NetMQSocket socket)
        {
            //get the instrument
            bool hasMore;
            var ms = new MemoryStream();
            byte[] buffer = socket.Receive(out hasMore);

            var instrument = MyUtils.ProtoBufDeserialize<Instrument>(buffer, ms);

            //log the request
            Log(LogLevel.Info, string.Format("Received local data storage info request for {0}.",
                instrument.Symbol));

            //and send the reply

            var storageInfo = _broker.GetAvailableDataInfo(instrument);
            socket.SendMore(requesterIdentity);
            socket.SendMore("AVAILABLEDATAREP");

            socket.SendMore(MyUtils.ProtoBufSerialize(instrument, ms));

            socket.SendMore(BitConverter.GetBytes(storageInfo.Count));
            foreach (StoredDataInfo sdi in storageInfo)
            {
                socket.SendMore(MyUtils.ProtoBufSerialize(sdi, ms));
            }
            socket.Send("END");
        }
コード例 #20
0
ファイル: HistoricalDataServer.cs プロジェクト: ychaim/qdms
        /// <summary>
        /// Handles incoming data "push" requests: the client sends data for us to add to local storage.
        /// </summary>
        private void AcceptDataAdditionRequest(string requesterIdentity, NetMQSocket socket)
        {
            //final message part: receive the DataAdditionRequest object
            bool hasMore;
            var ms = new MemoryStream();
            byte[] buffer = socket.Receive(out hasMore);

            var request = MyUtils.ProtoBufDeserialize<DataAdditionRequest>(buffer, ms);

            //log the request
            Log(LogLevel.Info, string.Format("Received data push request for {0}.",
                request.Instrument.Symbol));

            //start building the reply
            socket.SendMore(requesterIdentity);
            socket.SendMore("PUSHREP");
            try
            {
                _broker.AddData(request);
                socket.Send("OK");
            }
            catch (Exception ex)
            {
                socket.SendMore("ERROR");
                socket.Send(ex.Message);
            }
        }
コード例 #21
0
        void _socket_ReceiveReady(object sender, NetMQSocketEventArgs e)
        {
            var ms = new MemoryStream();
            List <Instrument> instruments;
            bool   hasMore;
            string request = _socket.ReceiveString(SendReceiveOptions.DontWait, out hasMore);

            if (request == null)
            {
                return;
            }

            //if the request is for a search, receive the instrument w/ the search parameters and pass it to the searcher
            if (request == "SEARCH" && hasMore)
            {
                byte[] buffer           = _socket.Receive();
                var    searchInstrument = MyUtils.ProtoBufDeserialize <Instrument>(buffer, ms);

                Log(LogLevel.Info, string.Format("Instruments Server: Received search request: {0}",
                                                 searchInstrument));

                try
                {
                    instruments = _instrumentManager.FindInstruments(null, searchInstrument);
                }
                catch (Exception ex)
                {
                    Log(LogLevel.Error, string.Format("Instruments Server: Instrument search error: {0}",
                                                      ex.Message));
                    instruments = new List <Instrument>();
                }
            }
            else if (request == "ALL") //if the request is for all the instruments, we don't need to receive anything else
            {
                Log(LogLevel.Info, "Instruments Server: received request for list of all instruments.");
                instruments = _instrumentManager.FindInstruments();
            }
            else if (request == "ADD" && hasMore) //request to add instrument
            {
                byte[] buffer     = _socket.Receive();
                var    instrument = MyUtils.ProtoBufDeserialize <Instrument>(buffer, ms);

                Log(LogLevel.Info, string.Format("Instruments Server: Received instrument addition request. Instrument: {0}",
                                                 instrument));

                Instrument addedInstrument;
                try
                {
                    addedInstrument = _instrumentManager.AddInstrument(instrument);
                }
                catch (Exception ex)
                {
                    addedInstrument = null;
                    Log(LogLevel.Error, string.Format("Instruments Server: Instrument addition error: {0}",
                                                      ex.Message));
                }
                _socket.SendMore(addedInstrument != null ? "SUCCESS" : "FAILURE");

                _socket.Send(MyUtils.ProtoBufSerialize(addedInstrument, ms));

                return;
            }
            else //no request = loop again
            {
                return;
            }

            byte[] uncompressed = MyUtils.ProtoBufSerialize(instruments, ms); //serialize the list of instruments
            ms.Read(uncompressed, 0, (int)ms.Length);                         //get the uncompressed data
            byte[] 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.SendMore(BitConverter.GetBytes(uncompressed.Length));

            //then finally send the results
            _socket.Send(result);
        }
コード例 #22
0
        public void OnDataReady()
        {
            switch (m_state)
            {
            case WebSocketClientState.Closed:
                m_state = WebSocketClientState.Handshake;
                string clientHandshake = m_streamSocket.ReceiveString();

                string[] lines = clientHandshake.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

                string key;

                if (ValidateClientHandshake(lines, out key))
                {
                    string acceptKey = GenerateAcceptKey(key);

                    try
                    {
                        m_streamSocket.SendMore(Identity, Identity.Length, true);
                        m_streamSocket.Send("HTTP/1.1 101 Switching Protocols\r\n" +
                                            "Upgrade: websocket\r\n" +
                                            "Connection: Upgrade\r\n" +
                                            "Sec-WebSocket-Accept: " + acceptKey + "\r\n" +
                                            "Sec-WebSocket-Protocol: WSNetMQ\r\n\r\n");

                        m_decoder          = new Decoder();
                        m_decoder.Message += OnMessage;
                        m_state            = WebSocketClientState.Ready;
                    }
                    catch (NetMQException)
                    {
                        m_state = WebSocketClientState.Closed;
                    }
                }
                else
                {
                    m_state = WebSocketClientState.Closed;

                    try
                    {
                        m_streamSocket.SendMore(Identity, Identity.Length, true);
                        m_streamSocket.Send("HTTP/1.1 400 Bad Request\r\nSec-WebSocket-Version: 13\r\n");

                        // invalid request, close the socket and raise closed event
                        m_streamSocket.SendMore(Identity, Identity.Length, true);
                        m_streamSocket.Send("");
                    }
                    catch (NetMQException ex)
                    {
                    }
                }

                break;

            case WebSocketClientState.Ready:
                byte[] message = m_streamSocket.Receive();
                m_decoder.Process(message);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
コード例 #23
0
        /// <summary>
        /// Query the server for contracts matching a particular set of features.
        /// </summary>
        /// <param name="instrument">An Instrument object; any features that are not null will be search parameters. If null, all instruments are returned.</param>
        /// <returns>A list of instruments matching these features.</returns>
        public List <Instrument> FindInstruments(Instrument instrument = null)
        {
            if (!Connected)
            {
                RaiseEvent(Error, this, new ErrorArgs(-1, "Could not request instruments - not connected."));
                return(new List <Instrument>());
            }

            using (NetMQSocket s = _context.CreateSocket(ZmqSocketType.Req))
            {
                s.Connect(string.Format("tcp://{0}:{1}", _host, _instrumentServerPort));
                var ms = new MemoryStream();

                if (instrument == null) //all contracts
                {
                    s.Send("ALL");
                }
                else //an actual search
                {
                    s.SendMore("SEARCH"); //first we send a search request

                    //then we need to serialize and send the instrument
                    s.Send(MyUtils.ProtoBufSerialize(instrument, ms));
                }

                //first we receive the size of the final uncompressed byte[] array
                bool   hasMore;
                byte[] sizeBuffer = s.Receive(out hasMore);
                if (sizeBuffer.Length == 0)
                {
                    RaiseEvent(Error, this, new ErrorArgs(-1, "Contract request failed, received no reply."));
                    return(new List <Instrument>());
                }

                int outputSize = BitConverter.ToInt32(sizeBuffer, 0);

                //then the actual data
                byte[] buffer = s.Receive(out hasMore);
                if (buffer.Length == 0)
                {
                    RaiseEvent(Error, this, new ErrorArgs(-1, "Contract request failed, received no data."));
                    return(new List <Instrument>());
                }

                try
                {
                    //then we process it by first decompressing
                    ms.SetLength(0);
                    byte[] decoded = LZ4Codec.Decode(buffer, 0, buffer.Length, outputSize);
                    ms.Write(decoded, 0, decoded.Length);
                    ms.Position = 0;

                    //and finally deserializing
                    return(Serializer.Deserialize <List <Instrument> >(ms));
                }
                catch (Exception ex)
                {
                    RaiseEvent(Error, this, new ErrorArgs(-1, "Error processing instrument data: " + ex.Message));
                    return(new List <Instrument>());
                }
            }
        }