int couchbase_remove(cachedb_con *connection,str *attr)
{
lcb_t instance;
lcb_error_t oprc;
lcb_remove_cmd_t cmd;
const lcb_remove_cmd_t *commands[1];
struct timeval start;
start_expire_timer(start,couch_exec_threshold);
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
oprc = lcb_remove(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
if (oprc == LCB_KEY_ENOENT) {
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase remove",attr->s,attr->len,0);
return -1;
}
LM_ERR("Failed to send the remove query - %s\n", lcb_strerror(instance, oprc));
if (couchbase_conditional_reconnect(connection, oprc) != 1) {
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase remove",attr->s,attr->len,0);
return -2;
};
instance = COUCHBASE_CON(connection);
oprc = lcb_remove(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
if (oprc == LCB_KEY_ENOENT) {
LM_ERR("Remove command successfully retried\n");
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase remove",attr->s,attr->len,0);
return -1;
}
LM_ERR("Remove command retry failed - %s\n", lcb_strerror(instance, oprc));
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase remove",attr->s,attr->len,0);
return -2;
}
LM_ERR("Remove command successfully retried\n");
}
LM_DBG("Succesfully removed\n");
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase remove",attr->s,attr->len,0);
return 1;
}
int couchbase_add(cachedb_con *connection,str *attr,int val,int expires,int *new_val)
{
lcb_t instance;
lcb_error_t oprc;
lcb_arithmetic_cmd_t cmd;
const lcb_arithmetic_cmd_t *commands[1];
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
cmd.v.v0.delta = val;
cmd.v.v0.create = 1;
cmd.v.v0.initial = val;
cmd.v.v0.exptime = expires;
oprc = lcb_arithmetic(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
if (oprc == LCB_KEY_ENOENT) {
return -1;
}
LM_ERR("Failed to send the arithmetic query - %s\n", lcb_strerror(instance, oprc));
//Attempt reconnect
if (couchbase_conditional_reconnect(connection, oprc) != 1) {
return -2;
}
//Try again
instance = COUCHBASE_CON(connection);
oprc = lcb_arithmetic(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
if (oprc == LCB_KEY_ENOENT) {
LM_ERR("Arithmetic command successfully retried\n");
return -1;
}
LM_ERR("Arithmetic command retry failed - %s\n", lcb_strerror(instance, oprc));
return -2;
}
LM_ERR("Arithmetic command successfully retried\n");
}
if (new_val)
*new_val = arithmetic_res;
return 1;
}
int couchbase_set(cachedb_con *connection,str *attr,
str *val,int expires)
{
lcb_t instance;
lcb_error_t oprc;
lcb_store_cmd_t cmd;
const lcb_store_cmd_t *commands[1];
struct timeval start;
start_expire_timer(start,couch_exec_threshold);
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.operation = LCB_SET;
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
cmd.v.v0.bytes = val->s;
cmd.v.v0.nbytes = val->len;
cmd.v.v0.exptime = expires;
oprc = lcb_store(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
LM_ERR("Set request failed - %s\n", lcb_strerror(instance, oprc));
//Attempt reconnect
if(couchbase_conditional_reconnect(connection, oprc) != 1) {
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase set",attr->s,attr->len,0);
return -2;
}
//Try again
instance = COUCHBASE_CON(connection);
oprc = lcb_store(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
LM_ERR("Set command retry failed - %s\n", lcb_strerror(instance, oprc));
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase set",attr->s,attr->len,0);
return -2;
}
LM_ERR("Set command successfully retried\n");
}
LM_DBG("Succesfully stored\n");
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase set",attr->s,attr->len,0);
return 1;
}
int couchbase_get(cachedb_con *connection,str *attr,str *val)
{
lcb_t instance;
lcb_error_t oprc;
lcb_get_cmd_t cmd;
const lcb_get_cmd_t *commands[1];
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
oprc = lcb_get(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
/* Key not present, record does not exist */
if (oprc == LCB_KEY_ENOENT) {
return -1;
}
//Attempt reconnect
if (couchbase_conditional_reconnect(connection, oprc) != 1) {
return -2;
}
//Try Again
instance = COUCHBASE_CON(connection);
oprc = lcb_get(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
if (oprc == LCB_KEY_ENOENT) {
LM_ERR("Get command successfully retried\n");
return -1;
}
LM_ERR("Get command retry failed - %s\n", lcb_strerror(instance, oprc));
return -2;
}
LM_ERR("Get command successfully retried\n");
}
//Incase of malloc failure
if (!get_res.s) {
return -2;
}
*val = get_res;
return 1;
}
/*Conditionally reconnect based on the error code*/
void couchbase_conditional_reconnect(cachedb_con *con, lcb_error_t err) {
cachedb_pool_con *tmp;
void *newcon;
if (!con) return;
switch (err) {
/* Error codes to attempt reconnects on */
case LCB_EINTERNAL:
case LCB_CLIENT_ETMPFAIL:
case LCB_EBADHANDLE:
break;
default:
/*nothing to do*/
return;
break;
}
tmp = (cachedb_pool_con*)(con->data);
LM_ERR("Attempting reconnect to Couchbase. Host: %s Bucket: %s On Error: %s",
tmp->id->host, tmp->id->database, lcb_strerror(COUCHBASE_CON(con), err));
newcon = couchbase_new_connection(tmp->id);
/*Successful reconnect, get rid of the old handle*/
if (newcon != NULL) {
tmp->id = NULL;
couchbase_free_connection(tmp);
con->data = newcon;
}
}
int couchbase_set(cachedb_con *connection,str *attr,
str *val,int expires)
{
lcb_t instance;
lcb_error_t oprc;
lcb_store_cmd_t cmd;
const lcb_store_cmd_t *commands[1];
last_error = LCB_SUCCESS;
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.operation = LCB_SET;
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
cmd.v.v0.bytes = val->s;
cmd.v.v0.nbytes = val->len;
cmd.v.v0.exptime = expires;
oprc = lcb_store(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
LM_ERR("Failed to send the insert query - %s\n", lcb_strerror(instance, oprc));
couchbase_conditional_reconnect(connection, oprc);
return -2;
}
lcb_wait(instance);
oprc = lcb_get_last_error(instance);
if (last_error != LCB_SUCCESS) {
couchbase_conditional_reconnect(connection, last_error);
return -1;
}
LM_DBG("Succesfully stored\n");
return 1;
}
int couchbase_add(cachedb_con *connection,str *attr,int val,int expires,int *new_val)
{
lcb_t instance;
lcb_error_t oprc;
lcb_arithmetic_cmd_t cmd;
const lcb_arithmetic_cmd_t *commands[1];
last_error = LCB_SUCCESS;
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
cmd.v.v0.delta = val;
cmd.v.v0.create = 1;
cmd.v.v0.initial = val;
cmd.v.v0.exptime = expires;
oprc = lcb_arithmetic(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
LM_ERR("Failed to send the arithmetic query - %s\n", lcb_strerror(instance, oprc));
couchbase_conditional_reconnect(connection, oprc);
return -2;
}
lcb_wait(instance);
if (last_error != LCB_SUCCESS) {
couchbase_conditional_reconnect(connection, last_error);
return -1;
}
if (new_val)
*new_val = arithmetic_res;
return 1;
}
int couchbase_get(cachedb_con *connection,str *attr,str *val)
{
lcb_t instance;
lcb_error_t oprc;
lcb_get_cmd_t cmd;
const lcb_get_cmd_t *commands[1];
last_error = LCB_SUCCESS;
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
oprc = lcb_get(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
LM_ERR("Failed to send the get query - %s\n", lcb_strerror(instance, oprc));
couchbase_conditional_reconnect(connection, oprc);
return -2;
}
lcb_wait(instance);
if (last_error != LCB_SUCCESS) {
/* Key not present, record does not exist */
if (last_error == LCB_KEY_ENOENT) {
return -1;
}
couchbase_conditional_reconnect(connection, last_error);
return -2;
}
*val = get_res;
return 1;
}
int couchbase_get_counter(cachedb_con *connection,str *attr,int *val)
{
lcb_t instance;
lcb_error_t oprc;
lcb_get_cmd_t cmd;
const lcb_get_cmd_t *commands[1];
struct timeval start;
start_expire_timer(start,couch_exec_threshold);
instance = COUCHBASE_CON(connection);
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = attr->s;
cmd.v.v0.nkey = attr->len;
oprc = lcb_get(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
/* Key not present, record does not exist */
if (oprc == LCB_KEY_ENOENT) {
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase get counter",attr->s,attr->len,0);
return -1;
}
//Attempt reconnect
if (couchbase_conditional_reconnect(connection, oprc) != 1) {
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase get counter ",attr->s,attr->len,0);
return -2;
}
//Try Again
instance = COUCHBASE_CON(connection);
oprc = lcb_get(instance, NULL, 1, commands);
if (oprc != LCB_SUCCESS) {
if (oprc == LCB_KEY_ENOENT) {
LM_ERR("Get counter command successfully retried\n");
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase get counter",attr->s,attr->len,0);
return -1;
}
LM_ERR("Get counter command retry failed - %s\n", lcb_strerror(instance, oprc));
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase get counter",attr->s,attr->len,0);
return -2;
}
LM_ERR("Get command successfully retried\n");
}
//Incase of malloc failure
if (!get_res.s) {
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase get counter",attr->s,attr->len,0);
return -2;
}
stop_expire_timer(start,couch_exec_threshold,
"cachedb_couchbase get counter",attr->s,attr->len,0);
if (str2sint((str *)&get_res,val)) {
LM_ERR("Failued to convert counter [%.*s] to int\n",get_res.len,get_res.s);
pkg_free(get_res.s);
get_res.s = NULL;
return -1;
}
pkg_free(get_res.s);
get_res.s = NULL;
return 1;
}
