connect_pool* connect_manager::get(const char* addr,
bool exclusive /* = true */, bool restore /* = false */)
{
char key[256];
ACL_SAFE_STRNCPY(key, addr, sizeof(key));
acl_lowercase(key);
if (exclusive)
lock_.lock();
std::vector<connect_pool*>::iterator it = pools_.begin();
for (; it != pools_.end(); ++it)
{
if (strcasecmp(key, (*it)->get_addr()) == 0)
{
if (restore && (*it)->aliving() == false)
(*it)->set_alive(true);
if (exclusive)
lock_.unlock();
return *it;
}
}
if (exclusive)
lock_.unlock();
logger_error("no connect pool for addr %s", addr);
return NULL;
}
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));
acl_lowercase(key);
lock_.lock();
std::vector<connect_pool*>::iterator it = pools_.begin();
for (; it != pools_.end(); ++it)
{
if (strcasecmp(key, (*it)->get_addr()) == 0)
{
lock_.unlock();
return **it;
}
}
connect_pool* pool = create_pool(key, count, pools_.size() - 1);
pool->set_retry_inter(retry_inter_);
pool->set_timeout(conn_timeout, rw_timeout);
if (idle_ttl_ >= 0)
pool->set_idle_ttl(idle_ttl_);
if (check_inter_ > 0)
pool->set_check_inter(check_inter_);
pools_.push_back(pool);
lock_.unlock();
logger("Add one service, addr: %s, count: %d", addr, (int) count);
return *pool;
}
ACL_DNS_DB *acl_netdb_new(const char *domain)
{
const char *myname = "acl_netdb_new";
ACL_DNS_DB *dns_db;
char buf[256];
dns_db = acl_mycalloc(1, sizeof(ACL_DNS_DB));
if (dns_db == NULL) {
acl_msg_error("%s, %s(%d): calloc error(%s)",
__FILE__, myname, __LINE__,
acl_last_strerror(buf, sizeof(buf)));
return (NULL);
}
dns_db->h_db = acl_array_create(5);
if (dns_db->h_db == NULL) {
acl_msg_error("%s, %s(%d): create array error(%s)",
__FILE__, myname, __LINE__,
acl_last_strerror(buf, sizeof(buf)));
acl_myfree(dns_db);
return (NULL);
}
snprintf(dns_db->name, sizeof(dns_db->name), "%s", domain);
acl_lowercase(dns_db->name);
dns_db->iter_head = netdb_iter_head;
dns_db->iter_next = netdb_iter_next;
dns_db->iter_tail = netdb_iter_tail;
dns_db->iter_prev = netdb_iter_prev;
dns_db->iter_info = netdb_iter_info;
return (dns_db);
}
connect_pool& connect_manager::set(const char* addr, int count)
{
char key[256];
ACL_SAFE_STRNCPY(key, addr, sizeof(key));
acl_lowercase(key);
lock_.lock();
std::vector<connect_pool*>::iterator it = pools_.begin();
for (; it != pools_.end(); ++it)
{
if (strcasecmp(key, (*it)->get_addr()) == 0)
{
lock_.unlock();
return **it;
}
}
connect_pool* pool = create_pool(key, count, pools_.size() - 1);
pools_.push_back(pool);
lock_.unlock();
logger("Add one service, addr: %s, count: %d", addr, count);
return *pool;
}
void acl_xml3_tag_add(const char *tag)
{
if (tag_tree) {
char buf[256];
ACL_SAFE_STRNCPY(buf, tag, sizeof(buf));
acl_lowercase(buf);
acl_token_tree_add(tag_tree, buf, ACL_TOKEN_F_STOP, NULL);
}
}
beanstalk::beanstalk(const char* addr, int conn_timeout,
bool retry /* = true */)
: timeout_(conn_timeout)
, retry_(retry)
{
addr_ = acl_mystrdup(addr);
acl_lowercase(addr_);
errbuf_[0] = 0;
tube_used_ = NULL;
// 放置缺省队列
tubes_watched_.push_back(acl_mystrdup("default"));
}
bool query::append_key(string& buf, char* key)
{
acl_lowercase(key);
std::map<string, query_param*>::iterator it = params_.find(key);
if (it == params_.end())
{
logger_warn("unknown key: %s", key);
buf.append(key);
return false;
}
char fmt[256];
query_param* param = it->second;
switch (param->type)
{
case DB_PARAM_CHAR:
buf.format_append("'%c'", param->v.c);
break;
case DB_PARAM_SHORT:
buf.format_append("%d", param->v.s);
break;
case DB_PARAM_INT32:
buf.format_append("%d", param->v.n);
break;
case DB_PARAM_INT64:
buf.format_append("%lld", param->v.l);
break;
case DB_PARAM_STR:
buf.format_append("'%s'",
escape(param->v.S, param->dlen, buf_).c_str());
break;
case DB_PARAM_FLOAT:
safe_snprintf(fmt, sizeof(fmt), "%%.%df", param->precision);
buf.format_append(fmt, param->v.f);
break;
case DB_PARAM_DOUBLE:
safe_snprintf(fmt, sizeof(fmt), "%%.%df", param->precision);
buf.format_append(fmt, param->v.d);
break;
default:
logger_error("unknown type: %d", param->type);
break;
}
return true;
}
int acl_xml3_tag_selfclosed(const char *tag)
{
const ACL_TOKEN *token;
char buf[256];
if (tag_tree == NULL)
return (0);
ACL_SAFE_STRNCPY(buf, tag, sizeof(buf));
acl_lowercase(buf);
token = acl_token_tree_word_match(tag_tree, buf);
if (token)
return 1;
else
return 0;
}
ACL_DNS_DB *acl_netdb_new(const char *domain)
{
ACL_DNS_DB *db;
db = acl_mycalloc(1, sizeof(ACL_DNS_DB));
db->h_db = acl_array_create(5);
snprintf(db->name, sizeof(db->name), "%s", domain);
acl_lowercase(db->name);
db->iter_head = netdb_iter_head;
db->iter_next = netdb_iter_next;
db->iter_tail = netdb_iter_tail;
db->iter_prev = netdb_iter_prev;
db->iter_info = netdb_iter_info;
return db;
}
/* 查询DNS信息，采用协议发送的方式 */
static void inner_nslookup(SERVICE *service, CLIENT_ENTRY *entry,
const char *domain, int port)
{
char *ptr;
STRNCPY(entry->dns_ctx.domain_key, domain,
sizeof(entry->dns_ctx.domain_key));
acl_lowercase(entry->dns_ctx.domain_key);
ptr = strchr(entry->dns_ctx.domain_key, ':');
if (ptr)
*ptr = 0;
entry->server_port = port;
if (entry->server_port <= 0)
entry->server_port = 80;
STRNCPY(entry->domain_key, entry->dns_ctx.domain_key,
sizeof(entry->domain_key));
acl_dns_lookup(service->dns_handle, entry->domain_key,
inner_nslookup_complete, entry);
}
void connect_manager::remove(const char* addr)
{
char key[256];
ACL_SAFE_STRNCPY(key, addr, sizeof(key));
acl_lowercase(key);
lock_.lock();
std::vector<connect_pool*>::iterator it = pools_.begin();
for (; it != pools_.end(); ++it)
{
if (strcasecmp(key, (*it)->get_addr()) == 0)
{
(*it)->set_delay_destroy();
pools_.erase(it);
break;
}
}
if (it == pools_.end())
logger_warn("addr(%s) not found!", addr);
lock_.unlock();
}
/* 查询DNS信息，采用外挂模块的方式 */
static void thrpool_nslookup(SERVICE *service, CLIENT_ENTRY *entry,
const char *domain, int port)
{
const char *myname = "thrpool_nslookup";
DNS_CTX dns_ctx;
DNS_RING *list;
char *ptr;
entry->tm.stamp = time(NULL);
memset(&dns_ctx, 0, sizeof(dns_ctx));
dns_ctx.begin = entry->tm.stamp;
STRNCPY(dns_ctx.domain_key, domain, sizeof(dns_ctx.domain_key));
ptr = strchr(dns_ctx.domain_key, ':');
/* 仅留下域名部分 */
if (ptr)
*ptr = 0;
entry->server_port = port;
if (entry->server_port <= 0)
entry->server_port = 80;
/* 将域名字符串都转换成小写，以便于进行哈希查询 */
acl_lowercase(dns_ctx.domain_key);
dns_ctx.context = service;
dns_ctx.callback = thrpool_nslookup_complete;
STRNCPY(entry->domain_key, dns_ctx.domain_key, sizeof(entry->domain_key));
/* 先查询DNS查询表中是否已经包含本次需要被查询的域名 */
list = (DNS_RING *) acl_htable_find(service->dns_table, dns_ctx.domain_key);
if (list) {
/* 将本次对同一域名的查询添加进同一个查询链中 */
acl_ring_prepend(&list->ring, &entry->dns_entry);
/* 将查询链对象的引用计数加1 */
list->nrefer++;
/* 如果该查询链已经存在，说明有查询任务等待返回，其返回后会一同将
* 本次任务进行触发，如果此处触发新任务，则会造成内存访问冲突，因为
* 查询DNS的过程是由一组线程池进行查询的。
* (void) dns_server_lookup(proxy_entry->aio_proxy->dns_server, &dns_ctx);
*/
return;
}
/* 创建一个新的查询链对象，并将本次查询任务加入该查询链中及将该查询链加入查询表中 */
list = (DNS_RING *) acl_mycalloc(1, sizeof(DNS_RING));
acl_ring_init(&list->ring);
STRNCPY(list->domain_key, dns_ctx.domain_key, sizeof(list->domain_key));
/* 将本次查询任务加入新的查询链中且将查询链的引用计数加1 */
acl_ring_prepend(&list->ring, &entry->dns_entry);
list->nrefer++;
/* 将新的查询链加入查询表中 */
if (acl_htable_enter(service->dns_table, list->domain_key, (char *) list) == NULL)
acl_msg_fatal("%s: add domain(%s) to table error", myname, list->domain_key);
/* 开始启动DNS查询过程 */
(void) dns_server_lookup(service->dns_server, &dns_ctx);
}