public override void Init(IConfiguration configuration)
{
if (RedisManagerPool == null)
{
RedisManagerPool = new RedisManagerPool(configuration.GetConnectionString("RedisConnection"));
}
}
public void Execute()
{
LogManager.LogFactory = new ConsoleLogFactory();
Licensing.RegisterLicense("<removed>");
var redisManagerPool = new RedisManagerPool("redis://redisHost?db=7");
for (int i = 0; i < 5; i++)
{
try
{
using (IRedisClient client = redisManagerPool.GetClient())
{
string value = client.GetValue("status");
Console.WriteLine($"Successfully retrieved value => '{value}'");
}
}
catch (Exception ex)
{
Console.WriteLine($"Exception handled \n{ex}");
}
Console.WriteLine("Sleeping for 25 seconds to allow client to be garbage collected");
Thread.Sleep(TimeSpan.FromSeconds(25));
}
}
public void Execute(string ipAddress, int noOfThreads = 64)
{
redisManager = new RedisManagerPool(new[] { ipAddress }, new RedisPoolConfig {
MaxPoolSize = noOfThreads
});
var StartedAt = DateTime.UtcNow;
Interlocked.Increment(ref running);
"Starting HashStressTest with {0} threads".Print(noOfThreads);
var threads = new List <Thread>();
for (int i = 0; i < noOfThreads; i++)
{
threads.Add(new Thread(WorkerLoop));
}
threads.ForEach(t => t.Start());
"Press Enter to Stop...".Print();
Console.ReadLine();
Interlocked.Decrement(ref running);
"Writes: {0}, Reads: {1}".Print(writeCount, readCount);
"{0} EndedAt: {1}".Print(GetType().Name, DateTime.UtcNow.ToLongTimeString());
"{0} TimeTaken: {1}s".Print(GetType().Name, (DateTime.UtcNow - StartedAt).TotalSeconds);
//Uncomment to wait for all threads to finish
//threads.Each(t => t.Join());
"\nPress Enter to Quit...".Print();
Console.ReadLine();
}
public IActionResult Index()
{
try
{
var ip = Environment.GetEnvironmentVariable("redisip");
_logger.LogCritical("ip = " + ip);
var manager = new RedisManagerPool($"{ip}:6379");
_logger.LogCritical("After RedisManagerPool");
using (var client = manager.GetClient())
{
_logger.LogCritical("After GetClient");
client.Set("foo", "bar");
ViewData["cachedvalue"] = client.Get <string>("foo");
_logger.LogCritical("foo={0}", client.Get <string>("foo"));
_logger.LogCritical("Set/Get Succeeded");
}
}
catch (Exception ex)
{
_logger.LogCritical($"Exception: {ex.Message + Environment.NewLine + ex.StackTrace}");
}
return(View());
}
private void RedisUpload(string blobName, string localFile)
{
var redisClient = new RedisManagerPool(_config["RedisStorage:ConnectionString"])
.GetClient();
redisClient.Set(blobName, System.IO.File.ReadAllBytes(localFile));
}
private IRedisClient GetRedisClient()
{
var conString = _config.GetValue <String>("Redis:ConnectionString");
var manager = new RedisManagerPool(conString);
return(manager.GetClient());
}
public static void StartDemo()
{
var redisManger = new RedisManagerPool("127.0.0.1:6379"); //Redis的连接字符串
var redis = redisManger.GetClient(); //获取一个Redis Client
var redisTodos = redis.As <Todo>();
var newTodo = new Todo //实例化一个Todo类
{
Id = redisTodos.GetNextSequence(),
Content = "Learn Redis",
Order = 1,
};
redisTodos.Store(newTodo); //把newTodo实例保存到数据库中 增
Todo saveTodo = redisTodos.GetById(newTodo.Id); //根据Id查询 查
"Saved Todo: {0}".Print(saveTodo.Dump());
saveTodo.Done = true; //改
redisTodos.Store(saveTodo);
var updateTodo = redisTodos.GetById(newTodo.Id); //查
"Updated Todo: {0}".Print(updateTodo.Dump());
redisTodos.DeleteById(newTodo.Id); //删除
var remainingTodos = redisTodos.GetAll();
"No more Todos:".Print(remainingTodos.Dump());
Console.ReadLine();
}
public void ConfigureServices(IServiceCollection services)
{
var redisEndpointUrl = (Environment.GetEnvironmentVariable("REDIS_ENDPOINT_URL") ?? "127.0.0.1:6379").Split(':');
var redisHost = redisEndpointUrl[0];
var redisPort = redisEndpointUrl[1];
string redisConnectionUrl = string.Empty;
var redisPassword = Environment.GetEnvironmentVariable("REDIS_PASSWORD");
if (redisPassword != null)
{
redisConnectionUrl = $"{redisPassword}@{redisHost}:{redisPort}";
}
else
{
redisConnectionUrl = $"{redisHost}:{redisPort}";
}
var redisManager = new RedisManagerPool(redisConnectionUrl);
var redis = redisManager.GetClient();
services.AddSingleton(redis);
Assembly.Load("BasicRedisLeaderboardDemoDotNetCore.BLL");
ServiceAutoConfig.Configure(services);
services.AddControllers();
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/dist";
});
}
private static IRedisClient GetRedisClient()
{
string redisIp = Dns.GetHostAddressesAsync("docker_redis_1").Result.FirstOrDefault().ToString();
var manager = new RedisManagerPool(redisIp);
return(manager.GetClient());
}
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 IRedisClient Create(RedisSettings settings)
{
RedisManagerPool client = null;
Lock.EnterUpgradeableReadLock();
try
{
if (Cache.TryGetValue(settings.Signature, out client) == false)
{
Lock.EnterWriteLock();
try
{
if (Cache.TryGetValue(settings.Signature, out client) == false)
{
client = new RedisManagerPool(settings.Hosts.ToArray());
Cache[settings.Signature] = client;
}
}
finally
{
Lock.ExitWriteLock();
}
}
}
finally
{
Lock.ExitUpgradeableReadLock();
}
return(client.GetClient());
}
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 T Get <T>(string key)
{
var redisUrl = _configuration["RedisUrl"];
using (var client = new RedisManagerPool(redisUrl).GetClient())
return(client.Get <T>(key));
}
public static void Start()
{
var redisMangement = new RedisManagerPool("127.0.0.1:6379");
var client = redisMangement.GetClient();
//队列的使用 //先进先出
client.EnqueueItemOnList("name", "zhangsan"); //入列
client.EnqueueItemOnList("name", "lisi"); //入列
long count = client.GetListCount("name");
for (int i = 0; i < count; i++)
{
Console.WriteLine(client.DequeueItemFromList("name")); //出列
}
//栈的使用 //先进后出
client.PushItemToList("name2", "wangwu"); //推入
client.PushItemToList("name2", "maliu"); //推入
long count2 = client.GetListCount("name2");
for (int i = 0; i < count2; i++)
{
Console.WriteLine(client.PopItemFromList("name2")); //弹出
}
}
public void Remove(string key)
{
var redisUrl = _configuration["RedisUrl"];
using (var client = new RedisManagerPool(redisUrl).GetClient())
client.Remove(key);
}
public void Set(string key, object result)
{
var redisUrl = _configuration["RedisUrl"];
using (var client = new RedisManagerPool(redisUrl).GetClient())
client.Set(key, result, System.DateTime.Now.AddMinutes(int.Parse(_configuration["TokenExpireMin"])));
}
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 IActionResult Index()
{
string EndPoint = configuration.GetSection("REDIS").Value;
var manager = new RedisManagerPool(EndPoint);
ViewBag.value1 = 0;
ViewBag.value2 = 0;
string cats, dogs;
using (var client = manager.GetClient())
{
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 static void Main(string[] args)
{
DoRedisString drs = new DoRedisString();
drs.Append("nick", " is bad guy");
string nick = drs.Get("nick");
Console.WriteLine(nick);
var redisManager = new RedisManagerPool("localhost:6379");
using (var client = redisManager.GetClient())
{
var redisTodos = client.As <Todo>();
var newTodo = new Todo
{
Id = redisTodos.GetNextSequence(),
Content = "Learn Redis",
Order = 1,
};
redisTodos.Store(newTodo);
Todo savedTodo = redisTodos.GetById(newTodo.Id);
"Saved Todo: {0}".Print(savedTodo.Dump());
savedTodo.Done = true;
redisTodos.Store(savedTodo);
var updatedTodo = redisTodos.GetById(newTodo.Id);
"Updated Todo: {0}".Print(updatedTodo.Dump());
redisTodos.DeleteById(newTodo.Id);
var remainingTodos = redisTodos.GetAll();
"No more Todos:".Print(remainingTodos.Dump());
}
}
public LocationsService()
{
var redisManager = new RedisManagerPool();
var redisClient = redisManager.GetClient();
redisLocations = redisClient.As <Location>();
}
public void Does_set_all_properties_on_Client_using_ClientsManagers()
{
var connStr =
"redis://*****:*****@host:1?ssl=true&db=0&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix.";
var expected = new RedisEndpoint {
Host = "host",
Port = 1,
Ssl = true,
Client = "nunit",
Password = "******",
Db = 0,
ConnectTimeout = 2,
SendTimeout = 3,
ReceiveTimeout = 4,
IdleTimeoutSecs = 5,
NamespacePrefix = "prefix."
};
using (var pooledManager = new RedisManagerPool(connStr)) {
AssertClientManager(pooledManager, expected);
}
using (var pooledManager = new PooledRedisClientManager(connStr)) {
AssertClientManager(pooledManager, expected);
}
using (var basicManager = new BasicRedisClientManager(connStr)) {
AssertClientManager(basicManager, expected);
}
}
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 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 Execute()
{
const int noOfThreads = 64;
this.RedisManager = new RedisManagerPool(Config.MasterHost, new RedisPoolConfig {
MaxPoolSize = noOfThreads
});
var startedAt = DateTime.UtcNow;
Interlocked.Increment(ref this._running);
Console.WriteLine("Starting HashStressTest with {0} threads", noOfThreads);
var threads = new List <Thread>();
for (var i = 0; i < noOfThreads; i++)
{
threads.Add(new Thread(this.WorkerLoop));
}
threads.ForEach(t => t.Start());
Interlocked.Decrement(ref this._running);
Console.WriteLine("Writes: {0}, Reads: {1}", this._writeCount, this._readCount);
Console.WriteLine("{0} EndedAt: {1}", this.GetType().Name, DateTime.UtcNow.ToLongTimeString());
Console.WriteLine("{0} TimeTaken: {1}s", this.GetType().Name, (DateTime.UtcNow - startedAt).TotalSeconds);
threads.ForEach(t => t.Join());
}
public void UpdateLike()
{
var clientsManager = new RedisManagerPool(RedisIP + ":" + RedisPort);
var redisPubSub = new RedisPubSubServer(clientsManager, "recordlike")
{
OnMessage = (channel, message) => {
string[] strs = message.Split('|');
string userid = strs[1];
string recordid = strs[0].TrimStart('r');
var like = _db.RecordLikes.FirstOrDefault(t => t.CommentUserId == userid && t.RecordId == recordid);
if (like == null)
{
like = new RecordLike();
like.CommentUserId = userid;
like.RecordId = recordid;
like.CreateTime = DateTime.Now;
like.IsCancel = false;
_db.RecordLikes.Add(like);
}
else if (Convert.ToBoolean(strs[2]))
{
like.IsCancel = false;
}
else
{
like.IsCancel = true;
}
_db.SaveChanges();
}
}.Start();
}
private void ConfigureRedis(IServiceCollection services)
{
var redisConnection = Configuration.GetConnectionString("RedisConnection");
var manager = new RedisManagerPool(redisConnection);
services.AddSingleton <IRedisClientsManager>(manager);
}
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));
}
}
}
static void Main(string[] args)
{
var redisManager = new RedisManagerPool("localhost:6379");
using (var redis = redisManager.GetCacheClient())
{
try
{
var json = "{\"acct_id\":1016,\"user_id\":\"17\",\"email_address\":\"[email protected]\",\"api_key\":\"asfasfasfasd\",\"subscription\":{\"subscription_id\":1,\"urls_per_month\":1000,\"max_retention_days\":15,\"cost_per_month_usd\":5.00},\"created_date\":\"2019-04-06T19:19:59.4200190Z\",\"start_current_month\":\"2019-04-06T19:19:59.4200900Z\",\"stripe_subscription\":{\"id\":\"safasdsda\",\"object\":\"subscription\",\"billing\":\"charge_automatically\",\"billingCycleAnchor\":\"2019-04-06T19:19:55.0000000Z\",\"cancelAtPeriodEnd\":false,\"created\":\"2019-04-06T19:19:55.0000000Z\",\"currentPeriodEnd\":\"2019-04-13T19:19:55.0000000Z\",\"currentPeriodStart\":\"2019-04-06T19:19:55.0000000Z\",\"items\":[{\"id\":\"sadf\",\"object\":\"subscription_item\",\"created\":\"2019-04-06T19:19:56.0000000Z\",\"metadata\":{},\"plan\":{\"id\":\"plan_EpYQHnD2Ksn25r\",\"object\":\"plan\",\"active\":true,\"aggregateUsage\":\"sum\",\"amount\":1,\"billingScheme\":\"per_unit\",\"created\":\"2019-04-05T14:46:52.0000000Z\",\"currency\":\"usd\",\"interval\":\"week\",\"intervalCount\":1,\"livemode\":false,\"metadata\":{},\"nickname\":\"per url\",\"usageType\":\"metered\"},\"quantity\":0,\"subscription\":\"sub_Eq03qDgdXjV8zu\"}],\"livemode\":false,\"metadata\":{},\"plan\":{\"id\":\"asdfsad\",\"object\":\"plan\",\"active\":true,\"aggregateUsage\":\"sum\",\"amount\":1,\"billingScheme\":\"per_unit\",\"created\":\"2019-04-05T14:46:52.0000000Z\",\"currency\":\"usd\",\"interval\":\"week\",\"intervalCount\":1,\"livemode\":false,\"metadata\":{},\"nickname\":\"per url\",\"usageType\":\"metered\"},\"quantity\":1,\"start\":\"2019-04-06T19:19:55.0000000Z\",\"status\":\"active\"},\"stripe_customer\":{\"id\":\"cus_Eq03mgKkLr5YHj\",\"object\":\"customer\",\"accountBalance\":0,\"created\":\"2019-04-06T19:19:54.0000000Z\",\"defaultSourceId\":\"card_1EMK3SKf8n8rpwYnBMEp5u4V\",\"delinquent\":false,\"email\":\"[email protected]\",\"invoicePrefix\":\"7927E6A6\",\"invoiceSettings\":{},\"livemode\":false,\"metadata\":{},\"sources\":[{\"__type\":\"Stripe.Card, Stripe.net\",\"id\":\"card_1EMK3SKf8n8rpwYnBMEp5u4V\",\"object\":\"card\",\"brand\":\"Visa\",\"country\":\"US\",\"defaultForCurrency\":false,\"expMonth\":4,\"expYear\":2020,\"fingerprint\":\"eSS4xyRaH5gdg55C\",\"funding\":\"credit\",\"last4\":\"4242\",\"metadata\":{}}],\"subscriptions\":[]}}";
var acct = ServiceStack.Text.JsonSerializer.DeserializeFromString <SubscriptionAccount>(json);
//items are null, try to put it back in and reserialize
acct.stripe_subscription.Items = new Stripe.StripeList <Stripe.SubscriptionItem>();
acct.stripe_subscription.Items.Data = new List <Stripe.SubscriptionItem>();
var json2 = acct.ToJson();
var acct2 = ServiceStack.Text.JsonSerializer.DeserializeFromString <SubscriptionAccount>(json2);
if (acct2.stripe_subscription.Items == null)
{
throw new Exception("Items null");
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
public void Register(IAppHost appHost)
{
var container = appHost.GetContainer();
var appSettings = appHost.AppSettings;
var connections = appSettings.Get <Dictionary <string, string> >("connectionStrings");
#if DEBUG
var sentinelHosts = new[] { connections.GetValueOrDefault("Sentinel0"), connections.GetValueOrDefault("Sentinel1"), connections.GetValueOrDefault("Sentinel2") };
var sentinel = new RedisSentinel(sentinelHosts, masterName: appSettings.GetString("redis.mastername"))
{
RedisManagerFactory = (master, slaves) => new RedisManagerPool(master, new RedisPoolConfig()
{
MaxPoolSize = 20
}),
HostFilter = host => "{0}?db=0".Fmt(host)
};
container.Register <IRedisClientsManager>(c => sentinel.Start());
#else
var redisManager = new RedisManagerPool(connections.GetValueOrDefault("Sentinel0"), new RedisPoolConfig()
{
MaxPoolSize = 20,
});
container.Register <IRedisClientsManager>(c => redisManager);
#endif
}
public void Execute()
{
RedisConfig.DefaultConnectTimeout = 1 * 1000;
RedisConfig.DefaultSendTimeout = 1 * 1000;
RedisConfig.DefaultReceiveTimeout = 1 * 1000;
RedisConfig.DefaultRetryTimeout = 10 * 1000;
RedisConfig.DefaultIdleTimeoutSecs = 240;
RedisConfig.BackOffMultiplier = 10;
RedisConfig.BufferPoolMaxSize = 500000;
RedisConfig.VerifyMasterConnections = true;
RedisConfig.HostLookupTimeoutMs = 1000;
RedisConfig.DeactivatedClientsExpiry = TimeSpan.FromSeconds(15);
RedisConfig.DisableVerboseLogging = false;
var redisManager = new RedisManagerPool(Config.MasterHost);
// how many test items to create
var items = 5;
// how long to try popping
var waitForSeconds = 5;
// name of list
var listId = "testlist";
var startedAt = DateTime.Now;
Console.WriteLine("--------------------------");
Console.WriteLine("push {0} items to a list, then try pop for {1} seconds. repeat.", items, waitForSeconds);
Console.WriteLine("--------------------------");
using (var redis = redisManager.GetClient()) {
do
{
// add items to list
for (var i = 1; i <= items; i++)
{
redis.PushItemToList(listId, string.Format("item {0}", i));
}
do
{
var item = redis.BlockingPopItemFromList(listId, null);
// log the popped item. if BRPOP timeout is null and list empty, I do not expect to print anything
Console.WriteLine("{0}", string.IsNullOrEmpty(item) ? " list empty " : item);
Thread.Sleep(1000);
} while (DateTime.Now - startedAt < TimeSpan.FromSeconds(waitForSeconds));
Console.WriteLine("--------------------------");
Console.WriteLine("completed first loop");
Console.WriteLine("--------------------------");
} while (DateTime.Now - startedAt < TimeSpan.FromSeconds(2 * waitForSeconds));
Console.WriteLine("--------------------------");
Console.WriteLine("completed outer loop");
}
}
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 Does_set_all_properties_on_Client_using_ClientsManagers()
{
var connStr = "redis://*****:*****@host:1?ssl=true&db=0&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix.";
var expected = "{Host:host,Port:1,Ssl:True,Client:nunit,Password:pass,Db:0,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,IdleTimeOutSecs:5,NamespacePrefix:prefix.}"
.FromJsv<RedisEndpoint>();
using (var pooledManager = new RedisManagerPool(connStr))
{
AssertClientManager(pooledManager, expected);
}
using (var pooledManager = new PooledRedisClientManager(connStr))
{
AssertClientManager(pooledManager, expected);
}
using (var basicManager = new BasicRedisClientManager(connStr))
{
AssertClientManager(basicManager, expected);
}
}
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 Can_increment_and_reset_values()
{
using (var client = new RedisManagerPool(TestConfig.SingleHost).GetCacheClient())
{
Assert.That(client.Increment("incr:counter", 10), Is.EqualTo(10));
client.Set("incr:counter", 0);
Assert.That(client.Increment("incr:counter", 10), Is.EqualTo(10));
}
}
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 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();
}
}
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 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"));
}
}
}
