/**
  * The following Activation methods are used to install the individual handlers.
  * The LOCK keyword restricts code from being executed by more than one thread at the same time.
  * This makes threaded programs reliable.
  */
 private void ActivateResultHandler(int sequenceNumber, IListResultHandler listResultHandler)
 {
     lock (Controller.Instance.resultLock)
     {
         Controller.Instance.resultHandlers.Add(sequenceNumber, listResultHandler);
     }
 }
Example #2
0
        public void Run()
        {
            try
            {
                while (true)
                {
                    Frame   frame          = Frame.ReadFromStream(Controller.Instance.inputStream);
                    int     sequenceNumber = frame.sequenceNumber;
                    Command command        = frame.command;
                    switch (command)
                    {
                    case Command.RESULT:
                        IMessageHandler messageHandler;
                        lock (Controller.Instance.messageLock)
                        {
                            messageHandler = Controller.Instance.messageHandlers[sequenceNumber];
                        }

                        IListResultHandler listResultHandler = null;
                        if (Controller.Instance.resultHandlers.Count >= 1)
                        {
                            lock (Controller.Instance.resultLock)
                            {
                                Console.WriteLine(Controller.Instance.resultHandlers.Count);
                                listResultHandler = Controller.Instance.resultHandlers[sequenceNumber];
                            }
                        }
                        if (messageHandler != null)
                        {
                            string uri    = Encoding.UTF8.GetString(frame.PopFirstValue("uri"));
                            string from   = Encoding.UTF8.GetString(frame.PopFirstValue("from"));
                            bool   unpack = true;
                            byte[] bytes  = frame.PopFirstValue("unpack");
                            if (bytes != null)
                            {
                                unpack = bool.Parse(Encoding.UTF8.GetString(bytes));
                            }

                            Message message;
                            if (unpack)
                            {
                                message = new Message(from, uri, frame.payloadObjects, frame.routingObjects);
                            }
                            else
                            {
                                message = new Message(from, uri, null, null);
                            }

                            messageHandler.ResultReceived(message);
                        }
                        else if (listResultHandler != null)
                        {
                            string finishedStr = Encoding.UTF8.GetString(frame.PopFirstValue("finished"));
                            bool   finished    = bool.Parse(finishedStr);
                            if (finished)
                            {
                                listResultHandler.finish();
                            }
                            else
                            {
                                string child = Encoding.UTF8.GetString(frame.PopFirstValue("child"));
                                listResultHandler.Result(child);
                            }
                        }
                        break;

                    case Command.RESPONSE:
                        IResponseHandler responseHandler;
                        lock (Controller.Instance.responseLock)
                        {
                            responseHandler = Controller.Instance.responseHandlers[sequenceNumber];
                        }

                        if (responseHandler != null)
                        {
                            string status = Encoding.UTF8.GetString(frame.PopFirstValue("status"));
                            string reason = null;
                            if (!status.Equals("okay"))
                            {
                                reason = Encoding.UTF8.GetString(frame.PopFirstValue("reason"));
                            }

                            responseHandler.ResponseReceived(new Response(status, reason));
                        }

                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception ex) when(ex is SocketException || ex is SystemException || ex is IOException || ex is ObjectDisposedException)
            {
                if (ex is IOException)
                {
                    throw new SystemException("Failed to read Frame.\n", ex);
                }
            }
        }