public void Init() { var services = new ServiceCollection(); var redisConfig = new RedisConfiguration { MaxValueLength = 2810, PoolSize = 20, AbortOnConnectFail = false, Database = 0, KeyPrefix = "lyl:", ConnectTimeout = 100, Hosts = new RedisHost[] { new RedisHost { Host = "198.185.15.16", Port = 6379 } }, }; redisConfig.ServerEnumerationStrategy = new ServerEnumerationStrategy() { Mode = ServerEnumerationStrategy.ModeOptions.All, TargetRole = ServerEnumerationStrategy.TargetRoleOptions.Any, UnreachableServerAction = ServerEnumerationStrategy.UnreachableServerActionOptions.Throw }; IRedisCacheConnectionPoolManager poolManager = new RedisCacheConnectionPoolManager(redisConfig); _redisDatabase = new RedisDatabase(connectionPoolManager: poolManager, new SystemTextJsonSerializer(), redisConfig.ServerEnumerationStrategy, 0, 0, redisConfig.KeyPrefix); }
public CacheClient(RedisConfiguration config) { this.config = config; ConnectionPool = new RedisCacheConnectionPoolManager(this.config); Client = new RedisCacheClient(ConnectionPool, new Utf8JsonSerializer(), config); RedisDb = Client.GetDbFromConfiguration(); Db = RedisDb.Database; }
public RedisDbConnector() { var config = new RedisConfiguration { Hosts = new[] { new RedisHost { Host = "localhost", Port = 6379 } } }; _connectionPool = new RedisCacheConnectionPoolManager(config); }
public CacheClient(RedisConfiguration config) { this.config = config; config.ConfigurationOptions.CertificateSelection += ConfigurationOptions_CertificateSelection; // MEMO: Don't do this in production (Dev only) // hack for local redis tls docker config.ConfigurationOptions.CertificateValidation += ConfigurationOptions_CertificateValidation; ConnectionPool = new RedisCacheConnectionPoolManager(this.config); Client = new RedisCacheClient(ConnectionPool, new Utf8JsonSerializer(), config); RedisDb = Client.GetDbFromConfiguration(); Db = RedisDb.Database; }
private static IRedisCacheClient GetCacheClient(RedisConfiguration redisConfig, ISerializer sz = null) { var poolManager = new RedisCacheConnectionPoolManager(redisConfig); if (sz == null) { sz = new MsgPackObjectSerializer(); } var cacheClient = new RedisCacheClient(poolManager, sz, redisConfig); return(cacheClient); }
public RedisCache() { var configuration = ConfigurationManagerExtension.GetSection("redisCacheClient") as RedisCachingSectionHandler; if (configuration == null) { throw new ConfigurationErrorsException("Unable to locate <redisCacheClient> section into your configuration file. Take a look https://github.com/imperugo/StackExchange.Redis.Extensions"); } var redisConfiguration = RedisCachingSectionHandler.GetConfig(); var connectionPoolManager = new RedisCacheConnectionPoolManager(redisConfiguration); _redis = new RedisCacheClient(connectionPoolManager, new NewtonsoftSerializer(), redisConfiguration).GetDbFromConfiguration(); }
/// <summary> /// Add AddCacheStores to ServiceCollection /// </summary> /// <param name="services"></param> /// <param name="options"></param> /// <returns></returns> public static IServiceCollection AddCacheStores(this IServiceCollection services, IOptions <CacheStoreOptions> options) { Console.WriteLine("Deregistering providers for ICacheStore"); services.Remove <ICacheStore>(); services.Remove <ISerializer>(); services .AddOptions() .AddOptions <CacheStoreOptions>(); if (options.Value.CacheStorage.Equals("redis", StringComparison.OrdinalIgnoreCase)) { Console.WriteLine("Registering RedisStore provider for ICacheStore"); Console.WriteLine($"Using {options.Value.Serializer} serializer."); if (options.Value.Serializer == CacheStoreSerializer.Protobuf) { services.AddSingleton <ISerializer, ProtobufSerializer>(); } else { services.AddSingleton <ISerializer, MsgPackObjectSerializer>(); } services.AddSingleton(RedisCacheConnectionPoolManager.GetRedisConfiguration(options.Value.RedisHost)); services.AddSingleton <IRedisCacheClient, RedisCacheClient>(); services.AddSingleton <IRedisCacheConnectionPoolManager, RedisCacheConnectionPoolManager>(); services.AddSingleton <IRedisDefaultCacheClient, StackExchange.Redis.Extensions.Core.Implementations.RedisDefaultCacheClient>(); services.AddScoped <ICacheStore, RedisStore>(); } else if (options.Value.CacheStorage.Equals("memory", StringComparison.OrdinalIgnoreCase)) { Console.WriteLine("Registering MemoryStore provider for ICacheStore"); services.AddMemoryCache(); services.AddScoped <ICacheStore, MemoryStore>(); } else { Console.WriteLine("Registering NullStore provider for ICacheStore"); services.AddScoped <ICacheStore, NullStore>(); } return(services); }
public static void Connect(string redisIp, int port) { if (ConnectionPoolManager != null) { return; } ConnectionPoolManager = new RedisCacheConnectionPoolManager(new RedisConfiguration { Hosts = new RedisHost[] { new RedisHost { Host = redisIp, Port = port } } }); }
public RedisDistributedAppLockProviderTest() { _hostname = "127.0.0.1"; _port = 6379; _connectionPool = new RedisCacheConnectionPoolManager(new RedisConfiguration { Hosts = new RedisHost[] { new RedisHost() { Host = _hostname, Port = _port } } }); }
private static ICodeStorage GetRedisCacheStorage() { var redisConfig = new RedisConfiguration { Hosts = new RedisHost[] { new RedisHost { Host = "127.0.0.1", Port = 6379 } } }; var redisManager = new RedisCacheConnectionPoolManager(redisConfig); var redisClient = new RedisCacheClient(redisManager, new NewtonsoftSerializer(), redisConfig);//new ProtobufSerializer(); var storage = new RedisCacheStorage(redisClient); return(storage); }
/// <summary> /// Adds the services. /// </summary> /// <param name="services">The services.</param> private void AddServices(IServiceCollection services) { services.AddHttpContextAccessor(); services.AddSingleton <ISerializer>(service => new NewtonsoftSerializer(new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.All, NullValueHandling = NullValueHandling.Include })); services.AddSingleton <IRedisCacheClient>(service => { RedisConfiguration redisConfiguration = new RedisConfiguration() { AbortOnConnectFail = true, Hosts = new RedisHost[] { new RedisHost { Host = Configuration["KeyValueStore:host"], Port = Convert.ToInt32(Configuration["KeyValueStore:port"]) } }, AllowAdmin = true, Database = 0, ServerEnumerationStrategy = new ServerEnumerationStrategy() { Mode = ServerEnumerationStrategy.ModeOptions.All, TargetRole = ServerEnumerationStrategy.TargetRoleOptions.Any, UnreachableServerAction = ServerEnumerationStrategy.UnreachableServerActionOptions.Throw }, PoolSize = 50 }; IRedisCacheConnectionPoolManager redisCacheConnectionPoolManager = new RedisCacheConnectionPoolManager(redisConfiguration); ISerializer serializer = service.GetRequiredService <ISerializer>(); return(new RedisCacheClient(redisCacheConnectionPoolManager, serializer, redisConfiguration)); }); services.AddSingleton <IUrlService>(service => new UrlService(service.GetRequiredService <IKeyValueStore>(), service.GetRequiredService <IHttpContextAccessor>())); services.AddSingleton <IKeyValueStore>(service => new KeyValueStore(service.GetRequiredService <IRedisCacheClient>())); services.AddControllers(options => options.Filters.Add(new HttpResponseExceptionFilter())); }
public async Task Open_Tons_of_concurrent_connections() { var sut = new RedisCacheConnectionPoolManager(new RedisConfiguration() { AbortOnConnectFail = false, Hosts = new RedisHost[] { new RedisHost() { Host = "localhost", Port = 6379 } }, AllowAdmin = true, ConnectTimeout = 5000, Database = 8, PoolSize = 10, ServerEnumerationStrategy = new ServerEnumerationStrategy() { Mode = ServerEnumerationStrategy.ModeOptions.All, TargetRole = ServerEnumerationStrategy.TargetRoleOptions.Any, UnreachableServerAction = ServerEnumerationStrategy.UnreachableServerActionOptions.Throw } }); await sut.GetConnection().GetDatabase().StringSetAsync("key", "value"); var conn = sut.GetConnection(); Parallel.For(0, 1000, x => { try { sut.GetConnection().GetDatabase().StringGet("key"); } catch (Exception exc) { output.WriteLine($"Index: {x} - Exception {exc.ToString()}"); throw; } }); }
public RedisCacheConnectionPoolManagerTests(ITestOutputHelper output) { // See more info here: https://gist.github.com/JonCole/e65411214030f0d823cb#file-threadpool-md // Everything started from here https://gist.github.com/JonCole/925630df72be1351b21440625ff2671f#file-redis-bestpractices-stackexchange-redis-md ThreadPool.GetMaxThreads(out var maxThread, out var maxIOThread); ThreadPool.SetMinThreads(maxThread / 2, maxIOThread); this.output = output; var configuration = new RedisConfiguration() { AbortOnConnectFail = true, KeyPrefix = "MyPrefix__", Hosts = new RedisHost[] { new RedisHost { Host = "localhost", Port = 6379 } }, AllowAdmin = true, ConnectTimeout = 3000, Database = 0, PoolSize = 5, ServerEnumerationStrategy = new ServerEnumerationStrategy() { Mode = ServerEnumerationStrategy.ModeOptions.All, TargetRole = ServerEnumerationStrategy.TargetRoleOptions.Any, UnreachableServerAction = ServerEnumerationStrategy.UnreachableServerActionOptions.Throw } }; var logger = output.BuildLoggerFor <RedisCacheConnectionPoolManager>(); sut = new RedisCacheConnectionPoolManager(configuration, logger); this.output = output; }
public void ConfigureServices(IServiceCollection services) { var redisConfiguration = _configuration.GetSection(ConfigConstants.REDIS).Get <RedisConfiguration>(); if (redisConfiguration == null) { throw new InvalidOperationException( $"Unable to locate the [{ConfigConstants.REDIS}] configuration block."); } var redisCacheConnectionPoolManager = new RedisCacheConnectionPoolManager(redisConfiguration); var serializer = new NewtonsoftSerializer(); var redisCacheClient = new RedisCacheClient(redisCacheConnectionPoolManager, serializer, redisConfiguration); var redisCacheProvider = new JdtRedisCacheProvider(Log.Logger, _configuration, redisCacheClient); services.AddSingleton(redisConfiguration); services.AddSingleton <ISerializer>(serializer); services.AddSingleton <IRedisCacheClient, RedisCacheClient>(); services.AddSingleton <IRedisCacheConnectionPoolManager>(redisCacheConnectionPoolManager); services.AddSingleton <IRedisCacheClient>(redisCacheClient); Log.Logger.Information("A Redis connection has been initialized for this service"); services.AddAuthentication(options => { options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme; options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme; }) .AddOpenIdConnect(OpenIdConnectDefaults.AuthenticationScheme, options => { options.ClientId = _configuration["oidc:clientId"]; options.ClientSecret = _configuration["oidc:clientSecret"]; options.Authority = _configuration["oidc:authority"]; options.ResponseType = _configuration["oidc:responseType"]; options.GetClaimsFromUserInfoEndpoint = bool.TryParse(_configuration["oidc:getClaimsFromUserInfoEndpoint"], out var option) && option; options.RequireHttpsMetadata = true; options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme; options.SaveTokens = true; var stsDiscoveryEndpoint = _configuration[ConfigConstants.STS_DISCOVERY_ENDPOINT]; options.ConfigurationManager = new ConfigurationManager <OpenIdConnectConfiguration>(stsDiscoveryEndpoint, new JdtOpenIdRedisConfigurationRetriever(redisCacheProvider, Log.Logger)); options.Validate(); }) .AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options => { options.Cookie.HttpOnly = true; options.Cookie.SecurePolicy = CookieSecurePolicy.Always; options.Cookie.SameSite = SameSiteMode.Lax; }) .AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, options => { var stsDiscoveryEndpoint = _configuration[ConfigConstants.STS_DISCOVERY_ENDPOINT]; options.ConfigurationManager = new ConfigurationManager <OpenIdConnectConfiguration>(stsDiscoveryEndpoint, new JdtOpenIdRedisConfigurationRetriever(redisCacheProvider, Log.Logger)); options.Audience = _configuration["oidc:audience"]; options.Authority = _configuration["oidc:authority"]; }); services.AddAuthorization(options => { var defaultAuthorizationPolicyBuilder = new AuthorizationPolicyBuilder( JwtBearerDefaults.AuthenticationScheme, OpenIdConnectDefaults.AuthenticationScheme, CookieAuthenticationDefaults.AuthenticationScheme); defaultAuthorizationPolicyBuilder = defaultAuthorizationPolicyBuilder.RequireAuthenticatedUser(); var defaultAuthorizationPolicy = defaultAuthorizationPolicyBuilder.Build(); options.DefaultPolicy = defaultAuthorizationPolicy; // oidc var oidcAuthorizationPolicyBuilder = new AuthorizationPolicyBuilder(OpenIdConnectDefaults.AuthenticationScheme); oidcAuthorizationPolicyBuilder = oidcAuthorizationPolicyBuilder.RequireAuthenticatedUser(); var oidcAuthorizationPolicy = oidcAuthorizationPolicyBuilder.Build(); options.AddPolicy(OpenIdConnectDefaults.AuthenticationScheme, oidcAuthorizationPolicy); // bearer var bearerAuthorizationPolicyBuilder = new AuthorizationPolicyBuilder(JwtBearerDefaults.AuthenticationScheme); bearerAuthorizationPolicyBuilder = bearerAuthorizationPolicyBuilder.RequireAuthenticatedUser(); var bearerAuthorizationPolicy = bearerAuthorizationPolicyBuilder.Build(); options.AddPolicy(JwtBearerDefaults.AuthenticationScheme, bearerAuthorizationPolicy); }); services.AddSingleton(redisCacheClient); services.AddControllers(); }