public NetMessage DealRequestData(RoundedMessage reqMsg, ref bool closeConnection)
        {
            closeConnection = false;

            #region 验证消息
            if (reqMsg.IsFirstMessage)
            {
                if (!this.contractHelper.VerifyFirstMessage(reqMsg))
                {
                    closeConnection = true;
                    return(null);
                }
            }
            else
            {
                if (!this.contractHelper.VerifyOtherMessage(reqMsg))
                {
                    closeConnection = true;
                    return(null);
                }
            }
            #endregion

            return(this.messageDispatcher.DispatchMessage(reqMsg));
        }
示例#2
0
        private void DataManaging(ContextKey key)
        {
            int streamHashCode = key.NetStream.GetHashCode();
            int headerLen      = this.contractHelper.MessageHeaderLength;

            while ((key.NetStream.DataAvailable) && (!this.stop))
            {
                byte[] rentBuff = null;                 //每次分派的消息中,最多有一个rentBuff

                try
                {
                    #region 构造 RoundedMessage
                    NetHelper.ReceiveData(key.NetStream, key.Buffer, 0, headerLen);
                    IMessageHeader header = this.contractHelper.ParseMessageHeader(key.Buffer, 0);
                    if (!this.contractHelper.ValidateMessageToken(header))
                    {
                        this.DisposeOneConnection(streamHashCode, DisconnectedCause.MessageTokenInvalid);
                        return;
                    }

                    RoundedMessage requestMsg = new RoundedMessage();
                    requestMsg.ConnectID = streamHashCode;
                    requestMsg.Header    = header;

                    if (!key.FirstMessageExist)
                    {
                        requestMsg.IsFirstMessage = true;
                        key.FirstMessageExist     = true;
                    }

                    if ((headerLen + header.MessageBodyLength) > this.maxMessageSize)
                    {
                        this.DisposeOneConnection(streamHashCode, DisconnectedCause.MessageSizeOverflow);
                        return;
                    }

                    if (header.MessageBodyLength > 0)
                    {
                        if ((header.MessageBodyLength + headerLen) <= this.recieveBuffSize)
                        {
                            NetHelper.ReceiveData(key.NetStream, key.Buffer, 0, header.MessageBodyLength);
                            requestMsg.Body = key.Buffer;
                        }
                        else
                        {
                            rentBuff = this.bufferPool.RentBuffer(header.MessageBodyLength);

                            NetHelper.ReceiveData(key.NetStream, rentBuff, 0, header.MessageBodyLength);
                            requestMsg.Body = rentBuff;
                        }
                    }
                    #endregion

                    bool       closeConnection = false;
                    NetMessage resMsg          = this.tcpStreamDispatcher.DealRequestData(requestMsg, ref closeConnection);

                    if (rentBuff != null)
                    {
                        this.bufferPool.GivebackBuffer(rentBuff);
                    }

                    if (closeConnection)
                    {
                        this.DisposeOneConnection(streamHashCode, DisconnectedCause.OtherCause);
                        return;
                    }

                    if ((resMsg != null) && (!this.stop))
                    {
                        byte[] bRes = resMsg.ToStream();
                        key.NetStream.Write(bRes, 0, bRes.Length);

                        if (this.ServiceCommitted != null)
                        {
                            this.ServiceCommitted(streamHashCode, resMsg);
                        }
                    }
                }
                catch (Exception ee)
                {
                    if (ee is System.IO.IOException)                    //正在读写流的时候,连接断开
                    {
                        this.DisposeOneConnection(streamHashCode, DisconnectedCause.NetworkError);
                        break;
                    }
                    else
                    {
                        this.esbLogger.Log(ee.GetType().ToString(), ee.Message, "ESFramework.Network.Tcp.AgileTcp", ErrorLevel.Standard);
                    }

                    ee = ee;
                }
            }

            key.IsDataManaging = false;
        }
示例#3
0
        private void ServeOverLap(IAsyncResult ar)
        {
            ContextKey key            = (ContextKey)ar.AsyncState;
            int        streamHashCode = key.NetStream.GetHashCode();       //是SafeNetworkStream的hashcode

            try
            {
                #region 构造RoundedMessage
                byte[] rentBuff  = null;
                int    bytesRead = key.NetStream.NetworkStream.EndRead(ar);
                if (bytesRead == 0)
                {
                    this.DisposeOneConnection(streamHashCode, DisconnectedCause.NetworkError);
                    return;
                }

                int headerLen   = this.contractHelper.MessageHeaderLength;
                int exceptCount = headerLen - bytesRead;
                NetHelper.ReceiveData(key.NetStream.NetworkStream, key.Buffer, bytesRead, exceptCount);

                IMessageHeader header = this.contractHelper.ParseMessageHeader(key.Buffer, 0);
                if (!this.contractHelper.ValidateMessageToken(header))
                {
                    this.DisposeOneConnection(streamHashCode, DisconnectedCause.MessageTokenInvalid);
                    return;
                }

                RoundedMessage requestMsg = new RoundedMessage();
                requestMsg.ConnectID = streamHashCode;
                requestMsg.Header    = header;

                if (!key.FirstMessageExist)
                {
                    requestMsg.IsFirstMessage = true;
                    key.FirstMessageExist     = true;
                }

                if ((headerLen + header.MessageBodyLength) > this.maxMessageSize)
                {
                    this.DisposeOneConnection(streamHashCode, DisconnectedCause.MessageSizeOverflow);
                    return;
                }

                if (header.MessageBodyLength > 0)
                {
                    if ((header.MessageBodyLength + headerLen) <= this.recieveBuffSize)
                    {
                        NetHelper.ReceiveData(key.NetStream, key.Buffer, 0, header.MessageBodyLength);
                        requestMsg.Body = key.Buffer;
                    }
                    else
                    {
                        rentBuff = this.bufferPool.RentBuffer(header.MessageBodyLength);

                        NetHelper.ReceiveData(key.NetStream, rentBuff, 0, header.MessageBodyLength);
                        requestMsg.Body = rentBuff;
                    }
                }
                #endregion

                bool       closeConnection = false;
                NetMessage resMsg          = this.tcpStreamDispatcher.DealRequestData(requestMsg, ref closeConnection);

                if (rentBuff != null)
                {
                    this.bufferPool.GivebackBuffer(rentBuff);
                }

                if (closeConnection)
                {
                    this.DisposeOneConnection(streamHashCode, DisconnectedCause.OtherCause);
                    return;
                }

                if ((resMsg != null) && (!this.stop))
                {
                    byte[] bRes = resMsg.ToStream();
                    key.NetStream.Write(bRes, 0, bRes.Length);

                    if (this.ServiceCommitted != null)
                    {
                        this.ServiceCommitted(streamHashCode, resMsg);
                    }
                }

                if (!this.stop)
                {
                    key.NetStream.NetworkStream.BeginRead(key.Buffer, 0, this.contractHelper.MessageHeaderLength, new AsyncCallback(this.ServeOverLap), key);
                }
            }
            catch (Exception ee)
            {
                if (ee is System.IO.IOException)                //正在读写流的时候,连接断开
                {
                    this.DisposeOneConnection(streamHashCode, DisconnectedCause.NetworkError);
                }
                else
                {
                    this.esbLogger.Log(ee.GetType().ToString(), ee.Message, "ESFramework.Network.Tcp.AsynTcp", ErrorLevel.Standard);
                }

                ee = ee;
            }
        }