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

data/ext/couchbase_ext/delete.c

@@ -18,38 +18,39 @@
 #include "couchbase_ext.h"
 
     void
-delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_remove_resp_t *resp)
+cb_delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_remove_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, *rv = ctx->rv, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-    strip_key_prefix(bucket, key);
+    cb_strip_key_prefix(bucket, key);
 
     if (error != LCB_KEY_ENOENT || !ctx->quiet) {
         exc = cb_check_error(error, "failed to remove value", key);
         if (exc != Qnil) {
-            rb_ivar_set(exc, id_iv_operation, sym_delete);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_delete);
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
     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_delete);
-            rb_ivar_set(res, id_iv_key, key);
-            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_delete);
+            rb_ivar_set(res, cb_id_iv_key, key);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         rb_hash_aset(*rv, key, (error == LCB_SUCCESS) ? Qtrue : Qfalse);
     }
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
     (void)handle;
 }
@@ -99,29 +100,29 @@ delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_r
     VALUE
 cb_bucket_delete(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;
     VALUE 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");
     }
-    rb_funcall(args, id_flatten_bang, 0);
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_remove;
+    rb_funcall(args, cb_id_flatten_bang, 0);
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_remove;
     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->quiet = params.cmd.remove.quiet;
     ctx->proc = cb_gc_protect(bucket, proc);
@@ -135,12 +136,12 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule delete 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) {
@@ -148,12 +149,14 @@ cb_bucket_delete(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));
         }
-        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.remove.num > 1) {
             return rv;  /* return as a hash {key => true, ...} */

data/ext/couchbase_ext/extconf.rb

@@ -20,7 +20,7 @@ require 'rbconfig'
 # This hack is more robust, because in bundler environment bundler touches
 # all constants from rbconfig.rb before loading any scripts. This is why
 # RC_ARCHS doesn't work under bundler on MacOS.
-if RUBY_PLATFORM =~ /darwin/
+if RUBY_PLATFORM =~ /darwin/ && defined?(RbConfig::ARCHFLAGS)
   [RbConfig::CONFIG, RbConfig::MAKEFILE_CONFIG].each do |cfg|
     cfg["CFLAGS"].gsub!(RbConfig::ARCHFLAGS, '')
     cfg["LDFLAGS"].gsub!(RbConfig::ARCHFLAGS, '')
@@ -119,14 +119,26 @@ if try_compile(<<-SRC)
   define("HAVE_STDARG_PROTOTYPES")
 end
 
+def die(message)
+  STDERR.puts "\n#{"*" * 70}"
+  STDERR.puts "#{message}"
+  STDERR.puts "#{"*" * 70}\n\n"
+  abort
+end
 
-have_library("couchbase", "lcb_get", "libcouchbase/couchbase.h") or abort "You should install libcouchbase >= 2.0.0. See http://www.couchbase.com/develop/ for more details"
+have_library("couchbase", "lcb_verify_compiler_setup", "libcouchbase/couchbase.h") or die("You must install libcouchbase >= 2.0.0beta3. See http://www.couchbase.com/develop/ for more details")
 have_header("mach/mach_time.h")
-have_header("stdint.h") or abort "Failed to locate stdint.h"
+have_header("stdint.h") or die("Failed to locate stdint.h")
 have_header("sys/time.h")
+have_header("fcntl.h")
 have_func("clock_gettime")
 have_func("gettimeofday")
 have_func("QueryPerformanceCounter")
+have_func("rb_hash_lookup2")
+have_func("rb_thread_fd_select")
+have_func("rb_thread_blocking_region")
+have_func("poll", "poll.h")
+have_func("ppoll", "poll.h")
 define("_GNU_SOURCE")
 create_header("couchbase_config.h")
 create_makefile("couchbase_ext")

data/ext/couchbase_ext/get.c

@@ -18,23 +18,21 @@
 #include "couchbase_ext.h"
 
     void
-get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_get_resp_t *resp)
+cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_get_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, val, flags, cas, *rv = ctx->rv, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-    strip_key_prefix(bucket, key);
+    cb_strip_key_prefix(bucket, key);
 
     if (error != LCB_KEY_ENOENT || !ctx->quiet) {
         exc = cb_check_error(error, "failed to get value", key);
         if (exc != Qnil) {
-            rb_ivar_set(exc, id_iv_operation, sym_get);
-            if (NIL_P(ctx->exception)) {
-                ctx->exception = cb_gc_protect(bucket, exc);
-            }
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_get);
+            ctx->exception = cb_gc_protect(bucket, exc);
         }
     }
 
