Ejemplo n.º 1
0
        public void Broadcast(INetCommand command, Func <INetSession, bool> check)
        {
            List <INetSession> bcList = new List <INetSession>();

            lock (SyncLocker)
            {
                foreach (KeyValuePair <string, INetSession> kv in SessionList)
                {
                    if (check(kv.Value))
                    {
                        bcList.Add(kv.Value);
                    }
                }
            }
            bcList.All(x =>
            {
                if (x != null)
                {
                    try
                    {
                        x.Protocol.WriteCommand(command, x);
                    }

                    catch (Exception e)
                    {
                        logger.Warn("广播消息失败:{0}", x.SessionID);
                    }
                }

                return(true);
            });
        }
Ejemplo n.º 2
0
 public virtual void Broadcast(INetCommand command)
 {
     lock (SyncLocker)
     {
         Broadcast(command, (x) => { return(true); });
     }
 }
        public virtual void WriteCommand(INetCommand command, INetSession session)
        {
            Byte[] rdata = null;
            if (command != null)
            {
                rdata = command.CommandName;
                if (rdata != null && rdata.Length > 0)
                {
                    session.WriteBytes(rdata, 0, rdata.Length);
                    WriteCommandNameEndBytes(command, session);
                }

                if (command.Parameters != null)
                {
                    foreach (Byte[] pData in command.Parameters)
                    {
                        if (pData != null && pData.Length > 0)
                        {
                            session.WriteBytes(pData, 0, pData.Length);
                        }
                        WriteCommandParameterSplitBytes(command, session);
                    }
                }
            }

            WriteFrameEndBytes(command, session);
        }
Ejemplo n.º 4
0
        public override Dynamic.Net.Base.INetCommand GetCommand(INetSession session, System.IO.Stream stream)
        {
            INetCommand  command = null;
            StreamReader sr      = new StreamReader(stream);
            string       header  = sr.ReadToEnd();

            if (header.StartsWith("GET ", StringComparison.OrdinalIgnoreCase))
            {
                HandshakeRequestCommand handshakeCmd = new HandshakeRequestCommand();
                if (handshakeCmd.Parse(header))
                {
                    command = handshakeCmd;
                }
            }
            else
            {
                WebSocketSession wSession = session as WebSocketSession;
                if (wSession != null && wSession.IsHandShake)
                {
                }
                else
                {
                    session.Close();
                }
            }
            return(command);
        }
        public override Dynamic.Net.Base.INetCommand Execute(Dynamic.Net.Base.INetSession session)
        {
            WebSocketSessionBase ws = session as WebSocketSessionBase;

            if (ws == null)
            {
                return(null);
            }

            MessageReceivedEventArgs args = new MessageReceivedEventArgs()
            {
                ContentType = MessageContentType.Binary,
                Data        = InnerData,
                Session     = session as WebSocketSessionBase,
                IsAync      = false
            };

            ws.OnMessageReceived(args);

            INetCommand responseCommand = null;

            if (!args.IsAync && args.ResponseData != null && args.ResponseData.Length > 0)
            {
                responseCommand = WebSocketCommandFactory.CreateCommand(args.ResponseData);
            }

            return(responseCommand);
        }
        public override Dynamic.Net.Base.INetCommand Execute(Dynamic.Net.Base.INetSession session)
        {
            if (InnerData != null && InnerData.Length > 0)
            {
                Content = session.Encoding.GetString(InnerData);
            }

            WebSocketSessionBase ws = session as WebSocketSessionBase;

            if (ws == null)
            {
                return(null);
            }

            MessageReceivedEventArgs args = new MessageReceivedEventArgs()
            {
                Content     = this.Content,
                ContentType = MessageContentType.Text,
                Data        = InnerData,
                Session     = ws,
                IsAync      = false
            };

            ws.OnMessageReceived(args);

            INetCommand responseCommand = null;

            if (!args.IsAync && !String.IsNullOrEmpty(args.ResponseContent))
            {
                responseCommand = WebSocketCommandFactory.CreateCommand(args.ResponseContent);
            }

            return(responseCommand);
        }
Ejemplo n.º 7
0
        protected virtual void AsyncEventArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            if (e.BytesTransferred <= 0)
            {
                Offline();
                return;
            }



            if (e.SocketError != SocketError.Success)
            {
                Offline();
                return;
            }

            ReceivedBytes += e.BytesTransferred - e.Offset;

            for (int i = e.Offset; i < e.Offset + e.BytesTransferred; i++)
            {
                frameStream.WriteByte(e.Buffer[i]);
                frameStream.Flush();
                if (isNoCheck && noCheckCount > 0)
                {
                    noCheckCount--;
                    continue;
                }
                else if (isNoCheck)
                {
                    isNoCheck    = false;
                    noCheckCount = 0;
                }

                if (Protocol.IsFrameEnd(frameStream))
                {
                    frameStream.Position = 0;
                    INetCommand command = Protocol.GetCommand(this, frameStream);
                    if (command != null)
                    {
                        frameStream.Position = 0;
                        frameStream.SetLength(0);
                        command = command.Execute(this);
                    }
                    Protocol.WriteCommand(command, this);
                }
            }



            if (!isClosed)
            {
                Protocol.TryGetCommand(this);
            }
        }
