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; }