private void OnSaveReply(Msg_DL_SaveResult msg, PBChannel channel, int src, uint session) { KeyString key = KeyString.Wrap(msg.PrimaryKeys); ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> > dict; if (m_SaveRequestQueues.TryGetValue(msg.MsgId, out dict)) { ConcurrentQueue <SaveRequestInfo> reqQueue; if (dict.TryGetValue(key, out reqQueue)) { SaveRequestInfo info; if (reqQueue.TryPeek(out info)) { if (info.m_Request.SerialNo == msg.SerialNo) { if (null != info.m_Callback) { info.m_Callback(msg); } SaveRequestInfo delInfo; if (reqQueue.TryDequeue(out delInfo)) { m_SaveRequestPool.Recycle(delInfo); } //发送队列中的下一个消息 if (reqQueue.TryPeek(out info)) { info.m_LastSendTime = TimeUtility.GetLocalMilliseconds(); m_DataStoreChannel.Send(info.m_Request); } } } } } }
private void DoSaveReply(NLRep_Save msg, PBChannel channel, int src, uint session) { string timeoutKey = string.Format("{0}:{1}", msg.DsMsgId, msg.Key); SaveCallback cb = saveOpt_timeout_.Get(timeoutKey); if (null != cb) { DSSaveResult saveRet = DSSaveResult.UnknownError; string errorStr = "Save Unknown Error"; if (msg.Result == NLRep_Save.Types.SaveResult.Success) { saveRet = DSSaveResult.Success; errorStr = "Save Success"; } else if (msg.Result == NLRep_Save.Types.SaveResult.Error) { saveRet = DSSaveResult.PostError; if (msg.HasError) { errorStr = msg.Error.ToString(); } else { errorStr = "Save Post Error"; } } cb(saveRet, errorStr); saveOpt_timeout_.Remove(timeoutKey); } }
private void HandleBattleEnd(Msg_RL_BattleEnd msg, PBChannel channel, int src, uint session) { int roomID = msg.RoomID; LogSys.Log(LOG_TYPE.DEBUG, "Battle Info: RoomID = {0}", roomID); m_RoomProcessThread.QueueAction(m_RoomProcessThread.OnRoomBattleEnd, msg); }
private void ConnectHandler(LNReq_Connect msg, PBChannel channel, int handle, uint seq) { if (!Enable) { LogSys.Log(LOG_TYPE.ERROR, "Connect to DataStorNode while DataOperator is Disable"); return; } try { bool ret = true; string errorMsg = string.Empty; LogSys.Log(LOG_TYPE.INFO, "DataStoreClient connect :{0} ", msg.ClientName); var reply = NLRep_Connect.CreateBuilder(); reply.SetResult(ret); reply.SetError(errorMsg); channel.Send(reply.Build()); } catch (Exception e) { var reply = NLRep_Connect.CreateBuilder(); reply.SetResult(false); reply.SetError(e.Message); channel.Send(reply.Build()); } }
private void HandleReconnectUser(Msg_LR_ReconnectUser urMsg, PBChannel channel, int handle, uint seq) { bool isFieldThread; int ix = GetActiveRoomThreadIndex(urMsg.RoomID, out isFieldThread); if (ix < 0) { Msg_RL_ReplyReconnectUser replyBuilder = new Msg_RL_ReplyReconnectUser(); replyBuilder.UserGuid = urMsg.UserGuid; replyBuilder.RoomID = urMsg.RoomID; replyBuilder.Result = (int)Msg_RL_ReplyReconnectUser.ReconnectResultEnum.NotExist; channel.Send(replyBuilder); } else { if (isFieldThread) { RoomThread roomThread = field_roomthread_list_[ix]; roomThread.QueueAction(roomThread.HandleReconnectUser, urMsg, channel, handle, seq); } else { RoomThread roomThread = roomthread_list_[ix]; roomThread.QueueAction(roomThread.HandleReconnectUser, urMsg, channel, handle, seq); } } }
private void HandleUserQuit(Msg_LR_UserQuit msg, PBChannel channel, int handle, uint seq) { bool isFieldThread; int ix = GetActiveRoomThreadIndex(msg.RoomID, out isFieldThread); if (ix >= 0) { if (isFieldThread) { RoomThread roomThread = field_roomthread_list_[ix]; roomThread.QueueAction(roomThread.HandleUserQuit, msg, channel); } else { RoomThread roomThread = roomthread_list_[ix]; roomThread.QueueAction(roomThread.HandleUserQuit, msg, channel); } } else { Msg_RL_UserQuit replyBuilder = new Msg_RL_UserQuit(); replyBuilder.UserGuid = msg.UserGuid; replyBuilder.RoomID = msg.RoomID; channel.Send(replyBuilder); } }
/// <summary> /// 解码protobuf消息 /// </summary> /// <param name="data">字节数据</param> /// <param name="t_query">消息(id->type)查询函数</param> /// <param name="msg">返回的消息object</param> /// <param name="id">返回的消息id</param> /// <returns></returns> public static bool Decode( byte[] data, PBChannel.MsgTypeQuery t_query, out object msg, out int id) { bool ret = false; id = BitConverter.ToInt32(data, 0); id = IPAddress.NetworkToHostOrder(id); Type t = t_query(id); if (null != t) { DataStream.SetLength(0); DataStream.Write(data, 4, data.Length - 4); DataStream.Position = 0; try { msg = Serializer.Deserialize(DataStream, null, t); if (msg == null) { ret = false; } else { ret = true; } } catch { msg = null; ret = false; } } else { msg = null; } return ret; }
private void HandleActiveScene(Msg_LR_ActiveScene msg, PBChannel channel, int handle, uint seq) { int roomid = msg.RoomID; int sceneId = msg.SceneID; List <ulong> users = msg.UserGuids; int thread_id = GetIdleThread(); if (thread_id < 0) { LogSys.Log(LOG_TYPE.ERROR, "all room are using, active room failed!"); Msg_RL_ActiveSceneResult retMsg = new Msg_RL_ActiveSceneResult(); retMsg.UserGuids.AddRange(users); retMsg.RoomID = roomid; retMsg.Result = (int)SceneOperationResultEnum.Cant_Find_Room; return; } RoomThread roomThread = roomthread_list_[thread_id]; AddActiveRoom(roomid, thread_id, false); roomThread.PreActiveRoom(); LogSys.Log(LOG_TYPE.INFO, "queue active room {0} scene {1} thread {2}", roomid, sceneId, thread_id); roomThread.QueueAction(roomThread.ActiveRoom, roomid, sceneId, (MyAction <bool>)((bool val) => { Msg_RL_ActiveSceneResult retMsg = new Msg_RL_ActiveSceneResult(); retMsg.UserGuids.AddRange(users); retMsg.RoomID = roomid; retMsg.Result = val ? (int)SceneOperationResultEnum.Success : (int)SceneOperationResultEnum.Cant_Find_Room; })); }
internal void Init(PBChannel channel) { channel_ = channel; channel_.Register <LNReq_Connect>(ConnectHandler); channel_.Register <LNReq_Load>(LoadHandler); LogSys.Log(LOG_TYPE.INFO, "DataScheduler initialized"); }
private void OnLoadReply(NLRep_Load msg, PBChannel channel, int src, uint session) { if (null != m_RunningThread) { m_RunningThread.QueueAction(this.DoLoadReply, msg, channel, src, session); } }
internal void HandleReconnectUser(Msg_LR_ReconnectUser urMsg, PBChannel channel, int handle, uint seq) { Msg_RL_ReplyReconnectUser.ReconnectResultEnum result; User us = GetUserByGuid(urMsg.UserGuid); if (null != us) { if ((int)UserControlState.UserDropped == us.UserControlState || !us.IsConnected()) { result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.Drop; } else { result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.Online; } } else { result = Msg_RL_ReplyReconnectUser.ReconnectResultEnum.NotExist; } Msg_RL_ReplyReconnectUser replyBuilder = new Msg_RL_ReplyReconnectUser(); replyBuilder.UserGuid = urMsg.UserGuid; replyBuilder.RoomID = urMsg.RoomID; replyBuilder.Result = (int)result; channel.Send(replyBuilder); }
private void OnLoadReply(Msg_DL_LoadResult msg, PBChannel channel, int src, uint session) { KeyString key = KeyString.Wrap(msg.PrimaryKeys); ConcurrentDictionary <KeyString, LoadRequestInfo> dict; if (m_LoadRequests.TryGetValue(msg.MsgId, out dict)) { LoadRequestInfo info; if (dict.TryGetValue(key, out info)) { if (info.m_Request.SerialNo == msg.SerialNo) { if (null != info.m_Callback) { info.m_Callback(msg); } LoadRequestInfo delInfo; if (dict.TryRemove(key, out delInfo)) { m_LoadRequestPool.Recycle(delInfo); } } } } }
private void Init(string[] args) { m_NameHandleCallback = this.OnNameHandleChanged; m_MsgCallback = this.OnMessage; m_MsgResultCallback = this.OnMessageResultCallback; m_CmdCallback = this.OnCommand; m_LogHandler = this.OnCenterLog; CenterClientApi.SetCenterLogHandler(m_LogHandler); CenterClientApi.Init("datacache", args.Length, args, m_NameHandleCallback, m_MsgCallback, m_MsgResultCallback, m_CmdCallback); m_Channel = new PBChannel(DataMessageEnum2Type.Query, DataMessageEnum2Type.Query); m_Channel.DefaultServiceName = "UserSvr"; LogSys.Init("./config/logconfig.xml"); DataCacheConfig.Init(); GlobalVariables.Instance.IsClient = false; string key = "防君子不防小人"; byte[] xor = Encoding.UTF8.GetBytes(key); ResourceReadProxy.OnReadAsArray = ((string filePath) => { byte[] buffer = null; try { buffer = File.ReadAllBytes(filePath); } catch (Exception e) { LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", e.Message, e.StackTrace); return(null); } return(buffer); }); LogSystem.OnOutput += (Log_Type type, string msg) => { switch (type) { case Log_Type.LT_Debug: LogSys.Log(LOG_TYPE.DEBUG, msg); break; case Log_Type.LT_Info: LogSys.Log(LOG_TYPE.INFO, msg); break; case Log_Type.LT_Warn: LogSys.Log(LOG_TYPE.WARN, msg); break; case Log_Type.LT_Error: case Log_Type.LT_Assert: LogSys.Log(LOG_TYPE.ERROR, msg); break; } }; DbThreadManager.Instance.Init(DataCacheConfig.LoadThreadNum, DataCacheConfig.SaveThreadNum); DataOpSystem.Instance.Init(m_Channel); DataCacheSystem.Instance.Init(); LogSys.Log(LOG_TYPE.INFO, "DataCache initialized"); }
private void HandleUserChangeScene(Msg_BL_UserChangeScene msg_, PBChannel channel, int src, uint session) { UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler; UserInfo user = dataProcess.GetUserInfo(msg_.Guid); if (user != null) { user.SceneId = msg_.SceneId; } }
private void HandleQueryUserStateResult(Msg_BL_QueryUserStateResult msg_, PBChannel channel, int src, uint session) { UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler; UserInfo user = dataProcess.GetUserInfo(msg_.Guid); if (user != null && user.CurrentState == UserState.Room) { user.CurrentState = UserState.Online; } }
internal void Init(PBChannel channel) { m_DataStoreChannel = channel; channel.Register <Msg_DL_Connect>(OnConnectDataStore); channel.Register <Msg_DL_LoadResult>(OnLoadReply); channel.Register <Msg_DL_SaveResult>(OnSaveReply); }
private void Init(string[] args) { m_NameHandleCallback = this.OnNameHandleChanged; m_MsgCallback = this.OnMessage; m_CmdCallback = this.OnCommand; m_MsgResultCallback = this.OnMessageResult; CenterClientApi.Init("store", args.Length, args, m_NameHandleCallback, m_MsgCallback, m_MsgResultCallback, m_CmdCallback); m_Channel = new PBChannel(DashFire.DataStore.MessageMapping.Query, DashFire.DataStore.MessageMapping.Query); m_Channel.DefaultServiceName = "Lobby"; LogSys.Init("./config/logconfig.xml"); DataStoreConfig.Init(); ArkCrossEngine.GlobalVariables.Instance.IsClient = false; FileReaderProxy.RegisterReadFileHandler((string filePath) => { byte[] buffer = null; try { buffer = File.ReadAllBytes(filePath); } catch (Exception e) { LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", e.Message, e.StackTrace); return(null); } return(buffer); }, (string filepath) => { return(File.Exists(filepath)); }); LogSystem.OnOutput += (Log_Type type, string msg) => { switch (type) { case Log_Type.LT_Debug: LogSys.Log(LOG_TYPE.DEBUG, msg); break; case Log_Type.LT_Info: LogSys.Log(LOG_TYPE.INFO, msg); break; case Log_Type.LT_Warn: LogSys.Log(LOG_TYPE.WARN, msg); break; case Log_Type.LT_Error: case Log_Type.LT_Assert: LogSys.Log(LOG_TYPE.ERROR, msg); break; } }; DbThreadManager.Instance.Init(DataStoreConfig.LoadThreadNum, DataStoreConfig.SaveThreadNum); DataOpSystem.Instance.Init(m_Channel); DataCacheSystem.Instance.Init(); LogSys.Log(LOG_TYPE.INFO, "DataStore initialized"); }
private void HandleUserOffline(Msg_BL_UserOffline msg_, PBChannel channel, int src, uint session) { UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler; UserInfo user = dataProcess.GetUserInfo(msg_.Guid); if (user != null && user.CurrentState == UserState.Room) { user.CurrentState = UserState.Online; user.LeftLife = 0; } }
private void HandleStoryMessageFromRoom(Msg_LRL_StoryMessage msg, PBChannel channel, int src, uint session) { UserInfo user = m_UserProcessScheduler.GetUserInfo(msg.UserGuid); if (null != user) { ForwardToWorld(user.UserSvrName, msg); } }
internal void Init(PBChannel channel) { channel_ = channel; channel_.Register <LNReq_Connect>(ConnectHandler); channel_.Register <LNReq_Load>(LoadHandler); channel_.Register <LNReq_Save>(SaveHandler); InitDSNodeVersion(); LogSys.Log(LOG_TYPE.INFO, "DataOperator initialized"); }
private void HandleRoomServerUpdateInfo(Msg_RL_RoomServerUpdateInfo updateMsg, PBChannel channel, int src, uint session) { //更新RoomServer信息 m_RoomProcessThread.UpdateRoomServerInfo(new RoomServerInfo { RoomServerName = updateMsg.ServerName, IdleRoomNum = updateMsg.IdleRoomNum, UserNum = updateMsg.UserNum }); }
private void HandleRegisterRoomServer(Msg_RL_RegisterRoomServer msg_, PBChannel channel, int src, uint session) { m_RoomProcessThread.RegisterRoomServer(new RoomServerInfo { RoomServerName = msg_.ServerName, MaxRoomNum = msg_.MaxRoomNum, ServerIp = msg_.ServerIp, ServerPort = msg_.ServerPort }); }
private void HandleUserRelive(Msg_LR_UserReLive msg, PBChannel channel, int handle, uint seq) { int ix = GetActiveRoomThreadIndex(msg.RoomID); if (ix >= 0) { RoomThread roomThread = roomthread_list_[ix]; roomThread.QueueAction(roomThread.HandleUserRelive, msg); } }
private void InstallMessageHandlers() { m_DataCacheChannel = new PBChannel(DataMessageEnum2Type.Query, DataMessageEnum2Type.Query); m_DataCacheChannel.WorldId = UserServerConfig.WorldId; m_DataCacheChannel.DefaultServiceName = "DataCache"; InstallNodeHandlers(); InstallGmJsonHandlers(); InstallBigworldHandlers(); }
private void HandleRoomStoryMessage(Msg_LRL_StoryMessage msg_, PBChannel channel, int src, uint session) { UserProcessScheduler dataProcess = UserServer.Instance.UserProcessScheduler; UserThread userThread = dataProcess.GetUserThread(msg_.UserGuid); if (null != userThread) { userThread.QueueAction(userThread.HandleRoomStoryMessage, msg_); } else { dataProcess.DefaultUserThread.QueueAction(dataProcess.DefaultUserThread.HandleRoomStoryMessage, msg_); } }
private void InstallServerHandlers() { m_RoomSvrChannel = new PBChannel(MessageMapping.Query, MessageMapping.Query); m_RoomSvrChannel.Register <Msg_RL_RegisterRoomServer>(HandleRegisterRoomServer); m_RoomSvrChannel.Register <Msg_RL_RoomServerUpdateInfo>(HandleRoomServerUpdateInfo); m_RoomSvrChannel.Register <Msg_RL_ReplyCreateBattleRoom>(HandelReplyCreateBattleRoom); m_RoomSvrChannel.Register <Msg_RL_UserQuit>(HandleUserQuit); m_RoomSvrChannel.Register <Msg_RL_ReplyReconnectUser>(HandelReplyReconnectUser); m_RoomSvrChannel.Register <Msg_RL_BattleEnd>(HandleBattleEnd); }
private void InstallMessageHandlers() { m_DataCacheChannel = new PBChannel(DataMessageEnum2Type.Query, DataMessageEnum2Type.Query); m_DataCacheChannel.DefaultServiceName = "DataCache"; InstallUserHandlers(); InstallServerHandlers(); InstallNodeHandlers(); }
public BillingClient(PBChannel channel, MyServerThread thread) { channel_ = channel; m_RunningThread = thread; channel_.Register <BL_VerifyAccountResult>(OnVerifyAccountResult); m_VerifyAccountTimeout = new Timeout <VerifyAccountCB>(); m_VerifyAccountTimeout.DefaultTimeoutMS = 10000; //超时时间 m_VerifyAccountWatch = new OperationWatch(); }
/// <summary> /// 注意,userserver来的消息在主线程处理,再分发到其它线程 /// </summary> private void InstallUserHandlers() { m_UserChannel = new PBChannel(BigworldAndRoomServerMessageEnum2Type.Query, BigworldAndRoomServerMessageEnum2Type.Query); m_UserChannel.Register <Msg_LBL_Message>(HandleGeneralMessage); m_UserChannel.Register <Msg_LB_UpdateUserServerInfo>(HandleUpdateUserServerInfo); m_UserChannel.Register <Msg_LB_QueryUserState>(HandleQueryUserState); m_UserChannel.Register <Msg_LB_UserOffline>(HandleUserOffline); m_UserChannel.Register <Msg_LB_UserRelogin>(HandleUserRelogin); m_UserChannel.Register <Msg_LB_RequestEnterScene>(HandleRequestEnterScene); m_UserChannel.Register <Msg_LRL_StoryMessage>(HandleStoryMessageFromUserServer); }
//-------------------------------------- internal void RegisterMsgHandler(PBChannel channel) { channel.Register <Msg_LR_EnterScene>(HandleEnterScene); channel.Register <Msg_LR_ChangeScene>(HandleChangeScene); channel.Register <Msg_LR_ActiveScene>(HandleActiveScene); channel.Register <Msg_LR_ReconnectUser>(HandleReconnectUser); channel.Register <Msg_LR_UserReLive>(HandleUserRelive); channel.Register <Msg_LR_UserQuit>(HandleUserQuit); channel.Register <Msg_LR_ReclaimItem>(HandleReclaimItem); channel.Register <Msg_LRL_StoryMessage>(HandleRoomStoryMessage); }
private void HandleChangeSceneResult(Msg_RL_ChangeSceneResult msg, PBChannel channel, int src, uint session) { //响应RoomServer消息,进入野外场景结果消息 int hp = 0; int mp = 0; if (msg.HP > 0 && msg.MP > 0) { hp = msg.HP; mp = msg.MP; } m_RoomProcessThread.OnChangeSceneResult(msg.UserGuid, msg.RoomID, msg.TargetRoomID, msg.Result, hp, mp); }
private void Init(string[] args) { m_NameHandleCallback = this.OnNameHandleChanged; m_MsgCallback = this.OnMessage; m_MsgResultCallback = this.OnMessageResultCallback; m_CmdCallback = this.OnCommand; m_LogHandler = this.OnCenterLog; CenterClientApi.SetCenterLogHandler(m_LogHandler); CenterClientApi.Init("datacache", args.Length, args, m_NameHandleCallback, m_MsgCallback, m_MsgResultCallback, m_CmdCallback); m_Channel = new PBChannel(DataMessageEnum2Type.Query, DataMessageEnum2Type.Query); m_Channel.DefaultServiceName = "UserSvr"; LogSys.Init("./config/logconfig.xml"); DataCacheConfig.Init(); GlobalVariables.Instance.IsClient = false; string key = "防君子不防小人"; byte[] xor = Encoding.UTF8.GetBytes(key); ResourceReadProxy.OnReadAsArray = ((string filePath) => { byte[] buffer = null; try { buffer = File.ReadAllBytes(filePath); } catch (Exception e) { LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", e.Message, e.StackTrace); return null; } return buffer; }); LogSystem.OnOutput += (Log_Type type, string msg) => { switch (type) { case Log_Type.LT_Debug: LogSys.Log(LOG_TYPE.DEBUG, msg); break; case Log_Type.LT_Info: LogSys.Log(LOG_TYPE.INFO, msg); break; case Log_Type.LT_Warn: LogSys.Log(LOG_TYPE.WARN, msg); break; case Log_Type.LT_Error: case Log_Type.LT_Assert: LogSys.Log(LOG_TYPE.ERROR, msg); break; } }; DbThreadManager.Instance.Init(DataCacheConfig.LoadThreadNum, DataCacheConfig.SaveThreadNum); DataOpSystem.Instance.Init(m_Channel); DataCacheSystem.Instance.Init(); LogSys.Log(LOG_TYPE.INFO, "DataCache initialized"); }
internal void Init(PBChannel channel) { channel_ = channel; channel_.Register <Msg_LD_Connect>(DSConnectHandler); channel_.Register <Msg_LD_Load>(DSLoadHandler); channel_.Register <Msg_LD_Save>(DSSaveHandler); InitDSNodeVersion(); InitGlobalDataVersion(); LogSys.Log(LOG_TYPE.INFO, "DataOperator initialized"); }
private void LoadHandler(LNReq_Load msg, PBChannel channel, int handle, uint seq) { if (!Enable) { LogSys.Log(LOG_TYPE.ERROR, "Load a message while DataOperator is Disable"); return; } try { DataCacheSystem.Instance.LoadActionQueue.QueueAction((MyAction <uint, string, MyAction <DSLoadResult, string, IMessage> >)DataCacheSystem.Instance.Load, msg.DsMsgId, msg.Key, (ret, error, data) => { //这段代码必须保证线程安全,会在不同线程调用!!! var reply = NLRep_Load.CreateBuilder(); reply.SetDsMsgId(msg.DsMsgId); reply.SetKey(msg.Key); if (ret == DSLoadResult.Success) { reply.SetResult(NLRep_Load.Types.LoadResult.Success); reply.SetData(ByteString.Unsafe.FromBytes(channel_.Encode(data))); } else if (ret == DSLoadResult.Undone) { reply.SetResult(NLRep_Load.Types.LoadResult.Undone); reply.SetData(ByteString.Unsafe.FromBytes(channel_.Encode(data))); } else if (ret == DSLoadResult.NotFound) { reply.SetResult(NLRep_Load.Types.LoadResult.NotFound); reply.SetError(error); } else { reply.SetResult(NLRep_Load.Types.LoadResult.Error); reply.SetError(error); } NLRep_Load replyData = reply.Build(); channel.Send(replyData); LogSys.Log(LOG_TYPE.INFO, "Load data finished. msgId:({0}) key:({1}) result:({2}) ", msg.DsMsgId, msg.Key, ret); }); } catch (Exception e) { var errorReply = NLRep_Load.CreateBuilder(); errorReply.SetResult(NLRep_Load.Types.LoadResult.Error); errorReply.SetError(e.Message); channel.Send(errorReply.Build()); LogSys.Log(LOG_TYPE.ERROR, "DataStore load data failed. msgId:({0}) key:({1}) seq:({2}) error:({3} detail:{4})", msg.DsMsgId, msg.Key, seq, e.Message, e.StackTrace); } }
internal void Init(PBChannel channel) { channel_ = channel; channel_.Register<Msg_LD_Connect>(DSConnectHandler); channel_.Register<Msg_LD_Load>(DSLoadHandler); channel_.Register<Msg_LD_Save>(DSSaveHandler); InitDSNodeVersion(); InitGlobalDataVersion(); LogSys.Log(LOG_TYPE.INFO, "DataOperator initialized"); }
/// <summary> /// 初始化一个channel /// </summary> /// <param name="channel">CoreMessageExtendType的枚举值</param> /// <param name="msgid_query">id->type的查询函数</param> /// <param name="msgtype_query">type->id的查询函数</param> public void AddChannel(byte channel, PBChannel.MsgIdQuery msgid_query, PBChannel.MsgTypeQuery msgtype_query) { if (channel < channels_.Length) { if (null == channels_[channel]) { channels_[channel] = new PBChannel(channel, svr_api_, msgid_query, msgtype_query); } } }
private void HandleGeneralMessage(Msg_LBL_Message msg_, PBChannel channel, int src, uint session) { try { if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Node) { m_UserProcessScheduler.DispatchJsonMessage(session, src, GetMyHandle(), msg_.Data); } else if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Room) { byte[] msgData = msg_.Data; m_UserChannel.Dispatch(src, session, msgData); } } catch (Exception ex) { LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", ex.Message, ex.StackTrace); } }
private void HandleQueryUserState(Msg_LB_QueryUserState msg_, PBChannel channel, int src, uint session) { Msg_BL_QueryUserStateResult builder = new Msg_BL_QueryUserStateResult(); builder.Guid = msg_.Guid; UserInfo info = m_UserProcessScheduler.GetUserInfo(msg_.Guid); if (null == info) { builder.State = (int)UserState.DropOrOffline; } else { builder.State = (int)info.CurrentState; } m_UserChannel.Send(src, builder); }
private void HandleGeneralMessage(Msg_LBL_Message msg_, PBChannel channel, int src, uint session) { try { if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Node) { byte[] msgData = msg_.Data; //观察 m_UserProcessScheduler.DispatchJsonMessage(false, session, 0, 0, msgData); //转发 NodeMessageDispatcher.ForwardMessage(msg_.TargetName, msgData); } else if (msg_.MsgType == Msg_LBL_Message.MsgTypeEnum.Room) { m_BigworldChannel.Dispatch(src, session, msg_.Data); } } catch (Exception ex) { LogSys.Log(LOG_TYPE.ERROR, "Exception:{0}\n{1}", ex.Message, ex.StackTrace); } }
private void HandleUserDrop(Msg_RL_UserDrop msg_, PBChannel channel, int src, uint session) { }
internal void HandleUserQuit(Msg_LR_UserQuit msg, PBChannel channel) { Room room = GetRoomByID(msg.RoomID); if (null != room) { User user = room.GetUserByGuid(msg.UserGuid); if (null != user) { room.DeleteUser(user); } } Msg_RL_UserQuit replyBuilder = new Msg_RL_UserQuit(); replyBuilder.UserGuid = msg.UserGuid; replyBuilder.RoomID = msg.RoomID; channel.Send(replyBuilder); }
private void HandlePickMoney(Msg_RL_PickMoney msg_, PBChannel channel, int src, uint session) { }
private void HandleUserDrop(Msg_RL_UserDrop msg, PBChannel channel, int src, uint session) { //响应RoomServer游戏客户端退出消息 m_RoomProcessThread.OnRoomUserDrop(msg.RoomID, msg.UserGuid, msg.IsBattleEnd, msg); }
private void HandleStoryMessageFromRoom(Msg_LRL_StoryMessage msg, PBChannel channel, int src, uint session) { UserInfo user = m_UserProcessScheduler.GetUserInfo(msg.UserGuid); if(null!=user){ ForwardToWorld(user.UserSvrName, msg); } }
private void DSLoadHandler(Msg_LD_Load msg, PBChannel channel, int handle, uint seq) { try { DataCacheSystem.Instance.LoadActionQueue.QueueAction<Msg_LD_Load, PBChannel, int>(DataCacheSystem.Instance.Load, msg, channel, handle); } catch (Exception e) { var errorReply = new Msg_DL_LoadResult(); errorReply.MsgId = msg.MsgId; errorReply.PrimaryKeys.AddRange(msg.PrimaryKeys); errorReply.SerialNo = msg.SerialNo; errorReply.ErrorNo = Msg_DL_LoadResult.ErrorNoEnum.Exception; errorReply.ErrorInfo = e.Message; channel.Send(errorReply); LogSys.Log(LOG_TYPE.ERROR, "Load data failed. MsgId:{0}, Key:{1} Error:{2} Detail:{3}", msg.MsgId, msg.PrimaryKeys, e.Message, e.StackTrace); } }
private void DSSaveHandler(Msg_LD_Save msg, PBChannel channel, int handle, uint seq) { var saveResult = new Msg_DL_SaveResult(); saveResult.MsgId = msg.MsgId; saveResult.PrimaryKeys.AddRange(msg.PrimaryKeys); saveResult.SerialNo = msg.SerialNo; saveResult.ErrorNo = Msg_DL_SaveResult.ErrorNoEnum.Success; saveResult.ErrorInfo = string.Empty; try { //写入数据缓存 //TODO:是否将byte[]解析出protobuf对象? 提前反序列化成对象的好处:1.若数据有错误,反序列化失败,可反馈给lobby;2.protobuf对象可重用? //TODO:解析primaryKey和foreignKey DataCacheSystem.Instance.SaveActionQueue.QueueAction(DataCacheSystem.Instance.Save, msg.MsgId, msg.PrimaryKeys, msg.ForeignKeys, msg.Data, msg.SerialNo); } catch (Exception e) { saveResult.ErrorNo = Msg_DL_SaveResult.ErrorNoEnum.PostError; saveResult.ErrorInfo = e.Message; LogSys.Log(LOG_TYPE.ERROR, "Save data ERROR: MsgId:{0}, Key:{1}, Error:{2}, Detail:{3}", msg.MsgId, msg.PrimaryKeys, e.Message, e.StackTrace); } channel.Send(saveResult); }
private void HandleUserQuit(Msg_RL_UserQuit msg_, PBChannel channel, int src, uint session) { }
internal void Release() { channel_ = null; LogSys.Log(LOG_TYPE.INFO, "DataOperator disposed"); }
/// <summary> /// 注意,bigworld的消息已经分发到RoomProcessThread线程里进行处理,不需要再QueueAction到RoomProcessThread线程 /// </summary> private void InstallBigworldHandlers() { if (UserServerConfig.WorldIdNum > 0) { m_BigworldChannel = new PBChannel(BigworldAndRoomServerMessageEnum2Type.Query, BigworldAndRoomServerMessageEnum2Type.Query); m_BigworldChannel.WorldId = UserServerConfig.WorldId1; m_BigworldChannel.DefaultServiceName = "Lobby"; m_BigworldChannel.Register<Msg_LBL_Message>(HandleGeneralMessage); m_BigworldChannel.Register<Msg_BL_QueryUserStateResult>(HandleQueryUserStateResult); m_BigworldChannel.Register<Msg_BL_UserOffline>(HandleUserOffline); m_BigworldChannel.Register<Msg_BL_BroadcastText>(HandleBroadcastText); m_BigworldChannel.Register<Msg_BL_UserChangeScene>(HandleUserChangeScene); m_BigworldChannel.Register<Msg_RL_UserDrop>(HandleUserDrop); m_BigworldChannel.Register<Msg_RL_UserQuit>(HandleUserQuit); m_BigworldChannel.Register<Msg_RL_PickMoney>(HandlePickMoney); m_BigworldChannel.Register<Msg_RL_PickItem>(HandlePickItem); m_BigworldChannel.Register<Msg_LRL_StoryMessage>(HandleRoomStoryMessage); } }
internal void HandleReclaimItem(Msg_LR_ReclaimItem msg, PBChannel channel) { Room room = GetRoomByID(msg.RoomID); if (null != room) { User user = room.GetUserByGuid(msg.UserGuid); Scene curScene = room.ActiveScene; if (null != curScene) { } } }
private void HandlePickItem(Msg_RL_PickItem msg_, PBChannel channel, int src, uint session) { }
private void DSConnectHandler(Msg_LD_Connect msg, PBChannel channel, int handle, uint seq) { try { LogSys.Log(LOG_TYPE.INFO, "DataStoreClient connect :{0} ", msg.ClientName); var reply = new Msg_DL_Connect(); reply.Result = true; reply.Error = string.Empty; channel.Send(reply); } catch (Exception e) { var reply = new Msg_DL_Connect(); reply.Result = false; reply.Error = e.Message; channel.Send(reply); LogSys.Log(LOG_TYPE.ERROR, "Connect failed. ClientName:{0}", msg.ClientName); } }
private void RemoveUserForChangeScene(Room room, User user, ulong userGuid, int roomId, int targetRoomId, PBChannel channel, int handle, uint seq) { Msg_RL_ChangeSceneResult replyBuilder = new Msg_RL_ChangeSceneResult(); EntityInfo info = user.Info; if (null != info) { replyBuilder.HP = info.Hp; replyBuilder.MP = info.Energy; } room.RemoveUserFromRoomThread(user, true); replyBuilder.UserGuid = userGuid; replyBuilder.RoomID = roomId; replyBuilder.TargetRoomID = targetRoomId; replyBuilder.Result = (int)SceneOperationResultEnum.Success; channel.Send(replyBuilder); }
internal void HandleRoomStoryMessage(Msg_LRL_StoryMessage msg, PBChannel channel) { Room room = GetRoomByID(msg.RoomId); if (null != room) { User user = room.GetUserByGuid(msg.UserGuid); Scene curScene = room.ActiveScene; if (null != user && null != curScene) { try { string msgId = string.Format("server:{0}", msg.MsgId); ArrayList args = new ArrayList(); args.Add(user.RoleId); for (int i = 0; i < msg.Args.Count; i++) { switch (msg.Args[i].val_type) { case Msg_LRL_StoryMessage.ArgType.NULL://null args.Add(null); break; case Msg_LRL_StoryMessage.ArgType.INT://int args.Add(int.Parse(msg.Args[i].str_val)); break; case Msg_LRL_StoryMessage.ArgType.FLOAT://float args.Add(float.Parse(msg.Args[i].str_val)); break; default://string args.Add(msg.Args[i].str_val); break; } } object[] objArgs = args.ToArray(); curScene.StorySystem.SendMessage(msgId, objArgs); } catch (Exception ex) { LogSys.Log(LOG_TYPE.ERROR, "Msg_CRC_StoryMessage throw exception:{0}\n{1}", ex.Message, ex.StackTrace); } } } }
private void HandleBroadcastText(Msg_BL_BroadcastText msg_, PBChannel channel, int src, uint session) { m_UserProcessScheduler.DefaultUserThread.QueueAction(m_UserProcessScheduler.HandleBroadcast, (BroadcastType)msg_.BroadcastType, msg_.Content, msg_.RollCount); }