couchbase 1.2.1-x86-mingw32 → 1.2.2-x86-mingw32

data/ext/couchbase_ext/store.c

@@ -31,51 +31,52 @@ storage_observe_callback(VALUE args, VALUE cookie)
     if (!RTEST(ctx->observe_options)) {
         ctx->nqueries--;
         if (ctx->nqueries == 0) {
-            cb_gc_unprotect(bucket, ctx->proc);
+            ctx->proc = Qnil;
             if (bucket->async) {
-                free(ctx);
+                cb_context_free(ctx);
             }
         }
     }
     return Qnil;
 }
 
+    VALUE
+storage_opcode_to_sym(lcb_storage_t operation)
+{
+    switch(operation) {
+        case LCB_ADD:
+            return cb_sym_add;
+        case LCB_REPLACE:
+            return cb_sym_replace;
+        case LCB_SET:
+            return cb_sym_set;
+        case LCB_APPEND:
+            return cb_sym_append;
+        case LCB_PREPEND:
+            return cb_sym_prepend;
+        default:
+            return Qnil;
+    }
+}
+
     void
 cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
         lcb_error_t error, const lcb_store_resp_t *resp)
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE key, cas, *rv = ctx->rv, exc, res;
+    VALUE key, cas, exc, res;
 
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
     cb_strip_key_prefix(bucket, key);
 
     cas = resp->v.v0.cas > 0 ? ULL2NUM(resp->v.v0.cas) : Qnil;
