public PooledRedisClientManager(
            IEnumerable <string> readWriteHosts,
            IEnumerable <string> readOnlyHosts,
            RedisClientManagerConfig config,
            int initalDb)
        {
            int    iConfigedPoolSizeMultiplier;
            string strMultiplier = ConfigurationManager.AppSettings["RedisPoolSizeMultiplier"];

            if (string.IsNullOrEmpty(strMultiplier) == false && int.TryParse(strMultiplier, out iConfigedPoolSizeMultiplier) && iConfigedPoolSizeMultiplier > 0)
            {
                this.PoolSizeMultiplier = iConfigedPoolSizeMultiplier;
            }

            this.Db = config != null
                ? config.DefaultDb.GetValueOrDefault(initalDb)
                : initalDb;

            ReadWriteHosts = readWriteHosts.ToRedisEndPoints();
            ReadOnlyHosts  = readOnlyHosts.ToRedisEndPoints();

            this.RedisClientFactory = Redis.RedisClientFactory.Instance;

            this.Config = config ?? new RedisClientManagerConfig
            {
                MaxWritePoolSize = ReadWriteHosts.Count * PoolSizeMultiplier,
                MaxReadPoolSize  = ReadOnlyHosts.Count * PoolSizeMultiplier,
            };

            if (this.Config.AutoStart)
            {
                this.OnStart();
            }
        }
Esempio n. 2
0
        static RedisHelper()
        {
            try
            {

                RedisClientManagerConfig RedisConfig = new RedisClientManagerConfig();

                RedisConfig.AutoStart = true;
                RedisConfig.MaxReadPoolSize = 60;
                RedisConfig.MaxWritePoolSize = 60;
                var hostWrite = System.Configuration.ConfigurationManager.AppSettings["RedisServerWrite"];
                var arryWrite = hostWrite.Split(';').ToList();
                var hostRead = System.Configuration.ConfigurationManager.AppSettings["RedisServerRead"];
                var arryRead = hostWrite.Split(';').ToList();
                if (arryWrite.Count > 0 && arryRead.Count > 0)
                {
                    prcm = new PooledRedisClientManager(arryWrite, arryRead, RedisConfig);
                    redisClient = prcm.GetClient();
                }
                else
                {
                    throw new Exception("连接服务器失败,请检查配置文件");
                }
            }
            catch
            {
                throw new Exception("连接服务器失败,请检查配置文件");
            }
        }
        public PooledRedisClientManager(
            IEnumerable <string> readWriteHosts,
            IEnumerable <string> readOnlyHosts,
            RedisClientManagerConfig config,
            long initalDb,
            int?poolSizeMultiplier,
            int?poolTimeOutSeconds)
        {
            this.Db = config != null
                                ? config.DefaultDb.GetValueOrDefault(initalDb)
                                : initalDb;

            ReadWriteHosts = readWriteHosts.ToRedisEndPoints();
            ReadOnlyHosts  = readOnlyHosts.ToRedisEndPoints();

            this.RedisClientFactory = Redis.RedisClientFactory.Instance;

            this.PoolSizeMultiplier = poolSizeMultiplier ?? 10;

            this.Config = config ?? new RedisClientManagerConfig {
                MaxWritePoolSize = ReadWriteHosts.Count * PoolSizeMultiplier,
                MaxReadPoolSize  = ReadOnlyHosts.Count * PoolSizeMultiplier,
            };

            // if timeout provided, convert into milliseconds
            this.PoolTimeOut = poolTimeOutSeconds != null
                                ? poolTimeOutSeconds * 1000
                                : null;


            if (this.Config.AutoStart)
            {
                this.OnStart();
            }
        }
