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_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_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 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 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();
}
}