public RedisClient([NotNull] IRedisConfiguration configuration,
[NotNull] IJsonSerializer jsonSerializer,
[CanBeNull] IRedisClientLogger logger = null)
{
Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
JsonSerializer = jsonSerializer ?? throw new ArgumentNullException(nameof(jsonSerializer));
Log = logger;
}
public RedisConnection(IRedisConfiguration configuration)
{
_configuration = configuration;
_connectionMultiplexer = ConnectionMultiplexer.Connect(configuration.ConnectionString);
_connectionMultiplexer.ConnectionFailed += (sender, args) => Reconnect();
_connectionMultiplexer.InternalError += (sender, args) => Reconnect();
}
public RedisMultiplexer(ILogger<RedisMultiplexer> log,
IRedisConfiguration configuration,
Func<ConfigurationOptions, Task<IConnectionMultiplexer>> multiplexerFactory)
{
Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
this.multiplexerFactory = multiplexerFactory ?? throw new ArgumentNullException(nameof(multiplexerFactory));
this.log = log ?? throw new ArgumentNullException(nameof(log));
}
public StackExchangeRedisFactory(string redisConfigName)
{
var configuration = RedisConfigurationHandler.GetConfig(redisConfigName);
if (configuration == null)
{
var msg = "Unable to locate <redisConfig> section into your configuration file.";
throw new ConfigurationErrorsException(msg);
}
this.redisConfigName = redisConfigName;
this.redisConfiguration = configuration;
}
public AdminModeRedisConnectionFactory(IRedisConfiguration configuration)
{
connectionProvider = new Lazy <IConnectionMultiplexer>(() =>
{
var options = new ConfigurationOptions()
{
EndPoints = { configuration.Host },
AllowAdmin = true
};
return(ConnectionMultiplexer.Connect(options));
});
}
public RedisServer(IRedisConfiguration redisConfiguration)
{
var configurationOption = ConfigurationOptions.Parse(redisConfiguration.ConnectionString);
configurationOption.AllowAdmin = true;
_connectionMultiplexer = ConnectionMultiplexer.Connect(configurationOption);
if (!_connectionMultiplexer.IsConnected)
{
throw new Exception($"ConnectionMultiplexer didn't connect! Please check configuration settings in {redisConfiguration.GetType().Name}");
}
}
public StackExchangeRedisFactory(IRedisConfiguration configuration = null)
{
if (configuration == null)
{
configuration = RedisConfigurationHandler.GetConfig();
}
if (configuration == null)
{
throw new ConfigurationErrorsException("Unable to locate <redisConfig> section into your configuration file. Take a look https://github.com/imperugo/StackExchange.Redis.Extensions");
}
this.Configuration = configuration;
}
public RedisLink(ILoggerFactory loggerFactory,
IRedisConfiguration configuration,
IRedisMultiplexer multiplexer,
IResilience resilience,
IEntitySubscriber entitySubscriber,
IDataSerializer defaultSerialiser)
: base(configuration?.ServiceName)
{
this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
Multiplexer = multiplexer ?? throw new ArgumentNullException(nameof(multiplexer));
Resilience = resilience ?? throw new ArgumentNullException(nameof(resilience));
EntitySubscriber = entitySubscriber;
this.defaultSerialiser = defaultSerialiser ?? throw new ArgumentNullException(nameof(defaultSerialiser));
log = loggerFactory.CreateLogger <RedisLink>();
Generator = new ScriptGenerator();
IndexManager = new MainIndexManager(new IndexManagerFactory(loggerFactory, this));
Client = new RedisClient(loggerFactory?.CreateLogger <RedisClient>(), this, IndexManager);
PersistencyRegistration = new PersistencyRegistrationHandler(loggerFactory, this);
}
/// <summary>
/// Creates the client.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
/// <exception cref="NStruct.FatalException">
/// Redis host was not configured!
/// or
/// Redis password was not configured!
/// or
/// Redis port was not configured!
/// </exception>
private RedisClient CreateClient(IRedisConfiguration configuration)
{
if (string.IsNullOrEmpty(configuration.Host))
{
throw new FatalException("Redis host was not configured!");
}
if (string.IsNullOrEmpty(configuration.Password))
{
throw new FatalException("Redis password was not configured!");
}
if (configuration.Port == 0)
{
throw new FatalException("Redis port was not configured!");
}
var client = new RedisClient(configuration.Host, configuration.Port, configuration.Password);
client.ConnectTimeout = configuration.ConnectionTimeOut;
return(client);
}
public CartItemRedisGateway(IRedisConfiguration redisConfig)
{
this.mux = ConnectionMultiplexer.Connect(redisConfig.RedisEndpoint);
}
public RedisConnectionFactory(IRedisConfiguration configuration)
{
connectionProvider = new Lazy <IConnectionMultiplexer>(() => ConnectionMultiplexer.Connect(configuration.Host));
}
public RedisManagement(IRedisConfiguration redisServer)
{
_redisServer = redisServer;
}
public RedisClient(IRedisConfiguration redisConfiguration)
{
csredis = new CSRedisClient(redisConfiguration.Address);
RedisHelper.Initialization(csredis);
}
/// <summary>
/// Initializes a new instance of the <see cref="RedisRepository"/> class.
/// </summary>
/// <param name="configuration">The configuration.</param>
private RedisRepository(IRedisConfiguration configuration)
{
_client = CreateClient(configuration);
}
/// <summary>
/// News the specified configuration.
/// </summary>
/// <param name="configuration">The configuration.</param>
/// <returns></returns>
public static IRedisRepository New(IRedisConfiguration configuration)
{
return(new RedisRepository(configuration));
}
public RedisAccessService(IRedisConfiguration redisConfiguration)
{
_redisConfiguration = redisConfiguration;
_redisConnectionString = GetConnectionString();
Connect();
}
public KeySpaceNotificationService(IRedisServer redisServer, IRedisConfiguration redisConfiguration)
{
_redisServer = redisServer;
_redisConfiguration = redisConfiguration;
}
public RedisConnectionProvider(IRedisConfiguration configuration)
{
_configuration = configuration;
}
