public void RedisResolver_does_reset_when_detects_invalid_master()
{
var invalidMaster = new[] { SlaveHosts[0] };
var invalidSlaves = new[] { MasterHosts[0], SlaveHosts[1] };
using (var redisManager = new PooledRedisClientManager(invalidMaster, invalidSlaves))
{
var resolver = (RedisResolver)redisManager.RedisResolver;
using (var master = redisManager.GetClient())
{
master.SetValue("KEY", "1");
Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0]));
}
using (var master = redisManager.GetClient())
{
master.Increment("KEY", 1);
Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0]));
}
"Masters:".Print();
resolver.Masters.PrintDump();
"Slaves:".Print();
resolver.Slaves.PrintDump();
}
}
public void PooledRedisClientManager_alternates_hosts()
{
using (var redisManager = new PooledRedisClientManager(MasterHosts, SlaveHosts))
{
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(SlaveHosts[i % SlaveHosts.Length]));
Assert.That(readOnly.GetValue("KEY"), Is.EqualTo("2"));
}
});
using (var cahce = redisManager.GetCacheClient())
{
Assert.That(cahce.Get<string>("KEY"), Is.EqualTo("2"));
}
}
}
public void Crud_TODO_App()
{
//Thread-safe client factory
var redisManager = new PooledRedisClientManager(TestConfig.SingleHostConnectionString);
redisManager.ExecAs<Todo>(redisTodos =>
{
var todo = new Todo
{
Id = redisTodos.GetNextSequence(),
Content = "Learn Redis",
Order = 1,
};
redisTodos.Store(todo);
Todo savedTodo = redisTodos.GetById(todo.Id);
savedTodo.Done = true;
redisTodos.Store(savedTodo);
redisTodos.DeleteById(savedTodo.Id);
var allTodos = redisTodos.GetAll();
Assert.That(allTodos.Count, Is.EqualTo(0));
});
}
public void Can_support_64_threads_using_the_client_simultaneously()
{
var before = Stopwatch.GetTimestamp();
const int noOfConcurrentClients = 64; //WaitHandle.WaitAll limit is <= 64
var clientAsyncResults = new List<IAsyncResult>();
using (var manager = new PooledRedisClientManager(TestConfig.MasterHosts, TestConfig.SlaveHosts))
{
manager.GetClient().Run(x => x.FlushAll());
for (var i = 0; i < noOfConcurrentClients; i++)
{
var clientNo = i;
var action = (Action)(() => UseClientAsync(manager, clientNo));
clientAsyncResults.Add(action.BeginInvoke(null, null));
}
}
WaitHandle.WaitAll(clientAsyncResults.ConvertAll(x => x.AsyncWaitHandle).ToArray());
Debug.WriteLine(string.Format("Completed in {0} ticks", (Stopwatch.GetTimestamp() - before)));
RedisStats.ToDictionary().PrintDump();
}
public void Issue37_Cannot_add_unknown_client_back_to_pool_exception()
{
pool = new PooledRedisClientManager();
try
{
var threads = new Thread[100];
for (var i = 0; i < threads.Length; i++)
{
threads[i] = new Thread(Stuff);
threads[i].Start();
}
Debug.WriteLine("running, waiting 10secs..");
Thread.Sleep(10000);
using (var redisClient = (RedisClient)pool.GetClient())
{
Debug.WriteLine("shutdown Redis!");
redisClient.Shutdown();
}
}
catch (NotSupportedException nse)
{
Assert.Fail(nse.Message);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
Thread.Sleep(5000);
}
public void Can_Add_Update_and_Delete_Todo_item()
{
using (var redisManager = new PooledRedisClientManager())
using (var redis = redisManager.GetClient())
{
var redisTodos = redis.As<Todo>();
var todo = new Todo
{
Id = redisTodos.GetNextSequence(),
Content = "Learn Redis",
Order = 1,
};
redisTodos.Store(todo);
Todo savedTodo = redisTodos.GetById(todo.Id);
savedTodo.Done = true;
redisTodos.Store(savedTodo);
"Updated Todo:".Print();
redisTodos.GetAll().ToList().PrintDump();
redisTodos.DeleteById(savedTodo.Id);
"No more Todos:".Print();
redisTodos.GetAll().ToList().PrintDump();
}
}
public void Can_have_different_pool_size_and_host_configurations()
{
var writeHosts = new[] { "readwrite1" };
var readHosts = new[] { "read1", "read2" };
const int poolSizeMultiplier = 4;
using (var manager = new PooledRedisClientManager(writeHosts,
readHosts,
new RedisClientManagerConfig {
MaxWritePoolSize = writeHosts.Length * poolSizeMultiplier,
MaxReadPoolSize = readHosts.Length * poolSizeMultiplier,
AutoStart = true
}
)
) {
// A pool size 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]);
}
}
}
}
// A pool size of 8 will not block getting 8 clients
using (var client1 = manager.GetReadOnlyClient()) {
using (var client2 = manager.GetReadOnlyClient()) {
using (var client3 = manager.GetReadOnlyClient()) {
using (var client4 = manager.GetReadOnlyClient()) {
using (var client5 = manager.GetReadOnlyClient()) {
using (var client6 = manager.GetReadOnlyClient()) {
using (var client7 = manager.GetReadOnlyClient()) {
using (var client8 = manager.GetReadOnlyClient()) {
AssertClientHasHost(client1, readHosts[0]);
AssertClientHasHost(client2, readHosts[1]);
AssertClientHasHost(client3, readHosts[0]);
AssertClientHasHost(client4, readHosts[1]);
AssertClientHasHost(client5, readHosts[0]);
AssertClientHasHost(client6, readHosts[1]);
AssertClientHasHost(client7, readHosts[0]);
AssertClientHasHost(client8, readHosts[1]);
}
}
}
}
}
}
}
}
}
}
public void Can_recover_from_server_terminated_client_connection()
{
const int SleepHoldingClientMs = 5;
const int SleepAfterReleasingClientMs = 0;
const int loop = 1000;
var admin = new RedisClient("localhost");
admin.SetConfig("timeout", "0");
var timeout = admin.GetConfig("timeout");
timeout.Print("timeout: {0}");
int remaining = loop;
var stopwatch = Stopwatch.StartNew();
var clientManager = new PooledRedisClientManager(new[] { "localhost" })
{
};
loop.Times(i =>
{
ThreadPool.QueueUserWorkItem(x =>
{
try
{
using (var client = (RedisClient)clientManager.GetClient())
{
client.IncrementValue("key");
var val = client.Get <long>("key");
"#{0}, isConnected: {1}".Print(val, true); //client.IsSocketConnected()
Thread.Sleep(SleepHoldingClientMs);
}
Thread.Sleep(SleepAfterReleasingClientMs);
}
catch (Exception ex)
{
ex.Message.Print();
}
finally
{
remaining--;
}
});
});
while (remaining > 0)
{
Thread.Sleep(10);
}
"Elapsed time: {0}ms".Print(stopwatch.ElapsedMilliseconds);
var managerStats = clientManager.GetStats();
managerStats.PrintDump();
}
/// <summary>
/// 创建链接池管理对象
/// </summary>
private static void CreateManager()
{
if (String.IsNullOrEmpty(ConfigurationManager.AppSettings["RedisConnectionString"]))
{
throw new Exception("Redis connection string is empty");
}
RedisPath = ConfigurationManager.AppSettings["RedisConnectionString"];
Int32.TryParse(ConfigurationManager.AppSettings["RedisDBIndex"], out DBIndex);
_prcm = CreateManager(new string[] { RedisPath }, new string[] { RedisPath });
}
public IRedisClient GetRedisClient()
{
_prcm = new PooledRedisClientManager(this.ReadWriteHosts, this.ReadOnlyHosts, new RedisClientManagerConfig()
{
AutoStart = true,
MaxReadPoolSize = 5000,
MaxWritePoolSize = 5000
});
return(_prcm.GetClient());
}
public static bool Clear()
{
using (var redisManager = new PooledRedisClientManager())
using (var client = redisManager.GetClient())
{
var typedClient = client.As <CacheObject>();
typedClient.FlushAll();
}
return(true);
}
/// <summary>
/// 创建链接池管理对象
/// </summary>
private static void CreateManager()
{
_prcm = new PooledRedisClientManager(RedisWriteServers, RedisReadServers, new RedisClientManagerConfig
{
AutoStart = true,
MaxReadPoolSize = RedisPoolMaxRead,
MaxWritePoolSize = RedisPoolMaxWrite,
DefaultDb = DefaultDb,
});
}
/// <summary>
/// 创建redis连接池
/// </summary>
/// <returns></returns>
private static void CreateRedisPool()
{
// 支持读写分离，均衡负载
redisPoolManager = new PooledRedisClientManager(writeRedis, readOnlyRedis, new RedisClientManagerConfig
{
MaxWritePoolSize = 50, // “写”链接池链接数
MaxReadPoolSize = 50, // “读”链接池链接数
AutoStart = true,
});
}
public void Can_connect_to_redis_with_password_with_equals()
{
var connString = "127.0.0.1?password="******"p@55w0rd=".UrlEncode();
var redisManager = new PooledRedisClientManager(connString);
using (var redis = redisManager.GetClient())
{
Assert.That(redis.Password, Is.EqualTo("p@55w0rd="));
}
}
public void Does_set_Client_on_Pooled_Connection()
{
using (var redisManager = new PooledRedisClientManager("localhost?Client=nunit"))
using (var redis = redisManager.GetClient())
{
var clientName = redis.GetClient();
Assert.That(clientName, Is.EqualTo("nunit"));
}
}
public string GetCacheItem(string key)
{
using (var manager = new PooledRedisClientManager(_redisCacheConfiguration.RedisCacheServerAddress))
{
using (var client = manager.GetClient())
{
return(client.Get <string>(key));
}
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="OpenPooledRedis">是否开启缓冲池</param>
public RedisService(bool OpenPooledRedis = false)
{
if (OpenPooledRedis)
{
//prcm = CreateManager(new[] { "[email protected]:6379" }, new[] { "[email protected]:6379" });
prcm = CreateManager(new[] { "172.19.20.72:6379" }, new[] { "172.19.20.73:6379" });
Redis = prcm.GetClient() as ServiceStack.Redis.RedisClient;
}
}
public NotificationsHandlingHostedService(IConfiguration configuration, IHubContext <ChatHub> hub)
{
_configuration = configuration;
_hubContext = hub;
var masters = _configuration.GetSection("ConnectionStrings:Redis:Masters").Get <string[]>();
var slaves = _configuration.GetSection("ConnectionStrings:Redis:Slaves").Get <string[]>();
_clientManager = new PooledRedisClientManager(masters, slaves);
}
public DequeueManager(PooledRedisClientManager clientManager, RedisSequentialWorkQueue <T> workQueue, string workItemId, string dequeueLockKey, int numberOfDequeuedItems, int dequeueLockTimeout)
{
this.workQueue = workQueue;
this.workItemId = workItemId;
this.clientManager = clientManager;
this.numberOfDequeuedItems = numberOfDequeuedItems;
myLock = new DistributedLock();
this.dequeueLockKey = dequeueLockKey;
this.dequeueLockTimeout = dequeueLockTimeout;
}
/// <summary>
/// 创建链接池管理对象
/// </summary>
private static void CreateManager(ref long initialDb, ref string[] readWriteHosts)
{
_prcm = new PooledRedisClientManager(readWriteHosts, readWriteHosts, new RedisClientManagerConfig
{
MaxWritePoolSize = 20, //“写”链接池链接数
MaxReadPoolSize = 20, //“写”链接池链接数
DefaultDb = 0,
AutoStart = true
}, initialDb, null, null);
}
public void Can_connect_to_ssl_azure_redis_with_PooledClientsManager()
{
using (var redisManager = new PooledRedisClientManager(connectionString))
using (var client1 = redisManager.GetClient())
using (var client2 = redisManager.GetClient())
{
client1.Set("foo", "bar");
var foo = client2.GetValue("foo");
foo.Print();
}
}
private static void CreateManager()
{
string[] WriteServerConStr = SplitString(RedisConfig.WriteServerConStr, ",");
string[] ReadServerConStr = SplitString(RedisConfig.ReadServerConStr, ",");
prcm = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr, new RedisClientManagerConfig()
{
MaxWritePoolSize = RedisConfig.MaxWritePoolSize,
MaxReadPoolSize = RedisConfig.MaxReadPoolSize,
AutoStart = RedisConfig.AutoStart
});
}
public void Can_MqServer_recover_from_server_terminated_client_connections()
{
LogManager.LogFactory = new ConsoleLogFactory();
var clientManager = new PooledRedisClientManager(new[] { "localhost" }) { CheckConnected = true };
var mqHost = new RedisMqServer(clientManager, retryCount: 2);
var sum = 0;
mqHost.RegisterHandler<Incr>(c =>
{
var dto = c.GetBody();
sum += dto.Value;
"Received {0}, sum: {1}".Print(dto.Value, sum);
return null;
});
mqHost.Start();
10.Times(i =>
{
ThreadPool.QueueUserWorkItem(x => {
using (var client = mqHost.CreateMessageQueueClient())
{
"Publish: {0}...".Print(i);
client.Publish(new Incr { Value = i });
Thread.Sleep(10);
}
});
});
ThreadPool.QueueUserWorkItem(_ =>
{
using (var client = (RedisClient)clientManager.GetClient())
{
client.SetConfig("timeout", "1");
var clientAddrs = client.GetClientList().ConvertAll(x => x["addr"]);
"Killing clients: {0}...".Print(clientAddrs.Dump());
clientAddrs.ForEach(client.ClientKill);
}
});
20.Times(i =>
{
using (var client = mqHost.CreateMessageQueueClient())
{
"Publish: {0}...".Print(i);
client.Publish(new Incr { Value = i });
}
Thread.Sleep(2000);
});
}
public RedisClientService(string key, int maxReadPoolSize = 80, int maxWritePoolSize = 50)
{
string[] redisServerReadWrite = ConfigParam.RedisServerReadWrite.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
string[] redisServerRead = ConfigParam.RedisServerRead.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
Manager = new PooledRedisClientManager(redisServerReadWrite, redisServerRead,
new RedisClientManagerConfig()
{
MaxReadPoolSize = maxReadPoolSize, MaxWritePoolSize = maxWritePoolSize
});
}
// private static RedisClient redis;
//Redis缓冲池
// PooledRedisClientManager poolRedis = new PooledRedisClientManager();
/// <summary>
/// 创建Redis连接池管理对象
/// </summary>
/// <param name="readWriteUrl"></param>
/// <param name="readOnlyUrl"></param>
/// <returns></returns>
public static void CreateManager(string[] readWriteUrl, string[] readOnlyUrl)
{
prc_Manager = new PooledRedisClientManager(readWriteUrl, readOnlyUrl, new RedisClientManagerConfig
{
MaxReadPoolSize = redis_config.MaxReadPoolSize,
MaxWritePoolSize = redis_config.MaxWritePoolSize,
AutoStart = redis_config.AutoStart
});
prc_Manager.PoolTimeOut = 2;
//return manager;
}
public void Purge()
{
using var redisManager = new PooledRedisClientManager();
using var redis = redisManager.GetClient();
var redisStoredEvent = redis.As <StoredEvent>();
redisStoredEvent.SetSequence(0);
redisStoredEvent.DeleteAll();
}
public void Store(StoredEvent storedEvent)
{
using var redisManager = new PooledRedisClientManager();
using var redis = redisManager.GetClient();
var redisStoredEvent = redis.As <StoredEvent>();
storedEvent.Id = redisStoredEvent.GetNextSequence();
redisStoredEvent.Store(storedEvent);
}
/// <summary>
/// 创建连接对象
/// </summary>
private static void CreateManager()
{
string[] WriteServerConStr = _RedisConfigInfo.WriteServerList.Split(',');
string[] ReadServerConStr = _RedisConfigInfo.ReadServerList.Split(',');
prcManager = new PooledRedisClientManager(ReadServerConStr, WriteServerConStr, new RedisClientManagerConfig
{
MaxReadPoolSize = _RedisConfigInfo.MaxReadPoolSize,
MaxWritePoolSize = _RedisConfigInfo.MaxReadPoolSize,
AutoStart = _RedisConfigInfo.AutoStart
});
}
/// <summary>
/// 使用redis配置对象初始化连接池管理对象
/// </summary>
private static void CreateManager()
{
string[] readServerList = redisConfig.ReadServerList.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
string[] writeServerList = redisConfig.WriteServerList.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
redisClientManager = new PooledRedisClientManager(writeServerList, readServerList, new RedisClientManagerConfig
{
MaxReadPoolSize = redisConfig.MaxReadPoolSize,
MaxWritePoolSize = redisConfig.MaxWritePoolSize,
AutoStart = redisConfig.AutoStart
});
}
public static object GetItem(string key)
{
using (var redisManager = new PooledRedisClientManager())
using (var client = redisManager.GetClient())
{
var typedClient = client.As <CacheObject>();
var savedCacheObject = typedClient.GetValue(key);
return(savedCacheObject?.Content);
}
}
/// <summary>
/// 创建PooledRedisClientManager
/// </summary>
private void CreateManager()
{
string[] writeServerList = _redisConfig.WriteServerList.Split(',');
string[] readServerList = _redisConfig.ReadServerList.Split(',');
_prcm = new PooledRedisClientManager(readServerList, writeServerList, new RedisClientManagerConfig
{
MaxWritePoolSize = _redisConfig.MaxWritePoolSize,
MaxReadPoolSize = _redisConfig.MaxReadPoolSize,
AutoStart = _redisConfig.AutoStart,
});
}
/// <summary>
/// 创建连接池管理对象
/// </summary>
private static void CreateManager()
{
redisConfigInfo = RedisHelper.GetConfig();
string[] writeServerList = SplitString(redisConfigInfo.WriteServerList, ",");
string[] readServerList = SplitString(redisConfigInfo.ReadServerList, ",");
prcm = new PooledRedisClientManager(readServerList, writeServerList, new RedisClientManagerConfig {
AutoStart = redisConfigInfo.AutoStart,
MaxReadPoolSize = redisConfigInfo.MaxReadPoolSize,
MaxWritePoolSize = redisConfigInfo.MaxWritePoolSize,
});
}
/// <summary>
/// 创建PooledRedisClientManager
/// </summary>
private static void CreateManager()
{
string[] _writeServerList = redisConfigInfo.WriteServerList.Split(',');
string[] _readServerList = redisConfigInfo.ReadServerList.Split(',');
prcm = new PooledRedisClientManager(_readServerList, _writeServerList, new RedisClientManagerConfig
{
MaxWritePoolSize = redisConfigInfo.MaxWritePoolSize,
MaxReadPoolSize = redisConfigInfo.MaxReadPoolSize,
AutoStart = redisConfigInfo.AutoStart,
});
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="openPooledRedis">是否开启缓冲池</param>
public RedisHelper(bool openPooledRedis = false)
{
if(openPooledRedis)
{
prcm = CreateManager(new string[] { "127.0.0.1:6379" }, new string[] { "127.0.0.1:6379" });
Redis = prcm.GetClient() as RedisClient;
}
}
private PooledRedisClientManager GetDefaultManager()
{
if (_pcm != null)
{
return(_pcm);
}
_pcm = new PooledRedisClientManager(new[] { _RedisConnection });
_pcm.ConnectTimeout = 3000;
_pcm.IdleTimeOutSecs = 30;
return(_pcm);
}
public RedisCache()
{
ConfigurationFileMap filemap = new ConfigurationFileMap(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config/redis.config"));
RedisConfig config = ConfigurationManager.OpenMappedMachineConfiguration(filemap).GetSection("redis") as RedisConfig;
host = config.Host;
if (!string.IsNullOrEmpty(host))
{
clientManager = new PooledRedisClientManager(host.Split(';'));
}
}
public TodoService()
{
#if DEBUG
this._redisManager = new PooledRedisClientManager("localhost");
#else
this._redisManager = new PooledRedisClientManager("4lEL8GyQRI9grcsO1fm9URhsNBRxRD8pbHeBuvIeN7Q=@todo.redis.cache.windows.net:6379");
#endif
this._redis = this._redisManager.GetClient();
this._redisTodos = _redis.As <Todo>();
}
public void Can_connect_to_ssl_azure_redis_with_PooledClientsManager()
{
using (var redisManager = new PooledRedisClientManager(connectionString))
using (var client1 = redisManager.GetClient())
using (var client2 = redisManager.GetClient())
{
client1.Set("foo", "bar");
var foo = client2.GetValue("foo");
foo.Print();
}
}
public void Can_recover_from_server_terminated_client_connection()
{
const int SleepHoldingClientMs = 5;
const int SleepAfterReleasingClientMs = 0;
const int loop = 1000;
var admin = new RedisClient("localhost");
admin.SetConfig("timeout", "0");
var timeout = admin.GetConfig("timeout");
timeout.Print("timeout: {0}");
int remaining = loop;
var stopwatch = Stopwatch.StartNew();
var clientManager = new PooledRedisClientManager(new[] { "localhost" })
{
};
loop.Times(i =>
{
ThreadPool.QueueUserWorkItem(x =>
{
try
{
using (var client = (RedisClient)clientManager.GetClient())
{
client.IncrementValue("key");
var val = client.Get<long>("key");
"#{0}, isConnected: {1}".Print(val, true); //client.IsSocketConnected()
Thread.Sleep(SleepHoldingClientMs);
}
Thread.Sleep(SleepAfterReleasingClientMs);
}
catch (Exception ex)
{
ex.Message.Print();
}
finally
{
remaining--;
}
});
});
while (remaining > 0)
{
Thread.Sleep(10);
}
"Elapsed time: {0}ms".Print(stopwatch.ElapsedMilliseconds);
var managerStats = clientManager.GetStats();
managerStats.PrintDump();
}
public void Can_connect_to_Slaves_and_Masters_with_Password()
{
var factory = new PooledRedisClientManager(
readWriteHosts: new[] { "[email protected]:6379" },
readOnlyHosts: new[] { "[email protected]:6380" });
using (var readWrite = factory.GetClient())
using (var readOnly = factory.GetReadOnlyClient())
{
readWrite.SetEntry("Foo", "Bar");
var value = readOnly.GetEntry("Foo");
Assert.That(value, Is.EqualTo("Bar"));
}
}
public void Passwords_are_not_leaked_in_exception_messages()
{
const string password = "******";
try
{
var factory = new PooledRedisClientManager(password + "@" + TestConfig.SingleHost); // redis will throw when using password and it's not configured
using (var redis = factory.GetClient())
{
redis.SetEntry("Foo", "Bar");
}
}
catch (RedisResponseException ex)
{
Assert.That(ex.Message, Is.Not.StringContaining(password));
throw;
}
}
public void Can_recover_from_server_terminated_client_connection()
{
const int loop = 200;
var admin = new RedisClient("localhost");
admin.SetConfig("timeout", "1");
var timeout = admin.GetConfig("timeout");
timeout.Print("timeout: {0}");
int remaining = loop;
var clientManager = new PooledRedisClientManager(new[] { "localhost" });
loop.Times(i =>
{
ThreadPool.QueueUserWorkItem(x =>
{
try
{
using (var client = clientManager.GetClient())
{
client.IncrementValue("key");
var val = client.Get<long>("key");
val.ToString().Print();
Thread.Sleep(2000);
}
}
catch (Exception ex)
{
ex.Message.Print();
}
finally
{
remaining--;
}
});
});
while (remaining > 0)
{
Thread.Sleep(100);
}
var managerStats = clientManager.GetStats();
managerStats.PrintDump();
}
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 Passwords_are_not_leaked_in_exception_messages()
{
const string password = "******";
Assert.Throws<ServiceStack.Redis.RedisResponseException>(() => {
try
{
var factory = new PooledRedisClientManager(password + "@" + TestConfig.SingleHost); // redis will throw when using password and it's not configured
using (var redis = factory.GetClient())
{
redis.SetEntry("Foo", "Bar");
}
}
catch (RedisResponseException ex)
{
Assert.That(ex.Message, Is.Not.StringContaining(password));
throw;
}
},
"Expected an exception after Redis AUTH command; try using a password that doesn't match.");
}
public bool Can_connect_to_password_protected_redis_using_PooledRedisClientManager(string host)
{
try
{
var rPool = new PooledRedisClientManager(new List<string> { host }, new List<string> { host });
rPool.GetClient();
return true;
}
catch (Exception)
{
return false;
}
}
public void Can_have_different_pool_size_and_host_configurations()
{
var writeHosts = new[] { "readwrite1" };
var readHosts = new[] { "read1", "read2" };
const int poolSizeMultiplier = 4;
using (var manager = new PooledRedisClientManager(writeHosts, readHosts,
new RedisClientManagerConfig {
MaxWritePoolSize = writeHosts.Length * poolSizeMultiplier,
MaxReadPoolSize = readHosts.Length * poolSizeMultiplier,
AutoStart = true,
}
) {
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]);
}
//A poolsize of 8 will not block getting 8 clients
using (var client1 = manager.GetReadOnlyClient())
using (var client2 = manager.GetReadOnlyClient())
using (var client3 = manager.GetReadOnlyClient())
using (var client4 = manager.GetReadOnlyClient())
using (var client5 = manager.GetReadOnlyClient())
using (var client6 = manager.GetReadOnlyClient())
using (var client7 = manager.GetReadOnlyClient())
using (var client8 = manager.GetReadOnlyClient())
{
AssertClientHasHost(client1, readHosts[0]);
AssertClientHasHost(client2, readHosts[1]);
AssertClientHasHost(client3, readHosts[0]);
AssertClientHasHost(client4, readHosts[1]);
AssertClientHasHost(client5, readHosts[0]);
AssertClientHasHost(client6, readHosts[1]);
AssertClientHasHost(client7, readHosts[0]);
AssertClientHasHost(client8, readHosts[1]);
}
mockFactory.VerifyAll();
}
}
public void Can_change_db_for_client()
{
using (var db1 = new PooledRedisClientManager(1, new string[] { TestConfig.SingleHost }))
using (var db2 = new PooledRedisClientManager(2, new string[] { TestConfig.SingleHost }))
{
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 SSL_can_support_64_threads_using_the_client_simultaneously()
{
var results = 100.Times(x => ModelWithFieldsOfDifferentTypes.Create(x));
var testData = TypeSerializer.SerializeToString(results);
var before = Stopwatch.GetTimestamp();
const int noOfConcurrentClients = 64; //WaitHandle.WaitAll limit is <= 64
var clientAsyncResults = new List<IAsyncResult>();
using (var manager = new PooledRedisClientManager(TestConfig.MasterHosts, TestConfig.SlaveHosts))
{
manager.GetClient().Run(x => x.FlushAll());
for (var i = 0; i < noOfConcurrentClients; i++)
{
var clientNo = i;
var action = (Action)(() => UseClientAsync(manager, clientNo, testData));
clientAsyncResults.Add(action.BeginInvoke(null, null));
}
}
WaitHandle.WaitAll(clientAsyncResults.ConvertAll(x => x.AsyncWaitHandle).ToArray());
Debug.WriteLine(String.Format("Completed in {0} ticks", (Stopwatch.GetTimestamp() - before)));
}
public void Does_throw_TimeoutException_when_PoolTimeout_exceeded()
{
using (var manager = new PooledRedisClientManager(testReadWriteHosts, testReadOnlyHosts,
new RedisClientManagerConfig
{
MaxWritePoolSize = 4,
MaxReadPoolSize = 4,
AutoStart = false,
}))
{
manager.PoolTimeout = 100;
manager.Start();
var masters = 4.Times(i => manager.GetClient());
try
{
manager.GetClient();
Assert.Fail("Should throw TimeoutException");
}
catch (TimeoutException ex)
{
Assert.That(ex.Message, Is.StringStarting("Redis Timeout expired."));
}
var slaves = 4.Times(i => manager.GetReadOnlyClient());
try
{
manager.GetReadOnlyClient();
Assert.Fail("Should throw TimeoutException");
}
catch (TimeoutException ex)
{
Assert.That(ex.Message, Is.StringStarting("Redis Timeout expired."));
}
}
}
public void PooledRedisClientManager_can_execute_CustomResolver()
{
var resolver = new FixedResolver(MasterHosts[0].ToRedisEndpoint(), SlaveHosts[0].ToRedisEndpoint());
using (var redisManager = new PooledRedisClientManager("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(SlaveHosts[0]));
Assert.That(slave.GetValue("KEY"), Is.EqualTo("2"));
}
});
Assert.That(resolver.NewClientsInitialized, Is.EqualTo(2));
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(SlaveHosts[0]));
Assert.That(slave.GetValue("KEY"), Is.EqualTo("2"));
}
});
Assert.That(resolver.NewClientsInitialized, Is.EqualTo(4));
}
}
public void Can_failover_MqServer_at_runtime()
{
const int iterations = 100;
var failoverHost = "redis-failover:6379";
var localClient = new RedisClient("localhost:6379");
localClient.FlushDb();
var failoverClient = new RedisClient(failoverHost);
failoverClient.FlushDb();
var clientManager = new PooledRedisClientManager(new[] { "localhost" });
var mqHost = new RedisMqServer(clientManager);
var map = new Dictionary<string, int>();
var received = 0;
mqHost.RegisterHandler<Msg>(c =>
{
var dto = c.GetBody();
received++;
int count;
map.TryGetValue(dto.Host, out count);
map[dto.Host] = count + 1;
lock (clientManager)
{
"Received #{0} from {1}".Print(received, dto.Host);
if (received == iterations)
Monitor.Pulse(clientManager);
}
return null;
});
mqHost.Start();
RunMqInLoop(mqHost, iterations: iterations, callback: () =>
{
lock (clientManager)
"{0} msgs were published.".Print(iterations);
});
Thread.Sleep(500);
clientManager.FailoverTo(failoverHost);
lock (clientManager)
Monitor.Wait(clientManager);
map.PrintDump();
"localclient inq: {0}, outq: {1}".Print(
localClient.GetListCount("mq:Msg.inq"),
localClient.GetListCount("mq:Msg.outq"));
"failoverClient inq: {0}, outq: {1}".Print(
failoverClient.GetListCount("mq:Msg.inq"),
failoverClient.GetListCount("mq:Msg.outq"));
Assert.That(received, Is.EqualTo(100));
Assert.That(map.Count, Is.EqualTo(2));
var msgsFromAllHosts = 0;
foreach (var count in map.Values)
{
Assert.That(count, Is.GreaterThan(0));
msgsFromAllHosts += count;
}
Assert.That(msgsFromAllHosts, Is.EqualTo(iterations));
}
public static bool RunInLoop(PooledRedisClientManager clientManager, int iterations = 100, int sleepMs = 10, Action callback=null)
{
int count = 0;
int errors = 0;
10.Times(i =>
{
ThreadPool.QueueUserWorkItem(_ =>
{
while (Interlocked.Decrement(ref iterations) >= 0)
{
using (var client = clientManager.GetClient())
{
try
{
var result = client.Increment("test:failover", 1);
Interlocked.Increment(ref count);
if (count % (iterations / 10) == 0)
lock (clientManager)
Console.WriteLine("count: {0}, errors: {1}", count, errors);
}
catch (Exception ex)
{
Interlocked.Increment(ref errors);
}
Thread.Sleep(sleepMs);
}
}
if (callback != null)
{
callback();
callback = null;
}
});
});
return true;
}
public void Can_failover_at_runtime()
{
var failoverHost = "redis-failover:6379";
string key = "test:failover";
var localClient = new RedisClient("localhost");
localClient.Remove(key);
var failoverClient = new RedisClient(failoverHost);
failoverClient.Remove(key);
var clientManager = new PooledRedisClientManager(new[] { "localhost" });
RunInLoop(clientManager, callback:() =>
{
lock (clientManager)
Monitor.Pulse(clientManager);
});
Thread.Sleep(100);
clientManager.FailoverTo(failoverHost);
lock (clientManager)
Monitor.Wait(clientManager);
var localIncr = localClient.Get<int>(key);
var failoverIncr = failoverClient.Get<int>(key);
Assert.That(localIncr, Is.GreaterThan(0));
Assert.That(failoverIncr, Is.GreaterThan(0));
Assert.That(localIncr + failoverIncr, Is.EqualTo(100));
}
