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);
}