@@ -42,30 +40,35 @@ get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_get_
     cas = ULL2NUM(resp->v.v0.cas);
     val = Qnil;
     if (resp->v.v0.nbytes != 0) {
-        val = decode_value(STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes),
-                resp->v.v0.flags, ctx->force_format);
-        if (val == Qundef) {
+        VALUE raw = STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes);
+        val = cb_decode_value(raw, resp->v.v0.flags, ctx->force_format);
+        if (rb_obj_is_kind_of(val, rb_eStandardError)) {
+            VALUE exc_str = rb_funcall(val, cb_id_to_s, 0);
+            VALUE msg = rb_funcall(rb_mKernel, cb_id_sprintf, 3,
+                    rb_str_new2("unable to convert value for key '%s': %s"), key, exc_str);
             if (ctx->exception != Qnil) {
                 cb_gc_unprotect(bucket, ctx->exception);
             }
-            ctx->exception = rb_exc_new2(eValueFormatError, "unable to convert value");
-            rb_ivar_set(ctx->exception, id_iv_operation, sym_get);
-            rb_ivar_set(ctx->exception, id_iv_key, key);
+            ctx->exception = rb_exc_new3(cb_eValueFormatError, msg);
+            rb_ivar_set(ctx->exception, cb_id_iv_operation, cb_sym_get);
+            rb_ivar_set(ctx->exception, cb_id_iv_key, key);
+            rb_ivar_set(ctx->exception, cb_id_iv_inner_exception, val);
             cb_gc_protect(bucket, ctx->exception);
+            val = raw;
         }
-    } else if (flags_get_format(resp->v.v0.flags) == sym_plain) {
-        val = STR_NEW_CSTR("");
+    } else if (cb_flags_get_format(resp->v.v0.flags) == cb_sym_plain) {
+        val = cb_vStrEmpty;
     }
     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_get);
-            rb_ivar_set(res, id_iv_key, key);
-            rb_ivar_set(res, id_iv_value, val);
-            rb_ivar_set(res, id_iv_flags, flags);
-            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_operation, cb_sym_get);
+            rb_ivar_set(res, cb_id_iv_key, key);
+            rb_ivar_set(res, cb_id_iv_value, val);
+            rb_ivar_set(res, cb_id_iv_flags, flags);
+            rb_ivar_set(res, cb_id_iv_cas, cas);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         if (NIL_P(exc) && error != LCB_KEY_ENOENT) {
@@ -79,6 +82,9 @@ get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_get_
 
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
     (void)handle;
 }
