public void Execute() { var data = CacheSet.PvpTitleTable.GetAllData(); var highestTitle = data[data.Count - 1]; int maxScore = highestTitle.TitleMinScore; var players = CacheSet.PlayerSinglePvpCache.FindAll(); foreach (var player in players) { if (player.SinglePvpScore > maxScore) { player.DeductedScore += player.SinglePvpScore - maxScore; player.SinglePvpScore = maxScore; } } if (PVPLogic.Year == 0 || PVPLogic.Year != DateTime.UtcNow.Year) { PVPLogic.SeasonId = 1; PVPLogic.Year = DateTime.UtcNow.Year; RedisConnectionPool.GetClient().Set(GameConsts.Pvp.PvpSeasonOfYearKey, PVPLogic.Year); } else { PVPLogic.SeasonId += 1; } RedisConnectionPool.GetClient().Set(GameConsts.Pvp.PvpSeasonCountKey, PVPLogic.SeasonId); }
/// <summary> /// /// </summary> /// <param name="token"></param> /// <returns></returns> public static UserToken GetUserToken(string token) { UserToken userToken = null; string redisKey = string.Format("{0}@{1}", AccountServerToken, token); if (!string.IsNullOrEmpty(RedisHost) && RedisConnected) { //use redis cache. RedisConnectionPool.Process(client => { var val = client.Get(redisKey); userToken = val == null || val.Length == 0 ? new UserToken() : MathUtils.ParseJson <UserToken>(Encoding.UTF8.GetString(val)); }); return(userToken); } if (HttpContext.Current != null && HttpContext.Current.Cache != null) { userToken = (UserToken)HttpContext.Current.Cache[redisKey]; } if (Equals(userToken, null) && userTokenCache.ContainsKey(redisKey)) { userToken = (UserToken)userTokenCache[redisKey]; } return(userToken); }
/// <summary> /// 放到消息队列池中 /// </summary> /// <param name="statement"></param> public static bool Put(SqlStatement statement) { bool result = false; try { if (!IsUseSyncQueue) { return(false); } string tableName = statement.Table; string key = GetSqlQueueKey(statement.IdentityID); byte[] value = ProtoBufUtils.Serialize(statement); RedisConnectionPool.Process(client => { client.ZAdd(key, DateTime.Now.Ticks, value); ProfileManager.PostSqlOfMessageQueueTimes(tableName, 1); }); result = true; } catch (Exception ex) { TraceLog.WriteError("Sql update queue write error:{0}\r\n{1}", ex, JsonUtils.SerializeCustom(statement)); } return(result); }
/// <summary> /// 创建链接池管理对象 /// IP地址中可以加入auth验证 password@ip:port /// </summary> private static void CreateManager() { { //IPEndPoint result = null; var host = ConfigHelper.RedisEndPoint.Trim(); if (host.IndexOf("@") > -1) { var hostParts = host.Split('@'); _pwd = hostParts[0]; var ip = hostParts[1].Split(':'); _host = ip[0]; _port = int.Parse(ip[1]); //result = new IPEndPoint(IPAddress.Parse(ip[0]), int.Parse(ip[1])); } else { var hostParts = host.Split(':'); _host = hostParts[0]; _port = int.Parse(hostParts[1]); //result = new IPEndPoint(IPAddress.Parse(hostParts[0]), int.Parse(hostParts[1])); } //_IP = result; _PoolMaxSize = ConfigHelper.PoolMaxSize; } //_prcm = new RedisConnectionPool(_IP, _PoolMaxSize); _prcm = new RedisConnectionPool(_host, _port, _PoolMaxSize); }
private static void OnModelChangeAtfer(Assembly assembly) { if (assembly == null) { return; } try { TypeAccessor.Init(); RedisConnectionPool.Initialize(_setting.Serializer); DbConnectionProvider.Initialize(); ProtoBufUtils.Initialize(); ProtoBufUtils.LoadProtobufType(assembly); EntitySchemaSet.Init(); EntitySchemaSet.LoadAssembly(assembly); EntitySchemaSet.InitSchema(typeof(SensitiveWord)); Language.Reset(); CacheFactory.ResetCache(); TraceLog.ReleaseWrite("Update Model script success."); IsRunning = true; } catch (Exception ex) { TraceLog.WriteError("OnModelChangeAtfer error:{0}", ex); } }
/// <summary> /// 以同步的方式更新Entity /// </summary> /// <param name="entityList"></param> public static bool SendSync(IEnumerable <AbstractEntity> entityList) { var keyList = new List <byte[]>(); var valueList = new List <byte[]>(); foreach (var entity in entityList) { if (entity == null) { continue; } entity.TempTimeModify = MathUtils.Now; string key = GetQueueFormatKey(entity); var keyValues = key.Split('_', '|'); int id = AbstractEntity.DecodeKeyCode(keyValues[1]).ToInt(); string keyCode = keyValues[2]; string redisKey = string.Format("{0}_{1}", keyValues[0], keyCode); byte[] idBytes = BufferUtils.GetBytes(id); var keyBytes = RedisConnectionPool.ToByteKey(redisKey); byte[] entityBytes; bool isDelete = entity.IsDelete; entityBytes = _serializer.Serialize(entity); //modify resean: set unchange status. entity.Reset(); byte[] stateBytes = BufferUtils.GetBytes(isDelete ? 1 : 0); byte[] values = BufferUtils.MergeBytes(BufferUtils.GetBytes(idBytes.Length + stateBytes.Length), idBytes, stateBytes, entityBytes); keyList.Add(keyBytes); valueList.Add(values); } return(ProcessRedisSyncQueue(string.Empty, keyList.ToArray(), valueList.ToArray())); }
public void RedisListTest() { var watch = Stopwatch.StartNew(); var keys = new List <string> { "__List:1000:1", "__List:1000:2" }; var script = @" local result={} local index = 0 local len = table.getn(KEYS) for i=1, len do local key = KEYS[i] local values = redis.call('lrange',key,0,-1) local l = table.getn(values) result[i] = table.concat(values,',') end return result "; List <string> valueList = null; RedisConnectionPool.Process(c => { valueList = c.ExecLuaAsList(script, keys.ToArray(), new string[0]); }); Trace.WriteLine("value count:" + valueList.Count + "\r\n" + string.Join("\r\n", valueList)); WaitEnd(watch); }
public void CheckCompletedTest() { var keys = new[] { "testkey1", "testkey2" }; var vals = new[] { "1", "2" }; RedisConnectionPool.SetExpire(keys, vals, 300); RedisConnectionPool.Process(c => { var values = new List <string>(); using (var p = c.CreatePipeline()) { foreach (var key in keys) { string k = key; p.QueueCommand(cli => cli.Get <string>(k), v => { values.Add(v); }); } p.Flush(); } Trace.WriteLine(string.Join(",", values)); }); var watch = Stopwatch.StartNew(); var data = ShareCacheStruct.Get <ChildData>(1); data.Age++; bool result = CacheFactory.CheckCompleted(); Trace.WriteLine("Queue result:" + result); WaitEnd(watch); }
public void ReUsePoolConnection_test() { var host = "127.0.0.1"; var port = 6379; var connections = new List <RedisConnection>() { RedisConnectionPool.GetConnection(host, port) , RedisConnectionPool.GetConnection(host, port) , RedisConnectionPool.GetConnection(host, port) , RedisConnectionPool.GetConnection(host, port) , RedisConnectionPool.GetConnection(host, port) , RedisConnectionPool.GetConnection(host, port) }; foreach (var conn in connections) { conn.OnConnectionReleased(); } Assert.True(RedisConnectionPool.GetPoolSizeForHost(host, port).Equals(6)); var newConn = RedisConnectionPool.GetConnection(host, port); Assert.True(connections.Any(c => c.Id.Equals(newConn.Id))); }
public void FindRedis() { RedisConnectionPool.Process(cli => { /* * var watch = Stopwatch.StartNew(); * key = "$FrameworkUnitTest.Cache.Model.UserKeyData";//"$FrameworkUnitTest.Cache.Model.QuestProcess";// * //var keys = cli.HKeys(key); * //Trace.WriteLine("load time:" + watch.ElapsedMilliseconds + "ms." + "keys:" + keys.Length); * //var valueBytes = cli.HGet(key, keys); * //Trace.WriteLine("load time:" + watch.ElapsedMilliseconds + "ms." + "vals:" + valueBytes.Length); * byte[] suBytes = Encoding.Default.GetBytes("1380000"); * var script = @" * local userId = KEYS[2] * local key = KEYS[1] * local keyBytes = redis.call('HKeys',key) * print('keys:'.. table.getn(keyBytes)) * local valueBytes = {} * for i,k in pairs(keyBytes) do * if string.find(k, userId) then * local val = redis.call('HGet',key, k) * table.insert(valueBytes, val) * end * end * return valueBytes * "; * var keybytes = Encoding.Default.GetBytes(key); * var valueBytes = cli.Eval(script, 2, keybytes, suBytes); * Trace.WriteLine("load time:" + watch.ElapsedMilliseconds + "ms." + "vals:" + (valueBytes.Length > 0 && valueBytes[0] != null ? Encoding.Default.GetString(valueBytes[0]) + "count:" + valueBytes.Length : "count:" + valueBytes.Length)); * */ }); }
/// <summary> /// /// </summary> /// <param name="assembly"></param> public static void Init(Assembly assembly) { var htype = Type.GetType("ZyGames.Framework.Game.Sns.Service.IHandler`1", false, true); var types = assembly.GetTypes(); foreach (var type in types) { if (type.GetInterfaces().Select(t => t.Name).Contains(htype.Name)) { handlerTypes[type.Name] = type; } } if (!string.IsNullOrEmpty(RedisHost)) { try { //use redis cache. RedisConnectionPool.Initialize(new RedisPoolSetting() { Host = RedisHost, DbIndex = RedisDb }, new JsonCacheSerializer(Encoding.UTF8)); RedisConnected = true; } catch (Exception ex) { TraceLog.WriteError("Redis Initialize error:{0}", ex); } } }
/// <summary> /// Get entity from redis, but not surported mutil key of entity. /// </summary> /// <param name="personalId"></param> /// <param name="types"></param> /// <returns></returns> public static object[] Load(string personalId, params Type[] types) { personalId = AbstractEntity.EncodeKeyCode(personalId); var param = types.Where(t => !CacheFactory.ContainEntityKey(t, personalId)).ToArray(); if (param.Length == 0) { return(null); } var result = RedisConnectionPool.GetAllEntity(personalId, param); foreach (var t in result) { var entity = t as AbstractEntity; if (entity == null) { continue; } CacheItemSet itemSet; if (CacheFactory.AddOrUpdateEntity(entity, out itemSet)) { itemSet.OnLoadSuccess(); } } return(result); }
private static void LoadUnLineData() { try { RedisConnectionPool.ProcessReadOnly(client => { byte[] data = client.Get(sessionRedisKey) ?? new byte[0]; if (data.Length == 0) { return; } var temp = ProtoBufUtils.Deserialize <ConcurrentDictionary <Guid, GameSession> >(data); if (temp != null) { var paris = temp.Where(p => { p.Value.UserId = 0;//reset userid return(!p.Value.CheckExpired()); }).ToArray(); _globalSession = new ConcurrentDictionary <Guid, GameSession>(paris); } }); } catch (Exception er) { TraceLog.WriteError("Load GameSession from redis faild,{0}", er); } }
/// <summary> /// /// </summary> /// <param name="personalId"></param> /// <param name="dataList"></param> /// <returns></returns> protected bool TryLoadFromRedis(out List <T> dataList, string personalId = null) { string redisKey = string.IsNullOrEmpty(personalId) ? containerKey : string.Format("{0}_{1}", containerKey, personalId); SchemaTable schema = EntitySchemaSet.Get <T>(); return(RedisConnectionPool.TryGetEntity(redisKey, schema, out dataList)); }
/// <summary> /// Check queue is completed. /// </summary> /// <param name="keyIndex"></param> /// <returns></returns> public static bool CheckCompleted(int keyIndex = 0) { var keys = new string[DataSyncQueueManager.SyncQueueCount]; if (keys.Length == 1) { keys[0] = (DataSyncQueueManager.RedisSyncQueueKey); } else { for (int i = 0; i < keys.Length; i++) { keys[i] = string.Format("{0}:{1}", DataSyncQueueManager.RedisSyncQueueKey, i); } } bool result = false; RedisConnectionPool.ProcessReadOnly(client => { var values = client.MGet(keys); result = values == null || values.Length == 0 || values.Any(t => t == null); }); return(result); }
public void ReLoadRedis() { try { RedisConfig = RedisSettingFactory.Load(); ICacheSerializer serializer = RedisConfig.Serializer == StorageMode.Protobuf ? (ICacheSerializer) new ProtobufCacheSerializer() : new JsonCacheSerializer(Encoding.UTF8); RedisConnectionPool.Initialize(new RedisPoolSetting() { Host = RedisConfig.Host, ReadOnlyHost = RedisConfig.Host, MaxWritePoolSize = 2, MaxReadPoolSize = 2, DbIndex = RedisConfig.Db }, serializer); var _redisSection = ConfigManager.Configger.GetFirstOrAddConfig <RedisSection>(); if (_redisSection == null) { } } catch (Exception ex) { TraceLog.WriteError("ReLoadRedis error:{0}", ex); } }
public bool TrySearchRedisKeys(out List <string> keys, int top = 0) { string pattern = "*"; if (_redisSearchPatternList.Count == 1) { pattern = _redisSearchPatternList[0]; } List <string> list = null; bool result = false; RedisConnectionPool.ProcessReadOnly(client => { if (top > 0) { list = _redisSearchPatternList.Count > 1 ? SearchKeys(client, _redisSearchPatternList).OrderBy(k => k).Take(top).ToList() : client.SearchKeys(pattern).OrderBy(k => k).Take(top).ToList(); } else { list = _redisSearchPatternList.Count > 1 ? SearchKeys(client, _redisSearchPatternList).OrderBy(k => k).ToList() : client.SearchKeys(pattern).OrderBy(k => k).ToList(); } result = true; }); keys = list; return(result); }
public static void TestCheckSqlSyncQueue(int identity) { if (Interlocked.Exchange(ref _isWatchWorking[identity], 1) == 0) { try { string queueKey = GetSqlQueueKey(identity); string workingKey = queueKey + "_temp"; bool result; byte[][] bufferBytes = new byte[0][]; do { result = false; RedisConnectionPool.ProcessReadOnly(client => { bool hasWorkingQueue = client.ContainsKey(workingKey); bool hasNewWorkingQueue = client.ContainsKey(queueKey); if (!hasWorkingQueue && !hasNewWorkingQueue) { return; } if (!hasWorkingQueue) { try { client.Rename(queueKey, workingKey); } catch { } } bufferBytes = client.ZRange(workingKey, 0, sqlSyncPackSize); if (bufferBytes.Length > 0) { client.ZRemRangeByRank(workingKey, 0, sqlSyncPackSize); result = true; } else { client.Remove(workingKey); } }); if (!result) { break; } DoProcessSqlSyncQueue(workingKey, bufferBytes); } while (true); } catch (Exception ex) { TraceLog.WriteError("OnCheckSqlSyncQueue error:{0}", ex); } finally { Interlocked.Exchange(ref _isWatchWorking[identity], 0); } } }
/// <summary> /// Send entity to db saved. /// </summary> /// <param name="postColumnFunc"></param> /// <param name="getPropertyFunc"></param> /// <param name="entityList"></param> public static void SendToDb <T>(EntityPropertyGetFunc <T> getPropertyFunc, EnttiyPostColumnFunc <T> postColumnFunc, params T[] entityList) where T : ISqlEntity { string key = ""; try { if (entityList == null || entityList.Length == 0) { return; } var sender = new SqlDataSender(false); var groupList = entityList.GroupBy(t => t.GetMessageQueueId()); var sqlList = new List <KeyValuePair <string, KeyValuePair <byte[], long> > >(); foreach (var g in groupList) { key = g.Key.ToString(); var valueList = g.ToList(); foreach (var entity in valueList) { if (entity == null) { continue; } SqlStatement statement = sender.GenerateSqlQueue <T>(entity, getPropertyFunc, postColumnFunc); if (statement == null) { throw new Exception(string.Format("Generate sql of \"{0}\" entity error", entity.GetType().FullName)); } var sqlValueBytes = ProtoBufUtils.Serialize(statement); string sqlQueueKey = SqlStatementManager.GetSqlQueueKey(statement.IdentityID); sqlList.Add(new KeyValuePair <string, KeyValuePair <byte[], long> >(sqlQueueKey, new KeyValuePair <byte[], long>(sqlValueBytes, DateTime.Now.Ticks))); } } RedisConnectionPool.ProcessPipeline(p => { bool hasPost = false; var groupSqlList = sqlList.GroupBy(t => t.Key); foreach (var g in groupSqlList) { var pairs = g.Select(t => t.Value).ToList(); p.QueueCommand(client => ((RedisClient)client).ZAdd(g.Key, pairs)); hasPost = true; } if (hasPost) { p.Flush(); } }); } catch (Exception ex) { TraceLog.WriteError("Send To Db key:{0} error:{1}", key, ex); } }
/// <summary> /// /// </summary> /// <param name="key"></param> /// <param name="userToken"></param> public static void SaveToken(string key, UserToken userToken) { string userKey = string.Format("{0}:{1}", AccountServerToken, userToken.UserId); string redisKey = string.Format("{0}@{1}", AccountServerToken, key); if (!string.IsNullOrEmpty(RedisHost) && RedisConnected) { try { string script = @" local redisKey = KEYS[1] local userKey = KEYS[2] local key = KEYS[3] local timeout = ARGV[1] local val = ARGV[2] local oldToken = redis.call('Get', userKey) if oldToken and oldToken ~= nil then local k = '__AccountToken@'..oldToken redis.call('del', k) end redis.call('Set', redisKey, val, 'EX', timeout) redis.call('Set', userKey, key, 'EX', timeout) return 0 "; //use redis cache. RedisConnectionPool.Process(client => { int timeout = (int)(userToken.ExpireTime - DateTime.Now).TotalSeconds; client.ExecLuaAsInt(script, new[] { redisKey, userKey, key }, new[] { timeout.ToString(), MathUtils.ToJson(userToken) }); }); } catch (Exception ex) { TraceLog.WriteError("Save token errror:{0}", ex); } return; } if (HttpContext.Current != null && HttpContext.Current.Cache != null) { var cache = HttpContext.Current.Cache; var oldToken = cache[userKey] as string; if (!string.IsNullOrEmpty(oldToken)) { cache.Remove(string.Format("{0}@{1}", AccountServerToken, oldToken)); } cache[redisKey] = userToken; cache[userKey] = key; } else { string oldToken; if (userHashCache.TryGetValue(userToken.UserId, out oldToken)) { UserToken temp; userTokenCache.TryRemove(oldToken, out temp); } userTokenCache[key] = userToken; } }
/// <summary> /// 生成存储在Redis的Key /// </summary> /// <param name="type"></param> /// <param name="personalKey"></param> /// <returns></returns> public static string GenerateRedisKey(Type type, string personalKey) { if (string.IsNullOrEmpty(personalKey)) { return(string.Format("{0}", RedisConnectionPool.EncodeTypeName(type.FullName))); } return(string.Format("{0}_{1}", RedisConnectionPool.EncodeTypeName(type.FullName), personalKey)); }
public bool Send <T>(params T[] dataList) where T : AbstractEntity { if (_sendParam.Schema.CacheType == CacheType.Rank) { return(RedisConnectionPool.TryUpdateRankEntity(_sendParam.Key, dataList)); } return(RedisConnectionPool.TryUpdateEntity(dataList)); }
private static string GetEntityTypeFromKey(string key, out string typeName, ref Type type, out string asmName, out bool isEntityType, out string redisKey) { int index = key.IndexOf(','); var arr = (index > -1 ? key.Substring(0, index) : key).Split('_'); typeName = arr[0]; asmName = index == -1 ? "" : key.Substring(index + 1, key.Length - index - 1); string persionKey = string.Empty; string entityKey = string.Empty; if (arr.Length > 1) { entityKey = arr[1]; var tempArr = entityKey.Split('|'); if (tempArr.Length > 1) { persionKey = tempArr[0]; entityKey = tempArr[1]; } } isEntityType = false; if (string.IsNullOrEmpty(persionKey)) { isEntityType = true; redisKey = string.Format("{0}_{1}", RedisConnectionPool.EncodeTypeName(typeName), entityKey); } else { //私有类型 redisKey = string.Format("{0}_{1}", RedisConnectionPool.EncodeTypeName(typeName), persionKey); } string formatString = entityTypeNameFormat; if (isEntityType) { formatString = "{0},{1}"; } if (type == null) { string entityTypeName = RedisConnectionPool.DecodeTypeName(typeName); type = Type.GetType(string.Format(formatString, entityTypeName, asmName), false, true); if (Equals(type, null)) { var enitityAsm = ScriptEngines.GetEntityAssembly(); if (enitityAsm != null) { asmName = enitityAsm.GetName().Name; type = Type.GetType(string.Format(formatString, entityTypeName, asmName), false, true); if (Equals(type, null)) { //调试模式下type为空处理 type = enitityAsm.GetType(entityTypeName, false, true); } } } } return(entityKey); }
private static void OnCheckSqlSyncQueue(object state) { int identity = (int)state; if (Interlocked.CompareExchange(ref _isWatchWorking[identity], 1, 0) == 0) { try { string queueKey = GetSqlQueueKey(identity); string workingKey = queueKey + "_temp"; bool result; byte[][] bufferBytes = new byte[0][]; byte[][] valueBytes = new byte[0][]; byte[][] scoreBytes = new byte[0][]; do { result = false; RedisConnectionPool.ProcessReadOnly(client => { bool hasWorkingQueue = client.ContainsKey(workingKey); bool hasNewWorkingQueue = client.ContainsKey(queueKey); if (!hasWorkingQueue && !hasNewWorkingQueue) { return; } if (!hasWorkingQueue) { try { client.Rename(queueKey, workingKey); } catch { } } bufferBytes = GetPackFromQueue(client, workingKey, sqlSyncPackSize); if (bufferBytes.Length > 0) { result = true; } }); if (!result) { break; } DoProcessSqlSyncQueue(workingKey, queueKey, bufferBytes); } while (true); } catch (Exception ex) { TraceLog.WriteError("OnCheckSqlSyncQueue error:{0}", ex); } finally { Interlocked.Exchange(ref _isWatchWorking[identity], 0); } } }
/// <summary> /// The game service start. /// </summary> /// <param name="setting">Environment setting.</param> /// <param name="cacheSetting">Cache setting.</param> public static void Start(EnvironmentSetting setting, CacheSetting cacheSetting) { if (IsRunning) { return; } TraceLog.WriteLine("{0} Server is starting...", DateTime.Now.ToString("HH:mm:ss")); _setting = setting; if (!RedisConnectionPool.Ping("127.0.0.1")) { string error = string.Format("Error: NIC is not connected or no network."); TraceLog.WriteLine(error); TraceLog.WriteError(error); return; } RedisConnectionPool.Initialize(_setting.Serializer); if (!RedisConnectionPool.CheckConnect()) { string error = string.Format("Error: the redis server is not started."); TraceLog.WriteLine(error); TraceLog.WriteError(error); return; } TraceLog.WriteLine("{0} Redis server connect successfully.", DateTime.Now.ToString("HH:mm:ss")); DbConnectionProvider.Initialize(); TraceLog.WriteLine("{0} DB server connect successfully.", DateTime.Now.ToString("HH:mm:ss")); EntitySchemaSet.CacheGlobalPeriod = _setting.CacheGlobalPeriod; EntitySchemaSet.CacheUserPeriod = _setting.CacheUserPeriod; if (_setting.EntityAssembly != null) { ProtoBufUtils.LoadProtobufType(_setting.EntityAssembly); EntitySchemaSet.LoadAssembly(_setting.EntityAssembly); } ZyGameBaseConfigManager.Intialize(); //init script. if (_setting.ScriptSysAsmReferences.Length > 0) { ScriptEngines.AddSysReferencedAssembly(_setting.ScriptSysAsmReferences); } ScriptEngines.AddReferencedAssembly("ZyGames.Framework.Game.dll"); if (_setting.ScriptAsmReferences.Length > 0) { ScriptEngines.AddReferencedAssembly(_setting.ScriptAsmReferences); } ScriptEngines.RegisterModelChangedBefore(OnModelChangeBefore); ScriptEngines.RegisterModelChangedAfter(OnModelChangeAtfer); ScriptEngines.OnLoaded += OnScriptLoaded; ScriptEngines.Initialize(); Language.SetLang(); CacheFactory.Initialize(cacheSetting, _setting.Serializer); EntitySchemaSet.StartCheckTableTimer(); Global = new ContextCacheSet <CacheItem>("__gameenvironment_global"); }
/// <summary> /// 获取Container中存在的Cache,不重新创建 /// </summary> /// <param name="redisKey"></param> /// <param name="itemPair"></param> /// <param name="periodTime"></param> /// <returns></returns> public static bool TryGetContainerCacheItem(string redisKey, out KeyValuePair <string, CacheItemSet> itemPair, int periodTime = 0) { itemPair = default(KeyValuePair <string, CacheItemSet>); CacheItemSet cacheItem; string[] keys = (redisKey ?? "").Split('_'); if (keys.Length == 2 && !string.IsNullOrEmpty(keys[0])) { CacheContainer container = null; string typeName = RedisConnectionPool.DecodeTypeName(keys[0]); var schema = EntitySchemaSet.Get(typeName); periodTime = periodTime > 0 ? periodTime : schema.PeriodTime; if (_writePools != null && !_writePools.TryGetValue(typeName, out container)) { _writePools.InitContainer(typeName); _writePools.TryGetValue(typeName, out container); } if (container == null) { return(false); } string[] childKeys = keys[1].Split('|'); string personalKey = childKeys[0]; string entityKey = childKeys.Length > 1 ? childKeys[1] : ""; if (schema.CacheType == CacheType.Dictionary)//|| schema.CacheType == CacheType.Entity) { var result = container.Collection.TryGetValue(personalKey, out cacheItem); itemPair = new KeyValuePair <string, CacheItemSet>(entityKey, cacheItem); return(result); } if (schema.CacheType == CacheType.Entity) { var result = container.Collection.TryGetValue(entityKey, out cacheItem); itemPair = new KeyValuePair <string, CacheItemSet>(entityKey, cacheItem); return(result); } if (schema.CacheType == CacheType.Queue) { TraceLog.WriteError("Not support CacheType.Queue get cache, key:{0}.", redisKey); } ////存在分类id与实体主键相同情况, 要优先判断实体主键 //if (!string.IsNullOrEmpty(personalKey) && container.Collection.TryGetValue(entityKey, out cacheItem)) //{ // itemPair = new KeyValuePair<string, CacheItemSet>(entityKey, cacheItem); // return true; //} //if (!string.IsNullOrEmpty(personalKey) && container.Collection.TryGetValue(personalKey, out cacheItem)) //{ // itemPair = new KeyValuePair<string, CacheItemSet>(entityKey, cacheItem); // return true; //} } return(false); }
/// <summary> /// Check to be synchronized queue of redis /// </summary> /// <param name="state"></param> private static void OnCheckRedisSyncQueue(object state) { int identity = (int)state; if (Interlocked.CompareExchange(ref _isRedisSyncWorking[identity], 1, 0) == 0) { try { string queueKey = GetRedisSyncQueueKey(identity); string workingKey = queueKey + "_temp"; byte[][] keys = new byte[0][]; byte[][] values = new byte[0][]; RedisConnectionPool.ProcessReadOnly(client => { bool hasWorkingQueue = client.HLen(workingKey) > 0; bool hasNewWorkingQueue = client.HLen(queueKey) > 0; if (!hasWorkingQueue && !hasNewWorkingQueue) { return; } if (!hasWorkingQueue) { try { client.Rename(queueKey, workingKey); } catch { } } var keyValuePairs = client.HGetAll(workingKey); if (keyValuePairs != null && keyValuePairs.Length > 0) { keys = keyValuePairs.Where((buffs, index) => index % 2 == 0).ToArray(); values = keyValuePairs.Where((buffs, index) => index % 2 == 1).ToArray(); client.Remove(workingKey); } }); if (keys != null && keys.Length > 0) { _threadPools.QueueWorkItem(DoProcessRedisSyncQueue, workingKey, keys, values); } } catch (Exception ex) { TraceLog.WriteError("OnCheckRedisSyncQueue error:{0}", ex); } finally { Interlocked.Exchange(ref _isRedisSyncWorking[identity], 0); } } }
public RedisClient(String host, int port = 6379, String password = null, Int32?db = null) { Host = host; Port = port; Password = password; Db = db; _connection = RedisConnectionPool.GetConnection(host, port, password); _connection.Connect(); _selectDb(); }
/// <summary> /// Check queue is completed. /// </summary> /// <param name="keyIndex"></param> /// <returns></returns> public static bool CheckCompleted(int keyIndex = 0) { bool result = false; RedisConnectionPool.ProcessReadOnly(client => { result = client.SearchKeys(DataSyncQueueManager.RedisSyncQueueKey + "*").Count == 0; }); return(result); }
public RedisClient(RedisHostInfo hostInfo) { this.Host = hostInfo.Host; this.Port = hostInfo.Port; this.Password = hostInfo.Password; this.Db = hostInfo.Db; _connection = RedisConnectionPool.GetConnection(this.Host, this.Port, this.Password); _connection.Connect(); _selectDb(); }