-    switch(operation) {
-        case LCB_ADD:
-            ctx->operation = cb_sym_add;
-            break;
-        case LCB_REPLACE:
-            ctx->operation = cb_sym_replace;
-            break;
-        case LCB_SET:
-            ctx->operation = cb_sym_set;
-            break;
-        case LCB_APPEND:
-            ctx->operation = cb_sym_append;
-            break;
-        case LCB_PREPEND:
-            ctx->operation = cb_sym_prepend;
-            break;
-        default:
-            ctx->operation = Qnil;
-    }
+    ctx->operation = storage_opcode_to_sym(operation);
     exc = cb_check_error(error, "failed to store value", key);
     if (exc != Qnil) {
         rb_ivar_set(exc, cb_id_iv_cas, cas);
         rb_ivar_set(exc, cb_id_iv_operation, ctx->operation);
-        ctx->exception = cb_gc_protect(bucket, exc);
+        ctx->exception = exc;
     }
 
     if (bucket->async) { /* asynchronous */
@@ -86,7 +87,7 @@ cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
             args[1] = ctx->observe_options;
             rb_block_call(bucket->self, cb_id_observe_and_wait, 2, args,
                     storage_observe_callback, (VALUE)ctx);
-            cb_gc_unprotect(bucket, ctx->observe_options);
+            ctx->observe_options = Qnil;
         } else if (ctx->proc != Qnil) {
             res = rb_class_new_instance(0, NULL, cb_cResult);
             rb_ivar_set(res, cb_id_iv_error, exc);
@@ -96,15 +97,15 @@ cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
             cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {             /* synchronous */
-        rb_hash_aset(*rv, key, cas);
+        rb_hash_aset(ctx->rv, key, cas);
     }
 
     if (!RTEST(ctx->observe_options)) {
         ctx->nqueries--;
         if (ctx->nqueries == 0) {
-            cb_gc_unprotect(bucket, ctx->proc);
+            ctx->proc = Qnil;
             if (bucket->async) {
-                free(ctx);
+                cb_context_free(ctx);
             }
         }
     }
@@ -116,40 +117,36 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
     struct cb_context_st *ctx;
-    VALUE args, rv, proc, exc, obs = Qnil;
+    VALUE rv, proc, exc, obs = Qnil;
     lcb_error_t err;
     struct cb_params_st params;
 
-    if (bucket->handle == NULL) {
-        rb_raise(cb_eConnectError, "closed connection");
+    if (!cb_bucket_connected_bang(bucket, storage_opcode_to_sym(cmd))) {
+        return Qnil;
     }
-    rb_scan_args(argc, argv, "0*&", &args, &proc);
+    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_scan_args(argc, argv, "0*&", &params.args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    memset(&params, 0, sizeof(struct cb_params_st));
     params.type = cb_cmd_store;
     params.bucket = bucket;
     params.cmd.store.operation = cmd;
-    cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
-    }
-    rv = rb_hash_new();
-    ctx->rv = &rv;
-    ctx->bucket = bucket;
-    ctx->proc = cb_gc_protect(bucket, proc);
-    ctx->observe_options = cb_gc_protect(bucket, obs);
-    ctx->exception = Qnil;
+    cb_params_build(&params);
     obs = params.cmd.store.observe;
+    ctx = cb_context_alloc(bucket);
+    if (!bucket->async) {
+        ctx->rv = rb_hash_new();
+        ctx->observe_options = obs;
+    }
+    ctx->proc = proc;
     ctx->nqueries = params.cmd.store.num;
     err = lcb_store(bucket->handle, (const void *)ctx,
             params.cmd.store.num, params.cmd.store.ptr);
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule set request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        cb_context_free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -162,9 +159,9 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        free(ctx);
+        rv = ctx->rv;
+        cb_context_free(ctx);
         if (exc != Qnil) {
-            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         exc = bucket->exception;
@@ -173,7 +170,6 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
             rb_exc_raise(exc);
         }
         if (RTEST(obs)) {
-            cb_gc_unprotect(bucket, obs);
             rv = rb_funcall(bucket->self, cb_id_observe_and_wait, 2, rv, obs);
         }
         if (params.cmd.store.num > 1) {

data/ext/couchbase_ext/touch.c

@@ -22,7 +22,7 @@ cb_touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE key, *rv = ctx->rv, exc = Qnil, res;
+    VALUE key, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
@@ -32,7 +32,7 @@ cb_touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb
         exc = cb_check_error(error, "failed to touch value", key);
         if (exc != Qnil) {
             rb_ivar_set(exc, cb_id_iv_operation, cb_sym_touch);
-            ctx->exception = cb_gc_protect(bucket, exc);
+            ctx->exception = exc;
         }
     }
 
@@ -45,12 +45,12 @@ cb_touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb
             cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
-        rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
+        rb_hash_aset(ctx->rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
     }
     if (ctx->nqueries == 0) {
-        cb_gc_unprotect(bucket, ctx->proc);
+        ctx->proc = Qnil;
         if (bucket->async) {
-            free(ctx);
+            cb_context_free(ctx);
         }
     }
     (void)handle;
@@ -126,39 +126,31 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
     struct cb_context_st *ctx;
-    VALUE args, rv, proc, exc;
+    VALUE rv, proc, exc;
     lcb_error_t err;
     struct cb_params_st params;
 
-    if (bucket->handle == NULL) {
-        rb_raise(cb_eConnectError, "closed connection");
+    if (!cb_bucket_connected_bang(bucket, cb_sym_touch)) {
+        return Qnil;
     }
-    rb_scan_args(argc, argv, "0*&", &args, &proc);
+
+    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_scan_args(argc, argv, "0*&", &params.args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    rb_funcall(args, cb_id_flatten_bang, 0);
-    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_funcall(params.args, cb_id_flatten_bang, 0);
     params.type = cb_cmd_touch;
     params.bucket = bucket;
-    cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
-    }
-    ctx->proc = cb_gc_protect(bucket, proc);
-    ctx->bucket = bucket;
-    rv = rb_hash_new();
-    ctx->rv = &rv;
-    ctx->exception = Qnil;
+    cb_params_build(&params);
+    ctx = cb_context_alloc_common(bucket, proc, params.cmd.touch.num);
     ctx->quiet = params.cmd.touch.quiet;
-    ctx->nqueries = params.cmd.touch.num;
     err = lcb_touch(bucket->handle, (const void *)ctx,
             params.cmd.touch.num, params.cmd.touch.ptr);
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule touch request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        cb_context_free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -171,9 +163,10 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        free(ctx);
+        rv = ctx->rv;
+        cb_context_free(ctx);
         if (exc != Qnil) {
-            rb_exc_raise(cb_gc_unprotect(bucket, exc));
+            rb_exc_raise(exc);
         }
         exc = bucket->exception;
         if (exc != Qnil) {

data/ext/couchbase_ext/unlock.c

@@ -22,7 +22,7 @@ cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE key, *rv = ctx->rv, exc = Qnil, res;
+    VALUE key, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
@@ -32,7 +32,7 @@ cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
         exc = cb_check_error(error, "failed to unlock value", key);
         if (exc != Qnil) {
             rb_ivar_set(exc, cb_id_iv_operation, cb_sym_unlock);
-            ctx->exception = cb_gc_protect(bucket, exc);
+            ctx->exception = exc;
         }
     }
 
@@ -45,12 +45,12 @@ cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
             cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
-        rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
+        rb_hash_aset(ctx->rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
     }
     if (ctx->nqueries == 0) {
-        cb_gc_unprotect(bucket, ctx->proc);
+        ctx->proc = Qnil;
         if (bucket->async) {
-            free(ctx);
+            cb_context_free(ctx);
         }
     }
     (void)handle;
@@ -116,39 +116,31 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
     struct cb_context_st *ctx;
-    VALUE args, rv, proc, exc;
+    VALUE rv, proc, exc;
     lcb_error_t err;
     struct cb_params_st params;
 
-    if (bucket->handle == NULL) {
-        rb_raise(cb_eConnectError, "closed connection");
+    if (!cb_bucket_connected_bang(bucket, cb_sym_unlock)) {
+        return Qnil;
     }
-    rb_scan_args(argc, argv, "0*&", &args, &proc);
+
+    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_scan_args(argc, argv, "0*&", &params.args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    rb_funcall(args, cb_id_flatten_bang, 0);
-    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_funcall(params.args, cb_id_flatten_bang, 0);
     params.type = cb_cmd_unlock;
     params.bucket = bucket;
-    cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
-    }
-    ctx->proc = cb_gc_protect(bucket, proc);
-    ctx->bucket = bucket;
-    rv = rb_hash_new();
-    ctx->rv = &rv;
-    ctx->exception = Qnil;
+    cb_params_build(&params);
+    ctx = cb_context_alloc_common(bucket, proc, params.cmd.unlock.num);
     ctx->quiet = params.cmd.unlock.quiet;
-    ctx->nqueries = params.cmd.unlock.num;
     err = lcb_unlock(bucket->handle, (const void *)ctx,
             params.cmd.unlock.num, params.cmd.unlock.ptr);
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule unlock request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        cb_context_free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -161,9 +153,10 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        free(ctx);
+        rv = ctx->rv;
+        cb_context_free(ctx);
         if (exc != Qnil) {
-            rb_exc_raise(cb_gc_unprotect(bucket, exc));
+            rb_exc_raise(exc);
         }
         exc = bucket->exception;
         if (exc != Qnil) {

data/ext/couchbase_ext/utils.c

@@ -17,18 +17,16 @@
 
 #include "couchbase_ext.h"
 
-    VALUE
-cb_gc_protect(struct cb_bucket_st *bucket, VALUE val)
+    void
+cb_gc_protect_ptr(struct cb_bucket_st *bucket, void *ptr, mark_f mark_func)
 {
-    rb_hash_aset(bucket->object_space, val|1, val);
-    return val;
+    st_insert(bucket->object_space, (st_index_t)ptr, (st_data_t)mark_func);
 }
 
-    VALUE
-cb_gc_unprotect(struct cb_bucket_st *bucket, VALUE val)
+    void
+cb_gc_unprotect_ptr(struct cb_bucket_st *bucket, void *ptr)
 {
-    rb_funcall(bucket->object_space, cb_id_delete, 1, val|1);
-    return val;
+    st_delete(bucket->object_space, (st_index_t*)&ptr, NULL);
 }
 
 struct proc_params_st
@@ -67,6 +65,23 @@ cb_async_error_notify(struct cb_bucket_st *bucket, VALUE exc)
     }
 }
 
+    int
+cb_bucket_connected_bang(struct cb_bucket_st *bucket, VALUE operation)
+{
+    if (bucket->handle == NULL || !bucket->connected) {
+        VALUE exc = rb_exc_new2(cb_eConnectError, "not connected to the server");
+        rb_ivar_set(exc, cb_id_iv_operation, operation);
+        rb_ivar_set(exc, cb_id_iv_value, bucket->self);
+        if (bucket->async) {
+            cb_async_error_notify(bucket, exc);
+        } else {
+            rb_exc_raise(exc);
+        }
+        return 0;
+    }
+    return 1;
+}
+
     static VALUE
 func_call_failed(VALUE ptr, VALUE exc)
 {

data/ext/couchbase_ext/version.c

@@ -22,13 +22,13 @@ cb_version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE node, val, *rv = ctx->rv, exc, res;
+    VALUE node, val, exc, res;
 
     node = resp->v.v0.server_endpoint ? STR_NEW_CSTR(resp->v.v0.server_endpoint) : Qnil;
     exc = cb_check_error(error, "failed to get version", node);
     if (exc != Qnil) {
         rb_ivar_set(exc, cb_id_iv_operation, cb_sym_version);
-        ctx->exception = cb_gc_protect(bucket, exc);
+        ctx->exception = exc;
     }
 
     if (node != Qnil) {
@@ -44,14 +44,14 @@ cb_version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
             }
         } else {                /* synchronous */
             if (NIL_P(exc)) {
-                rb_hash_aset(*rv, node, val);
+                rb_hash_aset(ctx->rv, node, val);
             }
         }
     } else {
         ctx->nqueries--;
-        cb_gc_unprotect(bucket, ctx->proc);
+        ctx->proc = Qnil;
         if (bucket->async) {
-            free(ctx);
+            cb_context_free(ctx);
         }
     }
 
@@ -90,37 +90,29 @@ cb_bucket_version(int argc, VALUE *argv, VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
     struct cb_context_st *ctx;
-    VALUE rv, exc, args, proc;
+    VALUE rv, exc, proc;
     lcb_error_t err;
     struct cb_params_st params;
 
-    if (bucket->handle == NULL) {
-        rb_raise(cb_eConnectError, "closed connection");
+    if (!cb_bucket_connected_bang(bucket, cb_sym_version)) {
+        return Qnil;
     }
-    rb_scan_args(argc, argv, "0*&", &args, &proc);
+
+    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_scan_args(argc, argv, "0*&", &params.args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    memset(&params, 0, sizeof(struct cb_params_st));
     params.type = cb_cmd_version;
     params.bucket = bucket;
-    cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = calloc(1, sizeof(struct cb_context_st));
-    if (ctx == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
-    }
-    rv = rb_hash_new();
-    ctx->rv = &rv;
-    ctx->bucket = bucket;
-    ctx->exception = Qnil;
-    ctx->proc = cb_gc_protect(bucket, proc);
-    ctx->nqueries = params.cmd.version.num;
+    cb_params_build(&params);
+    ctx = cb_context_alloc_common(bucket, proc, params.cmd.version.num);
     err = lcb_server_versions(bucket->handle, (const void *)ctx,
             params.cmd.version.num, params.cmd.version.ptr);
     exc = cb_check_error(err, "failed to schedule version request", Qnil);
     cb_params_destroy(&params);
     if (exc != Qnil) {
-        free(ctx);
+        cb_context_free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -133,9 +125,9 @@ cb_bucket_version(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        free(ctx);
+        rv = ctx->rv;
+        cb_context_free(ctx);
         if (exc != Qnil) {
-            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         exc = bucket->exception;