lcb_t AdFeedbackMgr::get_conn_from_pool()
{
lcb_t ret;
{
boost::unique_lock<boost::mutex> dmp_pool_lock_;
if (!dmp_conn_pool_.empty())
{
ret = dmp_conn_pool_.front();
dmp_conn_pool_.pop_front();
return ret;
}
}
lcb_error_t err;
struct lcb_create_st options;
memset(&options, 0, sizeof(options));
options.v.v0.host = dmp_server_ip_.c_str();
options.v.v0.user = "******";
options.v.v0.passwd = "";
options.v.v0.bucket = "user_profile";
err = lcb_create(&ret, &options);
if (err != LCB_SUCCESS)
{
LOG(ERROR) << "failed to create couchbase connection." << lcb_strerror(NULL, err);
return NULL;
}
lcb_set_error_callback(ret, err_callback);
err = lcb_connect(ret);
if (err != LCB_SUCCESS)
{
LOG(ERROR) << "failed to connect to couchbase." << lcb_strerror(NULL, err);
lcb_destroy(ret);
ret = NULL;
return ret;
}
lcb_wait(ret);
// usec for timeout.
lcb_set_timeout(ret, 1000*100);
lcb_set_get_callback(ret, get_callback);
LOG(INFO) << "a new connection to DMP established";
return ret;
}
static int
Connection_set_timeout(pycbc_Connection *self,
PyObject *other, void *unused)
{
double newval;
lcb_uint32_t usecs;
newval = PyFloat_AsDouble(other);
if (newval == -1.0) {
if (PyErr_Occurred()) {
return -1;
}
}
if (newval <= 0) {
PyErr_SetString(PyExc_ValueError, "Timeout must not be 0");
return -1;
}
usecs = (lcb_uint32_t)(newval * 1000000);
lcb_set_timeout(self->instance, usecs);
(void)unused;
return 0;
}
static ngx_int_t
ngx_lcb_init_process(ngx_cycle_t *cycle)
{
ngx_lcb_main_conf_t *cmcf;
struct lcb_create_io_ops_st options;
lcb_error_t err;
ngx_int_t rc;
ngx_uint_t i;
ngx_lcb_connection_t *conn;
ngx_lcb_loc_conf_t **ccfp;
/* initialize libcouchbase IO plugin */
memset(&options, 0, sizeof(options));
options.version = 2;
options.v.v2.create = ngx_lcb_create_io_opts;
options.v.v2.cookie = &lcb_cookie;
err = lcb_create_io_ops(&lcb_cookie.io, &options);
if (err != LCB_SUCCESS) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"couchbase: failed to create IO object for libcouchbase: 0x%02xd \"%s\"",
err, lcb_strerror(NULL, err));
return NGX_ERROR;
}
lcb_cookie.log = cycle->log;
lcb_cookie.pool = cycle->pool;
/* materialize upstream connections */
rc = ngx_array_init(&lcb_connections, cycle->pool, 4, sizeof(ngx_lcb_connection_t));
if (rc != NGX_OK) {
return NGX_ERROR;
}
cmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_couchbase_module);
ccfp = cmcf->connection_confs.elts;
for (i = 0; i < cmcf->connection_confs.nelts; i++) {
struct lcb_create_st opts = ccfp[i]->options;
conn = ngx_array_push(&lcb_connections);
if (conn == NULL) {
return NGX_ERROR;
}
conn->log = cycle->log;
conn->name = ccfp[i]->name;
rc = ngx_array_init(&conn->backlog, cycle->pool, 4, sizeof(ngx_http_request_t *));
if (rc != NGX_OK) {
return NGX_ERROR;
}
opts.v.v0.io = lcb_cookie.io;
err = lcb_create(&conn->lcb, &opts);
if (err != LCB_SUCCESS) {
ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
"couchbase: failed to create libcouchbase instance: 0x%02xd \"%s\"",
err, lcb_strerror(NULL, err));
return NGX_ERROR;
}
(void)lcb_set_error_callback(conn->lcb, ngx_lcb_error_callback);
(void)lcb_set_timeout(conn->lcb, ccfp[i]->connect_timeout * 1000); /* in usec */
(void)lcb_set_get_callback(conn->lcb, ngx_lcb_get_callback);
(void)lcb_set_store_callback(conn->lcb, ngx_lcb_store_callback);
(void)lcb_set_remove_callback(conn->lcb, ngx_lcb_remove_callback);
(void)lcb_set_configuration_callback(conn->lcb, ngx_lcb_configuration_callback);
(void)lcb_set_cookie(conn->lcb, conn);
ngx_log_debug7(NGX_LOG_DEBUG_HTTP, cycle->log, 0,
"couchbase(%p): configured connection \"%V\": connect_timeout:%Mms "
"address:%s bucket:%s user:%s password:%s",
conn->lcb, &conn->name, ccfp[i]->connect_timeout,
opts.v.v0.host ? opts.v.v0.host : "(null)",
opts.v.v0.bucket ? opts.v.v0.bucket : "(null)",
opts.v.v0.user ? opts.v.v0.user : "******",
opts.v.v0.passwd ? opts.v.v0.passwd : "(null)");
}
return NGX_OK;
}
couchbase_con* couchbase_new_connection(struct cachedb_id* id)
{
couchbase_con *con;
struct lcb_create_st options;
lcb_t instance;
lcb_error_t rc;
last_error = LCB_SUCCESS;
if (id == NULL) {
LM_ERR("null cachedb_id\n");
return 0;
}
con = pkg_malloc(sizeof(couchbase_con));
if (con == NULL) {
LM_ERR("no more pkg \n");
return 0;
}
memset(con,0,sizeof(couchbase_con));
con->id = id;
con->ref = 1;
/* TODO - support custom ports - couchbase expects host:port in id->host */
memset(&options,0,sizeof(struct lcb_create_st));
options.version = 0;
options.v.v0.host = id->host;
options.v.v0.user = id->username;
options.v.v0.passwd = id->password;
options.v.v0.bucket = id->database;
rc=lcb_create(&instance, &options);
if (rc!=LCB_SUCCESS) {
LM_ERR("Failed to create libcouchbase instance: 0x%02x, %s\n",
rc, lcb_strerror(NULL, rc));
return 0;
}
(void)lcb_set_error_callback(instance,
couchbase_error_cb);
(void)lcb_set_get_callback(instance,
couchbase_get_cb);
(void)lcb_set_store_callback(instance,
couchbase_store_cb);
(void)lcb_set_remove_callback(instance,
couchbase_remove_cb);
(void)lcb_set_arithmetic_callback(instance,couchbase_arithmetic_cb);
(void)lcb_set_timeout(instance,couch_timeout_usec);
rc=lcb_connect(instance);
if (rc != LCB_SUCCESS) {
LM_ERR("Failed to connect to the Couchbase. Host: %s Bucket: %s Error: %s\n",
id->host, id->database, lcb_strerror(instance, rc));
lcb_destroy(instance);
return 0;
}
/* Wait for the connect to complete */
lcb_wait(instance);
/*Check connection*/
if (last_error != LCB_SUCCESS) {
/*Consider these connect failurs as fatal*/
if(last_error == LCB_AUTH_ERROR || last_error == LCB_INVALID_HOST_FORMAT || last_error == LCB_INVALID_CHAR) {
LM_ERR("Fatal connection error to Couchbase. Host: %s Bucket: %s Error: %s",
id->host, id->database, lcb_strerror(instance, last_error));
lcb_destroy(instance);
return 0;
} else {
/* Non-fatal errors, we may be able to connect later */
LM_ERR("Non-Fatal connection error to Couchbase. Host: %s Bucket: %s Error: %s",
id->host, id->database, lcb_strerror(instance, last_error));
}
} else {
LM_DBG("Succesfully connected to Couchbase Server. Host: %s Bucket: %s\n", id->host, id->database);
}
con->couchcon = instance;
return con;
}