Esempio n. 4
0
        static RedisClientPoolManager()
        {
            try
            {
                connectTimeout = ConfigUtils.GetSetting("Redis.ConnectTimeout", 1);
                poolTimeOut = ConfigUtils.GetSetting("Redis.PoolTimeOut", 300);
                var readWriteHosts = ConfigUtils.GetSetting("Redis.Host.ReadWrite").Split(',');
                var readOnlyHosts = ConfigUtils.GetSetting("Redis.Host.ReadOnly").Split(',');
                var password = ConfigUtils.GetConnectionString("Redis.RequirePass");
                var dbIndex = ConfigUtils.GetSetting("Redis.Db", 0);
                dbIndex = dbIndex < 0 ? 0 : dbIndex;

                readWriteHosts = ConvertHost(readWriteHosts, password);
                readOnlyHosts = ConvertHost(readOnlyHosts, password);

                var config = new RedisClientManagerConfig()
                {
                    //“写”链接池链接数
                    MaxWritePoolSize = ConfigUtils.GetSetting("Redis.WritePool.MaxSize", 200),
                    //“读”链接池链接数
                    MaxReadPoolSize = ConfigUtils.GetSetting("Redis.Read.MaxSize", 200),
                    AutoStart = true
                };
                prcm = new PooledRedisClientManager(readWriteHosts, readOnlyHosts, config, dbIndex, PoolSizeMultiplier, poolTimeOut);
            }
            catch (Exception ex)
            {
                TraceLog.WriteError("Init the redis pool manager error:{0}", ex);
            }
        }
		/// <summary>
		/// Hosts can be an IP Address or Hostname in the format: host[:port]
		/// e.g. 127.0.0.1:6379
		/// default is: localhost:6379
		/// </summary>
		/// <param name="readWriteHosts">The write hosts.</param>
		/// <param name="readOnlyHosts">The read hosts.</param>
		/// <param name="config">The config.</param>
		public PooledRedisClientManager(
			IEnumerable<string> readWriteHosts,
			IEnumerable<string> readOnlyHosts,
			RedisClientManagerConfig config)
			: this(readWriteHosts, readOnlyHosts, config, RedisNativeClient.DefaultDb)
		{
		}
Esempio n. 6
0
 /// <summary>
 /// Hosts can be an IP Address or Hostname in the format: host[:port]
 /// e.g. 127.0.0.1:6379
 /// default is: localhost:6379
 /// </summary>
 /// <param name="readWriteHosts">The write hosts.</param>
 /// <param name="readOnlyHosts">The read hosts.</param>
 /// <param name="config">The config.</param>
 public PooledRedisClientManager(
     IEnumerable <string> readWriteHosts,
     IEnumerable <string> readOnlyHosts,
     RedisClientManagerConfig config)
     : this(readWriteHosts, readOnlyHosts, config, RedisNativeClient.DefaultDb)
 {
 }
Esempio n. 7
0
 /// <summary>
 /// Hosts can be an IP Address or Hostname in the format: host[:port]
 /// e.g. 127.0.0.1:6379
 /// default is: localhost:6379
 /// </summary>
 /// <param name="readWriteHosts">The write hosts.</param>
 /// <param name="readOnlyHosts">The read hosts.</param>
 /// <param name="config">The config.</param>
 public PooledRedisClientManager(
     IEnumerable <string> readWriteHosts,
     IEnumerable <string> readOnlyHosts,
     RedisClientManagerConfig config)
     : this(readWriteHosts, readOnlyHosts, config, null, null, null)
 {
 }
Esempio n. 8
0
        public PooledRedisClientManager(
            IEnumerable <string> readWriteHosts,
            IEnumerable <string> readOnlyHosts,
            RedisClientManagerConfig config,
            int initalDb)
        {
            this.Db = config != null
                                ? config.DefaultDb.GetValueOrDefault(initalDb)
                                : initalDb;

            ReadWriteHosts = readWriteHosts.ToIpEndPoints();
            ReadOnlyHosts  = readOnlyHosts.ToIpEndPoints();

            this.RedisClientFactory = Redis.RedisClientFactory.Instance;

            this.Config = config ?? new RedisClientManagerConfig {
                MaxWritePoolSize = ReadWriteHosts.Count * PoolSizeMultiplier,
                MaxReadPoolSize  = ReadOnlyHosts.Count * PoolSizeMultiplier,
            };

            if (this.Config.AutoStart)
            {
                this.OnStart();
            }
        }
