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 as_ldt_lset_remove(ErlNifEnv* env, handle_t* handle, void* obj)
{
ldt_store_args_t * args = (ldt_store_args_t *)obj;
as_status res;
as_error err;
// Add an integer value to the set.
res = aerospike_lset_remove(&handle->instance, &err, &args->policy, &args->key, &args->ldt, args->p_value);
as_ldt_clean_store_args(env, args);
if(res != AEROSPIKE_OK)
return A_AS_ERROR(env, err);
return A_OK(env);
}
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_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);
}
