int conn_pool_put(conn_pool_t* pool, void* conn, int real_close)
{
conn_cb_t* cbs = pool->cbs;
if(real_close || cbs->test_close(conn)){//需要关闭
free_and_close(conn,cbs,&pool->statis);
uint64_inc(&pool->statis.release_real);
conn = NULL;
}
if(conn != NULL){
int islocked = (pthread_spin_lock(&pool->spin)==0);
if(!cpool_is_full(pool)){
assert(pool->conns[pool->end] == NULL);
pool->conns[pool->end] = conn;
conn = NULL;
pool->end = (pool->end+1) % pool->size;
sync_inc(&pool->curconns);
uint64_inc(&pool->statis.release);
}
if(islocked)pthread_spin_unlock(&pool->spin);
if(conn != NULL){
free_and_close(conn,cbs,&pool->statis);
uint64_inc(&pool->statis.release_real);
conn = NULL;
}
}
return 0;
}
conn_pool_t* conn_pool_new(int size,int lazy_init,conn_cb_t* cbs, void* args)
{
int i;
assert(size > 0);
conn_pool_t* pool = (conn_pool_t*)PCALLOC(sizeof(conn_pool_t));
pool->conns = (void**)PCALLOC(sizeof(void*)*size);
pool->size = size;
pool->args = args;
pool->curconns = 0;
pool->cbs = (conn_cb_t*)PCALLOC(sizeof(conn_cb_t));
memcpy(pool->cbs, cbs, sizeof(conn_cb_t));
if(lazy_init == 0){
pool->start = pool->end = 0;
for(i=0;i<size; i++){
pool->conns[i] = new_and_connect(cbs, args,&pool->statis);
if(pool->conns[i]) sync_inc(&pool->curconns);
}
}else{
pool->start = 0;
pool->end = 0;
}
pthread_spin_init(&pool->spin, 0);
return pool;
}
void ConnectionContext::Shutdown()
{
if (!check_closed() && type_ & ConnectionContext::ssl) {
if (sync_compare_and_swap(&shutdown_flag_, 0, 1))
sync_inc(&ref_);
ssl_stream_->asyn_shutdown(&IOCPWebServer::on_shutdown, this);
}
}
void ConnectionContext::Send(const char *buf, int len)
{
if (check_closed())
return;
sync_inc(&ref_);
if (ssl_stream_)
ssl_stream_->asyn_send(buf, len, &IOCPWebServer::on_send, this);
else
tcp_stream_->asyn_send(buf, len, &IOCPWebServer::on_send, this);
}
void ConnectionContext::Recv(char *buf, int len)
{
if (check_closed())
return;
sync_inc(&ref_);
if (ssl_stream_)
ssl_stream_->asyn_recv_some(buf, len, &IOCPWebServer::on_receive, this);
else
tcp_stream_->asyn_recv_some(buf, len, &IOCPWebServer::on_receive, this);
}
void ConnectionContext::Handshake()
{
if (!check_closed() && type_ & ConnectionContext::ssl) {
sync_inc(&ref_);
if (type_ == ConnectionContext::https)
ssl_stream_->asyn_handshake(ssl::server, &IOCPWebServer::on_handshake, this);
else
ssl_stream_->asyn_handshake(ssl::client, &IOCPWebServer::on_handshake, this);
}
}
void ConnectionContext::Connect(const char *pszIP, unsigned short port)
{
if (!check_closed()) {
sync_inc(&ref_);
if (ssl_stream_)
ssl_stream_->asyn_connect(pszIP, port, &IOCPWebServer::on_connect, this);
else
tcp_stream_->asyn_connect(pszIP, port, &IOCPWebServer::on_connect, this);
}
}
