couchbase 1.2.0.z.beta4-x86-mingw32 → 1.2.0.z.beta5-x86-mingw32

data/ext/couchbase_ext/delete.c

@@ -18,20 +18,20 @@
 #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);
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_delete);
             if (NIL_P(ctx->exception)) {
                 ctx->exception = cb_gc_protect(bucket, exc);
             }
@@ -39,10 +39,10 @@ delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_r
     }
     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);
+            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(ctx->proc, 1, res);
         }
     } else {                /* synchronous */
@@ -50,6 +50,9 @@ delete_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_r
     }
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            xfree(ctx);
+        }
     }
     (void)handle;
 }
@@ -99,29 +102,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 = xcalloc(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);
@@ -140,7 +143,7 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {

data/ext/couchbase_ext/extconf.rb

@@ -119,9 +119,16 @@ if try_compile(<<-SRC)
   define("HAVE_STDARG_PROTOTYPES")
 end
 
-have_library("couchbase", "lcb_verify_compiler_setup", "libcouchbase/couchbase.h") or abort "You should install libcouchbase >= 2.0.0beta3. See http://www.couchbase.com/develop/ for more details"
+def die(message)
+  STDERR.puts "\n#{"*" * 70}"
+  STDERR.puts "#{message}"
+  STDERR.puts "#{"*" * 70}\n\n"
+  abort
+end
+
+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_func("clock_gettime")
 have_func("gettimeofday")

data/ext/couchbase_ext/get.c

@@ -18,20 +18,20 @@
 #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);
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_get);
             if (NIL_P(ctx->exception)) {
                 ctx->exception = cb_gc_protect(bucket, exc);
             }
@@ -43,33 +43,33 @@ get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_get_
     val = Qnil;
     if (resp->v.v0.nbytes != 0) {
         VALUE raw = STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes);
-        val = decode_value(raw, resp->v.v0.flags, ctx->force_format);
+        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, id_to_s, 0);
-            VALUE msg = rb_funcall(rb_mKernel, id_sprintf, 3,
+            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_new3(eValueFormatError, msg);
-            rb_ivar_set(ctx->exception, id_iv_operation, sym_get);
-            rb_ivar_set(ctx->exception, id_iv_key, key);
-            rb_ivar_set(ctx->exception, id_iv_inner_exception, val);
+            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) {
+    } else if (cb_flags_get_format(resp->v.v0.flags) == cb_sym_plain) {
         val = STR_NEW_CSTR("");
     }
     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);
+            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(ctx->proc, 1, res);
         }
     } else {                /* synchronous */
@@ -84,6 +84,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) {
+            xfree(ctx);
+        }
     }
     (void)handle;
 }
@@ -219,28 +222,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 = xcalloc(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;
@@ -267,7 +270,7 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {

data/ext/couchbase_ext/http.c

@@ -18,35 +18,39 @@
 #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;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE *rv = ctx->rv, key, val, res;
     lcb_http_status_t status;
 
     ctx->request->completed = 1;
     key = STR_NEW((const char*)resp->v.v0.path, resp->v.v0.npath);
+    val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
     ctx->exception = cb_check_error_with_status(error,
             "failed to execute HTTP request", key, resp->v.v0.status);
     if (ctx->exception != Qnil) {
+        if (val != Qnil) {
+            rb_ivar_set(ctx->exception, cb_id_iv_body, val);
+        }
+        rb_funcall(ctx->exception, cb_id_parse_body_bang, 0);
         cb_gc_protect(bucket, ctx->exception);
     }
-    val = resp->v.v0.nbytes ? STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes) : Qnil;
     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_status, status ? INT2FIX(status) : Qnil);
-        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;
     }
@@ -61,35 +65,45 @@ 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;
     status = resp->v.v0.status;
-    if (ctx->exception != Qnil) {
-        cb_gc_protect(bucket, ctx->exception);
-        lcb_cancel_http_request(bucket->handle, request);
+    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_status, status ? INT2FIX(status) : Qnil);
-            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;
         }
@@ -101,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
@@ -119,7 +133,7 @@ cb_http_request_free(void *ptr)
     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);
     }
@@ -129,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;
 }
@@ -149,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("#<");
@@ -173,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));
@@ -197,36 +211,36 @@ 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);
             request->cmd.v.v0.content_type = strdup(RSTRING_PTR(arg));
@@ -244,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();
@@ -260,15 +274,15 @@ 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 = xcalloc(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;
@@ -310,7 +324,7 @@ cb_http_request_perform(VALUE self)
     VALUE
 cb_http_request_pause(VALUE self)
 {
-    struct http_request_st *req = DATA_PTR(self);
+    struct cb_http_request_st *req = DATA_PTR(self);
     lcb_breakout(req->bucket->handle);
     return Qnil;
 }
@@ -319,7 +333,7 @@ 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);
@@ -348,7 +362,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);
 }
 
@@ -362,7 +376,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;
 }
 
@@ -376,7 +390,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;
 }
 
@@ -402,7 +416,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);
 }