public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config) { if (config == null) { throw new ArgumentNullException("config"); } if (name == null || name.Length == 0) { name = "MyCacheStore"; } if (String.IsNullOrEmpty(config["description"])) { config.Remove("description"); config.Add("description", "Redis as a session data store"); } base.Initialize(name, config); // If configuration exists then use it otherwise read from config file and create one if (configuration == null) { lock (configurationCreationLock) { if (configuration == null) { configuration = ProviderConfiguration.ProviderConfigurationForOutputCache(config); } } } }
public StackExchangeClientConnection(ProviderConfiguration configuration) { _configuration = configuration; _configOption = ParseConfiguration(_configuration); if (!string.IsNullOrEmpty(_configOption.ServiceName)) { _sentinelConfiguration = CreateSentinellConfiguration(_configOption); ModifyEndpointsForSentinelConfiguration(_configOption); } ConnectToRedis(_configuration); }
public StackExchangeClientConnection(ProviderConfiguration configuration) { _configuration = configuration; _configOption = ParseConfiguration(_configuration); if (!string.IsNullOrEmpty(_configOption.ServiceName)) { _sentinelConfiguration = CreateSentinellConfiguration(_configOption); ModifyEndpointsForSentinelConfiguration(_configOption); } ConnectToRedis(_configuration); this.redisUtility = new RedisUtility(configuration); this.configuration = configuration; ConfigurationOptions configOption; }
public StackExchangeClientConnection(ProviderConfiguration configuration) { this.configuration = configuration; this.redisUtility = new RedisUtility(configuration); ConfigurationOptions configOption; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { configOption = ConfigurationOptions.Parse(configuration.ConnectionString); // Setting explicitly 'abortconnect' to false. It will overwrite customer provided value for 'abortconnect' // As it doesn't make sense to allow to customer to set it to true as we don't give them access to ConnectionMultiplexer // in case of failure customer can not create ConnectionMultiplexer so right choice is to automatically create it by providing AbortOnConnectFail = false configOption.AbortOnConnectFail = false; } else { configOption = new ConfigurationOptions(); if (configuration.Port == 0) { configOption.EndPoints.Add(configuration.Host); } else { configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } configOption.Password = configuration.AccessKey; configOption.Ssl = configuration.UseSsl; configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } } if (LogUtility.logger == null) { redisMultiplexer = ConnectionMultiplexer.Connect(configOption); } else { redisMultiplexer = ConnectionMultiplexer.Connect(configOption, LogUtility.logger); } this.connection = redisMultiplexer.GetDatabase(configuration.DatabaseId); }
public StackExchangeClientConnection(ProviderConfiguration configuration) { this.configuration = configuration; ConfigurationOptions configOption; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { configOption = ConfigurationOptions.Parse(configuration.ConnectionString); // Setting explicitly 'abortconnect' to false. It will overwrite customer provided value for 'abortconnect' // As it doesn't make sense to allow to customer to set it to true as we don't give them access to ConnectionMultiplexer // in case of failure customer can not create ConnectionMultiplexer so right choice is to automatically create it by providing AbortOnConnectFail = false configOption.AbortOnConnectFail = false; } else { configOption = new ConfigurationOptions(); if (configuration.Port == 0) { configOption.EndPoints.Add(configuration.Host); } else { configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } configOption.Password = configuration.AccessKey; configOption.Ssl = configuration.UseSsl; configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } } if (LogUtility.logger == null) { redisMultiplexer = ConnectionMultiplexer.Connect(configOption); } else { redisMultiplexer = ConnectionMultiplexer.Connect(configOption, LogUtility.logger); } this.connection = redisMultiplexer.GetDatabase(configuration.DatabaseId); }
internal RedisObjectCache(string name, NameValueCollection config) { if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } if (config == null) { throw new ArgumentNullException(nameof(config)); } Name = name; configuration = ProviderConfiguration.ProviderConfigurationForObjectCache(config, name); cache = new RedisObjectCacheConnectionWrapper(configuration, name); }
internal static ProviderConfiguration ProviderConfigurationForOutputCache(NameValueCollection config) { ProviderConfiguration configuration = new ProviderConfiguration(config); // No retry login for output cache provider configuration.RetryTimeout = TimeSpan.Zero; // Session state specific attribute which are not applicable to output cache configuration.ThrowOnError = true; configuration.RequestTimeout = TimeSpan.Zero; configuration.SessionTimeout = TimeSpan.Zero; LogUtility.LogInfo("Host: {0}, Port: {1}, UseSsl: {2}, DatabaseId: {3}, ApplicationName: {4}", configuration.Host, configuration.Port, configuration.UseSsl, configuration.DatabaseId, configuration.ApplicationName); return configuration; }
internal static ProviderConfiguration ProviderConfigurationForOutputCache(NameValueCollection config) { ProviderConfiguration configuration = new ProviderConfiguration(config); // No retry login for output cache provider configuration.RetryTimeout = TimeSpan.Zero; // Session state specific attribute which are not applicable to output cache configuration.ThrowOnError = true; configuration.RequestTimeout = TimeSpan.Zero; configuration.SessionTimeout = TimeSpan.Zero; LogUtility.LogInfo("Host: {0}, Port: {1}, UseSsl: {2}, DatabaseId: {3}, ApplicationName: {4}", configuration.Host, configuration.Port, configuration.UseSsl, configuration.DatabaseId, configuration.ApplicationName); return(configuration); }
internal static ProviderConfiguration ProviderConfigurationForObjectCache(NameValueCollection config, string cacheName) { ProviderConfiguration configuration = new ProviderConfiguration(config); configuration.RetryTimeout = TimeSpan.Zero; configuration.ThrowOnError = GetBoolSettings(config, "throwOnError", false); // Session state specific attribute which are not applicable to output cache configuration.RequestTimeout = TimeSpan.Zero; configuration.SessionTimeout = TimeSpan.Zero; configuration.ApplicationName += "_ObjectCache_" + cacheName; LogUtility.LogInfo("Host: {0}, Port: {1}, UseSsl: {2}, DatabaseId: {3}, ApplicationName: {4}, ThrowOnError: {5}", configuration.Host, configuration.Port, configuration.UseSsl, configuration.DatabaseId, configuration.ApplicationName, configuration.ThrowOnError); return(configuration); }
public RedisSharedConnection(ProviderConfiguration configuration) { _configuration = configuration; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { _configOption = ConfigurationOptions.Parse(configuration.ConnectionString); // Setting explicitly 'abortconnect' to false. It will overwrite customer provided value for 'abortconnect' // As it doesn't make sense to allow to customer to set it to true as we don't give them access to ConnectionMultiplexer // in case of failure customer can not create ConnectionMultiplexer so right choice is to automatically create it by providing AbortOnConnectFail = false _configOption.AbortOnConnectFail = false; } else { _configOption = new ConfigurationOptions(); if (configuration.Port == 0) { _configOption.EndPoints.Add(configuration.Host); } else { _configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } _configOption.Password = configuration.AccessKey; _configOption.Ssl = configuration.UseSsl; _configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { _configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { _configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } if (configuration.WriteBuffer != 0) { _configOption.WriteBuffer = configuration.WriteBuffer; } } CreateMultiplexer(); }
public StackExchangeClientConnection(ProviderConfiguration configuration) { this.configuration = configuration; ConfigurationOptions configOption; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { configOption = ConfigurationOptions.Parse(configuration.ConnectionString); } else { configOption = new ConfigurationOptions(); if (configuration.Port == 0) { configOption.EndPoints.Add(configuration.Host); } else { configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } configOption.Password = configuration.AccessKey; configOption.Ssl = configuration.UseSsl; configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } } if (LogUtility.logger == null) { redisMultiplexer = ConnectionMultiplexer.Connect(configOption); } else { redisMultiplexer = ConnectionMultiplexer.Connect(configOption, LogUtility.logger); } this.connection = redisMultiplexer.GetDatabase(configuration.DatabaseId); }
public StackExchangeClientConnection(ProviderConfiguration configuration) { _configuration = configuration; ConfigurationOptions configOption; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { configOption = ConfigurationOptions.Parse(configuration.ConnectionString); if (!string.IsNullOrEmpty(configOption.ServiceName)) { ModifyEndpointsForSentinelConfiguration(configOption); } } else { configOption = new ConfigurationOptions(); if (configuration.Port == 0) { configOption.EndPoints.Add(configuration.Host); } else { configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } configOption.Password = configuration.AccessKey; configOption.Ssl = configuration.UseSsl; configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } } _redisMultiplexer = LogUtility.logger == null ? ConnectionMultiplexer.Connect(configOption) : ConnectionMultiplexer.Connect(configOption, LogUtility.logger); _connection = _redisMultiplexer.GetDatabase(configuration.DatabaseId); }
public RedisOutputCacheConnectionWrapper(ProviderConfiguration configuration) { this.configuration = configuration; // Shared connection is created by server when it starts. don't want to lock everytime when check == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration,() => new StackExchangeClientConnection(configuration)); } } } redisConnection = sharedConnection.TryGetConnection(); }
public RedisOutputCacheConnectionWrapper(ProviderConfiguration configuration) { this.configuration = configuration; // Shared connection is created by server when it starts. don't want to lock everytime when check == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration, () => new StackExchangeClientConnection(configuration)); } } } redisConnection = sharedConnection.TryGetConnection(); }
public RedisOutputCacheConnectionWrapper(ProviderConfiguration configuration) { this.configuration = configuration; // only single object of RedisSharedConnection will be created and then reused if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration); redisUtility = new RedisUtility(configuration); } } } redisConnection = new StackExchangeClientConnection(configuration, redisUtility, sharedConnection); }
public RedisObjectCacheConnectionWrapper(ProviderConfiguration configuration, string name) { this.configuration = configuration; // Shared connection is created by server when it starts. don't want to lock everytime when check == null. // so that is why pool == null exists twice. if (!sharedConnections.ContainsKey(name)) { lock (lockForSharedConnection) { if (!sharedConnections.ContainsKey(name)) { sharedConnections[name] = new RedisSharedConnection(configuration, () => new StackExchangeClientConnection(configuration)); redisUtility = new RedisUtility(configuration); } } } redisConnection = sharedConnections[name].TryGetConnection(); }
private static void ConfigureHosts(ProviderConfiguration configuration, ConfigurationOptions configOption) { foreach (var host in configuration.Host.Split(',', ';')) { if (string.IsNullOrEmpty(host)) { continue; } if (configuration.Port == 0) { configOption.EndPoints.Add(host); } else { configOption.EndPoints.Add(host + ":" + configuration.Port); } } }
public RedisConnectionWrapper(ProviderConfiguration configuration, string id) { this.configuration = configuration; Keys = new KeyGenerator(id, configuration.ApplicationName); // Pool is created by server when it starts. don't want to lock everytime when check pool == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration, () => new StackExchangeClientConnection(configuration)); } } } redisConnection = sharedConnection.TryGetConnection(); }
public RedisConnectionWrapper(ProviderConfiguration configuration, string id) { this.configuration = configuration; Keys = new KeyGenerator(id, configuration.ApplicationName); // Pool is created by server when it starts. don't want to lock everytime when check pool == null. // so that is why pool == null exists twice. if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration,() => new StackExchangeClientConnection(configuration)); } } } redisConnection = sharedConnection.TryGetConnection(); }
public RedisConnectionWrapper(ProviderConfiguration configuration, string id) { this.configuration = configuration; Keys = new KeyGenerator(id, configuration.ApplicationName); // only single object of RedisSharedConnection will be created and then reused if (sharedConnection == null) { lock (lockForSharedConnection) { if (sharedConnection == null) { sharedConnection = new RedisSharedConnection(configuration); redisUtility = new RedisUtility(configuration); } } } redisConnection = new StackExchangeClientConnection(configuration, redisUtility, sharedConnection); }
internal static ProviderConfiguration ProviderConfigurationForSessionState(NameValueCollection config) { ProviderConfiguration configuration = new ProviderConfiguration(config); configuration.ThrowOnError = GetBoolSettings(config, "throwOnError", true); int retryTimeoutInMilliSec = GetIntSettings(config, "retryTimeoutInMilliseconds", 5000); configuration.RetryTimeout = new TimeSpan(0, 0, 0, 0, retryTimeoutInMilliSec); // Get request timeout from config HttpRuntimeSection httpRuntimeSection = ConfigurationManager.GetSection("system.web/httpRuntime") as HttpRuntimeSection; configuration.RequestTimeout = httpRuntimeSection.ExecutionTimeout; // Get session timeout from config SessionStateSection sessionStateSection = (SessionStateSection)WebConfigurationManager.GetSection("system.web/sessionState"); configuration.SessionTimeout = sessionStateSection.Timeout; LogUtility.LogInfo("Host: {0}, Port: {1}, ThrowOnError: {2}, UseSsl: {3}, RetryTimeout: {4}, DatabaseId: {5}, ApplicationName: {6}, RequestTimeout: {7}, SessionTimeout: {8}", configuration.Host, configuration.Port, configuration.ThrowOnError, configuration.UseSsl, configuration.RetryTimeout, configuration.DatabaseId, configuration.ApplicationName, configuration.RequestTimeout, configuration.SessionTimeout); return configuration; }
internal static ProviderConfiguration ProviderConfigurationForSessionState(NameValueCollection config) { ProviderConfiguration configuration = new ProviderConfiguration(config); configuration.ThrowOnError = GetBoolSettings(config, "throwOnError", true); int retryTimeoutInMilliSec = GetIntSettings(config, "retryTimeoutInMilliseconds", 5000); configuration.RetryTimeout = new TimeSpan(0, 0, 0, 0, retryTimeoutInMilliSec); // Get request timeout from config HttpRuntimeSection httpRuntimeSection = ConfigurationManager.GetSection("system.web/httpRuntime") as HttpRuntimeSection; configuration.RequestTimeout = httpRuntimeSection.ExecutionTimeout; // Get session timeout from config SessionStateSection sessionStateSection = (SessionStateSection)WebConfigurationManager.GetSection("system.web/sessionState"); configuration.SessionTimeout = sessionStateSection.Timeout; LogUtility.LogInfo("Host: {0}, Port: {1}, ThrowOnError: {2}, UseSsl: {3}, RetryTimeout: {4}, DatabaseId: {5}, ApplicationName: {6}, RequestTimeout: {7}, SessionTimeout: {8}", configuration.Host, configuration.Port, configuration.ThrowOnError, configuration.UseSsl, configuration.RetryTimeout, configuration.DatabaseId, configuration.ApplicationName, configuration.RequestTimeout, configuration.SessionTimeout); return(configuration); }
private static IConnectionMultiplexerFactory GetConnectionMultiplexerFactory(ProviderConfiguration configuration) { // use factory type if given if (!string.IsNullOrEmpty(configuration.ConnectionMultiplexerFactoryType)) { var factoryType = Type.GetType(configuration.ConnectionMultiplexerFactoryType, throwOnError: true); var factory = (IConnectionMultiplexerFactory)Activator.CreateInstance(factoryType); return(factory); } // otherwise use connection string if given if (!string.IsNullOrEmpty(configuration.ConnectionString)) { return(new ConnectionStringBasedConnectionMultiplexerFactory(configuration)); } // otherwise use individual provider fields if (!string.IsNullOrEmpty(configuration.Host)) { return(new ProviderFieldsBasedConnectionMultiplexerFactory(configuration)); } throw new ConfigurationErrorsException("Provider configuration is invalid, either provider 'connectionString', or 'host' (and other fields), or 'connectionMultiplexerFactoryType'"); }
public RedisSharedConnection(ProviderConfiguration configuration) : this(GetConnectionMultiplexerFactory(configuration)) { }
public StackExchangeClientConnection(ProviderConfiguration configuration, RedisUtility redisUtility, RedisSharedConnection sharedConnection) { _configuration = configuration; _redisUtility = redisUtility; _sharedConnection = sharedConnection; }
public RedisSharedConnection(ProviderConfiguration configuration, Func <IRedisClientConnection> factory) { this.configuration = configuration; lockObject = new object(); this.factory = factory; }
public RedisUtility(ProviderConfiguration configuration) { _configuration = configuration; _serializer = GetSerializer(); }
private ConfigurationOptions ParseConfiguration(ProviderConfiguration configuration) { ConfigurationOptions configOption; // If connection string is given then use it otherwise use individual options if (!string.IsNullOrEmpty(configuration.ConnectionString)) { configOption = ConfigurationOptions.Parse(configuration.ConnectionString); } else { configOption = new ConfigurationOptions(); if (configuration.Port == 0) { configOption.EndPoints.Add(configuration.Host); } else { configOption.EndPoints.Add(configuration.Host + ":" + configuration.Port); } configOption.Password = configuration.AccessKey; configOption.Ssl = configuration.UseSsl; configOption.AbortOnConnectFail = false; if (configuration.ConnectionTimeoutInMilliSec != 0) { configOption.ConnectTimeout = configuration.ConnectionTimeoutInMilliSec; } if (configuration.OperationTimeoutInMilliSec != 0) { configOption.SyncTimeout = configuration.OperationTimeoutInMilliSec; } } return configOption; }
public RedisSharedConnection(ProviderConfiguration configuration, Func<IRedisClientConnection> factory) { this.configuration = configuration; lockObject = new object(); this.factory = factory; }
private void ConnectToRedis(ProviderConfiguration configuration) { _redisMultiplexer = LogUtility.logger == null ? ConnectionMultiplexer.Connect(_configOption) : ConnectionMultiplexer.Connect(_configOption, LogUtility.logger); _connection = _redisMultiplexer.GetDatabase(configuration.DatabaseId); }