Example #1
0
 public void Send(Message message, IChannelSender sender, SendCallback callback)
 {
     if (callback != null)
     {
         message.Flag = System.Threading.Interlocked.Increment(ref this._flag);
         this._callbacks.Add(message.Flag, callback);
     }
     using (var s = new MemoryStream())
     {
         MessageIO.WriteMessage(s, message);
         this.GetChannel(sender).Send(s.ToArray());
     }
 }
Example #2
0
        private void OnMessage(object sender, ChannelContext ctx)
        {
            Message      msg      = MessageIO.ReadMessage(new MemoryStream((byte[])ctx.Message));
            SendCallback callback = this._callbacks.ContainsKey(msg.Flag)
                ? this._callbacks[msg.Flag]
                : null;

            if (msg.MessageType == MessageType.CONNECTACK)
            {
                this.HandleConnectAck(callback, msg);
                return;
            }

            Identity msgFrom = msg.Token != null && this._idByToken.ContainsKey(msg.Token)
                ? this._idByToken[msg.Token]
                : null;

            // must CONNECT/CONNECTACK for got token before SEND
            if (msgFrom == null)
            {
                var error = new LinkException(Text.E_UNKNOWN_MSG_FROM);
                if (callback == null)
                {
                    throw error;
                }
                callback.Error = error;
                return;
            }

            #region raise callback of client
            if (callback != null)
            {
                this.HandleCallback(callback, msg, msgFrom);
                return;
            }
            else if (this.IsError(msg))
            {
                this._log.ErrorFormat(Text.E_GOT_ERROR, msg.StatusCode, msg.StatusPhase);
                return;
            }
            #endregion

            #region raise event
            if (msg.MessageType == MessageType.SENDACK)
            {
                if (this.AckMessageHandler != null)
                {
                    this.AckMessageHandler(msg.Content, msgFrom);
                }
                return;
            }

            if (this.MessageHandler == null)
            {
                return;
            }
            EndpointContext endpointContext = new EndpointContext(ctx, this, msgFrom, msg.Flag, msg.Token);
            endpointContext.Message = msg.Content;
            try
            {
                this.MessageHandler(endpointContext);
            }
            catch (Exception e)
            {
                // onMessage error should be reply to client
                if (e is LinkException)
                {
                    endpointContext.Error(
                        ((LinkException)e).ErrorCode,
                        ((LinkException)e).Message);
                }
                else
                {
                    endpointContext.Error(0, e.Message);
                }
            }
            #endregion
        }