Ejemplo n.º 8
0
 public override void WriteCommand(INetCommand command, INetSession session)
 {
     if (command is HandshakeResponseCommand)
     {
         HandshakeResponseCommand response = command as HandshakeResponseCommand;
         Byte[] responseData = response.GetResponseData(session);
         session.WriteBytes(responseData, 0, responseData.Length);
     }
     else if (command is FrameCommandBase)
     {
         FrameStreamWriter writer = new FrameStreamWriter(command as FrameCommandBase);
         writer.Write(session);
     }
 }
Ejemplo n.º 9
0
        public static void Send(this INetCommand command, NetworkDestination destination, Int32 recievedFrom = -1)
        {
            if (destination.ShouldRun())
            {
                command.OnRecieved();
            }

            if (destination.ShouldSend())
            {
                Header header = destination.GetHeader(NetworkCore.GetNetworkCoreHash(command.GetType()));

                if (NetworkServer.active)
                {
                    for (Int32 i = 0; i < NetworkServer.connections.Count; ++i)
                    {
                        if (i == recievedFrom)
                        {
                            continue;
                        }

                        NetworkConnection conn = NetworkServer.connections[i];
                        if (conn == null)
                        {
                            continue;
                        }
                        if (NetworkServer.localClientActive && NetworkServer.localConnections.Contains(conn))
                        {
                            continue;
                        }

                        using (Writer netWriter = NetworkCore.GetWriter(NetworkCore.commandIndex, conn, NetworkCore.qos))
                        {
                            NetworkWriter writer = netWriter;
                            writer.Write(header);
                        }
                    }
                }
                else if (NetworkClient.active)
                {
                    using (Writer netWriter = NetworkCore.GetWriter(NetworkCore.commandIndex, ClientScene.readyConnection, NetworkCore.qos))
                    {
                        NetworkWriter writer = netWriter;
                        writer.Write(header);
                    }
                }
            }
        }
        public override INetCommand GetCommand(INetSession session, Stream stream)
        {
            INetCommand command = null;
            List <Byte> sb      = new List <Byte>();
            int         c       = 0;
            int         parIdx  = 0;

            while (true)
            {
                c = stream.ReadByte();
                if (c == -1)
                {
                    break;
                }
                if (c == 0xff && command == null)
                {
                    Byte[] cmdNam = sb.ToArray();
                    command = Commands.FirstOrDefault(x => x.IsMatch(cmdNam));
                    sb.Clear();

                    if (command == null)
                    {
                        break;
                    }
                }
                else if (command != null && c == 0xff)
                {
                    if (!command.SetParameter(sb.ToArray(), parIdx))
                    {
                        command = null;
                        break;
                    }

                    parIdx++;
                }
                else
                {
                    sb.Add((byte)c);
                }
            }

            return(command);
        }
Ejemplo n.º 11
0
        public static void Send(this INetCommand command, NetworkDestination destination)
        {
            if (destination.ShouldRun())
            {
                command.OnReceived();
            }

            if (destination.ShouldSend())
            {
                var header = destination.GetHeader(NetworkingAPI.GetNetworkHash(command.GetType()));

                if (NetworkServer.active)
                {
                    for (int i = 0; i < NetworkServer.connections.Count; ++i)
                    {
                        NetworkConnection conn = NetworkServer.connections[i];
                        if (conn == null)
                        {
                            continue;
                        }
                        if (NetworkServer.localClientActive && NetworkServer.localConnections.Contains(conn))
                        {
                            continue;
                        }

                        using (Writer netWriter = NetworkingAPI.GetWriter(NetworkingAPI.CommandIndex, conn, QosType.Reliable)) {
                            NetworkWriter writer = netWriter;
                            writer.Write(header);
                        }
                    }
                }
                else if (NetworkClient.active)
                {
                    using (var netWriter = NetworkingAPI.GetWriter(NetworkingAPI.CommandIndex, ClientScene.readyConnection, QosType.Reliable)) {
                        NetworkWriter writer = netWriter;
                        writer.Write(header);
                    }
                }
            }
        }
        public virtual void Start()
        {
            OnSessionStarted();

            while (true)
            {
                if (isClosed)
                {
                    break;
                }
                INetCommand command = protocol.GetCommand(this);
                if (isClosed)
                {
                    break;
                }
                if (command != null)
                {
                    command = command.Execute(this);
                }
                protocol.WriteCommand(command, this);
            }
        }
 protected override void WriteFrameEndBytes(INetCommand command, INetSession session)
 {
     session.WriteBytes(splitCommandBytes, 0, splitCommandBytes.Length);
 }
 protected abstract void WriteFrameEndBytes(INetCommand command, INetSession session);
 protected override void WriteCommandNameEndBytes(INetCommand command, INetSession session)
 {
     session.WriteBytes(new byte[] { 0xff }, 0, 1);
 }
 protected abstract void WriteCommandParameterSplitBytes(INetCommand command, INetSession session);
 protected override void WriteCommandParameterSplitBytes(INetCommand command, INetSession session)
 {
     session.WriteBytes(new byte[] { 0xff }, 0, 1);
 }