Esempio n. 1
0
        }                                                              // TODO use RedisCacheClient

        private RedisAccess()
        {
            _serializer = new NewtonsoftSerializer();
            var redisConfiguration = RedisCachingSectionHandler.GetConfig();

            RedisCacheClient = new StackExchangeRedisCacheClient(_serializer, redisConfiguration);
        }
Esempio n. 2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="StackExchangeRedisCacheClient"/> class.
        /// </summary>
        /// <param name="serializer">The serializer.</param>
        /// <param name="configuration">The configuration.</param>
        public StackExchangeRedisCacheClient(ISerializer serializer, IRedisCachingConfiguration configuration = null)
        {
            if (serializer == null)
            {
                throw new ArgumentNullException("serializer");
            }

            if (configuration == null)
            {
                configuration = RedisCachingSectionHandler.GetConfig();
            }

            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");
            }

            ConfigurationOptions options = new ConfigurationOptions
            {
                Ssl        = configuration.Ssl,
                AllowAdmin = configuration.AllowAdmin
            };

            foreach (RedisHost redisHost in configuration.RedisHosts)
            {
                options.EndPoints.Add(redisHost.Host, redisHost.CachePort);
            }

            this.connectionMultiplexer = ConnectionMultiplexer.Connect(options);
            db = connectionMultiplexer.GetDatabase(configuration.Database);
            this.serializer = serializer;
        }
Esempio n. 3
0
        public T Read <T>(string key)
        {
            serializer = new NewtonsoftSerializer();
            var redisConfiguration = RedisCachingSectionHandler.GetConfig();

            using (cacheClient = new StackExchangeRedisCacheClient(serializer, redisConfiguration))
            {
                return(cacheClient.Get <T>(key));
            }
        }
Esempio n. 4
0
        public static StackExchangeRedisCacheClient GetClient()
        {
            if (config == null)
            {
                config = RedisCachingSectionHandler.GetConfig();
            }



            client = new StackExchangeRedisCacheClient(new NewtonsoftSerializer(), config);

            return(client);
        }
Esempio n. 5
0
        public bool Save <T>(string key, T value)
        {
            bool isSuccess;

            serializer = new NewtonsoftSerializer();
            var redisConfiguration = RedisCachingSectionHandler.GetConfig();

            using (cacheClient = new StackExchangeRedisCacheClient(serializer, redisConfiguration))
            {
                isSuccess = cacheClient.Add <T>(key, value);
            }
            return(isSuccess);
        }
Esempio n. 6
0
        public RedisKeyValueStore()
        {
            _redisConfiguration = RedisCachingSectionHandler.GetConfig();
            var configurationOptions = new ConfigurationOptions
            {
                ConnectTimeout = _redisConfiguration.ConnectTimeout,
                Ssl            = _redisConfiguration.Ssl,
            };

            foreach (RedisHost redisHost in _redisConfiguration.RedisHosts)
            {
                configurationOptions.EndPoints.Add(redisHost.Host, redisHost.CachePort);
            }
            _redis = ConnectionMultiplexer.Connect(configurationOptions);
        }
Esempio n. 7
0
        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();
        }
Esempio n. 8
0
        private static void PrepareRedisSessionProvider()
        {
            var configuration = RedisCachingSectionHandler.GetConfig();

            if (configuration != null)
            {
                RedisConnectionConfig.GetSERedisServerConfig = (HttpContextBase context) =>
                {
                    if (configuration.RedisHosts != null && configuration.RedisHosts.Count > 0)
                    {
                        var host = configuration.RedisHosts[0];
                        return(new KeyValuePair <string, ConfigurationOptions>("DefaultConnection",
                                                                               ConfigurationOptions.Parse(String.Concat(host.Host, ":", host.CachePort))));
                    }
                    return(new KeyValuePair <string, ConfigurationOptions>());
                };
            }
        }
Esempio n. 9
0
        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 stringBuilder = new StringBuilder();

            using (var stream = new StringWriter(stringBuilder))
            {
                var opts = RedisCachingSectionHandler.GetConfig().ConfigurationOptions;
                opts.SyncTimeout = 60000;
                var connectionMultiplexer = (IConnectionMultiplexer)ConnectionMultiplexer.Connect(opts, stream);
                redis = new StackExchangeRedisCacheClient(connectionMultiplexer, new Serializer());
                LogManager.GetLogger("ASC").Debug(stringBuilder.ToString());
            }
        }
        public void ReadingFromConfigurationFile_ShouldReturnValidValues()
        {
            //NOTE: This isn't a good test, need to find a way to inject a config file in memory (no idea how to do that)
            var cfg = RedisCachingSectionHandler.GetConfig();

            Assert.NotNull(cfg);
            Assert.NotNull(cfg.ServerEnumerationStrategy);
            Assert.NotNull(cfg.Hosts);
            Assert.True(cfg.AllowAdmin);
            Assert.False(cfg.Ssl);
            Assert.Equal(3000, cfg.ConnectTimeout);
            Assert.Equal(24, cfg.Database);

            Assert.Equal(ServerEnumerationStrategy.ModeOptions.Single, cfg.ServerEnumerationStrategy.Mode);
            Assert.Equal(ServerEnumerationStrategy.TargetRoleOptions.PreferSlave, cfg.ServerEnumerationStrategy.TargetRole);
            Assert.Equal(ServerEnumerationStrategy.UnreachableServerActionOptions.IgnoreIfOtherAvailable, cfg.ServerEnumerationStrategy.UnreachableServerAction);

            Assert.Single(cfg.Hosts);
            Assert.Equal("127.0.0.1", cfg.Hosts.First().Host);
            Assert.Equal(6379, cfg.Hosts.First().Port);
        }
Esempio n. 11
0
        private void ConfigureRedis(IStoveRedisCacheConfiguration redisConfiguration)
        {
            redisConfiguration.Configuration = RedisCachingSectionHandler.GetConfig();

            if (redisConfiguration.Configuration == null)
            {
                throw new StoveException("There is no Redis connection string section in app.config or web.config file, " +
                                         "please define redisCacheClient section and configurations. " +
                                         "If it is, please make sure of your config file is setted as CopyAlways from it's properties.");
            }

            redisConfiguration.ConfigurationOptions = new ConfigurationOptions
            {
                AllowAdmin         = redisConfiguration.Configuration.AllowAdmin,
                Ssl                = redisConfiguration.Configuration.Ssl,
                ConnectTimeout     = redisConfiguration.Configuration.ConnectTimeout,
                AbortOnConnectFail = false
            };

            foreach (RedisHost redisHost in redisConfiguration.Configuration.RedisHosts)
            {
                redisConfiguration.ConfigurationOptions.EndPoints.Add(redisHost.Host, redisHost.CachePort);
            }
        }