private SHRPResult ReadSHRPResult() { var b = InternalPacket.ReadByte(); EnumHelpers.ThrowIfUndefined(typeof(SHRPResult), b); return((SHRPResult)b); }
public ServerObjectAvailabilityChanged(RoutingMetaPacket internalMetaPacket) : base(internalMetaPacket) { InternalMetaPacket.PacketId = AEPacketId.ServerNewObjectAvailable; RoutingObject = InternalPacket.ReadRoutingComponent(); Available = InternalPacket.ReadBoolean(); }
public override RoutingMetaPacket FinalizePacket() { InternalPacket.WriteRoutingComponent(RoutingObject); InternalPacket.WriteBoolean(Available); return(base.FinalizePacket()); }
public override RoutingMetaPacket FinalizePacket() { InternalPacket.WriteUInt32(Protocol); InternalPacket.WriteShortString(Password); InternalPacket.WriteRoutingComponent(Component); return(base.FinalizePacket()); }
public ClientHandshakeBeginPacket(RoutingMetaPacket metaPacket) : base(metaPacket) { InternalMetaPacket.PacketId = AEPacketId.ClientHandshakeBegin; Protocol = InternalPacket.ReadUInt32(); Password = InternalPacket.ReadShortString(); Component = InternalPacket.ReadRoutingComponent(); }
static void Main(string[] args) { //日志路径 Log.Instance().Init("./LogicServer"); //异常 GameBase.Core.GlobalException.InitException(); MemIniFile ini = new MemIniFile(); if (!ini.LoadFromFile(TextDefine.GoldConfig)) { return; } m_DicSession = new Dictionary <Socket, GameBase.Network.GameSession>(); m_DicSession.Clear(); String sIP = ini.ReadValue(TextDefine.LogicServerSection, TextDefine.NormalIPKey, TextDefine.NormalIP); int nPort = ini.ReadValue(TextDefine.LogicServerSection, TextDefine.NormalPortKey, TextDefine.LoginServerPort); m_Key = ini.ReadValue(TextDefine.GlobalSection, TextDefine.EncodeKey, System.Environment.TickCount); m_Key2 = ini.ReadValue(TextDefine.GlobalSection, TextDefine.EncodeKey2, System.Environment.TickCount); m_GameServerIP = ini.ReadValue(TextDefine.GameServerSetion, TextDefine.NormalIPKey, TextDefine.NormalIP); m_GameServerPort = ini.ReadValue(TextDefine.GameServerSetion, TextDefine.NormalPortKey, TextDefine.GameServerPort); server = new TcpServer(); server.onConnect += new TcpServerEvent.OnConnectEventHandler(OnConnect); server.onReceive += new TcpServerEvent.OnReceiveEventHandler(OnReceive); server.onClose += new TcpServerEvent.OnCloseEventHandler(OnClose); if (!server.Start(sIP, nPort)) { Console.WriteLine("start server error!"); return; } //连接dbserver mDBPacket = new InternalPacket(); GenerateKey.Init(m_Key, m_Key2); sIP = ini.ReadValue(TextDefine.DBServerSestion, TextDefine.NormalIPKey, TextDefine.NormalIP); nPort = ini.ReadValue(TextDefine.DBServerSestion, TextDefine.NormalPortKey, TextDefine.DBServerPort); mTcpClient = new GameBase.Network.TcpClient(); mTcpClient.onConnect += new TcpClientEvent.OnConnectEventHandler(OnDBConnect); mTcpClient.onReceive += new TcpClientEvent.OnReceiveEventHandler(OnDBReceive); mTcpClient.onClose += new TcpClientEvent.OnCloseEventHandler(OnDBClose); mTcpClient.Connect(sIP, nPort); //逻辑处理 Thread logicThread = new Thread(new ThreadStart(LogicTimer)); logicThread.IsBackground = true; logicThread.Start(); while (true) { String command = Console.ReadLine(); if (command == "exit") { break; } } }
public InternalSession(TcpServer server, Socket s) { mPacket = new InternalPacket(); mName = ""; mType = 0; lastTime = System.Environment.TickCount; mTcpServer = server; mSocket = s; }
public void SendPacket(InternalPacket packet) { if (Block) { return; } packet.Connection = this; byte[] buf = packet.Encode(); _session.SendPacket(buf); }
private void Send(BasePacket packet, int player = -1) { var internalPacket = new InternalPacket(); var packetType = packet.GetType(); var packetId = _packetTypes.FirstOrDefault(x => x.Value == packetType).Key; internalPacket.Write(packetId); packet.Encode(internalPacket); internalPacket.Send(player); }
public ServerHandshakeResultPacket(RoutingMetaPacket metaPacket) : base(metaPacket) { InternalMetaPacket.PacketId = AEPacketId.ServerHandshakeResult; Result = ReadSHRPResult(); if (Result == SHRPResult.Success) { OurComponent = InternalPacket.ReadRoutingComponent(); OtherAvailableComponents = InternalPacket.ReadList(PacketExtensions.ReadRoutingComponent); } }
public override RoutingMetaPacket FinalizePacket() { WriteSHRPResult(Result); if (Result == SHRPResult.Success) { InternalPacket.WriteRoutingComponent(OurComponent); InternalPacket.WriteList(OtherAvailableComponents, PacketExtensions.WriteRoutingComponent); } return(base.FinalizePacket()); }
public override RoutingMetaPacket FinalizePacket() { if (_finalized) { throw new InvalidOperationException("A packet may only be finalized once."); } _finalized = true; InternalMetaPacket.Payload = InternalPacket.FinalizePacket(); return(InternalMetaPacket); }
/// <summary> /// Callback de notificação de pacote recebido. /// Localiza o RPC a partir do número da mensagem e transmite o pacote /// para o RPC. /// </summary> /// <param name="sender"></param> /// <param name="packet"></param> protected void OnPacketReceived(object sender, InternalPacket packet) { int msgId = packet.MsgId; IRpc rpc = GetRpc(msgId); if (rpc != null) { rpc.OnPacketReceived(GetSession(), packet); return; } MyDebug.LogDebug("Channel.OnPacketReceived: msgid {0} desconhecido ou inesperado", packet.MsgId); }
private void OnProcessPacket(IPacketSession session, InternalPacket packet) { foreach (var service in m_Services) { IServerCallHandler methodHandler = null; if (service.CallHandlers.TryGetValue(packet.FullMethodName, out methodHandler)) { // TODO: Server: analise the need to store the call tasks. methodHandler.HandleCall(session, packet); return; } } // Discard unknow or unexpected packet }
/// <summary> /// Inicia o RPC enviando o pacote de dados para o ponto remoto. /// </summary> /// <param name="packet"></param> private void StartRequest(InternalPacket packet) { m_Session.AddRpc(this); this.m_State = StreamState.Open; try { m_Session.Send(packet); } catch (Exception) { this.m_State = StreamState.Closed; m_Session.RemoveRpc(this); throw; } }
public Task HandleCall(IPacketSession session, InternalPacket packet) { var rpc = new RpcTunnel <TResponse, TRequest>(session, m_MethodInv, packet.MsgId); rpc.Start(); return(Task.Factory.StartNew(() => { using (rpc) { m_Handler .Invoke(rpc.GetReceiver(), new ServerCallContext()) .ContinueWith((taskResult) => rpc.Close(taskResult)) .Wait(); } })); }
/// <summary> /// Callback de notificação de um pacote de rede recebido. /// Determina o RPC ativo para o número de mensagem e notifica o /// RPC do recebimento. /// Caso não haja um RPC ativo (p.ex. uma nova requisição), repassa /// o pacote recebido para o callback de recebimento registrado em /// ProcessPacketAction. /// </summary> /// <param name="packet">Pacote de dados contendo a requisição</param> private void OnPacketReceived(InternalPacket packet) { IRpc rpc = GetRpc(packet.MsgId); if (rpc != null) { rpc.OnPacketReceived(this, packet); return; } if (ProcessPacketAction != null) { ProcessPacketAction.Invoke(this, packet); return; } // Discard unknow or unexpected packet }
public void Init() { MemIniFile ini = new MemIniFile(); if (!ini.LoadFromFile(TextDefine.GoldConfig)) { Log.Instance().WriteLog("load golbalconfig error!"); return; } //连接dbserver的客户 InternalPacket mDBPacket = new InternalPacket(); mTcpDBClient = new GameBase.Network.TcpClient(); mTcpDBClient.onConnect += new TcpClientEvent.OnConnectEventHandler(OnDBConnectEventHandler); mTcpDBClient.onReceive += new TcpClientEvent.OnReceiveEventHandler(OnDBReceiveEventHandler); mTcpDBClient.onClose += new TcpClientEvent.OnCloseEventHandler(OnDBClose); String sIP = ini.ReadValue(TextDefine.DBServerSestion, TextDefine.NormalIPKey, TextDefine.NormalIP); int nPort = ini.ReadValue(TextDefine.DBServerSestion, TextDefine.NormalPortKey, TextDefine.DBServerPort); mTcpDBClient.Connect(sIP, nPort); }
public bool TrySend(InternalPacket packet) { return(m_channel.InternalGetTransport(false).TrySend(packet)); }
public void Send(InternalPacket packet) { m_channel.InternalGetTransport(false).Send(packet); }
void IPacketSession.Send(InternalPacket packet) { m_Transport.Send(packet); }
bool IPacketSession.TrySend(InternalPacket packet) { return(m_Transport?.TrySend(packet) ?? false); }
private void WriteSHRPResult(SHRPResult value) { InternalPacket.WriteByte((byte)value); }
public void SendPacket(InternalPacket packet) { Connection.SendPacket(packet); }
/// <summary> /// Desempacota o payload de dentro do pacote recebido. /// </summary> /// <param name="packet">Pacote contendo os dados recebidos.</param> /// <returns>Dados desempacotados.</returns> TReceive GetData(InternalPacket packet) { return(PacketHandler.GetData(packet, m_Method.ResponseMarshaller)); }
/// <summary> /// Callback de notificação de recebimento de pacote. /// </summary> /// <param name="session">Sessão de origem do pacote.</param> /// <param name="packet">Pacote de dados.</param> void IRpc.OnPacketReceived(IPacketSession session, InternalPacket packet) { if (m_State != StreamState.Open) { Debug.WriteLine(String.Format("{0}.OnPacketReceived: Unexpected packet: {1}", nameof(RpcTunnel <TSend, TReceive>), packet)); return; } var options = packet.Options; if (options == P_OPTIONS_RPC_ERROR) { m_State = StreamState.Error; var rpcException = PacketHandler.GetException(packet); m_ReturnValueTcs.TrySetException(rpcException); m_RpcStreamReader.OnError(rpcException); Finish(); return; } if (options == P_OPTIONS_RPC_CLOSE) { m_State = StreamState.Closed; Exception ex = new EndOfStreamException(); m_ReturnValueTcs.TrySetException(ex); m_RpcStreamReader.OnDataClosed(); Finish(); return; } if (options == P_OPTIONS_RPC_RETURN) { m_State = StreamState.Closed; var data = GetData(packet); m_ReturnValueTcs.TrySetResult(data); m_RpcStreamReader.OnDataClosed(); Finish(); return; } if (options == P_OPTIONS_STREAM_DATA) { var data = GetData(packet); m_RpcStreamReader.OnDataReceived(data); return; } if (options == P_OPTIONS_STREAM_CLOSE) { m_RpcStreamReader.OnDataClosed(); return; } // Unknow or unexpected value -> discard packet MyDebug.LogDebug("{0}.OnPacketReceived: Unknow or unexpected packet: {1}", nameof(RpcTunnel <TSend, TReceive>), packet); }