public IActionResult Index(string vote) { string EndPoint = configuration.GetSection("REDIS").Value; var manager = new RedisManagerPool(EndPoint); string cats, dogs; ViewBag.value1 = 0; ViewBag.value2 = 0; if (vote.Equals("reset")) { using (var client = manager.GetClient()) { client.Set("Cats", 0); client.Set("Dogs", 0); } } else { using (var client = manager.GetClient()) { client.IncrementValue(vote); cats = client.Get <string>("Cats"); dogs = client.Get <string>("Dogs"); if (cats != null) { ViewBag.value1 = cats; } if (dogs != null) { ViewBag.value2 = dogs; } } } return(View()); }
public void Does_not_throw_when_using_different_clients_on_same_Thread() { RedisConfig.AssertAccessOnlyOnSameThread = true; InvalidAccessException poolEx = null; using (var redisManager = new RedisManagerPool(Config.MasterHost)) { using (var redis = redisManager.GetClient()) { var threadId = Thread.CurrentThread.ManagedThreadId.ToString(); var key = $"Thread#{threadId}"; redis.SetValue(key, threadId); ThreadPool.QueueUserWorkItem(_ => { try { using (var poolRedis = redisManager.GetClient()) { var poolThreadId = Thread.CurrentThread.ManagedThreadId.ToString(); var poolKey = $"Thread#{poolThreadId}"; poolRedis.SetValue(poolKey, poolThreadId); Console.WriteLine("From Pool: " + poolRedis.GetValue(poolKey)); } } catch (InvalidAccessException ex) { poolEx = ex; } }); Thread.Sleep(100); Console.WriteLine("From Test: " + redis.GetValue(key)); } } Console.WriteLine(poolEx); RedisConfig.AssertAccessOnlyOnSameThread = false; }
public void Set(string key, object value, TimeSpan expireIn) { using (var client = _redisManagerPool.GetClient()) { client.Set(key, value, expireIn); } }
public void Set(string key, object value) { using (var client = _redisManagerPool.GetClient()) { client.Set(key, value); } }
public static bool Save(string key, Object value) { using (var redisClient = redisManager.GetClient()) { return(redisClient.Set(key, StringHelper.SerializeObject(value))); } }
public void Can_Set_with_DateTime_in_Pipeline() { using (var clientManager = new RedisManagerPool(Config.MasterHost)) { // ReSharper disable once NotAccessedVariable bool result; const int value = 111; var key = $"key:{value}"; // Set key with pipeline (batching many requests) using (var redis = clientManager.GetClient()) { using (var pipeline = redis.CreatePipeline()) { // Only atomic operations can be called within a Transaction or Pipeline Assert.Throws <NotSupportedException>(() => pipeline.QueueCommand(r => r.Set(key, value, DateTime.Now.AddMinutes(1)), r => result = r)); } using (var pipeline = redis.CreatePipeline()) { pipeline.QueueCommand(r => r.Set(key, value), r => result = r); pipeline.QueueCommand(r => r.ExpireEntryAt(key, DateTime.Now.AddMinutes(1))); pipeline.Flush(); } } // Get key using (var redis = clientManager.GetClient()) { var res = redis.Get <int>(key); Assert.That(res, Is.EqualTo(value)); } } }
public async Task <T> GetAsync <T>(string key) { using (var redis = _redisManagerPool.GetClient()) { return(await Task.Run(() => { return redis.Get <T>(GetPrefixedKey(key)); })); } }
public void RedisManagerPool_alternates_hosts() { using (var redisManager = new RedisManagerPool(Config.MasterHosts)) { using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380)); master.SetValue("KEY", "1"); } using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380)); master.Increment("KEY", 1); } for (var i = 0; i < 5; i++) { using (var readOnly = redisManager.GetReadOnlyClient()) { Assert.That(readOnly.GetHostString(), Is.EqualTo(Config.Sentinel6380)); Assert.That(readOnly.GetValue("KEY"), Is.EqualTo("2")); } } using (var cache = redisManager.GetCacheClient()) { Assert.That(cache.Get <string>("KEY"), Is.EqualTo("2")); } } }
public string Get(string key) { using (var client = redisManagerPool.GetClient()) { return(client.Get <string>(key)); } }
public void RedisManagerPool_alternates_hosts() { using (var redisManager = new RedisManagerPool(MasterHosts)) { using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0])); master.SetValue("KEY", "1"); } using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0])); master.Increment("KEY", 1); } 5.Times(i => { using (var readOnly = redisManager.GetReadOnlyClient()) { Assert.That(readOnly.GetHostString(), Is.EqualTo(MasterHosts[0])); Assert.That(readOnly.GetValue("KEY"), Is.EqualTo("2")); } }); using (var cahce = redisManager.GetCacheClient()) { Assert.That(cahce.Get <string>("KEY"), Is.EqualTo("2")); } } }
public T LookupToken(string token) { using (var client = ClientPool.GetClient()) { return(client.Get <T>(token)); } }
public void Can_have_different_pool_size_and_host_configurations() { var writeHosts = new[] { "readwrite1" }; using (var manager = new RedisManagerPool( writeHosts, new RedisPoolConfig { MaxPoolSize = 4 }) { RedisClientFactory = mockFactory.Object, } ) { //A poolsize of 4 will not block getting 4 clients using (var client1 = manager.GetClient()) using (var client2 = manager.GetClient()) using (var client3 = manager.GetClient()) using (var client4 = manager.GetClient()) { AssertClientHasHost(client1, writeHosts[0]); AssertClientHasHost(client2, writeHosts[0]); AssertClientHasHost(client3, writeHosts[0]); AssertClientHasHost(client4, writeHosts[0]); } mockFactory.VerifyAll(); } }
public void Write(CacheEntity entity) { using (var client = _manager.GetClient()) { var redisValue = JsonConvert.SerializeObject(entity); //client.RemoveItemFromSortedSet() } }
public void Create(string domain, string connectionId) { using (IRedisClient client = _redisManagerPool.GetClient()) { DrapoConnection connection = new DrapoConnection(connectionId, domain); client.Set <DrapoConnection>(this.CreateConnectionKey(domain, connectionId), connection); } }
public IDictionary <string, double> GetTaskList(int startIndex, int count) { using (var redis = _pool.GetClient()) { redis.Password = _password; return(redis.GetRangeWithScoresFromSortedSetDesc(RedisScheduler.TaskList, startIndex, startIndex + count)); } }
public void SendMessage(string message) { using (var client = _manager.GetClient()) { client.Db = 0; client.PushItemToList("Stock", message); } }
/// <summary> /// FLUSHALL /// </summary> /// <param name="id"></param> /// <returns></returns> public int Excluir(string id) { using (var client = _pool.GetClient()) { var obj = client.Remove(key + id); return(1); } }
public void Add <T>(Guid id, T @object) { string serializedObject = JsonConvert.SerializeObject(@object); using (var client = _redisManagerPool.GetClient()) { client.Set(id.ToString(), @serializedObject); } }
public void Save(BankAccountSummary summary) { using (var client = _redisManagerPool.GetClient()) { var accountSummaryClient = client.As <BankAccountSummary>(); accountSummaryClient.Store(summary); } }
public Task <CarrinhoDeCompra> ObterCarrinho(string carrinhoId) { return(Task.Factory.StartNew(() => { using (var redisClient = _manager.GetClient()) { return redisClient.Get <CarrinhoDeCompra>(carrinhoId); } })); }
public string[] GetTemplates() { string[] result; using (var client = _manager.GetClient()) { var templates = client.GetAllItemsFromSet(TemplatesSetKey); result = new string[templates.Count]; templates.CopyTo(result); } return(result); }
public bool CheckStatus() { using (var _client = _redisManagerPool.GetClient()) { try { return(_client.Get <bool>("status")); } catch (System.Exception) { return(false); } } }
public void Write(CacheLocation entity) { using (var client = _manager.GetClient()) { client.Set(entity.Key, entity.Nick, DateTime.Now.AddSeconds(30)); client.AddGeoMember("Sicily", entity.Lng, entity.Lat, entity.Key); var sub = client.CreateSubscription(); sub.SubscribeToChannels(entity.Key); sub.OnMessage = (x, y) => { var s = x + y; }; } }
public FundRedisModel GetFundInfoById(FundAnswerModel fundAnswerModel) { using (var redisManager = _redisManagerPool.GetClient()) { redisManager.Db = (int)RedisDB.DB4; var fundRedis = redisManager.As <FundRedisModel>(); var fundRedisModel = fundRedis.GetById(fundAnswerModel.AnswerFundId); if (fundAnswerModel != null) { JudgeFundAnswer(fundAnswerModel); } return(fundRedisModel); } }
public UserInfoViewModel AddUserInfo(UserInfoModel userInfoModel) { lock (userObject) { var userInfoEntity = _mapper.Map <UserInfoEntity>(userInfoModel); var userInfo = _con.GetEntities <UserInfoEntity>().Where(p => p.Valid == 1 && p.TelPhone == userInfoModel.TelPhone).QueryFirst <UserInfoEntity>(); //判断电话号码是否被注册 if (userInfo != null) { throw new CNException("电话号码已被注册"); } UserInfoEntity entity = null; //将用户数据存到数据库中 using (var transa = _con.BeginTransaction()) { try { int codeName = (int)CodeName.用户编码; string userCode = _generateCode.GetCode(codeName, transa); userInfoEntity.UserCode = userCode; entity = _con.AddRecord(userInfoEntity, transa); UserPsdEntity userPsdEntity = new UserPsdEntity { PassWord = userInfoModel.PassWord, UserId = entity.Id }; _con.AddRecord(userPsdEntity, transa); transa.Commit(); } catch (Exception e) { transa.Rollback(); throw e; } } //将用户的信息、产生的Token存到Redis中 using (var redisManager = _redisManagerPool.GetClient()) { redisManager.Db = (int)RedisDB.DB0; var currentUser = _mapper.Map <CurrentUser>(entity); currentUser.Token = Convert.ToBase64String(System.Text.Encoding.Default.GetBytes(Guid.NewGuid().ToString())); //存取用户编码(key:token value:用户编码) redisManager.Set <string>(currentUser.Token, currentUser.UserCode, DateTime.Now.AddMinutes(15)); //存取用户信息(key:用户编码 value:用户信息) redisManager.Set <CurrentUser>(currentUser.UserCode, currentUser, DateTime.Now.AddMinutes(15)); return(_mapper.Map <UserInfoViewModel>(currentUser)); } } }
public void RedisManagerPool_can_execute_CustomResolver() { var resolver = new FixedResolver(MasterHosts[0].ToRedisEndpoint(), SlaveHosts[0].ToRedisEndpoint()); using (var redisManager = new RedisManagerPool("127.0.0.1:8888") { RedisResolver = resolver }) { using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0])); master.SetValue("KEY", "1"); } using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0])); master.Increment("KEY", 1); } Assert.That(resolver.NewClientsInitialized, Is.EqualTo(1)); 5.Times(i => { using (var slave = redisManager.GetReadOnlyClient()) { Assert.That(slave.GetHostString(), Is.EqualTo(MasterHosts[0])); Assert.That(slave.GetValue("KEY"), Is.EqualTo("2")); } }); Assert.That(resolver.NewClientsInitialized, Is.EqualTo(1)); redisManager.FailoverTo("127.0.0.1:9999", "127.0.0.1:9999"); 5.Times(i => { using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0])); Assert.That(master.GetValue("KEY"), Is.EqualTo("2")); } using (var slave = redisManager.GetReadOnlyClient()) { Assert.That(slave.GetHostString(), Is.EqualTo(MasterHosts[0])); Assert.That(slave.GetValue("KEY"), Is.EqualTo("2")); } }); Assert.That(resolver.NewClientsInitialized, Is.EqualTo(2)); } }
public void RedisManagerPool_can_execute_CustomResolver() { var resolver = new FixedResolver(RedisEndpoint.Create(Config.Sentinel6380), RedisEndpoint.Create(Config.Sentinel6381)); using (var redisManager = new RedisManagerPool("127.0.0.1:8888") { RedisResolver = resolver }) { using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380)); master.SetValue("KEY", "1"); } using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380)); master.Increment("KEY", 1); } Assert.That(resolver.NewClientsInitialized, Is.EqualTo(1)); for (var i = 0; i < 5; i++) { using (var slave = redisManager.GetReadOnlyClient()) { Assert.That(slave.GetHostString(), Is.EqualTo(Config.Sentinel6380)); Assert.That(slave.GetValue("KEY"), Is.EqualTo("2")); } } Assert.That(resolver.NewClientsInitialized, Is.EqualTo(1)); redisManager.FailoverTo("127.0.0.1:9999", "127.0.0.1:9999"); for (var i = 0; i < 5; i++) { using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380)); Assert.That(master.GetValue("KEY"), Is.EqualTo("2")); } using (var slave = redisManager.GetReadOnlyClient()) { Assert.That(slave.GetHostString(), Is.EqualTo(Config.Sentinel6380)); Assert.That(slave.GetValue("KEY"), Is.EqualTo("2")); } } Assert.That(resolver.NewClientsInitialized, Is.EqualTo(2)); } }
public void Does_throw_when_using_same_client_on_different_threads() { RedisConfig.AssertAccessOnlyOnSameThread = true; InvalidAccessException poolEx = null; var redisManager = new RedisManagerPool(); using (var redis = redisManager.GetClient()) { var threadId = Thread.CurrentThread.ManagedThreadId.ToString(); var key = $"Thread#{threadId}"; redis.SetValue(key, threadId); ThreadPool.QueueUserWorkItem(_ => { using (var poolRedis = redisManager.GetClient()) { var poolThreadId = Thread.CurrentThread.ManagedThreadId.ToString(); var poolKey = $"Thread#{poolThreadId}"; poolRedis.SetValue(poolKey, poolThreadId); Console.WriteLine("From Pool: " + poolRedis.GetValue(poolKey)); try { Console.WriteLine("From Pool (using TEST): " + redis.GetValue(poolKey)); } catch (InvalidAccessException ex) { poolEx = ex; } } }); Thread.Sleep(100); Console.WriteLine("From Test: " + redis.GetValue(key)); if (poolEx == null) { throw new Exception("Should throw InvalidAccessException"); } Console.WriteLine("InvalidAccessException: " + poolEx.Message); } RedisConfig.AssertAccessOnlyOnSameThread = false; }
public int Get(string option) { using (var client = _redisManagerPool.GetClient()) { return(client.Get <int>(option)); } }
public async Task Invoke(HttpContext context) { if (context.GetEndpoint() == null) { await _next(context); } else { var isAllow = context.GetEndpoint().Metadata?.GetMetadata <AllowAnonymousAttribute>(); if (isAllow == null) { using (var redisClient = _redisManagerPool.GetClient()) { redisClient.Db = (int)RedisDB.DB0; AuthenticationHeaderValue.TryParse(context.Request.Headers["Authorization"].ToString(), out AuthenticationHeaderValue headerValue); var token = headerValue?.Parameter; if (String.IsNullOrWhiteSpace(token)) { context.Response.StatusCode = 401; throw new CNException("token信息错误"); } var userCode = redisClient.Get <string>(token); if (userCode == null) { context.Response.StatusCode = 401; throw new CNException("token信息错误"); } } } } await _next(context); }
private static RedisPubSubServer CreatePubSubServer( int intervalSecs = 1, int timeoutSecs = 3) { var clientsManager = new RedisManagerPool(TestConfig.MasterHosts); using (var redis = clientsManager.GetClient()) redis.FlushAll(); var pubSub = new RedisPubSubServer( clientsManager, "topic:test") { HeartbeatInterval = TimeSpan.FromSeconds(intervalSecs), HeartbeatTimeout = TimeSpan.FromSeconds(timeoutSecs) }; return pubSub; }
public void Can_change_db_for_client() { using (var db1 = new RedisManagerPool(TestConfig.SingleHost + "?db=1")) using (var db2 = new RedisManagerPool(TestConfig.SingleHost + "?db=2")) { var val = Environment.TickCount; var key = "test" + val; var db1c = db1.GetClient(); var db2c = db2.GetClient(); try { db1c.Set(key, val); Assert.That(db2c.Get<int>(key), Is.EqualTo(0)); Assert.That(db1c.Get<int>(key), Is.EqualTo(val)); } finally { db1c.Remove(key); } } }
public void RedisManagerPool_alternates_hosts() { using (var redisManager = new RedisManagerPool(MasterHosts)) { using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0])); master.SetValue("KEY", "1"); } using (var master = redisManager.GetClient()) { Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0])); master.Increment("KEY", 1); } 5.Times(i => { using (var readOnly = redisManager.GetReadOnlyClient()) { Assert.That(readOnly.GetHostString(), Is.EqualTo(MasterHosts[0])); Assert.That(readOnly.GetValue("KEY"), Is.EqualTo("2")); } }); using (var cahce = redisManager.GetCacheClient()) { Assert.That(cahce.Get<string>("KEY"), Is.EqualTo("2")); } } }
public void Does_not_block_ReadWrite_clients_pool() { using (var manager = new RedisManagerPool( hosts, new RedisPoolConfig { MaxPoolSize = 4 }) { RedisClientFactory = mockFactory.Object, } ) { var delay = TimeSpan.FromSeconds(1); var client1 = manager.GetClient(); var client2 = manager.GetClient(); var client3 = manager.GetClient(); var client4 = manager.GetClient(); Assert.That(((RedisClient)client1).IsManagedClient, Is.True); Assert.That(((RedisClient)client2).IsManagedClient, Is.True); Assert.That(((RedisClient)client3).IsManagedClient, Is.True); Assert.That(((RedisClient)client4).IsManagedClient, Is.True); Action func = delegate { Thread.Sleep(delay + TimeSpan.FromSeconds(0.5)); client4.Dispose(); }; func.BeginInvoke(null, null); var start = DateTime.Now; var client5 = manager.GetClient(); Assert.That(((RedisClient)client5).IsManagedClient, Is.False); //outside of pool Assert.That(DateTime.Now - start, Is.LessThan(delay)); AssertClientHasHost(client1, hosts[0]); AssertClientHasHost(client2, hosts[1]); AssertClientHasHost(client3, hosts[2]); AssertClientHasHost(client4, hosts[3]); AssertClientHasHost(client5, hosts[0]); mockFactory.VerifyAll(); } }