Esempio n. 9
0
 /// <summary>
 /// 建立连接池
 /// </summary>
 public void BuildRedisPoolClient()
 {
     RedisClientManagerConfig RedisConfig = new RedisClientManagerConfig();
     RedisConfig.AutoStart = true;
     RedisConfig.MaxReadPoolSize = RedisServicePoolSize;
     RedisConfig.MaxWritePoolSize = RedisServicePoolSize;
     PooledRedisClient = new PooledRedisClientManager(RedisServiceAddress, RedisServiceAddress, RedisConfig);
 }
Esempio n. 10
0
        /// <summary>
        /// 连接池进行创建连接
        /// </summary>
        /// <returns></returns>
        public IRedisClient GetClient(List<string> readwritehosts,List<string> readhosts)
        {
            RedisClientManagerConfig redisconfig = new RedisClientManagerConfig();
            redisconfig.MaxReadPoolSize = 5;
            redisconfig.MaxWritePoolSize = 5;
            redisconfig.AutoStart = true;

            PooledRedisClientManager poolredis = new PooledRedisClientManager(readwritehosts, readhosts, redisconfig);
            return poolredis.GetClient();
        }
Esempio n. 11
0
 public RedisCacheProvider(CacheServerInfo cacheServerInfo)
 {
     _cacheServerInfo = cacheServerInfo;
     var clientManagerConfig = new RedisClientManagerConfig();
     clientManagerConfig.MaxWritePoolSize = (int) cacheServerInfo.MaxPoolSize;
     clientManagerConfig.MaxReadPoolSize = (int) cacheServerInfo.MaxPoolSize;
     clientManagerConfig.AutoStart = true;
     var dictionary = new Dictionary<long, PooledRedisClientManager>
     {
         {0, new PooledRedisClientManager(cacheServerInfo.ServerHost.Split(','),cacheServerInfo.ServerHost.Split(','), clientManagerConfig)}
     };
     PooledRedisClientManager.Add(cacheServerInfo.CacheType.ToString(), dictionary);
 }
Esempio n. 12
0
        private RedisManager()
        {
            var config = new RedisClientManagerConfig
            {
                MaxWritePoolSize = 5,
                MaxReadPoolSize = 5,
                AutoStart = true
            };
            _manager = new PooledRedisClientManager(
                new[] { "deyi@[email protected]:6379" },
                new[] { "deyi@[email protected]:6380", "deyi@[email protected]:6381" }, config);
//            _manager = new PooledRedisClientManager(
//                new[] { "[email protected]:6379" },
//                new[] { "[email protected]:6380", "[email protected]:6381" }, config);
        }
Esempio n. 13
0
        static ClientRedis()
        {
            if (Hosts != null && Hosts.Count > 0 && Clients == null)
            {
                var config = new ServiceStack.Redis.RedisClientManagerConfig()
                {
                    MaxReadPoolSize  = PoolSize,
                    MaxWritePoolSize = PoolSize,
                    DefaultDb        = Db
                };

                Clients = new List <PooledRedisClientManager>();
                foreach (var item in Hosts)
                {
                    var connect = new string[] { item, item, item };
                    Clients.Add(new ServiceStack.Redis.PooledRedisClientManager(connect, connect, config));
                }
            }
        }
Esempio n. 14
0
 private void InitConfig()
 {
     var config = ConfigUtils<RedisConfig>.Instance.Get();
     if (config == null)
     {
         const string msg = "Redis配置文件加载失败!";
         _logger.Error(msg);
         throw new Exception(msg);
     }
     var redisConfig = new RedisClientManagerConfig
     {
         MaxWritePoolSize = config.WritePoolSize,
         MaxReadPoolSize = config.ReadPoolSize,
         AutoStart = config.AutoStart,
         DefaultDb = config.DefaultDb
     };
     _manager = new PooledRedisClientManager(config.ReadAndWriteServers.Select(t => t.ToString()),
         config.ReadOnlyServers.Select(t => t.ToString()), redisConfig, 0, 50, 5);
     _manager.Start();
 }
