Exemple #1
0
        public void Load <T>(string key, LoadCallback <T> cb)
            where T : IMessage
        {
            uint dsMsgId = MessageMapping.Query(typeof(T));

            if (dsMsgId == uint.MaxValue)
            {
                cb(DSLoadResult.PrepError, string.Format("unknown data message: {0}", typeof(T).Name), default(T));
                return;
            }
            string timeoutKey = string.Format("{0}:{1}", dsMsgId, key);

            if (loadOpt_timeout_.Exists(timeoutKey))
            {
                cb(DSLoadResult.PrepError, "Load operation are too frequent", default(T));
            }
            else
            {
                LNReq_Load.Builder loadBuilder = LNReq_Load.CreateBuilder();
                loadBuilder.SetDsMsgId(dsMsgId);
                loadBuilder.SetKey(key);
                LNReq_Load loadData = loadBuilder.Build();
                if (!channel_.Send(loadData))
                {
                    cb(DSLoadResult.PrepError, "Create protobuf data error.", default(T));
                }
                else
                {
                    LoadCBBox cbbox      = new LoadCBBoxI <T>(cb);
                    string    timeoutTip = string.Format("DataStore load request timeout. MsgId:{0}, Key:{1}", dsMsgId, key);
                    loadOpt_timeout_.Set(timeoutKey, cbbox, () => cbbox.Invoke(DSLoadResult.TimeoutError, timeoutTip, null));
                }
            }
        }
Exemple #2
0
 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);
     }
 }