make connections pool module supporting different network envirenment

lib_acl_cpp/Makefile

@@ -17,8 +17,8 @@ CFLAGS = -c -g -W \
 -D_POSIX_PTHREAD_SEMANTICS \
 -Wno-long-long \
 -Wformat \
--DHAS_MYSQL_DLL
+-DHAS_MYSQL_DLL \
-#-DHAS_POLARSSL
+-DHAS_POLARSSL
 #-DUSE_DYNAMIC
 # -Wcast-align
 #-Wcast-qual

lib_acl_cpp/changes.txt

@@ -2,7 +2,9 @@
 
 ------------------------------------------------------------------------
 375) 2015.11.13
-375.1) feature: 连接池模块增加了 set_timeout 方法，更加方便添加连接池的超时时间
+375.1) feature: 连接池模块简化接口设计，允许连接集群管理器在添加新的连接池时设置超时时间，
+从而使连接池集群管理器针对不同的服务器地址采用不同的超时时间，这样可以使连接池
+模块适应于异构网络环境中
 
 374) 2015.11.12
 374.1) feature: http_request_manager 的构造函数增加了连接 http 服务器的超时时间

lib_acl_cpp/include/acl_cpp/connpool/connect_manager.hpp

@@ -18,21 +18,9 @@ class connect_monitor;
 class ACL_CPP_API connect_manager
 {
 public:
-	/**
+	connect_manager();
-	 * 构造函数
-	 * @param conn_timeout {int} 网络连接超时时间(秒)
-	 * @param rw_timeout {int} 网络 IO 超时时间(秒)
-	 */
-	connect_manager(int conn_timeout = 30, int rw_timeout = 30);
 	virtual ~connect_manager();
 
-	/**
-	 * 设置网络连接及网络 IO 超时时间
-	 * @param conn_timeout {int} 网络连接时间(秒)
-	 * @param rw_timeout {int} 网络 IO 超时时间(秒)
-	 */
-	void set_timeout(int conn_timeout, int rw_timeout);
-
 	/**
 	 * 初始化所有服务器的连接池，该函数内部调用 set 过程添加每个服务的连接池
 	 * @param default_addr {const char*} 缺省的服务器地址，如果非空，
@@ -41,21 +29,26 @@ public:
 	 *  格式: IP:PORT:COUNT;IP:PORT:COUNT;IP:PORT;IP:PORT ...
 	 *    或  IP:PORT:COUNT,IP:PORT:COUNT,IP:PORT;IP:PORT ...
 	 *  如：127.0.0.1:7777:50;192.168.1.1:7777:10;127.0.0.1:7778
-	 * @param default_count {size_t} 当 addr_list 中分隔的某个服务没有
+	 * @param count {size_t} 当 addr_list 中分隔的某个服务没有
 	 *  COUNT 信息时便用此值，当此值为 0 时，则不限制连接数上限
+	 * @param conn_timeout {int} 网络连接时间(秒)
+	 * @param rw_timeout {int} 网络 IO 超时时间(秒)
 	 *  注：default_addr 和 addr_list 不能同时为空
 	 */
 	void init(const char* default_addr, const char* addr_list,
-		size_t default_count);
+		size_t count, int conn_timeout = 30, int rw_timeout = 30);
 
 	/**
 	* 添加服务器的客户端连接池，该函数可以在程序运行时被调用，内部自动加锁
 	 * @param addr {const char*} 服务器地址(ip:port)
 	 * @param count {size_t} 连接池数量限制, 如果该值设为 0，则不设置
 	 *  连接池的连接上限
+	 * @param conn_timeout {int} 网络连接时间(秒)
+	 * @param rw_timeout {int} 网络 IO 超时时间(秒)
 	 * @return {connect_pool&} 返回新添加的连接池对象
 	 */
-	connect_pool& set(const char* addr, size_t count);
+	connect_pool& set(const char* addr, size_t count,
+		int conn_timeout = 30, int rw_timeout = 30);
 
 	/**
 	 * 设置连接池失败后重试的时间时间隔（秒），该函数可以在程序运行时被调用，内部自动加锁
@@ -185,8 +178,6 @@ protected:
 
 protected:
 	string default_addr_;			// 缺省的服务地址
-	int  conn_timeout_;			// 连接服务器超时时间(秒)
-	int  rw_timeout_;			// 与服务器的 IO 超时时间(秒)
 	connect_pool* default_pool_;		// 缺省的服务连接池
 	std::vector<connect_pool*> pools_;	// 所有的服务连接池
 	size_t service_idx_;			// 下一个要访问的的下标值
@@ -196,7 +187,8 @@ protected:
 	connect_monitor* monitor_;		// 后台检测线程句柄
 
 	// 设置除缺省服务之外的服务器集群
-	void set_service_list(const char* addr_list, int count);
+	void set_service_list(const char* addr_list, int count,
+		int conn_timeout, int rw_timeout);
 };
 
 } // namespace acl

lib_acl_cpp/include/acl_cpp/http/http_request_manager.hpp

@@ -11,12 +11,7 @@ namespace acl
 class ACL_CPP_API http_request_manager : public acl::connect_manager
 {
 public:
-	/**
+	http_request_manager();
-	 * 构造函数
-	 * @param conn_timeout {int} 连接超时时间(秒)
-	 * @param rw_timeout {int} 网络 IO 读写超时时间(秒)
-	 */
-	http_request_manager(int conn_timeout = 30, int rw_timeout = 30);
 	virtual ~http_request_manager();
 
 protected:

