couchbase 1.2.0.z.beta-x86-mingw32 → 1.2.1-x86-mingw32

data/ext/couchbase_ext/observe.c

@@ -18,43 +18,43 @@
 #include "couchbase_ext.h"
 
     void
-observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_observe_resp_t *resp)
+cb_observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_observe_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
-    VALUE key, res, *rv = ctx->rv;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
+    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, cResult);
-        rb_ivar_set(res, id_iv_completed, Qfalse);
-        rb_ivar_set(res, id_iv_error, ctx->exception);
-        rb_ivar_set(res, id_iv_operation, sym_observe);
-        rb_ivar_set(res, id_iv_key, key);
-        rb_ivar_set(res, id_iv_cas, ULL2NUM(resp->v.v0.cas));
-        rb_ivar_set(res, id_iv_from_master, resp->v.v0.from_master ? Qtrue : Qfalse);
-        rb_ivar_set(res, id_iv_time_to_persist, ULONG2NUM(resp->v.v0.ttp));
-        rb_ivar_set(res, id_iv_time_to_replicate, ULONG2NUM(resp->v.v0.ttr));
+        res = rb_class_new_instance(0, NULL, cb_cResult);
+        rb_ivar_set(res, cb_id_iv_completed, Qfalse);
+        rb_ivar_set(res, cb_id_iv_error, ctx->exception);
+        rb_ivar_set(res, cb_id_iv_operation, cb_sym_observe);
+        rb_ivar_set(res, cb_id_iv_key, key);
+        rb_ivar_set(res, cb_id_iv_cas, ULL2NUM(resp->v.v0.cas));
+        rb_ivar_set(res, cb_id_iv_from_master, resp->v.v0.from_master ? Qtrue : Qfalse);
+        rb_ivar_set(res, cb_id_iv_time_to_persist, ULONG2NUM(resp->v.v0.ttp));
+        rb_ivar_set(res, cb_id_iv_time_to_replicate, ULONG2NUM(resp->v.v0.ttr));
         switch (resp->v.v0.status) {
             case LCB_OBSERVE_FOUND:
-                rb_ivar_set(res, id_iv_status, sym_found);
+                rb_ivar_set(res, cb_id_iv_status, cb_sym_found);
                 break;
             case LCB_OBSERVE_PERSISTED:
-                rb_ivar_set(res, id_iv_status, sym_persisted);
+                rb_ivar_set(res, cb_id_iv_status, cb_sym_persisted);
                 break;
             case LCB_OBSERVE_NOT_FOUND:
-                rb_ivar_set(res, id_iv_status, sym_not_found);
+                rb_ivar_set(res, cb_id_iv_status, cb_sym_not_found);
                 break;
             default:
-                rb_ivar_set(res, id_iv_status, Qnil);
+                rb_ivar_set(res, cb_id_iv_status, Qnil);
         }
         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)) {
@@ -68,12 +68,15 @@ observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
         }
     } else {
         if (bucket->async && ctx->proc != Qnil) {
-            res = rb_class_new_instance(0, NULL, cResult);
-            rb_ivar_set(res, id_iv_completed, Qtrue);
-            cb_proc_call(ctx->proc, 1, res);
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            rb_ivar_set(res, cb_id_iv_completed, Qtrue);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
         ctx->nqueries--;
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
     (void)handle;
 }
@@ -110,26 +113,26 @@ observe_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_
     VALUE
 cb_bucket_observe(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE args, rv, proc, exc;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_observe;
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_observe;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     ctx->proc = cb_gc_protect(bucket, proc);
     ctx->bucket = bucket;
@@ -142,12 +145,12 @@ 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;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {
@@ -155,13 +158,15 @@ 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);
         }
-        if (bucket->exception != Qnil) {
-            rb_exc_raise(bucket->exception);
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
         }
         if (params.cmd.observe.num > 1 || params.cmd.observe.array) {
             return rv;  /* return as a hash {key => {}, ...} */

data/ext/couchbase_ext/result.c

@@ -28,7 +28,7 @@
     VALUE
 cb_result_success_p(VALUE self)
 {
-    return RTEST(rb_ivar_get(self, id_iv_error)) ? Qfalse : Qtrue;
+    return RTEST(rb_ivar_get(self, cb_id_iv_error)) ? Qfalse : Qtrue;
 }
 
 /*
@@ -41,7 +41,7 @@ cb_result_success_p(VALUE self)
     VALUE
 cb_result_inspect(VALUE self)
 {
-    VALUE str, attr, error;
+    VALUE str, attr;
     char buf[100];
 
     str = rb_str_buf_new2("#<");
@@ -49,70 +49,67 @@ cb_result_inspect(VALUE self)
     snprintf(buf, 100, ":%p", (void *)self);
     rb_str_buf_cat2(str, buf);
 
-    attr = rb_ivar_get(self, id_iv_error);
+    attr = rb_ivar_get(self, cb_id_iv_operation);
     if (RTEST(attr)) {
-        error = rb_ivar_get(attr, id_iv_error);
-    } else {
-        error = INT2FIX(0);
+        rb_str_buf_cat2(str, " operation=");
+        rb_str_append(str, rb_inspect(attr));
     }
-    rb_str_buf_cat2(str, " error=0x");
-    rb_str_append(str, rb_funcall(error, id_to_s, 1, INT2FIX(16)));
 
-    attr = rb_ivar_get(self, id_iv_operation);
+    attr = rb_ivar_get(self, cb_id_iv_error);
     if (RTEST(attr)) {
-        rb_str_buf_cat2(str, " operation=");
+        rb_str_buf_cat2(str, " error=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_key);
+    attr = rb_ivar_get(self, cb_id_iv_key);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " key=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_status);
+    attr = rb_ivar_get(self, cb_id_iv_status);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " status=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_cas);
+    attr = rb_ivar_get(self, cb_id_iv_cas);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " cas=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_flags);
+    attr = rb_ivar_get(self, cb_id_iv_flags);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " flags=0x");
-        rb_str_append(str, rb_funcall(attr, id_to_s, 1, INT2FIX(16)));
+        rb_str_append(str, rb_funcall(attr, cb_id_to_s, 1, INT2FIX(16)));
     }
 
-    attr = rb_ivar_get(self, id_iv_node);
+    attr = rb_ivar_get(self, cb_id_iv_node);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " node=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_from_master);
+    attr = rb_ivar_get(self, cb_id_iv_from_master);
     if (attr != Qnil) {
         rb_str_buf_cat2(str, " from_master=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_time_to_persist);
+    attr = rb_ivar_get(self, cb_id_iv_time_to_persist);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " time_to_persist=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_time_to_replicate);
+    attr = rb_ivar_get(self, cb_id_iv_time_to_replicate);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " time_to_replicate=");
         rb_str_append(str, rb_inspect(attr));
     }
 
-    attr = rb_ivar_get(self, id_iv_headers);
+    attr = rb_ivar_get(self, cb_id_iv_headers);
     if (RTEST(attr)) {
         rb_str_buf_cat2(str, " headers=");
         rb_str_append(str, rb_inspect(attr));

data/ext/couchbase_ext/stats.c

@@ -18,32 +18,30 @@
 #include "couchbase_ext.h"
 
     void
-stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_server_stat_resp_t *resp)
+cb_stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_server_stat_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE stats, node, key, val, *rv = ctx->rv, exc = Qnil, res;
 
     node = resp->v.v0.server_endpoint ? STR_NEW_CSTR(resp->v.v0.server_endpoint) : Qnil;
     exc = cb_check_error(error, "failed to fetch stats", node);
     if (exc != Qnil) {
-        rb_ivar_set(exc, id_iv_operation, sym_stats);
-        if (NIL_P(ctx->exception)) {
-            ctx->exception = cb_gc_protect(bucket, exc);
-        }
+        rb_ivar_set(exc, cb_id_iv_operation, cb_sym_stats);
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
     if (node != Qnil) {
         key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
         val = STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes);
         if (bucket->async) {    /* asynchronous */
             if (ctx->proc != Qnil) {
-                res = rb_class_new_instance(0, NULL, cResult);
-                rb_ivar_set(res, id_iv_error, exc);
-                rb_ivar_set(res, id_iv_operation, sym_stats);
-                rb_ivar_set(res, id_iv_node, node);
-                rb_ivar_set(res, id_iv_key, key);
-                rb_ivar_set(res, id_iv_value, val);
-                cb_proc_call(ctx->proc, 1, res);
+                res = rb_class_new_instance(0, NULL, cb_cResult);
+                rb_ivar_set(res, cb_id_iv_error, exc);
+                rb_ivar_set(res, cb_id_iv_operation, cb_sym_stats);
+                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(bucket, ctx->proc, 1, res);
             }
         } else {                /* synchronous */
             if (NIL_P(exc)) {
@@ -56,8 +54,10 @@ stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_ser
             }
         }
     } else {
-        ctx->nqueries--;
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
     (void)handle;
 }