Esempio n. 15
0
        public PooledRedisClientManager(
            IEnumerable <string> readWriteHosts,
            IEnumerable <string> readOnlyHosts,
            RedisClientManagerConfig config,
            long?initalDb,
            int?poolSizeMultiplier,
            int?poolTimeOutSeconds)
        {
            this.Db = config != null
                ? config.DefaultDb ?? initalDb
                : initalDb;

            var masters  = (readWriteHosts ?? TypeConstants.EmptyStringArray).ToArray();
            var replicas = (readOnlyHosts ?? TypeConstants.EmptyStringArray).ToArray();

            RedisResolver = new RedisResolver(masters, replicas);

            this.PoolSizeMultiplier = poolSizeMultiplier ?? 20;

            this.Config = config ?? new RedisClientManagerConfig
            {
                MaxWritePoolSize = RedisConfig.DefaultMaxPoolSize ?? masters.Length * PoolSizeMultiplier,
                MaxReadPoolSize  = RedisConfig.DefaultMaxPoolSize ?? replicas.Length * PoolSizeMultiplier,
            };

            this.OnFailover = new List <Action <IRedisClientsManager> >();

            // if timeout provided, convert into milliseconds
            this.PoolTimeout = poolTimeOutSeconds != null
                ? poolTimeOutSeconds * 1000
                : 2000; //Default Timeout

            this.AssertAccessOnlyOnSameThread = RedisConfig.AssertAccessOnlyOnSameThread;

            JsConfig.InitStatics();

            if (this.Config.AutoStart)
            {
                this.OnStart();
            }
        }
        public PooledRedisClientManager(
            IEnumerable <string> readWriteHosts,
            IEnumerable <string> readOnlyHosts,
            RedisClientManagerConfig config,
            long?initalDb,
            int?poolSizeMultiplier,
            int?poolTimeOutSeconds)
        {
            this.Db = config != null
                ? config.DefaultDb ?? initalDb
                : initalDb;

            var masters = (readWriteHosts ?? new string[0]).ToArray();
            var slaves  = (readOnlyHosts ?? new string[0]).ToArray();

            RedisResolver = new RedisResolver(masters, slaves);

            this.PoolSizeMultiplier = poolSizeMultiplier ?? 10;

            this.Config = config ?? new RedisClientManagerConfig
            {
                MaxWritePoolSize = masters.Length * PoolSizeMultiplier,
                MaxReadPoolSize  = slaves.Length * PoolSizeMultiplier,
            };

            this.OnFailover = new List <Action <IRedisClientsManager> >();

            // if timeout provided, convert into milliseconds
            this.PoolTimeout = poolTimeOutSeconds != null
                ? poolTimeOutSeconds * 1000
                : 2000; //Default Timeout


            if (this.Config.AutoStart)
            {
                this.OnStart();
            }
        }
