public BaseRedisHelper(IRedisClientManager redisClientManager, ILogFactory logFactory, TimeSpan?ttlTimeSpan)
{
_redisClientManager = redisClientManager;
Logger = logFactory.GetLogger(GetType());
_contractResolver = new DefaultContractResolver();
TtlTimeSpan = ttlTimeSpan;
}
public RedisPubSubServer(IRedisClientManager clientsManager, params string[] channels)
{
this.ClientsManager = clientsManager;
this.Channels = channels;
var failoverHost = clientsManager as IRedisFailover;
failoverHost?.OnFailover.Add(this.HandleFailover);
}
public static void ExecTrans(this IRedisClientManager redisManager, Action <IRedisTransaction> lambda)
{
using (var redis = redisManager.GetClient()) {
using (var trans = redis.CreateTransaction()) {
lambda(trans);
trans.Commit();
}
}
}
public void WhenUsingAnInitialDatabase_CorrectDatabaseIsUsed() {
this._db1ClientManager = new BasicRedisClientManager(1, Config.MasterHost);
this._db2ClientManager = new BasicRedisClientManager(2, Config.MasterHost);
using (var cacheClient = this._db1ClientManager.GetCacheClient()) {
cacheClient.Set("key", "value");
}
using (var cacheClient = this._db2ClientManager.GetCacheClient()) {
Assert.Null(cacheClient.Get<string>("key"));
}
}
private void TestForDatabaseOnConnectionString(Func<string, IRedisClientManager> factory) {
this._db1ClientManager = factory(Config.MasterHost + "?db=1");
this._db2ClientManager = factory(Config.MasterHost + "?db=2");
using (var cacheClient = this._db1ClientManager.GetCacheClient()) {
cacheClient.Set("key", "value");
}
using (var cacheClient = this._db2ClientManager.GetCacheClient()) {
Assert.Null(cacheClient.Get<string>("key"));
}
}
private static void AssertClientManager(IRedisClientManager redisManager, RedisEndpoint expected)
{
using (var readWrite = (RedisClient)redisManager.GetClient()) {
using (var readOnly = (RedisClient)redisManager.GetReadOnlyClient()) {
using (var cacheClientWrapper = (RedisClientManagerCacheClient)redisManager.GetCacheClient()) {
AssertClient(readWrite, expected);
AssertClient(readOnly, expected);
using (var cacheClient = (RedisClient)cacheClientWrapper.GetClient()) {
AssertClient(cacheClient, expected);
}
}
}
}
}
private static void UseClient(IRedisClientManager manager, int clientNo)
{
using (var client = manager.GetReadOnlyClient()) {
lock (_hostCountMap) {
if (!_hostCountMap.TryGetValue(client.Host, out var hostCount))
{
hostCount = 0;
}
_hostCountMap[client.Host] = ++hostCount;
}
Console.WriteLine("Client '{0}' is using '{1}'", clientNo, client.Host);
}
}
/// <summary>
/// Creates a PubSubServer that uses a background thread to listen and process for
/// Redis Pub/Sub messages published to the specified channel.
/// Use optional callbacks to listen for message, error and life-cycle events.
/// Callbacks can be assigned later, then call Start() for PubSubServer to start listening for messages
/// </summary>
public static IRedisPubSubServer CreatePubSubServer(this IRedisClientManager redisManager,
string channel,
Action <string, string> onMessage = null,
Action <Exception> onError = null,
Action onInit = null,
Action onStart = null,
Action onStop = null)
{
return(new RedisPubSubServer(redisManager, channel)
{
OnMessage = onMessage,
OnError = onError,
OnInit = onInit,
OnStart = onStart,
OnStop = onStop
});
}
private static void InitializeEmptyRedisManagers(IRedisClientManager redisManager, string[] masters, string[] slaves)
{
var hasResolver = (IHasRedisResolver)redisManager;
hasResolver.RedisResolver.ResetMasters(masters);
hasResolver.RedisResolver.ResetSlaves(slaves);
using (var master = redisManager.GetClient()) {
Assert.That(master.GetHostString(), Is.EqualTo(Config.Sentinel6380));
master.SetValue("KEY", "1");
}
using (var slave = redisManager.GetReadOnlyClient()) {
Assert.That(slave.GetHostString(), Is.EqualTo(Config.Sentinel6380).Or.EqualTo(Config.Sentinel6381));
Assert.That(slave.GetValue("KEY"), Is.EqualTo("1"));
}
}
public static T ExecAs <T>(this IRedisClientManager redisManager, Func <IRedisTypedClient <T>, T> lambda)
{
using (var redis = redisManager.GetClient()) {
return(lambda(redis.As <T>()));
}
}
public static void ExecAs <T>(this IRedisClientManager redisManager, Action <IRedisTypedClient <T> > lambda)
{
using (var redis = redisManager.GetClient()) {
lambda(redis.As <T>());
}
}
public static bool Exec(this IRedisClientManager redisManager, Func <IRedisClient, bool> lambda)
{
using (var redis = redisManager.GetClient()) {
return(lambda(redis));
}
}
public static void Exec(this IRedisClientManager redisManager, Action <IRedisClient> lambda)
{
using (var redis = redisManager.GetClient()) {
lambda(redis);
}
}
public RedisHelper(IRedisClientManager redisClientManager, ILogFactory logFactory, TimeSpan?ttlTimeSpan)
: base(redisClientManager, logFactory, ttlTimeSpan)
{
}
/// <inheritdoc />
public RedisClientManagerCacheClient(IRedisClientManager redisManager)
{
this._redisManager = redisManager;
}
/// <inheritdoc />
public ManagedList(IRedisClientManager manager, string key)
{
this._key = key;
this._manager = manager;
}
public void TearDown()
{
this._redisManager?.Dispose();
this._redisManager = null;
}
public BaseRedisHelper(IRedisClientManager redisClientManager, ILogFactory logFactory)
: this(redisClientManager, logFactory, TimeSpan.FromMinutes(20))
{
}
private static void UseClientAsync(IRedisClientManager manager, int clientNo, string testData)
{
using (var client = manager.GetReadOnlyClient()) {
UseClient(client, clientNo, testData);
}
}
public void SetUp()
{
this._redisManager = new BasicRedisClientManager(Config.MasterHost);
this._redisManager.Exec(r => r.FlushAll());
}
public RedisHelper(IRedisClientManager redisClientManager, ILogFactory logFactory)
: base(redisClientManager, logFactory)
{
}
public RedisCachedCollection(IRedisClientManager clientsManager, string collectionKey)
{
this._clientsManager = clientsManager;
this._collectionKey = string.Format("urn:{0}:{1}", "XXXXX", collectionKey);
}
public static ManagedList <T> GetManagedList <T>(this IRedisClientManager manager, string key)
{
return(new ManagedList <T>(manager, key));
}
public RedisKvCache(IRedisClientManager clientManager)
{
AssertUtil.ArgumentNotNull(clientManager, nameof(clientManager));
ClientManager = clientManager;
}
private static void UseClientAsync(IRedisClientManager manager, int clientNo)
{
using (var client = manager.GetClient()) {
UseClient(client, clientNo);
}
}