lib_acl_cpp/include/acl_cpp/redis/redis_client_cluster.hpp

@@ -23,14 +23,9 @@ public:
 	/**
 	 * 构造函数;
 	 * constructor
-	 * @param conn_timeout {int} 服务器连接超时时间(秒);
-	 *  timeout in seconds for connecting the redis-server
-	 * @param rw_timeout {int}　网络 IO 读写超时时间(秒);
-	 *  read/write timeout in seconds from/to the redis-server
 	 * @param max_slot {int} 哈希槽最大值; the max hash-slot value of keys
 	 */
-	redis_client_cluster(int conn_timeout = 30, int rw_timeout = 30,
+	redis_client_cluster(int max_slot = 16384);
-		int max_slot = 16384);
 	virtual ~redis_client_cluster();
 
 	/**

lib_acl_cpp/samples/http_request_manager/main.cpp

@@ -21,18 +21,19 @@ static void sleep_while(int n)
 // 初始化过程
 static void init(const char* addrs, int count)
 {
+	int  cocurrent = 100, conn_timeout = 100, rw_timeout = 200;
+
 	// 创建 HTTP 请求连接池集群管理对象
 	__conn_manager = new http_request_manager();
 
-	__conn_manager->set_timeout(100, 120);
 	// 添加服务器集群地址
-	__conn_manager->init(addrs, addrs, 100);
+	__conn_manager->init(addrs, addrs, cocurrent, conn_timeout, rw_timeout);
 
 	printf(">>>start monitor thread\r\n");
 
-	int  check_inter = 1, conn_timeout = 5;
+	int  check_inter = 1, check_conn_timeout = 5;
 	acl::connect_monitor* monitor = new acl::connect_monitor(*__conn_manager);
-	(*monitor).set_check_inter(check_inter).set_conn_timeout(conn_timeout);
+	(*monitor).set_check_inter(check_inter).set_conn_timeout(check_conn_timeout);
 
 	// 启动后台检测线程
 	__conn_manager->start_monitor(monitor);

lib_acl_cpp/samples/redis/README.md

@@ -88,8 +88,8 @@ int main(void)
 	int conn_timeout = 10, rw_timeout = 10, max_conns = 100;
 
 	// declare redis cluster ojbect
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(redis_addr, max_conns);
+	cluster.set(redis_addr, max_conns, conn_timeout, rw_timeout);
 
 	// redis operation command
 	acl::redis_string cmd_string;
@@ -156,8 +156,8 @@ int main(void)
 	int conn_timeout = 10, rw_timeout = 10, max_conns = 100;
 
 	// declare redis cluster ojbect
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(redis_addr, max_conns);
+	cluster.set(redis_addr, max_conns, conn_timeout, rw_timeout);
 
 	// redis operation command
 	acl::redis cmd;
@@ -204,8 +204,8 @@ int main(void)
 	int conn_timeout = 10, rw_timeout = 10;
 
 	// declare redis cluster ojbect
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(redis_addr, __max_conns);
+	cluster.set(redis_addr, __max_conns, conn_timeout, rw_timeout);
 
 	pthread_attr_t attr;
 	pthread_attr_init(&attr);

lib_acl_cpp/samples/redis/redis_client_cluster/redis_client_cluster.cpp

@@ -292,7 +292,7 @@ int main(int argc, char* argv[])
 	acl::acl_cpp_init();
 	acl::log::stdout_open(true);
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
 
 	// 当某个连接池结点出问题，设置探测该连接结点是否恢复的时间间隔(秒)，当该值
 	// 为 0 时，则不检测
@@ -304,7 +304,7 @@ int main(int argc, char* argv[])
 	// 当重定向次数 >= 2 时每次再重定向此函数设置休息的时间(毫秒)
 	cluster.set_redirect_sleep(nsleep);
 
-	cluster.init(NULL, addrs.c_str(), max_threads);
+	cluster.init(NULL, addrs.c_str(), max_threads, conn_timeout, rw_timeout);
 
 	// 设置连接 redis 集群的密码，第一个参数为一个 redis 服务节点的服务地址，
 	// 当第一个参数值为 default 时，则设置了所有节点的统一连接密码

lib_acl_cpp/samples/redis/redis_client_cluster2/redis_client_cluster2.cpp

@@ -360,7 +360,7 @@ int main(int argc, char* argv[])
 	acl::acl_cpp_init();
 	acl::log::stdout_open(true);
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
 
 	// 当某个连接池结点出问题，设置探测该连接结点是否恢复的时间间隔(秒)，当该值
 	// 为 0 时，则不检测
@@ -372,7 +372,7 @@ int main(int argc, char* argv[])
 	// 当重定向次数 >= 2 时每次再重定向此函数设置休息的时间(毫秒)
 	cluster.set_redirect_sleep(nsleep);
 
-	cluster.init(NULL, addrs.c_str(), max_threads);
+	cluster.init(NULL, addrs.c_str(), max_threads, conn_timeout, rw_timeout);
 
 	// 是否需要将所有哈希槽的对应关系提前设置好，这样可以去掉运行时动态添加
 	// 哈希槽的过程，从而可以提高运行时的效率

lib_acl_cpp/samples/redis/redis_cluster/redis_cluster.cpp

@@ -100,7 +100,7 @@ static bool test_info(acl::redis_cluster& redis)
 static bool preset_all(const char* addr)
 {
 	int max_slot = 16384;
-	acl::redis_client_cluster cluster(10, 10, max_slot);
+	acl::redis_client_cluster cluster(max_slot);
 	cluster.set_all_slot(addr, 100);
 
 	for (int i = 0; i < max_slot; i++)

lib_acl_cpp/samples/redis/redis_geo/redis_geo.cpp

@@ -254,8 +254,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis redis;
 	redis.set_cluster(&cluster, 100);

lib_acl_cpp/samples/redis/redis_hash/redis_hash.cpp

@@ -413,8 +413,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 	client.set_slice_request(slice_req);

lib_acl_cpp/samples/redis/redis_hyperloglog/redis_hyperloglog.cpp

@@ -143,8 +143,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 	client.set_slice_request(slice_req);

lib_acl_cpp/samples/redis/redis_key/redis_key.cpp

@@ -157,8 +157,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 

lib_acl_cpp/samples/redis/redis_list/redis_list.cpp

@@ -746,8 +746,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 

lib_acl_cpp/samples/redis/redis_manager/redis_manager.cpp

@@ -217,8 +217,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster manager(conn_timeout, rw_timeout);
+	acl::redis_client_cluster manager;
-	manager.set(addr.c_str(), max_threads);
+	manager.set(addr.c_str(), max_threads, conn_timeout, rw_timeout);
 
 	std::vector<test_thread*> threads;
 	for (int i = 0; i < max_threads; i++)

lib_acl_cpp/samples/redis/redis_pubsub/redis_pubsub.cpp

@@ -163,8 +163,8 @@ int main(int argc, char* argv[])
 	acl::acl_cpp_init();
 	acl::log::stdout_open(true);
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 

lib_acl_cpp/samples/redis/redis_set/redis_set.cpp

@@ -444,8 +444,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 

lib_acl_cpp/samples/redis/redis_string/redis_string.cpp

@@ -699,8 +699,8 @@ int main(int argc, char* argv[])
 	acl::acl_cpp_init();
 	acl::log::stdout_open(true);
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 

lib_acl_cpp/samples/redis/redis_zset/redis_zset.cpp

@@ -586,8 +586,8 @@ int main(int argc, char* argv[])
 
 	acl::acl_cpp_init();
 
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr.c_str(), 100);
+	cluster.set(addr.c_str(), 100, conn_timeout, rw_timeout);
 
 	acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
 

lib_acl_cpp/samples/session/redis_session.cpp

@@ -91,8 +91,8 @@ private:
 bool test_redis_session(const char* addr, int n, int max_threads)
 {
 	int conn_timeout = 10, rw_timeout = 10;
-	acl::redis_client_cluster cluster(conn_timeout, rw_timeout);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr, max_threads);
+	cluster.set(addr, max_threads, conn_timeout, rw_timeout);
 
 	std::vector<test_thread*> threads;
 	for (int i = 0; i < max_threads; i++)
@@ -146,8 +146,8 @@ bool test_redis_session_attrs(const char* addr, int n)
 		attrs[name] = value;
 	}
 
-	acl::redis_client_cluster cluster(10, 10);
+	acl::redis_client_cluster cluster;
-	cluster.set(addr, 1);
+	cluster.set(addr, 1, 10, 10);
 
 	acl::redis_session sess(cluster, 1);
 	if (sess.set_attrs(attrs) == false)

lib_acl_cpp/src/connpool/connect_manager.cpp

@@ -9,10 +9,8 @@
 namespace acl
 {
 
-connect_manager::connect_manager(int conn_timeout, int rw_timeout)
+connect_manager::connect_manager()
-: conn_timeout_(conn_timeout)
+: default_pool_(NULL)
-, rw_timeout_(rw_timeout)
-, default_pool_(NULL)
 , service_idx_(0)
 , stat_inter_(1)
 , retry_inter_(1)
@@ -33,18 +31,6 @@ connect_manager::~connect_manager()
 	lock_.unlock();
 }
 
-void connect_manager::set_timeout(int conn_timeout, int rw_timeout)
-{
-	conn_timeout_ = conn_timeout;
-	rw_timeout_ = rw_timeout;
-
-	for (std::vector<connect_pool*>::iterator it = pools_.begin();
-		it != pools_.end(); ++it)
-	{
-		(*it)->set_timeout(conn_timeout, rw_timeout);
-	}
-}
-
 // 分析一个服务器地址，格式：IP:PORT[:MAX_CONN]
 // 返回值 < 0 表示非法的地址
 static int check_addr(const char* addr, string& buf, size_t default_count)
@@ -93,11 +79,11 @@ void connect_manager::set_retry_inter(int n)
 	lock_.unlock();
 }
 
-void connect_manager::init(const char* default_addr,
+void connect_manager::init(const char* default_addr, const char* addr_list,
-	const char* addr_list, size_t count)
+	size_t count, int conn_timeout /* = 30 */, int rw_timeout /* = 30 */)
 {
 	if (addr_list != NULL && *addr_list != 0)
-		set_service_list(addr_list, count);
+		set_service_list(addr_list, count, conn_timeout, rw_timeout);
 
 	// 创建缺省服务连接池对象，该对象一同放入总的连接池集群中
 	if (default_addr != NULL && *default_addr != 0)
@@ -107,8 +93,8 @@ void connect_manager::init(const char* default_addr,
 		if (max < 0)
 			logger("no default connection set");
 		else
-			default_pool_ = &set(default_addr_.c_str(),
+			default_pool_ = &set(default_addr_.c_str(), max,
-						(size_t) max);
+				conn_timeout, rw_timeout);
 	}
 	else
 		logger("no default connection set");
@@ -118,7 +104,8 @@ void connect_manager::init(const char* default_addr,
 		logger_fatal("no connection available!");
 }
 
-void connect_manager::set_service_list(const char* addr_list, int count)
+void connect_manager::set_service_list(const char* addr_list, int count,
+	int conn_timeout, int rw_timeout)
 {
 	if (addr_list == NULL || *addr_list == 0)
 	{
@@ -141,7 +128,7 @@ void connect_manager::set_service_list(const char* addr_list, int count)
 			logger_error("invalid server addr: %s", addr.c_str());
 			continue;
 		}
-		(void) set(addr.c_str(), max);
+		(void) set(addr.c_str(), max, conn_timeout, rw_timeout);
 		logger("add one service: %s, max connect: %d",
 			addr.c_str(), max);
 	}
@@ -149,7 +136,8 @@ void connect_manager::set_service_list(const char* addr_list, int count)
 	acl_myfree(buf);
 }
 
