couchbase 1.2.0.z.beta5 → 1.2.0

data/ext/couchbase_ext/observe.c

@@ -22,13 +22,13 @@ cb_observe_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 key, res, *rv = ctx->rv;
+    VALUE key, res, *rv = ctx->rv, exc;
 
     if (resp->v.v0.key) {
         key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-        ctx->exception = cb_check_error(error, "failed to execute observe request", key);
-        if (ctx->exception) {
-            cb_gc_protect(bucket, ctx->exception);
+        exc = cb_check_error(error, "failed to execute observe request", key);
+        if (exc != Qnil) {
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
         res = rb_class_new_instance(0, NULL, cb_cResult);
         rb_ivar_set(res, cb_id_iv_completed, Qfalse);
@@ -54,7 +54,7 @@ cb_observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
         }
         if (bucket->async) { /* asynchronous */
             if (ctx->proc != Qnil) {
-                cb_proc_call(ctx->proc, 1, res);
+                cb_proc_call(bucket, ctx->proc, 1, res);
             }
         } else {             /* synchronous */
             if (NIL_P(ctx->exception)) {
@@ -70,12 +70,12 @@ cb_observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
         if (bucket->async && ctx->proc != Qnil) {
             res = rb_class_new_instance(0, NULL, cb_cResult);
             rb_ivar_set(res, cb_id_iv_completed, Qtrue);
-            cb_proc_call(ctx->proc, 1, res);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
         ctx->nqueries--;
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
     (void)handle;
@@ -130,7 +130,7 @@ cb_bucket_observe(int argc, VALUE *argv, VALUE self)
     params.type = cb_cmd_observe;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -145,7 +145,7 @@ cb_bucket_observe(int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule observe request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -158,7 +158,7 @@ cb_bucket_observe(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);

data/ext/couchbase_ext/stats.c

@@ -28,9 +28,7 @@ cb_stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
     exc = cb_check_error(error, "failed to fetch stats", node);
     if (exc != Qnil) {
         rb_ivar_set(exc, cb_id_iv_operation, cb_sym_stats);
-        if (NIL_P(ctx->exception)) {
-            ctx->exception = cb_gc_protect(bucket, exc);
-        }
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
     if (node != Qnil) {
         key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
@@ -43,7 +41,7 @@ cb_stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
                 rb_ivar_set(res, cb_id_iv_node, node);
                 rb_ivar_set(res, cb_id_iv_key, key);
                 rb_ivar_set(res, cb_id_iv_value, val);
-                cb_proc_call(ctx->proc, 1, res);
+                cb_proc_call(bucket, ctx->proc, 1, res);
             }
         } else {                /* synchronous */
             if (NIL_P(exc)) {
@@ -58,7 +56,7 @@ cb_stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
     } else {
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
     (void)handle;
@@ -126,7 +124,7 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
     params.type = cb_cmd_stats;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -141,7 +139,7 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
     exc = cb_check_error(err, "failed to schedule stat request", Qnil);
     cb_params_destroy(&params);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -154,7 +152,7 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);

data/ext/couchbase_ext/store.c

@@ -26,14 +26,14 @@ storage_observe_callback(VALUE args, VALUE cookie)
 
     if (ctx->proc != Qnil) {
         rb_ivar_set(res, cb_id_iv_operation, ctx->operation);
-        cb_proc_call(ctx->proc, 1, res);
+        cb_proc_call(bucket, ctx->proc, 1, res);
     }
     if (!RTEST(ctx->observe_options)) {
         ctx->nqueries--;
         if (ctx->nqueries == 0) {
             cb_gc_unprotect(bucket, ctx->proc);
             if (bucket->async) {
-                xfree(ctx);
+                free(ctx);
             }
         }
     }
@@ -75,9 +75,7 @@ cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
     if (exc != Qnil) {
         rb_ivar_set(exc, cb_id_iv_cas, cas);
         rb_ivar_set(exc, cb_id_iv_operation, ctx->operation);
-        if (NIL_P(ctx->exception)) {
-            ctx->exception = cb_gc_protect(bucket, exc);
-        }
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
 
     if (bucket->async) { /* asynchronous */
@@ -95,7 +93,7 @@ cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
             rb_ivar_set(res, cb_id_iv_key, key);
             rb_ivar_set(res, cb_id_iv_operation, ctx->operation);
             rb_ivar_set(res, cb_id_iv_cas, cas);
-            cb_proc_call(ctx->proc, 1, res);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {             /* synchronous */
         rb_hash_aset(*rv, key, cas);
@@ -106,7 +104,7 @@ cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
         if (ctx->nqueries == 0) {
             cb_gc_unprotect(bucket, ctx->proc);
             if (bucket->async) {
-                xfree(ctx);
+                free(ctx);
             }
         }
     }
@@ -134,7 +132,7 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
     params.bucket = bucket;
     params.cmd.store.operation = cmd;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -150,7 +148,7 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule set request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -163,7 +161,7 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);

data/ext/couchbase_ext/timer.c

@@ -106,7 +106,7 @@ cb_timer_cancel(VALUE self)
 trigger_timer(VALUE timer)
 {
     struct cb_timer_st *tm = DATA_PTR(timer);
-    return cb_proc_call(tm->callback, 1, timer);
+    return cb_proc_call(tm->bucket, tm->callback, 1, timer);
 }
 
     static void

data/ext/couchbase_ext/touch.c

@@ -32,9 +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);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
 
@@ -44,7 +42,7 @@ cb_touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb
             rb_ivar_set(res, cb_id_iv_error, exc);
             rb_ivar_set(res, cb_id_iv_operation, cb_sym_touch);
             rb_ivar_set(res, cb_id_iv_key, key);
-            cb_proc_call(ctx->proc, 1, res);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
@@ -52,7 +50,7 @@ cb_touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
     (void)handle;
@@ -144,7 +142,7 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
     params.type = cb_cmd_touch;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -160,7 +158,7 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule touch request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -173,7 +171,7 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             rb_exc_raise(cb_gc_unprotect(bucket, exc));
         }

data/ext/couchbase_ext/unlock.c

@@ -32,9 +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);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
 
@@ -44,7 +42,7 @@ cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
             rb_ivar_set(res, cb_id_iv_error, exc);
             rb_ivar_set(res, cb_id_iv_operation, cb_sym_unlock);
             rb_ivar_set(res, cb_id_iv_key, key);
-            cb_proc_call(ctx->proc, 1, res);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
@@ -52,7 +50,7 @@ cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lc
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
     (void)handle;
@@ -134,7 +132,7 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
     params.type = cb_cmd_unlock;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -150,7 +148,7 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule unlock request", Qnil);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -163,7 +161,7 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             rb_exc_raise(cb_gc_unprotect(bucket, exc));
         }

data/ext/couchbase_ext/utils.c

@@ -31,13 +31,65 @@ cb_gc_unprotect(struct cb_bucket_st *bucket, VALUE val)
     return val;
 }
 
+struct proc_params_st
+{
+    struct cb_bucket_st *bucket;
+    VALUE recv;
+    ID mid;
+    int argc;
+    VALUE *argv;
+    VALUE exc;
+};
+
+    static VALUE
+do_async_error_notify(VALUE ptr)
+{
+    struct proc_params_st *p = (struct proc_params_st *)ptr;
+    return rb_funcall(p->bucket->on_error_proc, cb_id_call, 1, p->exc);
+}
+
+    void
+cb_async_error_notify(struct cb_bucket_st *bucket, VALUE exc)
+{
+    if (bucket->on_error_proc != Qnil) {
+        struct proc_params_st params;
+        int fail;
+        params.bucket = bucket;
+        params.exc = exc;
+        rb_protect(do_async_error_notify, (VALUE)&params, &fail);
+        if (fail) {
+            rb_warning("Couchbase::Bucket#on_error shouldn't raise exceptions");
+        }
+    } else {
+        if (NIL_P(bucket->exception)) {
+            bucket->exception = exc;
+        }
+    }
+}
+
+    static VALUE
+func_call_failed(VALUE ptr, VALUE exc)
+{
+    struct proc_params_st *p = (struct proc_params_st *)ptr;
+    cb_async_error_notify(p->bucket, exc);
+    return Qnil;
+}
+
+    static VALUE
+do_func_call(VALUE ptr)
+{
+    struct proc_params_st *p = (struct proc_params_st *)ptr;
+    return rb_funcall2(p->recv, p->mid, p->argc, p->argv);
+}
+
     VALUE
-cb_proc_call(VALUE recv, int argc, ...)
+cb_proc_call(struct cb_bucket_st *bucket, VALUE recv, int argc, ...)
 {
     VALUE *argv;
     va_list ar;
     int arity;
     int ii;
+    struct proc_params_st params;
 
     arity = FIX2INT(rb_funcall(recv, cb_id_arity, 0));
     if (arity < 0) {
@@ -57,7 +109,14 @@ cb_proc_call(VALUE recv, int argc, ...)
     } else {
         argv = NULL;
     }
-    return rb_funcall2(recv, cb_id_call, arity, argv);
+    params.bucket = bucket;
+    params.recv = recv;
+    params.mid = cb_id_call;
+    params.argc = arity;
+    params.argv = argv;
+    return rb_rescue2(do_func_call, (VALUE)&params,
+            func_call_failed, (VALUE)&params,
+            rb_eException, (VALUE)0);
 }
 
 VALUE
@@ -408,8 +467,8 @@ cb_decode_value(VALUE blob, uint32_t flags, VALUE force_format)
     void
 cb_strip_key_prefix(struct cb_bucket_st *bucket, VALUE key)
 {
-    if (bucket->key_prefix) {
-        rb_str_update(key, 0, RSTRING_LEN(bucket->key_prefix_val), STR_NEW_CSTR(""));
+    if (RTEST(bucket->key_prefix_val)) {
+        rb_str_update(key, 0, RSTRING_LEN(bucket->key_prefix_val), cb_vStrEmpty);
     }
 }
 
@@ -418,7 +477,7 @@ cb_unify_key(struct cb_bucket_st *bucket, VALUE key, int apply_prefix)
 {
     VALUE ret = Qnil, tmp;
 
-    if (bucket->key_prefix && apply_prefix) {
+    if (RTEST(bucket->key_prefix_val) && apply_prefix) {
         ret = rb_str_dup(bucket->key_prefix_val);
     }
     switch (TYPE(key)) {
@@ -476,3 +535,14 @@ cb_first_value_i(VALUE key, VALUE value, VALUE arg)
     (void)key;
     return ST_STOP;
 }
+
+#ifndef HAVE_RB_HASH_LOOKUP2
+    VALUE
+rb_hash_lookup2(VALUE hash, VALUE key, VALUE dflt)
+{
+    if (RTEST(rb_funcall2(hash, cb_id_has_key_p, 1, &key))) {
+        dflt = rb_hash_aref(hash, key);
+    }
+    return dflt;
+}
+#endif

data/ext/couchbase_ext/version.c

@@ -28,9 +28,7 @@ cb_version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
     exc = cb_check_error(error, "failed to get version", node);
     if (exc != Qnil) {
         rb_ivar_set(exc, cb_id_iv_operation, cb_sym_version);
-        if (NIL_P(ctx->exception)) {
-            ctx->exception = cb_gc_protect(bucket, exc);
-        }
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
 
     if (node != Qnil) {
@@ -42,7 +40,7 @@ cb_version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
                 rb_ivar_set(res, cb_id_iv_operation, cb_sym_version);
                 rb_ivar_set(res, cb_id_iv_node, node);
                 rb_ivar_set(res, cb_id_iv_value, val);
-                cb_proc_call(ctx->proc, 1, res);
+                cb_proc_call(bucket, ctx->proc, 1, res);
             }
         } else {                /* synchronous */
             if (NIL_P(exc)) {
@@ -53,7 +51,7 @@ cb_version_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
         ctx->nqueries--;
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
 
@@ -107,7 +105,7 @@ cb_bucket_version(int argc, VALUE *argv, VALUE self)
     params.type = cb_cmd_version;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -122,7 +120,7 @@ cb_bucket_version(int argc, VALUE *argv, VALUE self)
     exc = cb_check_error(err, "failed to schedule version request", Qnil);
     cb_params_destroy(&params);
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
@@ -135,7 +133,7 @@ cb_bucket_version(int argc, VALUE *argv, VALUE self)
             lcb_wait(bucket->handle);
         }
         exc = ctx->exception;
-        xfree(ctx);
+        free(ctx);
         if (exc != Qnil) {
             cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);