@@ -214,28 +220,28 @@ get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_get_
     VALUE
 cb_bucket_get(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;
     size_t ii;
     lcb_error_t err = LCB_SUCCESS;
-    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_get;
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_get;
     params.bucket = bucket;
     params.cmd.get.keys_ary = cb_gc_protect(bucket, rb_ary_new());
     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->extended = params.cmd.get.extended;
     ctx->quiet = params.cmd.get.quiet;
@@ -257,12 +263,12 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     cb_gc_unprotect(bucket, params.cmd.get.keys_ary);
     exc = cb_check_error(err, "failed to schedule get 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) {
@@ -270,13 +276,15 @@ cb_bucket_get(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.get.gat || params.cmd.get.assemble_hash ||
                 (params.cmd.get.extended && (params.cmd.get.num > 1 || params.cmd.get.array))) {

data/ext/couchbase_ext/http.c

@@ -18,37 +18,44 @@
 #include "couchbase_ext.h"
 
     void
-http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *cookie, lcb_error_t error, const lcb_http_resp_t *resp)
+cb_http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *cookie, lcb_error_t error, const lcb_http_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
-    VALUE *rv = ctx->rv, key, val, res;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
+    VALUE *rv = ctx->rv, key, val, res, exc;
+    lcb_http_status_t status;
 
     ctx->request->completed = 1;
     key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
-    ctx->exception = cb_check_error_with_status(error,
-            "failed to execute HTTP request", key, resp->v.v0.status);
-    if (ctx->exception != Qnil) {
-        cb_gc_protect(bucket, ctx->exception);
-    }
     val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
+    exc = cb_check_error_with_status(error, "failed to execute HTTP request", key, resp->v.v0.status);
+    if (exc != Qnil) {
+        if (val != Qnil) {
+            rb_ivar_set(exc, cb_id_iv_body, val);
+        }
+        rb_funcall(exc, cb_id_parse_body_bang, 0);
+        ctx->exception = cb_gc_protect(bucket, exc);
+    }
+    status = resp->v.v0.status;
     if (resp->v.v0.headers) {
         cb_build_headers(ctx, resp->v.v0.headers);
         cb_gc_unprotect(bucket, ctx->headers_val);
     }
     if (ctx->extended) {
-        res = rb_class_new_instance(0, NULL, cResult);
-        rb_ivar_set(res, id_iv_error, ctx->exception);
-        rb_ivar_set(res, id_iv_operation, sym_http_request);
-        rb_ivar_set(res, id_iv_key, key);
-        rb_ivar_set(res, id_iv_value, val);
-        rb_ivar_set(res, id_iv_completed, Qtrue);
-        rb_ivar_set(res, id_iv_headers, ctx->headers_val);
+        res = rb_class_new_instance(0, NULL, cb_cResult);
+        rb_ivar_set(res, cb_id_iv_error, ctx->exception);
+        rb_ivar_set(res, cb_id_iv_status, status ? INT2FIX(status) : Qnil);
+        rb_ivar_set(res, cb_id_iv_operation, cb_sym_http_request);
+        rb_ivar_set(res, cb_id_iv_key, key);
+        rb_ivar_set(res, cb_id_iv_value, val);
+        rb_ivar_set(res, cb_id_iv_completed, Qtrue);
+        rb_ivar_set(res, cb_id_iv_headers, ctx->headers_val);
     } else {
         res = val;
     }
     if (ctx->proc != Qnil) {
-        cb_proc_call(ctx->proc, 1, res);
+        cb_proc_call(bucket, ctx->proc, 1, res);
+        cb_gc_unprotect(bucket, ctx->proc);
     }
     if (!bucket->async && ctx->exception == Qnil) {
         *rv = res;
@@ -58,36 +65,49 @@ http_complete_callback(lcb_http_request_t request, lcb_t handle, const void *coo
 }
 
     void
-http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cookie, lcb_error_t error, const lcb_http_resp_t *resp)
+cb_http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cookie, lcb_error_t error, const lcb_http_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, val, res;
+    lcb_http_status_t status;
 
     key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
-    ctx->exception = cb_check_error_with_status(error,
-            "failed to execute HTTP request", key, resp->v.v0.status);
     val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
-    if (ctx->exception != Qnil) {
-        cb_gc_protect(bucket, ctx->exception);
-        lcb_cancel_http_request(bucket->handle, request);
+    status = resp->v.v0.status;
+    if (NIL_P(ctx->exception)) {
+        ctx->exception = cb_check_error_with_status(error,
+                "failed to execute HTTP request", key, resp->v.v0.status);
+        if (ctx->exception != Qnil) {
+            VALUE body_str = rb_ivar_get(ctx->exception, cb_id_iv_body);
+            if (NIL_P(body_str)) {
+                cb_gc_protect(bucket, ctx->exception);
+                rb_ivar_set(ctx->exception, cb_id_iv_body, val);
+            } else {
+                rb_str_concat(body_str, val);
+            }
+            if (ctx->http_cancel_on_error) {
+                lcb_cancel_http_request(bucket->handle, request);
+            }
+        }
     }
     if (resp->v.v0.headers) {
         cb_build_headers(ctx, resp->v.v0.headers);
     }
     if (ctx->proc != Qnil) {
         if (ctx->extended) {
-            res = rb_class_new_instance(0, NULL, cResult);
-            rb_ivar_set(res, id_iv_error, ctx->exception);
-            rb_ivar_set(res, id_iv_operation, sym_http_request);
-            rb_ivar_set(res, id_iv_key, key);
-            rb_ivar_set(res, id_iv_value, val);
-            rb_ivar_set(res, id_iv_completed, Qfalse);
-            rb_ivar_set(res, id_iv_headers, ctx->headers_val);
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            rb_ivar_set(res, cb_id_iv_error, ctx->exception);
+            rb_ivar_set(res, cb_id_iv_status, status ? INT2FIX(status) : Qnil);
+            rb_ivar_set(res, cb_id_iv_operation, cb_sym_http_request);
+            rb_ivar_set(res, cb_id_iv_key, key);
+            rb_ivar_set(res, cb_id_iv_value, val);
+            rb_ivar_set(res, cb_id_iv_completed, Qfalse);
+            rb_ivar_set(res, cb_id_iv_headers, ctx->headers_val);
         } else {
             res = val;
         }
-        cb_proc_call(ctx->proc, 1, res);
+        cb_proc_call(bucket, ctx->proc, 1, res);
     }
     (void)handle;
 }
@@ -95,7 +115,7 @@ http_data_callback(lcb_http_request_t request, lcb_t handle, const void *cookie,
     void
 cb_http_request_free(void *ptr)
 {
-    struct http_request_st *request = ptr;
+    struct cb_http_request_st *request = ptr;
     if (request) {
         request->running = 0;
         if (TYPE(request->bucket_obj) == T_DATA
@@ -103,17 +123,17 @@ cb_http_request_free(void *ptr)
                 && !request->completed) {
             lcb_cancel_http_request(request->bucket->handle, request->request);
         }
-        xfree((char *)request->cmd.v.v0.content_type);
-        xfree((char *)request->cmd.v.v0.path);
-        xfree((char *)request->cmd.v.v0.body);
-        xfree(request);
+        free((char *)request->cmd.v.v0.content_type);
+        free((char *)request->cmd.v.v0.path);
+        free((char *)request->cmd.v.v0.body);
     }
+    xfree(request);
 }
 
     void
 cb_http_request_mark(void *ptr)
 {
-    struct http_request_st *request = ptr;
+    struct cb_http_request_st *request = ptr;
     if (request) {
         rb_gc_mark(request->on_body_callback);
     }
@@ -123,10 +143,10 @@ cb_http_request_mark(void *ptr)
 cb_http_request_alloc(VALUE klass)
 {
     VALUE obj;
-    struct http_request_st *request;
+    struct cb_http_request_st *request;
 
     /* allocate new bucket struct and set it to zero */
-    obj = Data_Make_Struct(klass, struct http_request_st, cb_http_request_mark,
+    obj = Data_Make_Struct(klass, struct cb_http_request_st, cb_http_request_mark,
             cb_http_request_free, request);
     return obj;
 }
@@ -143,7 +163,7 @@ cb_http_request_alloc(VALUE klass)
 cb_http_request_inspect(VALUE self)
 {
     VALUE str;
-    struct http_request_st *req = DATA_PTR(self);
+    struct cb_http_request_st *req = DATA_PTR(self);
     char buf[200];
 
     str = rb_str_buf_new2("#<");
@@ -167,14 +187,14 @@ cb_http_request_inspect(VALUE self)
     VALUE
 cb_http_request_init(int argc, VALUE *argv, VALUE self)
 {
-    struct http_request_st *request = DATA_PTR(self);
+    struct cb_http_request_st *request = DATA_PTR(self);
     VALUE bucket, path, opts, on_body, pp, arg;
     rb_scan_args(argc, argv, "22", &bucket, &pp, &opts, &on_body);
 
     if (NIL_P(on_body) && rb_block_given_p()) {
         on_body = rb_block_proc();
     }
-    if (CLASS_OF(bucket) != cBucket) {
+    if (CLASS_OF(bucket) != cb_cBucket) {
         rb_raise(rb_eTypeError, "wrong argument type (expected Couchbase::Bucket)");
     }
     memset(&request->cmd, 0, sizeof(lcb_http_cmd_t));
@@ -191,38 +211,38 @@ cb_http_request_init(int argc, VALUE *argv, VALUE self)
 
     if (opts != Qnil) {
         Check_Type(opts, T_HASH);
-        request->extended = RTEST(rb_hash_aref(opts, sym_extended));
-        request->cmd.v.v0.chunked = RTEST(rb_hash_aref(opts, sym_chunked));
-        if ((arg = rb_hash_aref(opts, sym_type)) != Qnil) {
-            if (arg == sym_view) {
+        request->extended = RTEST(rb_hash_aref(opts, cb_sym_extended));
+        request->cmd.v.v0.chunked = RTEST(rb_hash_aref(opts, cb_sym_chunked));
+        if ((arg = rb_hash_aref(opts, cb_sym_type)) != Qnil) {
+            if (arg == cb_sym_view) {
                 request->type = LCB_HTTP_TYPE_VIEW;
-            } else if (arg == sym_management) {
+            } else if (arg == cb_sym_management) {
                 request->type = LCB_HTTP_TYPE_MANAGEMENT;
             } else {
                 rb_raise(rb_eArgError, "unsupported request type");
             }
         }
-        if ((arg = rb_hash_aref(opts, sym_method)) != Qnil) {
-            if (arg == sym_get) {
+        if ((arg = rb_hash_aref(opts, cb_sym_method)) != Qnil) {
+            if (arg == cb_sym_get) {
                 request->cmd.v.v0.method = LCB_HTTP_METHOD_GET;
-            } else if (arg == sym_post) {
+            } else if (arg == cb_sym_post) {
                 request->cmd.v.v0.method = LCB_HTTP_METHOD_POST;
-            } else if (arg == sym_put) {
+            } else if (arg == cb_sym_put) {
                 request->cmd.v.v0.method = LCB_HTTP_METHOD_PUT;
-            } else if (arg == sym_delete) {
+            } else if (arg == cb_sym_delete) {
                 request->cmd.v.v0.method = LCB_HTTP_METHOD_DELETE;
             } else {
                 rb_raise(rb_eArgError, "unsupported HTTP method");
             }
         }
-        if ((arg = rb_hash_aref(opts, sym_body)) != Qnil) {
+        if ((arg = rb_hash_aref(opts, cb_sym_body)) != Qnil) {
             Check_Type(arg, T_STRING);
             request->cmd.v.v0.body = strdup(RSTRING_PTR(arg));
             request->cmd.v.v0.nbody = RSTRING_LEN(arg);
         }
-        if ((arg = rb_hash_aref(opts, sym_content_type)) != Qnil) {
+        if ((arg = rb_hash_aref(opts, cb_sym_content_type)) != Qnil) {
             Check_Type(arg, T_STRING);
-            xfree((char *)request->cmd.v.v0.content_type);
+            free((char *)request->cmd.v.v0.content_type);
             request->cmd.v.v0.content_type = strdup(RSTRING_PTR(arg));
         }
     }
@@ -238,7 +258,7 @@ cb_http_request_init(int argc, VALUE *argv, VALUE self)
     VALUE
 cb_http_request_on_body(VALUE self)
 {
-    struct http_request_st *request = DATA_PTR(self);
+    struct cb_http_request_st *request = DATA_PTR(self);
     VALUE old = request->on_body_callback;
     if (rb_block_given_p()) {
         request->on_body_callback = rb_block_proc();
@@ -254,30 +274,31 @@ cb_http_request_on_body(VALUE self)
     VALUE
 cb_http_request_perform(VALUE self)
 {
-    struct http_request_st *req = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_http_request_st *req = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE rv, exc;
     lcb_error_t err;
-    struct bucket_st *bucket;
+    struct cb_bucket_st *bucket;
 
-    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");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory");
     }
     rv = Qnil;
     ctx->rv = &rv;
     ctx->bucket = bucket = req->bucket;
-    ctx->proc = rb_block_given_p() ? rb_block_proc() : req->on_body_callback;
+    ctx->proc = rb_block_given_p() ? cb_gc_protect(bucket, rb_block_proc()) : req->on_body_callback;
     ctx->extended = req->extended;
     ctx->request = req;
     ctx->headers_val = cb_gc_protect(bucket, rb_hash_new());
+    ctx->exception = Qnil;
 
     err = lcb_make_http_request(bucket->handle, (const void *)ctx,
             req->type, &req->cmd, &req->request);
     exc = cb_check_error(err, "failed to schedule document request",
             STR_NEW(req->cmd.v.v0.path, req->cmd.v.v0.npath));
     if (exc != Qnil) {
-        xfree(ctx);
+        free(ctx);
         rb_exc_raise(exc);
     }
     req->running = 1;
@@ -288,7 +309,7 @@ cb_http_request_perform(VALUE self)
         lcb_wait(bucket->handle);
         if (req->completed) {
             exc = ctx->exception;
-            xfree(ctx);
+            free(ctx);
             if (exc != Qnil) {
                 cb_gc_unprotect(bucket, exc);
                 rb_exc_raise(exc);
@@ -304,8 +325,8 @@ cb_http_request_perform(VALUE self)
     VALUE
 cb_http_request_pause(VALUE self)
 {
-    struct http_request_st *req = DATA_PTR(self);
-    req->bucket->io->stop_event_loop(req->bucket->io);
+    struct cb_http_request_st *req = DATA_PTR(self);
+    lcb_breakout(req->bucket->handle);
     return Qnil;
 }
 
@@ -313,14 +334,14 @@ cb_http_request_pause(VALUE self)
 cb_http_request_continue(VALUE self)
 {
     VALUE exc, *rv;
-    struct http_request_st *req = DATA_PTR(self);
+    struct cb_http_request_st *req = DATA_PTR(self);
 
     if (req->running) {
         lcb_wait(req->bucket->handle);
         if (req->completed) {
             exc = req->ctx->exception;
             rv = req->ctx->rv;
-            xfree(req->ctx);
+            free(req->ctx);
             if (exc != Qnil) {
                 cb_gc_unprotect(req->bucket, exc);
                 rb_exc_raise(exc);
@@ -342,7 +363,7 @@ cb_http_request_continue(VALUE self)
     VALUE
 cb_http_request_path_get(VALUE self)
 {
-    struct http_request_st *req = DATA_PTR(self);
+    struct cb_http_request_st *req = DATA_PTR(self);
     return STR_NEW_CSTR(req->cmd.v.v0.path);
 }
 
@@ -356,7 +377,7 @@ cb_http_request_path_get(VALUE self)
     VALUE
 cb_http_request_chunked_get(VALUE self)
 {
-    struct http_request_st *req = DATA_PTR(self);
+    struct cb_http_request_st *req = DATA_PTR(self);
     return req->cmd.v.v0.chunked ? Qtrue : Qfalse;
 }
 
@@ -370,7 +391,7 @@ cb_http_request_chunked_get(VALUE self)
     VALUE
 cb_http_request_extended_get(VALUE self)
 {
-    struct http_request_st *req = DATA_PTR(self);
+    struct cb_http_request_st *req = DATA_PTR(self);
     return req->extended ? Qtrue : Qfalse;
 }
 
@@ -396,7 +417,7 @@ cb_bucket_make_http_request(int argc, VALUE *argv, VALUE self)
     args[0] = self;
     rb_scan_args(argc, argv, "11&", &args[1], &args[2], &args[3]);
 
-    return rb_class_new_instance(4, args, cCouchRequest);
+    return rb_class_new_instance(4, args, cb_cCouchRequest);
 }