ERL_NIF_TERM cb_arithmetic(ErlNifEnv* env, handle_t* handle, void* obj)
{
arithmetic_args_t* args = (arithmetic_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret; //for checking responses
lcb_arithmetic_cmd_t arithmetic;
const lcb_arithmetic_cmd_t* commands[1];
commands[0] = &arithmetic;
memset(&arithmetic, 0, sizeof(arithmetic));
arithmetic.v.v0.key = args->key;
arithmetic.v.v0.nkey = args->nkey;
arithmetic.v.v0.initial = args->initial;
arithmetic.v.v0.create = args->create;
arithmetic.v.v0.delta = args->delta;
arithmetic.v.v0.exptime = args->exp;
ret = lcb_arithmetic(handle->instance, &cb, 1, commands);
free(args->key);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
return enif_make_tuple2(env, A_OK(env), return_value(env, &cb));
}
ERL_NIF_TERM cb_remove(ErlNifEnv* env, handle_t* handle, void* obj)
{
remove_args_t* args = (remove_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret; //for checking responses
lcb_remove_cmd_t remove;
const lcb_remove_cmd_t* commands[1];
commands[0] = &remove;
memset(&remove, 0, sizeof(remove));
remove.v.v0.key = args->key;
remove.v.v0.nkey = args->nkey;
remove.v.v0.cas = args->cas;
ret = lcb_remove(handle->instance, &cb, 1, commands);
free(args->key);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
return A_OK(env);
}
ERL_NIF_TERM cb_unlock(ErlNifEnv* env, handle_t* handle, void* obj)
{
unlock_args_t* args = (unlock_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret;
lcb_unlock_cmd_t unlock;
memset(&unlock, 0, sizeof(unlock));
unlock.v.v0.key = args->key;
unlock.v.v0.nkey = args->nkey;
unlock.v.v0.cas = args->cas;
const lcb_unlock_cmd_t* commands[] = { &unlock };
ret = lcb_unlock(handle->instance, &cb, 1, commands);
free(args->key);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
return A_OK(env);
}
ERL_NIF_TERM cb_http(ErlNifEnv* env, handle_t* handle, void* obj)
{
http_args_t* args = (http_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret;
lcb_http_request_t req;
lcb_http_cmd_t cmd;
cmd.version = 0;
cmd.v.v0.path = args->path;
cmd.v.v0.npath = strlen(args->path);
cmd.v.v0.body = args->body;
cmd.v.v0.nbody = strlen(args->body);
cmd.v.v0.method = args->method;
cmd.v.v0.chunked = 0; // no support for chunking
cmd.v.v0.content_type = args->content_type;
ret = lcb_make_http_request(handle->instance, &cb, args->type, &cmd, &req);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
ErlNifBinary value_binary;
enif_alloc_binary(cb.size, &value_binary);
memcpy(value_binary.data, cb.data, cb.size);
return enif_make_tuple2(env, A_OK(env), enif_make_binary(env, &value_binary));
}
ERL_NIF_TERM cb_getl(ErlNifEnv* env, handle_t* handle, void* obj)
{
getl_args_t* args = (getl_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret;
lcb_get_cmd_t cmd;
const lcb_get_cmd_t *commands[1];
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.key = args->key;
cmd.v.v0.nkey = args->nkey;
cmd.v.v0.exptime = args->exp;
cmd.v.v0.lock = 1;
ret = lcb_get(handle->instance, &cb, 1, commands);
free(args->key);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if(cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
return enif_make_tuple2(env, A_OK(env), return_value(env, &cb));
}
ERL_NIF_TERM cb_store(ErlNifEnv* env, handle_t* handle, void* obj)
{
store_args_t* args = (store_args_t*)obj;
struct libcouchbase_callback cb;
lcb_error_t ret;
lcb_store_cmd_t cmd;
const lcb_store_cmd_t *commands[1];
commands[0] = &cmd;
memset(&cmd, 0, sizeof(cmd));
cmd.v.v0.operation = args->operation;
cmd.v.v0.key = args->key;
cmd.v.v0.nkey = args->nkey;
cmd.v.v0.bytes = args->bytes;
cmd.v.v0.nbytes = args->nbytes;
cmd.v.v0.flags = args->flags;
cmd.v.v0.exptime = args->exp;
cmd.v.v0.cas = args->cas;
ret = lcb_store(handle->instance, &cb, 1, commands);
free(args->key);
free(args->bytes);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
if (cb.error != LCB_SUCCESS) {
return return_lcb_error(env, cb.error);
}
return A_OK(env);
}
ERL_NIF_TERM cb_connect(ErlNifEnv* env, handle_t* handle, void* obj)
{
connect_args_t* args = (connect_args_t*)obj;
lcb_error_t err;
struct lcb_create_st create_options;
struct lcb_create_io_ops_st io_opts;
io_opts.version = 0;
io_opts.v.v0.type = LCB_IO_OPS_DEFAULT;
io_opts.v.v0.cookie = NULL;
memset(&create_options, 0, sizeof(create_options));
err = lcb_create_io_ops(&create_options.v.v0.io, &io_opts);
if (err != LCB_SUCCESS) {
printf("failed create io ops\n");
fprintf(stderr, "Failed to create IO instance: %s\n",
lcb_strerror(NULL, err));
return return_lcb_error(env, err);
}
create_options.v.v0.host = args->host;
create_options.v.v0.user = args->user;
create_options.v.v0.bucket = args->bucket;
create_options.v.v0.passwd = args->pass;
err = lcb_create(&(handle->instance), &create_options);
free(args->host);
free(args->user);
free(args->pass);
free(args->bucket);
if (err != LCB_SUCCESS) {
return enif_make_tuple2(env, enif_make_atom(env, "error"),
enif_make_string(env, lcb_strerror(NULL, err), ERL_NIF_LATIN1));
}
(void)lcb_set_get_callback(handle->instance, get_callback);
(void)lcb_set_store_callback(handle->instance, store_callback);
(void)lcb_set_unlock_callback(handle->instance, unlock_callback);
(void)lcb_set_touch_callback(handle->instance, touch_callback);
(void)lcb_set_arithmetic_callback(handle->instance, arithmetic_callback);
(void)lcb_set_remove_callback(handle->instance, remove_callback);
(void)lcb_set_http_complete_callback(handle->instance, http_callback);
err = lcb_connect(handle->instance);
if (err != LCB_SUCCESS) {
return return_lcb_error(env, err);
}
err = lcb_wait(handle->instance);
if(err != LCB_SUCCESS) {
return return_lcb_error(env, err);
}
#ifdef LCB_CNTL_DETAILED_ERRCODES
int val = 1;
err = lcb_cntl(handle->instance, LCB_CNTL_SET, LCB_CNTL_DETAILED_ERRCODES, &val);
if(err != LCB_SUCCESS) {
return return_lcb_error(env, err);
}
#endif
return enif_make_atom(env, "ok");
}
ERL_NIF_TERM cb_mtouch(ErlNifEnv* env, handle_t* handle, void* obj)
{
mtouch_args_t* args = (mtouch_args_t*)obj;
struct libcouchbase_callback_m cb;
int i = 0;
lcb_error_t ret;
ERL_NIF_TERM* results;
ERL_NIF_TERM returnValue;
ErlNifBinary key_binary;
cb.currKey = 0;
cb.ret = malloc(sizeof(struct libcouchbase_callback*) * args->numkeys);
const lcb_touch_cmd_t* commands[args->numkeys];
i = 0;
for (; i < args->numkeys; i++) {
lcb_touch_cmd_t* touch = calloc(1, sizeof(*touch));
touch->version = 0;
touch->v.v0.key = args->keys[i];
touch->v.v0.nkey = args->nkeys[i];
touch->v.v0.exptime = args->exp[i];
commands[i] = touch;
}
ret = lcb_touch(handle->instance, &cb, args->numkeys, commands);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
results = malloc(sizeof(ERL_NIF_TERM) * args->numkeys);
i = 0;
for(; i < args->numkeys; i++) {
enif_alloc_binary(cb.ret[i]->nkey, &key_binary);
memcpy(key_binary.data, cb.ret[i]->key, cb.ret[i]->nkey);
ERL_NIF_TERM key = enif_make_binary(env, &key_binary);
if (cb.ret[i]->error == LCB_SUCCESS) {
results[i] = enif_make_tuple2(env,
key,
A_OK(env));
} else {
results[i] = enif_make_tuple2(env,
key,
return_lcb_error(env, cb.ret[i]->error));
}
free(cb.ret[i]->key);
free(cb.ret[i]);
free(args->keys[i]);
free((lcb_touch_cmd_t*) commands[i]);
}
returnValue = enif_make_list_from_array(env, results, args->numkeys);
free(results);
free(cb.ret);
free(args->keys);
free(args->exp);
free(args->nkeys);
return enif_make_tuple2(env, A_OK(env), returnValue);
}
ERL_NIF_TERM cb_mget(ErlNifEnv* env, handle_t* handle, void* obj)
{
mget_args_t* args = (mget_args_t*)obj;
struct libcouchbase_callback_m cb;
lcb_error_t ret;
ERL_NIF_TERM* results;
ERL_NIF_TERM returnValue;
ErlNifBinary databin;
ErlNifBinary key_binary;
unsigned int numkeys = args->numkeys;
void** keys = args->keys;
size_t* nkeys = args->nkeys;
int exp = args->exp;
int lock = args->lock;
int i = 0;
cb.currKey = 0;
cb.ret = malloc(sizeof(struct libcouchbase_callback*) * numkeys);
const lcb_get_cmd_t* commands[numkeys];
i = 0;
for (; i < numkeys; i++) {
lcb_get_cmd_t *get = calloc(1, sizeof(*get));
get->version = 0;
get->v.v0.key = keys[i];
get->v.v0.nkey = nkeys[i];
get->v.v0.exptime = exp;
get->v.v0.lock = lock;
commands[i] = get;
}
ret = lcb_get(handle->instance, &cb, numkeys, commands);
if (ret != LCB_SUCCESS) {
return return_lcb_error(env, ret);
}
lcb_wait(handle->instance);
results = malloc(sizeof(ERL_NIF_TERM) * numkeys);
i = 0;
for(; i < numkeys; i++) {
enif_alloc_binary(cb.ret[i]->nkey, &key_binary);
memcpy(key_binary.data, cb.ret[i]->key, cb.ret[i]->nkey);
if (cb.ret[i]->error == LCB_SUCCESS) {
enif_alloc_binary(cb.ret[i]->size, &databin);
memcpy(databin.data, cb.ret[i]->data, cb.ret[i]->size);
results[i] = enif_make_tuple4(env,
enif_make_uint64(env, cb.ret[i]->cas),
enif_make_int(env, cb.ret[i]->flag),
enif_make_binary(env, &key_binary),
enif_make_binary(env, &databin));
free(cb.ret[i]->data);
} else {
results[i] = enif_make_tuple2(env,
enif_make_binary(env, &key_binary),
return_lcb_error(env, cb.ret[i]->error));
}
free(cb.ret[i]->key);
free(cb.ret[i]);
free(keys[i]);
free((lcb_get_cmd_t*) commands[i]);
}
returnValue = enif_make_list_from_array(env, results, numkeys);
free(results);
free(cb.ret);
free(keys);
free(nkeys);
return enif_make_tuple2(env, A_OK(env), returnValue);
}