Esempio n. 17
0
 /// <summary>
 /// Redis Configuration
 /// </summary>
 public static PooledRedisClientManager GetRedisClientManager(string serverName)
 {
     var zone = Math.Max(ExecutionContext<RequestContext>.Current.Zone, 1);
     var doc = XmlHelper.GetXmlDocCache(EndpointFile);
     var node = doc != null ? doc.SelectSingleNode("/configuration/redis[@zone='" + zone + "']/server[@name='" + serverName + "']") : null;
     if (Equals(node, null)) return null;
     var config = new RedisClientManagerConfig();
     var readWriteHosts = new List<string>();
     var readOnlyHosts = new List<string>();
     foreach (XmlNode item in node.ChildNodes)
     {
         switch (item.Name)
         {
             case "read":
                 readOnlyHosts.AddRange(from XmlNode rcnode in item.ChildNodes select XmlHelper.GetXmlAttributeValue(rcnode, "uri", string.Empty));
                 break;
             case "write":
                 readWriteHosts.AddRange(from XmlNode rcnode in item.ChildNodes select XmlHelper.GetXmlAttributeValue(rcnode, "uri", string.Empty));
                 break;
             case "socketPool":
                 config.AutoStart = XmlHelper.GetXmlAttributeValue(item, "autoStart", true);
                 config.MaxReadPoolSize = XmlHelper.GetXmlAttributeValue(item, "maxReadPoolSize", 5);
                 config.MaxWritePoolSize = XmlHelper.GetXmlAttributeValue(item, "maxWritePoolSize", 5);
                 break;
         }
     }
     return new PooledRedisClientManager(readWriteHosts, readOnlyHosts, config);
 }
		public PooledRedisClientManager(
			IEnumerable<string> readWriteHosts,
			IEnumerable<string> readOnlyHosts,
			RedisClientManagerConfig config,
			int initalDb)
		{
			this.Db = config != null
				? config.DefaultDb.GetValueOrDefault(initalDb)
				: initalDb;

			ReadWriteHosts = readWriteHosts.ToRedisEndPoints();
			ReadOnlyHosts = readOnlyHosts.ToRedisEndPoints();

			this.RedisClientFactory = Redis.RedisClientFactory.Instance;

			this.Config = config ?? new RedisClientManagerConfig {
				MaxWritePoolSize = ReadWriteHosts.Count * PoolSizeMultiplier,
				MaxReadPoolSize = ReadOnlyHosts.Count * PoolSizeMultiplier,
			};

			if (this.Config.AutoStart)
			{
				this.OnStart();
			}
		}
		public PooledRedisClientManager(
			IEnumerable<string> readWriteHosts,
			IEnumerable<string> readOnlyHosts,
			RedisClientManagerConfig config,
			int initalDb,
			int? poolSizeMultiplier,
			int? poolTimeOutSeconds)
		{
			this.Db = config != null
				? config.DefaultDb.GetValueOrDefault(initalDb)
				: initalDb;

			ReadWriteHosts = readWriteHosts.ToRedisEndPoints();
			ReadOnlyHosts = readOnlyHosts.ToRedisEndPoints();

			this.RedisClientFactory = Redis.RedisClientFactory.Instance;

			this.PoolSizeMultiplier = poolSizeMultiplier ?? 10;

			this.Config = config ?? new RedisClientManagerConfig {
				MaxWritePoolSize = ReadWriteHosts.Count * PoolSizeMultiplier,
				MaxReadPoolSize = ReadOnlyHosts.Count * PoolSizeMultiplier,
			};

			// if timeout provided, convert into milliseconds
			this.PoolTimeOut = poolTimeOutSeconds != null
				? poolTimeOutSeconds * 1000
				: null;


			if (this.Config.AutoStart)
			{
				this.OnStart();
			}
		}
Esempio n. 20
0
        public void Start(IDictionary<string, string> properties)
        {
            // Needs to lock staticly because the pool and the internal maintenance thread
            // are both static, and I want them syncs between starts and stops.
            lock (SyncObject)
            {
                if (Config == null)
                {
                    throw new ConfigurationErrorsException("Configuration for NHRedis not found");
                }

                if (_clientManager == null)
                {

                    var poolConfig = new RedisClientManagerConfig
                    {
                        MaxReadPoolSize = Config.MaxReadPoolSize,
                        MaxWritePoolSize = Config.MaxWritePoolSize
                    };

                    _clientManager = new PooledRedisClientManager(new List<string>() { Config.Host }, new List<string>(), poolConfig)
                    {
                        RedisClientFactory = new SerializingRedisClientFactory()
                    };
                }
                if (_garbageCollector == null)
                {
                   // Note: garbage collections disabled because we are using the optimized NHRedis client that
                   // never clears, so no gc needed
                   // _garbageCollector = new RedisGarbageCollector(Config.Host, Config.Port);
                   // _garbageCollector.Start();
                }

            }
        }