-connect_pool& connect_manager::set(const char* addr, size_t count)
+connect_pool& connect_manager::set(const char* addr, size_t count,
+	int conn_timeout /* = 30 */, int rw_timeout /* = 30 */)
 {
 	char key[256];
 	ACL_SAFE_STRNCPY(key, addr, sizeof(key));
@@ -169,7 +157,7 @@ connect_pool& connect_manager::set(const char* addr, size_t count)
 
 	connect_pool* pool = create_pool(key, count, pools_.size() - 1);
 	pool->set_retry_inter(retry_inter_);
-	pool->set_timeout(conn_timeout_, rw_timeout_);
+	pool->set_timeout(conn_timeout, rw_timeout);
 	pools_.push_back(pool);
 
 	lock_.unlock();

lib_acl_cpp/src/http/http_request_manager.cpp

@@ -5,9 +5,7 @@
 namespace acl
 {
 
-http_request_manager::http_request_manager(
+http_request_manager::http_request_manager()
-	int conn_timeout /* = 30 */, int rw_timeout /* = 30 */)
-	: connect_manager(conn_timeout, rw_timeout)
 {
 }
 

lib_acl_cpp/src/redis/redis_client_cluster.cpp

@@ -10,10 +10,8 @@
 namespace acl
 {
 
-redis_client_cluster::redis_client_cluster(int conn_timeout /* = 30 */,
+redis_client_cluster::redis_client_cluster(int max_slot /* = 16384 */)
-	int rw_timeout /* = 30 */, int max_slot /* = 16384 */)
+: max_slot_(max_slot)
-: connect_manager(conn_timeout, rw_timeout)
-, max_slot_(max_slot)
 , redirect_max_(15)
 , redirect_sleep_(100)
 {