//--------------------------------------------------------------------------------------------------------------------------
//供外部通过QueueAction调用的方法，实际执行线程是DataCacheThread。
//--------------------------------------------------------------------------------------------------------------------------
internal void LoadAccount(string accountId)
{
Msg_LD_Load msg = new Msg_LD_Load();
msg.MsgId = (int)DataEnum.TableAccount;
msg.PrimaryKeys.Add(accountId);
Msg_LD_SingleLoadRequest reqAccount = new Msg_LD_SingleLoadRequest();
reqAccount.MsgId = (int)DataEnum.TableAccount;
reqAccount.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle;
reqAccount.Keys.Add(accountId);
msg.LoadRequests.Add(reqAccount);
RequestLoad(msg, (ret) => {
KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys);
if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Green, "DataCache Load Success: Msg:{0}, Key:{1}", "Account", primaryKey);
}
else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "Account", primaryKey);
}
else
{
LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "Account", primaryKey, ret.ErrorInfo);
}
UserProcessScheduler dataProcessScheduler = UserServer.Instance.UserProcessScheduler;
dataProcessScheduler.DefaultUserThread.QueueAction(dataProcessScheduler.LoadAccountCallback, accountId, ret);
});
}
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);
}
}
}
}
}
}
internal void RequestSave(Msg_LD_Save msg, MyAction <Msg_DL_SaveResult> callback = null)
{
lock (m_SaveRequestQueuesLock) {
msg.SerialNo = GenNextSerialNo();
KeyString key = KeyString.Wrap(msg.PrimaryKeys);
ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> > dict;
if (!m_SaveRequestQueues.TryGetValue(msg.MsgId, out dict))
{
dict = m_SaveRequestQueues.AddOrUpdate(msg.MsgId, new ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> >(), (k, v) => v);
}
ConcurrentQueue <SaveRequestInfo> queue;
if (!dict.TryGetValue(key, out queue))
{
queue = dict.AddOrUpdate(key, new ConcurrentQueue <SaveRequestInfo>(), (k, v) => v);
}
SaveRequestInfo info = m_SaveRequestPool.Alloc();
info.m_Request = msg;
info.m_Callback = callback;
if (queue.Count == 0)
{
//当前队列为空时直接发送消息
info.m_LastSendTime = TimeUtility.GetLocalMilliseconds();
m_DataStoreChannel.Send(msg);
}
queue.Enqueue(info);
}
}
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 static bool Equals(KeyString a, KeyString b)
{
bool ret = false;
if (object.ReferenceEquals(a, b))
{
ret = true;
}
else if (object.ReferenceEquals(a, null))
{
ret = false;
}
else if (object.ReferenceEquals(b, null))
{
ret = false;
}
else
{
int ct = a.m_Keys.Count;
if (ct == b.m_Keys.Count)
{
ret = true;
for (int ix = 0; ix < ct; ++ix)
{
if (a.m_Keys[ix] != b.m_Keys[ix])
{
ret = false;
break;
}
}
}
}
return(ret);
}
public static KeyString Wrap(List <string> strs)
{
KeyString obj = new KeyString();
obj.m_Keys = strs;
return(obj);
}
public static KeyString Wrap(params string[] strs)
{
KeyString obj = new KeyString();
for (int i = 0; i < strs.Length; ++i) {
obj.m_Keys.Add(strs[i]);
}
return obj;
}
/// <summary>
/// 主键查找
/// </summary>
/// <param name="msgId">数据类型ID</param>
/// <param name="key">主键</param>
/// <returns>查找成功返回对应数据对象，不存在返回null</returns>
internal InnerCacheItem Find(int msgId, KeyString key)
{
InnerCacheTable cacheTable = null;
m_CacheTableDict.TryGetValue(msgId, out cacheTable);
if (cacheTable != null) {
return cacheTable.Find(key);
}
return null;
}
/// <summary>
/// 外键查找
/// </summary>
/// <param name="msgId">数据类型ID</param>
/// <param name="key">外键</param>
/// <returns></returns>
internal List<InnerCacheItem> FindByForeignKey(int msgId, KeyString foreignKey)
{
InnerCacheTable cacheTable = null;
m_CacheTableDict.TryGetValue(msgId, out cacheTable);
if (cacheTable != null) {
return cacheTable.FindByForeignKey(foreignKey);
}
return new List<InnerCacheItem>();
}
internal void GMLoadUser(string gmAccount, ulong userGuid, LobbyGmMessageDefine jsonMsgId, int nodeHandle)
{
string key = userGuid.ToString();
Msg_LD_Load msg = new Msg_LD_Load();
msg.MsgId = (int)DataEnum.TableUserInfo;
msg.PrimaryKeys.Add(key);
Msg_LD_SingleLoadRequest reqUser = new Msg_LD_SingleLoadRequest();
reqUser.MsgId = (int)DataEnum.TableUserInfo;
reqUser.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle;
reqUser.Keys.Add(key);
msg.LoadRequests.Add(reqUser);
RequestLoad(msg, (ret) => {
JsonMessage resultMsg = new JsonMessage(jsonMsgId, gmAccount);
GameFrameworkMessage.Msg_LC_GmQueryUser protoData = new GameFrameworkMessage.Msg_LC_GmQueryUser();
protoData.m_Result = GameFrameworkMessage.GmResultEnum.Failed;
protoData.m_Info = null;
KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys);
if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, "DataCache Load Success: Msg:{0}, Key:{1}", "GmUser", primaryKey);
TableUserInfo dataUser = null;
foreach (var result in ret.Results)
{
object _msg;
if (DbDataSerializer.Decode(result.Data, DataEnum2Type.Query(result.MsgId), out _msg))
{
DataEnum msgEnum = (DataEnum)result.MsgId;
switch (msgEnum)
{
case DataEnum.TableUserInfo:
dataUser = _msg as TableUserInfo;
break;
default:
LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "Decode user data ERROR. Wrong message id. UserGuid:{0}, WrongId:{1}", userGuid, msgEnum);
break;
}
}
}
protoData.m_Result = GameFrameworkMessage.GmResultEnum.Success;
protoData.m_Info = CreateGmUserInfo(dataUser);
}
else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "GmUser", primaryKey);
}
else
{
LogSys.Log(LOG_TYPE.ERROR, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "GmUser", primaryKey, ret.ErrorInfo);
}
resultMsg.m_ProtoData = protoData;
JsonGmMessageDispatcher.SendNodeMessage(nodeHandle, resultMsg);
});
}
public static KeyString Wrap(params string[] strs)
{
KeyString obj = new KeyString();
for (int i = 0; i < strs.Length; ++i)
{
obj.m_Keys.Add(strs[i]);
}
return(obj);
}
private Dictionary<KeyString, KeyString> m_PrimaryForeignDict = new Dictionary<KeyString, KeyString>(); //primaryKey-foreignKey
#endregion Fields
#region Methods
/// <summary>
/// 添加或更新
/// </summary>
/// <param name="key">主键,不能为空</param>
/// <param name="foreignKey">外键，可以为空</param>
/// <param name="dataMessage">数据值</param>
/// <param name="dataVersion">数据版本</param>
internal void AddOrUpdate(KeyString key, KeyString foreignKey, byte[] dataMessage, long cacheVersion)
{
InnerCacheItem cacheItem = null;
m_PrimaryDict.TryGetValue(key, out cacheItem);
if (cacheItem == null) {
//数据不在缓存中
if (dataMessage == null) {
//被删除的数据
return;
}
cacheItem = new InnerCacheItem(dataMessage);
m_PrimaryDict.Add(key, cacheItem);
if (!KeyString.IsNullOrEmpty(foreignKey)) {
m_PrimaryForeignDict[foreignKey] = key;
HashSet<KeyString> associateKeys = null;
m_ForeignPrimaryDict.TryGetValue(foreignKey, out associateKeys);
if (associateKeys != null) {
associateKeys.Add(key);
} else {
associateKeys = new HashSet<KeyString>();
associateKeys.Add(key);
m_ForeignPrimaryDict.Add(foreignKey, associateKeys);
}
}
} else {
//数据已在缓存中
if (CompareDataVersion(cacheVersion, cacheItem.CacheVersion)) {
//更新缓存
cacheItem.DirtyState = DirtyState.Unsaved;
cacheItem.Valid = true;
cacheItem.CacheVersion = cacheVersion;
if (dataMessage == null) {
cacheItem.Valid = false;
} else {
cacheItem.DataMessage = dataMessage;
}
//更新外键关系
if (!KeyString.IsNullOrEmpty(foreignKey)) {
m_PrimaryForeignDict[foreignKey] = key;
HashSet<KeyString> associateKeys = null;
m_ForeignPrimaryDict.TryGetValue(foreignKey, out associateKeys);
if (associateKeys != null) {
associateKeys.Add(key);
} else {
associateKeys = new HashSet<KeyString>();
associateKeys.Add(key);
m_ForeignPrimaryDict.Add(foreignKey, associateKeys);
}
}
} else {
//新数据的dataVersion低,不更新缓存,输出警告日志
LogSys.Log(LOG_TYPE.WARN, "Update cache version WARN. Key:{0}, NewCacheVersion:{1}, OldCacheVersion:{2}", key, cacheVersion, cacheItem.CacheVersion);
}
}
}
static public int get_Keys(IntPtr l)
{
try {
GameFramework.KeyString self = (GameFramework.KeyString)checkSelf(l);
pushValue(l, true);
pushValue(l, self.Keys);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
/// <summary>
/// 添加或更新
/// </summary>
/// <param name="msgId">数据类型ID</param>
/// <param name="key">Key</param>
/// <param name="dataMessage">待添加的数据对象</param>
internal void AddOrUpdate(int msgId, KeyString key, KeyString foreignKey, byte[] dataMessage, long cacheVersion = InnerCacheSystem.InitialCacheVersion)
{
InnerCacheTable tableCache = null;
m_CacheTableDict.TryGetValue(msgId, out tableCache);
if (tableCache != null) {
tableCache.AddOrUpdate(key, foreignKey, dataMessage, cacheVersion);
} else {
InnerCacheTable newTableCache = new InnerCacheTable();
newTableCache.AddOrUpdate(key, foreignKey, dataMessage, cacheVersion);
m_CacheTableDict.Add(msgId, newTableCache);
}
}
static public int constructor(IntPtr l)
{
try {
GameFramework.KeyString o;
o = new GameFramework.KeyString();
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_Keys(IntPtr l)
{
try {
GameFramework.KeyString self = (GameFramework.KeyString)checkSelf(l);
List <System.String> v;
checkType(l, 2, out v);
self.Keys = v;
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
internal void LoadUser(ulong userGuid, string accountId, string nickname)
{
string key = userGuid.ToString();
Msg_LD_Load msg = new Msg_LD_Load();
msg.MsgId = (int)DataEnum.TableUserInfo;
msg.PrimaryKeys.Add(key);
Msg_LD_SingleLoadRequest reqUser = new Msg_LD_SingleLoadRequest();
reqUser.MsgId = (int)DataEnum.TableUserInfo;
reqUser.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle;
reqUser.Keys.Add(key);
msg.LoadRequests.Add(reqUser);
Msg_LD_SingleLoadRequest reqMember = new Msg_LD_SingleLoadRequest();
reqMember.MsgId = (int)DataEnum.TableMemberInfo;
reqMember.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadMulti;
reqMember.Keys.Add(key);
msg.LoadRequests.Add(reqMember);
Msg_LD_SingleLoadRequest reqItem = new Msg_LD_SingleLoadRequest();
reqItem.MsgId = (int)DataEnum.TableItemInfo;
reqItem.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadMulti;
reqItem.Keys.Add(key);
msg.LoadRequests.Add(reqItem);
Msg_LD_SingleLoadRequest reqFriend = new Msg_LD_SingleLoadRequest();
reqFriend.MsgId = (int)DataEnum.TableFriendInfo;
reqFriend.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadMulti;
reqFriend.Keys.Add(key);
msg.LoadRequests.Add(reqFriend);
RequestLoad(msg, (ret) => {
KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys);
if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, "DataCache Load Success: Msg:{0}, Key:{1}", "UserInfo", primaryKey);
}
else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "UserInfo", primaryKey);
}
else
{
LogSys.Log(LOG_TYPE.ERROR, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "UserInfo", primaryKey, ret.ErrorInfo);
}
UserProcessScheduler dataProcessScheduler = UserServer.Instance.UserProcessScheduler;
dataProcessScheduler.DefaultUserThread.QueueAction(dataProcessScheduler.LoadUserCallback, ret, accountId, nickname);
});
}
//--------------------------------------------------------------------------------------------------------------------------
//供内部通过DispatchAction(调用的方法，实际执行线程是DataCacheThread。
//--------------------------------------------------------------------------------------------------------------------------
private void DSSaveInternal(Msg_LD_Save msg)
{
try {
RequestSave(msg, (ret) => {
KeyString primaryKey = KeyString.Wrap(msg.PrimaryKeys);
if (ret.ErrorNo == Msg_DL_SaveResult.ErrorNoEnum.Success)
{
LogSys.Log(LOG_TYPE.INFO, "Save data success. MsgId:{0}, SerialNo:{1}, Key:{2}", msg.MsgId, msg.SerialNo, primaryKey);
}
else
{
LogSys.Log(LOG_TYPE.ERROR, "Save data failed. MsgId:{0}, SerialNo:{1}, Key:{2}, Error:{3}, ErrorInfo:{4}",
msg.MsgId, msg.SerialNo, primaryKey, ret.ErrorNo, ret.ErrorInfo);
}
});
} catch (Exception e) {
LogSys.Log(LOG_TYPE.ERROR, "DataCache Save ERROR:{0}, Stacktrace:{1}", e.Message, e.StackTrace);
}
}
internal void RequestLoad(Msg_LD_Load msg, MyAction <Msg_DL_LoadResult> callback)
{
msg.SerialNo = GenNextSerialNo();
KeyString key = KeyString.Wrap(msg.PrimaryKeys);
ConcurrentDictionary <KeyString, LoadRequestInfo> dict = null;
if (!m_LoadRequests.TryGetValue(msg.MsgId, out dict))
{
dict = m_LoadRequests.AddOrUpdate(msg.MsgId, new ConcurrentDictionary <KeyString, LoadRequestInfo>(), (k, v) => v);
}
LoadRequestInfo info;
if (!dict.TryGetValue(key, out info))
{
info = dict.AddOrUpdate(key, m_LoadRequestPool.Alloc(), (k, v) => v);
}
info.m_LastSendTime = TimeUtility.GetLocalMilliseconds();
info.m_Request = msg;
info.m_Callback = callback;
m_DataStoreChannel.Send(msg);
}
private static bool Equals(KeyString a, KeyString b)
{
bool ret = false;
if (object.ReferenceEquals(a, b)) {
ret = true;
} else if (object.ReferenceEquals(a, null)) {
ret = false;
} else if (object.ReferenceEquals(b, null)) {
ret = false;
} else {
int ct = a.m_Keys.Count;
if (ct == b.m_Keys.Count) {
ret = true;
for (int ix = 0; ix < ct; ++ix) {
if (a.m_Keys[ix] != b.m_Keys[ix]) {
ret = false;
break;
}
}
}
}
return ret;
}
public static bool IsNullOrEmpty(KeyString str)
{
return(str == null || str.m_Keys.Count == 0);
}
/// <summary>
/// 删除
/// </summary>
/// <param name="key">主键</param>
/// <returns>删除成功返回true，失败为false</returns>
internal bool Remove(KeyString key)
{
KeyString foreignKey = null;
m_PrimaryForeignDict.TryGetValue(key, out foreignKey);
if (!KeyString.IsNullOrEmpty(foreignKey)) {
HashSet<KeyString> priKeys = null;
m_ForeignPrimaryDict.TryGetValue(foreignKey, out priKeys);
if (priKeys != null) {
priKeys.Remove(key);
}
m_ForeignPrimaryDict.Remove(foreignKey);
}
m_PrimaryForeignDict.Remove(key);
return m_PrimaryDict.Remove(key);
}
/// <summary>
/// 外键查询
/// </summary>
/// <param name="foreignKey">外键</param>
/// <returns>外键所对应的数据值列表</returns>
internal List<InnerCacheItem> FindByForeignKey(KeyString foreignKey)
{
List<InnerCacheItem> cacheItemList = new List<InnerCacheItem>();
HashSet<KeyString> associateKeys = null;
m_ForeignPrimaryDict.TryGetValue(foreignKey, out associateKeys);
if (associateKeys != null) {
foreach (var key in associateKeys) {
InnerCacheItem cacheItem = this.Find(key);
if (cacheItem != null && cacheItem.Valid) {
cacheItemList.Add(cacheItem);
}
}
}
return cacheItemList;
}
/// <summary>
/// 主键查询
/// </summary>
/// <param name="key">主键</param>
/// <returns>若查找到返回唯一对应数据值，否则返回null</returns>
internal InnerCacheItem Find(KeyString key)
{
InnerCacheItem cacheItem = null;
m_PrimaryDict.TryGetValue(key, out cacheItem);
if (cacheItem != null && cacheItem.Valid) {
return cacheItem;
} else {
return null;
}
}
private void OnTick()
{
long curTime = TimeUtility.GetLocalMilliseconds();
if (m_LastTickTime != 0)
{
long elapsedTickTime = curTime - m_LastTickTime;
if (elapsedTickTime > c_WarningTickTime)
{
LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread Tick:{0}", elapsedTickTime);
}
}
m_LastTickTime = curTime;
if (m_LastLogTime + 60000 < curTime)
{
m_LastLogTime = curTime;
DebugPoolCount((string msg) => {
LogSys.Log(LOG_TYPE.INFO, "DataCacheThread.DispatchActionQueue {0}", msg);
});
DebugActionCount((string msg) => {
LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread.DispatchActionQueue {0}", msg);
});
LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread.ThreadActionQueue Current Action {0}", m_Thread.CurActionNum);
LogSys.Log(LOG_TYPE.MONITOR, "DataCacheThread Load Request Count {0} Save Request Count {1}", CalcLoadRequestCount(), CalcSaveRequestCount());
}
if (UserServerConfig.DataStoreAvailable == true)
{
if (m_LastOperateTickTime + c_OperateTickInterval < curTime)
{
m_LastOperateTickTime = curTime;
//Load操作
foreach (var pair in m_LoadRequests)
{
int msgId = pair.Key;
ConcurrentDictionary <KeyString, LoadRequestInfo> dict = pair.Value;
foreach (var reqPair in dict)
{
KeyString primaryKey = reqPair.Key;
LoadRequestInfo req = reqPair.Value;
if (req.m_LastSendTime + UserServerConfig.DSRequestTimeout < curTime)
{
m_WaitDeletedLoadRequests.Add(primaryKey, req.m_Request.SerialNo);
Msg_DL_LoadResult result = new Msg_DL_LoadResult();
result.MsgId = msgId;
result.PrimaryKeys.AddRange(primaryKey.Keys);
result.SerialNo = req.m_Request.SerialNo;
result.ErrorNo = Msg_DL_LoadResult.ErrorNoEnum.TimeoutError;
result.ErrorInfo = "Timeout Error";
if (null != req.m_Callback)
{
DispatchAction(req.m_Callback, result);
}
}
}
foreach (var delPair in m_WaitDeletedLoadRequests)
{
LoadRequestInfo info;
if (dict.TryRemove(delPair.Key, out info))
{
if (info.m_Request.SerialNo == delPair.Value)
{
m_LoadRequestPool.Recycle(info);
}
else
{
dict.TryAdd(delPair.Key, info);
}
}
}
m_WaitDeletedLoadRequests.Clear();
}
//Save操作
foreach (var pair in m_SaveRequestQueues)
{
int msgId = pair.Key;
ConcurrentDictionary <KeyString, ConcurrentQueue <SaveRequestInfo> > dict = pair.Value;
foreach (var reqPair in dict)
{
KeyString primaryKey = reqPair.Key;
ConcurrentQueue <SaveRequestInfo> saveReqQueue = reqPair.Value;
SaveRequestInfo req;
if (saveReqQueue.TryPeek(out req))
{
if (req.m_LastSendTime + UserServerConfig.DSRequestTimeout < curTime)
{
//超时,重新发送
LogSys.Log(LOG_TYPE.ERROR, "DataCacheThread. SaveRequest timeout. MsgId:{0}, PrimaryKey:{1}, SerialNo:{2}",
msgId, KeyString.Wrap(req.m_Request.PrimaryKeys), req.m_Request.SerialNo);
m_DataStoreChannel.Send(req.m_Request);
req.m_LastSendTime = curTime;
}
}
if (dict.Count > c_MaxRecordPerMessage && saveReqQueue.Count == 0)
{
m_WaitDeleteSaveRequests.Add(primaryKey);
}
}
foreach (KeyString key in m_WaitDeleteSaveRequests)
{
lock (m_SaveRequestQueuesLock) {
ConcurrentQueue <SaveRequestInfo> queue;
if (dict.TryGetValue(key, out queue))
{
if (queue.Count == 0)
{
ConcurrentQueue <SaveRequestInfo> dummy;
dict.TryRemove(key, out dummy);
}
}
}
}
m_WaitDeleteSaveRequests.Clear();
}
}
if (m_LastDSConnectTime + c_DSConnectInterval < curTime)
{
m_LastDSConnectTime = curTime;
if (m_CurrentStatus != ConnectStatus.Connected)
{
ConnectDataStore();
}
}
}
}
public static bool IsNullOrEmpty(KeyString str)
{
return str == null || str.m_Keys.Count == 0;
}
//
internal void GMLoadAccount(string gmAccount, string accountId, int nodeHandle)
{
Msg_LD_Load msg = new Msg_LD_Load();
msg.MsgId = (int)DataEnum.TableAccount;
msg.PrimaryKeys.Add(accountId);
Msg_LD_SingleLoadRequest reqAccount = new Msg_LD_SingleLoadRequest();
reqAccount.MsgId = (int)DataEnum.TableAccount;
reqAccount.LoadType = Msg_LD_SingleLoadRequest.LoadTypeEnum.LoadSingle;
reqAccount.Keys.Add(accountId);
msg.LoadRequests.Add(reqAccount);
RequestLoad(msg, (ret) => {
JsonMessage resultMsg = new JsonMessage(LobbyGmMessageDefine.Msg_CL_GmQueryAccount, gmAccount);
GameFrameworkMessage.Msg_LC_GmQueryAccount protoData = new GameFrameworkMessage.Msg_LC_GmQueryAccount();
protoData.m_Result = GameFrameworkMessage.GmResultEnum.Failed;
protoData.m_QueryAccount = accountId;
protoData.m_AccountState = GameFrameworkMessage.GmStateEnum.Offline;
resultMsg.m_ProtoData = protoData;
KeyString primaryKey = KeyString.Wrap(ret.PrimaryKeys);
if (Msg_DL_LoadResult.ErrorNoEnum.Success == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Green, "DataCache Load Success: Msg:{0}, Key:{1}", "GmAccount", primaryKey);
TableAccount dataAccount = null;
foreach (var result in ret.Results)
{
object _msg;
if (DbDataSerializer.Decode(result.Data, DataEnum2Type.Query(result.MsgId), out _msg))
{
DataEnum msgEnum = (DataEnum)result.MsgId;
switch (msgEnum)
{
case DataEnum.TableAccount:
dataAccount = _msg as TableAccount;
break;
default:
LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "Decode account data ERROR. Wrong message id. Account:{0}, WrongId:{1}", result.PrimaryKeys[0], msgEnum);
break;
}
}
}
protoData.m_Result = GameFrameworkMessage.GmResultEnum.Success;
protoData.m_QueryAccount = dataAccount.AccountId;
protoData.m_AccountState = GameFrameworkMessage.GmStateEnum.Online;
if (dataAccount.IsBanned)
{
protoData.m_AccountState = GameFrameworkMessage.GmStateEnum.Banned;
}
}
else if (Msg_DL_LoadResult.ErrorNoEnum.NotFound == ret.ErrorNo)
{
LogSys.Log(LOG_TYPE.INFO, ConsoleColor.Yellow, "DataCache Load NotFound: Msg:{0}, Key:{1}", "GmAccount", primaryKey);
}
else
{
LogSys.Log(LOG_TYPE.ERROR, ConsoleColor.Red, "DataCache Load Failed: Msg:{0}, Key:{1}, ERROR:{2}", "GmAccount", primaryKey, ret.ErrorInfo);
}
resultMsg.m_ProtoData = protoData;
JsonGmMessageDispatcher.SendNodeMessage(nodeHandle, resultMsg);
});
}
/// <summary>
/// 删除
/// </summary>
/// <param name="msgId">数据类型ID</param>
/// <param name="key">Key</param>
/// <returns>删除成功返回true，失败返回false</returns>
internal bool Remove(int msgId, KeyString key)
{
InnerCacheTable cacheTable = null;
m_CacheTableDict.TryGetValue(msgId, out cacheTable);
if (cacheTable != null) {
return cacheTable.Remove(key);
}
return false;
}
public static KeyString Wrap(List<string> strs)
{
KeyString obj = new KeyString();
obj.m_Keys = strs;
return obj;
}