@@ -107,26 +107,26 @@ stat_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_ser
     VALUE
 cb_bucket_stats(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE rv, exc, args, proc;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_stats;
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_stats;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     rv = rb_hash_new();
     ctx->rv = &rv;
@@ -139,12 +139,12 @@ 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;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {
@@ -152,13 +152,15 @@ 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);
         }
-        if (bucket->exception != Qnil) {
-            rb_exc_raise(bucket->exception);
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
         }
         return rv;
     }

data/ext/couchbase_ext/store.c

@@ -20,60 +20,62 @@
     static VALUE
 storage_observe_callback(VALUE args, VALUE cookie)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE res = rb_ary_shift(args);
 
     if (ctx->proc != Qnil) {
-        rb_ivar_set(res, id_iv_operation, ctx->operation);
-        cb_proc_call(ctx->proc, 1, res);
+        rb_ivar_set(res, cb_id_iv_operation, ctx->operation);
+        cb_proc_call(bucket, ctx->proc, 1, res);
     }
     if (!RTEST(ctx->observe_options)) {
         ctx->nqueries--;
         if (ctx->nqueries == 0) {
-            cb_gc_unprotect(ctx->bucket, ctx->proc);
+            cb_gc_unprotect(bucket, ctx->proc);
+            if (bucket->async) {
+                free(ctx);
+            }
         }
     }
     return Qnil;
 }
 
     void
-storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
+cb_storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
         lcb_error_t error, const lcb_store_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
+    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;
 
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-    strip_key_prefix(bucket, key);
+    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 = sym_add;
+            ctx->operation = cb_sym_add;
             break;
         case LCB_REPLACE:
-            ctx->operation = sym_replace;
+            ctx->operation = cb_sym_replace;
             break;
         case LCB_SET:
-            ctx->operation = sym_set;
+            ctx->operation = cb_sym_set;
             break;
         case LCB_APPEND:
-            ctx->operation = sym_append;
+            ctx->operation = cb_sym_append;
             break;
         case LCB_PREPEND:
-            ctx->operation = sym_prepend;
+            ctx->operation = cb_sym_prepend;
             break;
         default:
             ctx->operation = Qnil;
     }
     exc = cb_check_error(error, "failed to store value", key);
     if (exc != Qnil) {
-        rb_ivar_set(exc, id_iv_cas, cas);
-        rb_ivar_set(exc, id_iv_operation, ctx->operation);
-        if (NIL_P(ctx->exception)) {
-            ctx->exception = cb_gc_protect(bucket, exc);
-        }
+        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);
     }
 
     if (bucket->async) { /* asynchronous */
@@ -82,16 +84,16 @@ storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
             args[0] = rb_hash_new();
             rb_hash_aset(args[0], key, cas);
             args[1] = ctx->observe_options;
-            rb_block_call(bucket->self, id_observe_and_wait, 2, args,
+            rb_block_call(bucket->self, cb_id_observe_and_wait, 2, args,
                     storage_observe_callback, (VALUE)ctx);
             cb_gc_unprotect(bucket, ctx->observe_options);
         } else if (ctx->proc != Qnil) {
-            res = rb_class_new_instance(0, NULL, cResult);
-            rb_ivar_set(res, id_iv_error, exc);
-            rb_ivar_set(res, id_iv_key, key);
-            rb_ivar_set(res, id_iv_operation, ctx->operation);
-            rb_ivar_set(res, id_iv_cas, cas);
-            cb_proc_call(ctx->proc, 1, res);
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            rb_ivar_set(res, cb_id_iv_error, exc);
+            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(bucket, ctx->proc, 1, res);
         }
     } else {             /* synchronous */
         rb_hash_aset(*rv, key, cas);
@@ -101,6 +103,9 @@ storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
         ctx->nqueries--;
         if (ctx->nqueries == 0) {
             cb_gc_unprotect(bucket, ctx->proc);
+            if (bucket->async) {
+                free(ctx);
+            }
         }
     }
     (void)handle;
@@ -109,27 +114,27 @@ storage_callback(lcb_t handle, const void *cookie, lcb_storage_t operation,
     static inline VALUE
 cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE args, rv, proc, exc, obs = Qnil;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_store;
+    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 = xcalloc(1, sizeof(struct context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     rv = rb_hash_new();
     ctx->rv = &rv;
@@ -137,18 +142,19 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
     ctx->proc = cb_gc_protect(bucket, proc);
     ctx->observe_options = cb_gc_protect(bucket, obs);
     ctx->exception = Qnil;
+    obs = params.cmd.store.observe;
     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) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {
@@ -156,17 +162,19 @@ 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);
         }
-        if (bucket->exception != Qnil) {
-            rb_exc_raise(bucket->exception);
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
         }
         if (RTEST(obs)) {
             cb_gc_unprotect(bucket, obs);
-            return rb_funcall(bucket->self, id_observe_and_wait, 2, rv, obs);
+            rv = rb_funcall(bucket->self, cb_id_observe_and_wait, 2, rv, obs);
         }
         if (params.cmd.store.num > 1) {
             return rv;  /* return as a hash {key => cas, ...} */