/// <inheritdoc /> protected override async Task <BoolResult> StartupCoreAsync(OperationContext context) { Tracer.TraceStartupConfiguration(context, Configuration); if (Configuration.RedisGlobalStoreConnectionString != null) { RedisDatabaseFactoryForRedisGlobalStore = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(Configuration.RedisGlobalStoreConnectionString)); if (Configuration.RedisGlobalStoreSecondaryConnectionString != null) { RedisDatabaseFactoryForRedisGlobalStoreSecondary = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(Configuration.RedisGlobalStoreSecondaryConnectionString)); } } else { // Local location store can only be used if connection string is provided for redis global store Contract.Assert(!Configuration.HasReadOrWriteMode(ContentLocationMode.LocalLocationStore)); } // Instantiate factories for old redis only when we use old redis. if (Configuration.HasReadOrWriteMode(ContentLocationMode.Redis)) { Contract.Assert(_contentConnectionStringProvider != null); Contract.Assert(_machineConnectionStringProvider != null); RedisDatabaseFactoryForContent = await RedisDatabaseFactory.CreateAsync(context, _contentConnectionStringProvider); RedisDatabaseFactoryForMachineLocations = await RedisDatabaseFactory.CreateAsync(context, _machineConnectionStringProvider); } return(BoolResult.Success); }
public static async Task <RedisDatabaseFactory> CreateAsync(Func <IConnectionMultiplexer> connectionMultiplexerFactory, Func <IConnectionMultiplexer, Task> connectionMultiplexerShutdownFunc) { var databaseFactory = new RedisDatabaseFactory(() => Task.FromResult(connectionMultiplexerFactory()), connectionMultiplexerShutdownFunc); await databaseFactory.InitializeAsync(); return(databaseFactory); }
/// <summary> /// Initializes a new instance of the <see cref="RedisDatabaseAdapter"/> class. /// </summary> public RedisDatabaseAdapter(RedisDatabaseFactory databaseFactory, string keySpace, int redisConnectionErrorLimit = int.MaxValue) { _databaseFactory = databaseFactory; KeySpace = keySpace; _redisConnectionErrorLimit = redisConnectionErrorLimit; _redisRetryStrategy = new RetryPolicy(new RedisRetryPolicy(OnRedisException), RetryStrategy.DefaultExponential); }
/// <summary> /// Factory method for a database factory. /// </summary> public static Task <RedisDatabaseFactory> CreateAsync(IConnectionStringProvider provider, IConnectionMultiplexer connectionMultiplexer) { var databaseFactory = new RedisDatabaseFactory(provider); databaseFactory._connectionMultiplexer = connectionMultiplexer; return(Task.FromResult(databaseFactory)); }
public RedisDatabaseAdapter(RedisDatabaseFactory databaseFactory, RedisDatabaseAdapterConfiguration configuration, IClock?clock = null) { _configuration = configuration; _redisRetryStrategy = configuration.CreateRetryPolicy(OnRedisException); _databaseFactory = databaseFactory; _clock = clock ?? SystemClock.Instance; }
/// <summary> /// Factory method for a database factory. /// </summary> public static async Task <RedisDatabaseFactory> CreateAsync(Context context, IConnectionStringProvider provider) { var databaseFactory = new RedisDatabaseFactory(provider); await databaseFactory.StartupAsync(context); return(databaseFactory); }
public static Task <RedisDatabaseFactory> CreateAsync(Func <IConnectionMultiplexer> connectionMultiplexerFactory, Func <IConnectionMultiplexer, Task> connectionMultiplexerShutdownFunc) { var connectionMultiplexer = connectionMultiplexerFactory(); var databaseFactory = new RedisDatabaseFactory(connectionMultiplexer, () => Task.FromResult(connectionMultiplexerFactory()), connectionMultiplexerShutdownFunc); return(Task.FromResult(databaseFactory)); }
/// <inheritdoc /> public Task <BoolResult> StartupAsync(Context context) { StartupStarted = true; return(StartupCall <ContentSessionTracer> .RunAsync( _tracer, context, async() => { _tracer.TraceStartupConfiguration(context, _configuration); if (_configuration.RedisGlobalStoreConnectionString != null) { _redisDatabaseFactoryForRedisGlobalStore = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(_configuration.RedisGlobalStoreConnectionString)); if (_configuration.RedisGlobalStoreSecondaryConnectionString != null) { _redisDatabaseFactoryForRedisGlobalStoreSecondary = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(_configuration.RedisGlobalStoreSecondaryConnectionString)); } } else { // Local location store can only be used if connection string is provided for redis global store Contract.Assert(!_configuration.HasReadOrWriteMode(ContentLocationMode.LocalLocationStore)); } _redisDatabaseFactoryForContent = await RedisDatabaseFactory.CreateAsync(context, _contentConnectionStringProvider); _redisDatabaseFactoryForMachineLocations = await RedisDatabaseFactory.CreateAsync(context, _machineConnectionStringProvider); StartupCompleted = true; return BoolResult.Success; })); }
public static Task <RedisDatabaseFactory> CreateAsync(IConnectionStringProvider provider, IConnectionMultiplexer connectionMultiplexer) { Func <Task <IConnectionMultiplexer> > connectionMultiplexerFactory = () => Task.FromResult(connectionMultiplexer); Func <IConnectionMultiplexer, Task> connectionMultiplexerShutdownFunc = m => BoolResult.SuccessTask; var databaseFactory = new RedisDatabaseFactory(connectionMultiplexer, connectionMultiplexerFactory, connectionMultiplexerShutdownFunc); return(Task.FromResult(databaseFactory)); }
private RedisDatabaseAdapter CreateDatabase(RedisDatabaseFactory factory, bool optional = false) { if (factory != null) { return(new RedisDatabaseAdapter(factory, _keySpace)); } else { Contract.Assert(optional); return(null); } }
private RedisDatabaseAdapter CreateDatabase(RedisDatabaseFactory factory, bool optional = false) { if (factory != null) { return(new RedisDatabaseAdapter(factory, KeySpace, redisConnectionErrorLimit: Configuration.RedisConnectionErrorLimit)); } else { Contract.Assert(optional); return(null); } }
public static async Task <RedisDatabaseFactory> CreateAsync(Context context, IConnectionStringProvider provider) { Func <Task <IConnectionMultiplexer> > connectionMultiplexerFactory = () => RedisConnectionMultiplexer.CreateAsync(context, provider); Func <IConnectionMultiplexer, Task> connectionMultiplexerShutdownFunc = async m => { ConfigurationOptions options = ConfigurationOptions.Parse(m.Configuration); await RedisConnectionMultiplexer.ForgetAsync(options); }; var multiplexer = await RedisConnectionMultiplexer.CreateAsync(context, provider); var databaseFactory = new RedisDatabaseFactory(multiplexer, connectionMultiplexerFactory, connectionMultiplexerShutdownFunc); return(databaseFactory); }
protected override async Task <BoolResult> StartupCoreAsync(OperationContext context) { Tracer.TraceStartupConfiguration(context, Configuration); RedisDatabaseFactoryForRedisGlobalStore = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(Configuration.RedisGlobalStoreConnectionString)); if (Configuration.RedisGlobalStoreSecondaryConnectionString != null) { RedisDatabaseFactoryForRedisGlobalStoreSecondary = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(Configuration.RedisGlobalStoreSecondaryConnectionString)); } return(BoolResult.Success); }
private RedisDatabaseAdapter CreateDatabase(RedisDatabaseFactory factory, string databaseName, bool optional = false) { if (factory != null) { var adapterConfiguration = new RedisDatabaseAdapterConfiguration( KeySpace, Configuration.RedisConnectionErrorLimit, traceOperationFailures: Configuration.TraceRedisFailures, traceTransientFailures: Configuration.TraceRedisTransientFailures, databaseName: databaseName); return(new RedisDatabaseAdapter(factory, adapterConfiguration)); } else { Contract.Assert(optional); return(null); } }
protected override async Task <BoolResult> StartupCoreAsync(OperationContext context) { Tracer.TraceStartupConfiguration(context, Configuration); RedisDatabaseFactoryForRedisGlobalStore = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(Configuration.RedisGlobalStoreConnectionString), logSeverity : Configuration.RedisInternalLogSeverity ?? Severity.Unknown, usePreventThreadTheft : Configuration.UsePreventThreadTheftFeature); if (Configuration.RedisGlobalStoreSecondaryConnectionString != null) { RedisDatabaseFactoryForRedisGlobalStoreSecondary = await RedisDatabaseFactory.CreateAsync( context, new LiteralConnectionStringProvider(Configuration.RedisGlobalStoreSecondaryConnectionString), logSeverity : Configuration.RedisInternalLogSeverity ?? Severity.Unknown, usePreventThreadTheft : Configuration.UsePreventThreadTheftFeature); } return(BoolResult.Success); }
public RedisDatabaseAdapter(RedisDatabaseFactory databaseFactory, string keySpace) : this(databaseFactory, new RedisDatabaseAdapterConfiguration(keySpace)) { }
/// <summary> /// Initializes a new instance of the <see cref="RedisDatabaseAdapter"/> class. /// </summary> public RedisDatabaseAdapter(RedisDatabaseFactory databaseFactory, string keySpace) { _databaseFactory = databaseFactory; KeySpace = keySpace; _redisRetryStrategy = new RetryPolicy(new RedisRetryPolicy(), RetryStrategy.DefaultExponential); }
public RedisDatabaseAdapter(RedisDatabaseFactory databaseFactory, string keySpace, IClock?clock = null) : this(databaseFactory, new RedisDatabaseAdapterConfiguration(keySpace), clock) { }
public RedisDatabaseAdapter(RedisDatabaseFactory databaseFactory, RedisDatabaseAdapterConfiguration configuration) { _configuration = configuration; _redisRetryStrategy = configuration.CreateRetryPolicy(OnRedisException); _databaseFactory = databaseFactory; }