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

data/ext/couchbase_ext/arithmetic.c

@@ -18,46 +18,35 @@
 #include "couchbase_ext.h"
 
     void
-arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_arithmetic_resp_t *resp)
+cb_arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_arithmetic_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 cas, key, val, *rv = ctx->rv, exc, res;
     ID o;
 
     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);
 
     cas = resp->v.v0.cas > 0 ? ULL2NUM(resp->v.v0.cas) : Qnil;
-    o = ctx->arith > 0 ? sym_increment : sym_decrement;
+    o = ctx->arith > 0 ? cb_sym_increment : cb_sym_decrement;
     exc = cb_check_error(error, "failed to perform arithmetic operation", key);
     if (exc != Qnil) {
-        rb_ivar_set(exc, id_iv_cas, cas);
-        rb_ivar_set(exc, id_iv_operation, o);
-        if (bucket->async) {
-            if (bucket->on_error_proc != Qnil) {
-                cb_proc_call(bucket->on_error_proc, 3, o, key, exc);
-            } else {
-                if (NIL_P(bucket->exception)) {
-                    bucket->exception = exc;
-                }
-            }
-        }
-        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, o);
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
     val = ULL2NUM(resp->v.v0.value);
     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, o);
-            rb_ivar_set(res, id_iv_key, key);
-            rb_ivar_set(res, id_iv_value, val);
-            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, o);
+            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_cas, cas);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         if (NIL_P(exc)) {
@@ -70,6 +59,9 @@ arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
     }
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            free(ctx);
+        }
     }
     (void)handle;
 }
@@ -77,27 +69,27 @@ arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, const l
     static inline VALUE
 cb_bucket_arithmetic(int sign, 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_arith;
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_arith;
     params.bucket = bucket;
     params.cmd.arith.sign = sign;
     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;
@@ -110,12 +102,12 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
     cb_params_destroy(&params);
     exc = cb_check_error(err, "failed to schedule arithmetic 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) {
@@ -123,7 +115,7 @@ cb_bucket_arithmetic(int sign, 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/bucket.c

@@ -20,38 +20,38 @@
     static void
 error_callback(lcb_t handle, lcb_error_t error, const char *errinfo)
 {
-    struct bucket_st *bucket = (struct bucket_st *)lcb_get_cookie(handle);
+    struct cb_bucket_st *bucket = (struct cb_bucket_st *)lcb_get_cookie(handle);
 
-    bucket->io->stop_event_loop(bucket->io);
+    lcb_breakout(handle);
     bucket->exception = cb_check_error(error, errinfo, Qnil);
 }
 
     void
 cb_bucket_free(void *ptr)
 {
-    struct bucket_st *bucket = ptr;
+    struct cb_bucket_st *bucket = ptr;
 
     if (bucket) {
         if (bucket->handle) {
             lcb_destroy(bucket->handle);
+            lcb_destroy_io_ops(bucket->io);
         }
-        xfree(bucket->authority);
-        xfree(bucket->hostname);
-        xfree(bucket->pool);
-        xfree(bucket->bucket);
-        xfree(bucket->username);
-        xfree(bucket->password);
-        xfree(bucket->key_prefix);
-        xfree(bucket);
     }
+    xfree(bucket);
 }
 
     void
 cb_bucket_mark(void *ptr)
 {
-    struct bucket_st *bucket = ptr;
+    struct cb_bucket_st *bucket = ptr;
 
     if (bucket) {
+        rb_gc_mark(bucket->authority);
+        rb_gc_mark(bucket->hostname);
+        rb_gc_mark(bucket->pool);
+        rb_gc_mark(bucket->bucket);
+        rb_gc_mark(bucket->username);
+        rb_gc_mark(bucket->password);
         rb_gc_mark(bucket->exception);
         rb_gc_mark(bucket->on_error_proc);
         rb_gc_mark(bucket->key_prefix_val);
@@ -60,10 +60,10 @@ cb_bucket_mark(void *ptr)
 }
 
     static void
-do_scan_connection_options(struct bucket_st *bucket, int argc, VALUE *argv)
+do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
 {
     VALUE uri, opts, arg;
-    size_t len;
+    char port_s[8];
 
     if (rb_scan_args(argc, argv, "02", &uri, &opts) > 0) {
         if (TYPE(uri) == T_HASH && argc == 1) {
@@ -75,203 +75,210 @@ do_scan_connection_options(struct bucket_st *bucket, int argc, VALUE *argv)
             VALUE match, uri_obj, re;
 
             Check_Type(uri, T_STRING);
-            uri_obj = rb_funcall(mURI, id_parse, 1, uri);
+            uri_obj = rb_funcall(cb_mURI, cb_id_parse, 1, uri);
 
-            arg = rb_funcall(uri_obj, id_scheme, 0);
+            arg = rb_funcall(uri_obj, cb_id_scheme, 0);
             if (arg == Qnil || rb_str_cmp(arg, STR_NEW_CSTR("http"))) {
                 rb_raise(rb_eArgError, "invalid URI: invalid scheme");
             }
 
-            arg = rb_funcall(uri_obj, id_user, 0);
+            arg = rb_funcall(uri_obj, cb_id_user, 0);
             if (arg != Qnil) {
-                xfree(bucket->username);
-                bucket->username = strdup(RSTRING_PTR(arg));
-                if (bucket->username == NULL) {
-                    rb_raise(eClientNoMemoryError, "failed to allocate memory for Bucket");
-                }
+                bucket->username = rb_str_dup_frozen(StringValue(arg));
             }
 
-            arg = rb_funcall(uri_obj, id_password, 0);
+            arg = rb_funcall(uri_obj, cb_id_password, 0);
             if (arg != Qnil) {
-                xfree(bucket->password);
-                bucket->password = strdup(RSTRING_PTR(arg));
-                if (bucket->password == NULL) {
-                    rb_raise(eClientNoMemoryError, "failed to allocate memory for Bucket");
-                }
+                bucket->password = rb_str_dup_frozen(StringValue(arg));
             }
-            arg = rb_funcall(uri_obj, id_host, 0);
+            arg = rb_funcall(uri_obj, cb_id_host, 0);
             if (arg != Qnil) {
-                xfree(bucket->hostname);
-                bucket->hostname = strdup(RSTRING_PTR(arg));
-                if (bucket->hostname == NULL) {
-                    rb_raise(eClientNoMemoryError, "failed to allocate memory for Bucket");
-                }
+                bucket->hostname = rb_str_dup_frozen(StringValue(arg));
             } else {
                 rb_raise(rb_eArgError, "invalid URI: missing hostname");
             }
 
-            arg = rb_funcall(uri_obj, id_port, 0);
+            arg = rb_funcall(uri_obj, cb_id_port, 0);
             bucket->port = NIL_P(arg) ? 8091 : (uint16_t)NUM2UINT(arg);
 
-            arg = rb_funcall(uri_obj, id_path, 0);
+            arg = rb_funcall(uri_obj, cb_id_path, 0);
             re = rb_reg_new(path_re, sizeof(path_re) - 1, 0);
-            match = rb_funcall(re, id_match, 1, arg);
+            match = rb_funcall(re, cb_id_match, 1, arg);
             arg = rb_reg_nth_match(2, match);
-            xfree(bucket->pool);
-            bucket->pool = strdup(NIL_P(arg) ? "default" : RSTRING_PTR(arg));
+            bucket->pool = NIL_P(arg) ? cb_vStrDefault : rb_str_dup_frozen(StringValue(arg));
+            rb_str_freeze(bucket->pool);
             arg = rb_reg_nth_match(4, match);
-            xfree(bucket->bucket);
-            bucket->bucket = strdup(NIL_P(arg) ? "default" : RSTRING_PTR(arg));
+            bucket->bucket = NIL_P(arg) ? cb_vStrDefault : rb_str_dup_frozen(StringValue(arg));
+            rb_str_freeze(bucket->bucket);
         }
         if (TYPE(opts) == T_HASH) {
-            arg = rb_hash_aref(opts, sym_node_list);
+            arg = rb_hash_aref(opts, cb_sym_type);
+            if (arg != Qnil) {
+                if (arg == cb_sym_cluster) {
+                    bucket->type = LCB_TYPE_CLUSTER;
+                } else {
+                    bucket->type = LCB_TYPE_BUCKET;
+                }
+            }
+            arg = rb_hash_aref(opts, cb_sym_node_list);
             if (arg != Qnil) {
-                VALUE tt;
-                xfree(bucket->node_list);
                 Check_Type(arg, T_ARRAY);
-                tt = rb_ary_join(arg, STR_NEW_CSTR(";"));
-                bucket->node_list = strdup(StringValueCStr(tt));
+                bucket->node_list = rb_ary_join(arg, STR_NEW_CSTR(";"));
+                rb_str_freeze(bucket->node_list);
             }
-            arg = rb_hash_aref(opts, sym_hostname);
+            arg = rb_hash_aref(opts, cb_sym_hostname);
             if (arg != Qnil) {
-                xfree(bucket->hostname);
-                bucket->hostname = strdup(StringValueCStr(arg));
+                bucket->hostname = rb_str_dup_frozen(StringValue(arg));
             }
-            arg = rb_hash_aref(opts, sym_pool);
+            arg = rb_hash_aref(opts, cb_sym_pool);
             if (arg != Qnil) {
-                xfree(bucket->pool);
-                bucket->pool = strdup(StringValueCStr(arg));
+                bucket->pool = rb_str_dup_frozen(StringValue(arg));
             }
-            arg = rb_hash_aref(opts, sym_bucket);
+            arg = rb_hash_aref(opts, cb_sym_bucket);
             if (arg != Qnil) {
-                xfree(bucket->bucket);
-                bucket->bucket = strdup(StringValueCStr(arg));
+                bucket->bucket = rb_str_dup_frozen(StringValue(arg));
             }
-            arg = rb_hash_aref(opts, sym_username);
+            arg = rb_hash_aref(opts, cb_sym_username);
             if (arg != Qnil) {
-                xfree(bucket->username);
-                bucket->username = strdup(StringValueCStr(arg));
+                bucket->username = rb_str_dup_frozen(StringValue(arg));
             }
-            arg = rb_hash_aref(opts, sym_password);
+            arg = rb_hash_aref(opts, cb_sym_password);
             if (arg != Qnil) {
-                xfree(bucket->password);
-                bucket->password = strdup(StringValueCStr(arg));
+                bucket->password = rb_str_dup_frozen(StringValue(arg));
             }
-            arg = rb_hash_aref(opts, sym_port);
+            arg = rb_hash_aref(opts, cb_sym_port);
             if (arg != Qnil) {
                 bucket->port = (uint16_t)NUM2UINT(arg);
             }
-            if (RTEST(rb_funcall(opts, id_has_key_p, 1, sym_quiet))) {
-                bucket->quiet = RTEST(rb_hash_aref(opts, sym_quiet));
+            arg = rb_hash_lookup2(opts, cb_sym_quiet, Qundef);
+            if (arg != Qundef) {
+                bucket->quiet = RTEST(arg);
             }
-            arg = rb_hash_aref(opts, sym_timeout);
+            arg = rb_hash_aref(opts, cb_sym_timeout);
             if (arg != Qnil) {
                 bucket->timeout = (uint32_t)NUM2ULONG(arg);
             }
-            arg = rb_hash_aref(opts, sym_default_ttl);
+            arg = rb_hash_aref(opts, cb_sym_default_ttl);
             if (arg != Qnil) {
                 bucket->default_ttl = (uint32_t)NUM2ULONG(arg);
             }
-            arg = rb_hash_aref(opts, sym_default_observe_timeout);
+            arg = rb_hash_aref(opts, cb_sym_default_observe_timeout);
             if (arg != Qnil) {
                 bucket->default_observe_timeout = (uint32_t)NUM2ULONG(arg);
             }
-            arg = rb_hash_aref(opts, sym_default_flags);
+            arg = rb_hash_aref(opts, cb_sym_default_flags);
             if (arg != Qnil) {
                 bucket->default_flags = (uint32_t)NUM2ULONG(arg);
             }
-            arg = rb_hash_aref(opts, sym_default_format);
+            arg = rb_hash_aref(opts, cb_sym_default_format);
             if (arg != Qnil) {
                 if (TYPE(arg) == T_FIXNUM) {
                     switch (FIX2INT(arg)) {
-                        case FMT_DOCUMENT:
-                            arg = sym_document;
+                        case CB_FMT_DOCUMENT:
+                            arg = cb_sym_document;
                             break;
-                        case FMT_MARSHAL:
-                            arg = sym_marshal;
+                        case CB_FMT_MARSHAL:
+                            arg = cb_sym_marshal;
                             break;
-                        case FMT_PLAIN:
-                            arg = sym_plain;
+                        case CB_FMT_PLAIN:
+                            arg = cb_sym_plain;
                             break;
                     }
                 }
-                if (arg == sym_document || arg == sym_marshal || arg == sym_plain) {
+                if (arg == cb_sym_document || arg == cb_sym_marshal || arg == cb_sym_plain) {
                     bucket->default_format = arg;
-                    bucket->default_flags = flags_set_format(bucket->default_flags, arg);
+                    bucket->default_flags = cb_flags_set_format(bucket->default_flags, arg);
                 }
             }
-            arg = rb_hash_aref(opts, sym_environment);
+            arg = rb_hash_aref(opts, cb_sym_environment);
             if (arg != Qnil) {
-                if (arg == sym_production || arg == sym_development) {
+                if (arg == cb_sym_production || arg == cb_sym_development) {
                     bucket->environment = arg;
                 }
             }
-            arg = rb_hash_aref(opts, sym_key_prefix);
+            arg = rb_hash_aref(opts, cb_sym_key_prefix);
             if (arg != Qnil) {
-                xfree(bucket->key_prefix);
-                bucket->key_prefix = strdup(StringValueCStr(arg));
-                bucket->key_prefix_val = STR_NEW_CSTR(bucket->key_prefix);
+                bucket->key_prefix_val = rb_str_dup_frozen(StringValue(arg));
+            }
+            arg = rb_hash_aref(opts, cb_sym_default_arithmetic_init);
+            if (arg != Qnil) {
+                bucket->default_arith_create = RTEST(arg);
+                if (TYPE(arg) == T_FIXNUM) {
+                    bucket->default_arith_init = NUM2ULL(arg);
+                }
             }
         } else {
             opts = Qnil;
         }
     }
-    if (bucket->password && bucket->username == NULL) {
-        bucket->username = strdup(bucket->bucket);
+    if (RTEST(bucket->password) && !RTEST(bucket->username)) {
+        bucket->username = bucket->bucket;
     }
-    len = strlen(bucket->hostname) + 10;
     if (bucket->default_observe_timeout < 2) {
         rb_raise(rb_eArgError, "default_observe_timeout is too low");
     }
-    xfree(bucket->authority);
-    bucket->authority = xcalloc(len, sizeof(char));
-    if (bucket->authority == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for Bucket");
-    }
-    snprintf(bucket->authority, len, "%s:%u", bucket->hostname, bucket->port);
+    snprintf(port_s, sizeof(port_s), ":%u", bucket->port);
+    bucket->authority = rb_str_dup(bucket->hostname);
+    rb_str_cat2(bucket->authority, port_s);
+    rb_str_freeze(bucket->authority);
 }
 
     static void
-do_connect(struct bucket_st *bucket)
+do_connect(struct cb_bucket_st *bucket)
 {
     lcb_error_t err;
     struct lcb_create_st create_opts;
 
     if (bucket->handle) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
     }
+
+#ifndef _WIN32
+    {
+        struct lcb_create_io_ops_st ciops;
+        memset(&ciops, 0, sizeof(ciops));
+        ciops.version = 1;
+        ciops.v.v1.sofile = NULL;
+        ciops.v.v1.symbol = "cb_create_ruby_mt_io_opts";
+        ciops.v.v1.cookie = NULL;
+
+        err = lcb_create_io_ops(&bucket->io, &ciops);
+    }
+#else
     err = lcb_create_io_ops(&bucket->io, NULL);
+#endif
     if (err != LCB_SUCCESS) {
         rb_exc_raise(cb_check_error(err, "failed to create IO instance", Qnil));
     }
 
     memset(&create_opts, 0, sizeof(struct lcb_create_st));
-    create_opts.v.v0.host = bucket->node_list ? bucket-> node_list : bucket->authority;
-    create_opts.v.v0.user = bucket->username;
-    create_opts.v.v0.passwd = bucket->password;
-    create_opts.v.v0.bucket = bucket->bucket;
-    create_opts.v.v0.io = bucket->io;
+    create_opts.version = 1;
+    create_opts.v.v1.type = bucket->type;
+    create_opts.v.v1.host = RTEST(bucket->node_list) ? RSTRING_PTR(bucket-> node_list) : RSTRING_PTR(bucket->authority);
+    create_opts.v.v1.user = RTEST(bucket->username) ? RSTRING_PTR(bucket->username) : NULL;
+    create_opts.v.v1.passwd = RTEST(bucket->username) ? RSTRING_PTR(bucket->password) : NULL;
+    create_opts.v.v1.bucket = RSTRING_PTR(bucket->bucket);
+    create_opts.v.v1.io = bucket->io;
     err = lcb_create(&bucket->handle, &create_opts);
     if (err != LCB_SUCCESS) {
         rb_exc_raise(cb_check_error(err, "failed to create libcouchbase instance", Qnil));
     }
     lcb_set_cookie(bucket->handle, bucket);
     (void)lcb_set_error_callback(bucket->handle, error_callback);
-    (void)lcb_set_store_callback(bucket->handle, storage_callback);
-    (void)lcb_set_get_callback(bucket->handle, get_callback);
-    (void)lcb_set_touch_callback(bucket->handle, touch_callback);
-    (void)lcb_set_remove_callback(bucket->handle, delete_callback);
-    (void)lcb_set_stat_callback(bucket->handle, stat_callback);
-    (void)lcb_set_arithmetic_callback(bucket->handle, arithmetic_callback);
-    (void)lcb_set_version_callback(bucket->handle, version_callback);
-    (void)lcb_set_view_complete_callback(bucket->handle, http_complete_callback);
-    (void)lcb_set_view_data_callback(bucket->handle, http_data_callback);
-    (void)lcb_set_management_complete_callback(bucket->handle, http_complete_callback);
-    (void)lcb_set_management_data_callback(bucket->handle, http_data_callback);
-    (void)lcb_set_observe_callback(bucket->handle, observe_callback);
-    (void)lcb_set_unlock_callback(bucket->handle, unlock_callback);
+    (void)lcb_set_store_callback(bucket->handle, cb_storage_callback);
+    (void)lcb_set_get_callback(bucket->handle, cb_get_callback);
+    (void)lcb_set_touch_callback(bucket->handle, cb_touch_callback);
+    (void)lcb_set_remove_callback(bucket->handle, cb_delete_callback);
+    (void)lcb_set_stat_callback(bucket->handle, cb_stat_callback);
+    (void)lcb_set_arithmetic_callback(bucket->handle, cb_arithmetic_callback);
+    (void)lcb_set_version_callback(bucket->handle, cb_version_callback);
+    (void)lcb_set_http_complete_callback(bucket->handle, cb_http_complete_callback);
+    (void)lcb_set_http_data_callback(bucket->handle, cb_http_data_callback);
+    (void)lcb_set_observe_callback(bucket->handle, cb_observe_callback);
+    (void)lcb_set_unlock_callback(bucket->handle, cb_unlock_callback);
 
     if (bucket->timeout > 0) {
         lcb_set_timeout(bucket->handle, bucket->timeout);
@@ -281,6 +288,7 @@ do_connect(struct bucket_st *bucket)
     err = lcb_connect(bucket->handle);
     if (err != LCB_SUCCESS) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
         rb_exc_raise(cb_check_error(err, "failed to connect libcouchbase instance to server", Qnil));
@@ -289,6 +297,7 @@ do_connect(struct bucket_st *bucket)
     lcb_wait(bucket->handle);
     if (bucket->exception != Qnil) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
         rb_exc_raise(bucket->exception);
@@ -299,10 +308,10 @@ do_connect(struct bucket_st *bucket)
 cb_bucket_alloc(VALUE klass)
 {
     VALUE obj;
-    struct bucket_st *bucket;
+    struct cb_bucket_st *bucket;
 
     /* allocate new bucket struct and set it to zero */
-    obj = Data_Make_Struct(klass, struct bucket_st, cb_bucket_mark, cb_bucket_free,
+    obj = Data_Make_Struct(klass, struct cb_bucket_st, cb_bucket_mark, cb_bucket_free,
             bucket);
     return obj;
 }
@@ -360,6 +369,11 @@ cb_bucket_alloc(VALUE klass)
  *     returning back to the application.
  *   @option options [Fixnum] :timeout (2500000) the timeout for IO
  *     operations (in microseconds)
+ *   @option options [Fixnum, true] :default_arithmetic_init (0) the default
+ *     initial value for arithmetic operations. Setting this option to any
+ *     non positive number forces creation missing keys with given default
+ *     value. Setting it to +true+ will use zero as initial value. (see
+ *     {Bucket#incr} and {Bucket#decr}).
  *
  * @example Initialize connection using default options
  *   Couchbase.new
@@ -387,28 +401,31 @@ cb_bucket_alloc(VALUE klass)
     VALUE
 cb_bucket_init(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     bucket->self = self;
     bucket->exception = Qnil;
-    bucket->hostname = strdup("localhost");
+    bucket->type = LCB_TYPE_BUCKET;
+    bucket->hostname = rb_str_new2("localhost");
     bucket->port = 8091;
-    bucket->pool = strdup("default");
-    bucket->bucket = strdup("default");
+    bucket->pool = cb_vStrDefault;
+    rb_str_freeze(bucket->pool);
+    bucket->bucket = cb_vStrDefault;
+    rb_str_freeze(bucket->bucket);
+    bucket->username = Qnil;
+    bucket->password = Qnil;
     bucket->async = 0;
     bucket->quiet = 0;
     bucket->default_ttl = 0;
     bucket->default_flags = 0;
-    bucket->default_format = sym_document;
+    bucket->default_format = cb_sym_document;
     bucket->default_observe_timeout = 2500000;
     bucket->on_error_proc = Qnil;
     bucket->timeout = 0;
-    bucket->environment = sym_production;
-    bucket->key_prefix = NULL;
+    bucket->environment = cb_sym_production;
     bucket->key_prefix_val = Qnil;
-    bucket->node_list = NULL;
+    bucket->node_list = Qnil;
     bucket->object_space = rb_hash_new();
-    bucket->node_list = NULL;
 
     do_scan_connection_options(bucket, argc, argv);
     do_connect(bucket);
@@ -428,8 +445,8 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
     VALUE
 cb_bucket_init_copy(VALUE copy, VALUE orig)
 {
-    struct bucket_st *copy_b;
-    struct bucket_st *orig_b;
+    struct cb_bucket_st *copy_b;
+    struct cb_bucket_st *orig_b;
 
     if (copy == orig)
         return copy;
@@ -444,19 +461,12 @@ cb_bucket_init_copy(VALUE copy, VALUE orig)
 
     copy_b->self = copy_b->self;
     copy_b->port = orig_b->port;
-    copy_b->authority = strdup(orig_b->authority);
-    copy_b->hostname = strdup(orig_b->hostname);
-    copy_b->pool = strdup(orig_b->pool);
-    copy_b->bucket = strdup(orig_b->bucket);
-    if (orig_b->username) {
-        copy_b->username = strdup(orig_b->username);
-    }
-    if (orig_b->password) {
-        copy_b->password = strdup(orig_b->password);
-    }
-    if (orig_b->key_prefix) {
-        copy_b->key_prefix = strdup(orig_b->key_prefix);
-    }
+    copy_b->authority = orig_b->authority;
+    copy_b->hostname = orig_b->hostname;
+    copy_b->pool = orig_b->pool;
+    copy_b->bucket = orig_b->bucket;
+    copy_b->username = orig_b->username;
+    copy_b->password = orig_b->password;
     copy_b->async = orig_b->async;
     copy_b->quiet = orig_b->quiet;
     copy_b->default_format = orig_b->default_format;
@@ -466,11 +476,9 @@ cb_bucket_init_copy(VALUE copy, VALUE orig)
     copy_b->timeout = orig_b->timeout;
     copy_b->exception = Qnil;
     if (orig_b->on_error_proc != Qnil) {
-        copy_b->on_error_proc = rb_funcall(orig_b->on_error_proc, id_dup, 0);
-    }
-    if (orig_b->key_prefix_val != Qnil) {
-        copy_b->key_prefix_val = rb_funcall(orig_b->key_prefix_val, id_dup, 0);
+        copy_b->on_error_proc = rb_funcall(orig_b->on_error_proc, cb_id_dup, 0);
     }
+    copy_b->key_prefix_val = orig_b->key_prefix_val;
 
     do_connect(copy_b);
 
@@ -502,7 +510,7 @@ cb_bucket_init_copy(VALUE copy, VALUE orig)
     VALUE
 cb_bucket_reconnect(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     do_scan_connection_options(bucket, argc, argv);
     do_connect(bucket);
@@ -520,7 +528,7 @@ cb_bucket_reconnect(int argc, VALUE *argv, VALUE self)
     VALUE
 cb_bucket_connected_p(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return bucket->handle ? Qtrue : Qfalse;
 }
 
@@ -548,21 +556,21 @@ cb_bucket_connected_p(VALUE self)
     VALUE
 cb_bucket_async_p(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return bucket->async ? Qtrue : Qfalse;
 }
 
     VALUE
 cb_bucket_quiet_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return bucket->quiet ? Qtrue : Qfalse;
 }
 
     VALUE
 cb_bucket_quiet_set(VALUE self, VALUE val)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     VALUE new;
 
     bucket->quiet = RTEST(val);
@@ -573,48 +581,48 @@ cb_bucket_quiet_set(VALUE self, VALUE val)
     VALUE
 cb_bucket_default_flags_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return ULONG2NUM(bucket->default_flags);
 }
 
     VALUE
 cb_bucket_default_flags_set(VALUE self, VALUE val)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     bucket->default_flags = (uint32_t)NUM2ULONG(val);
-    bucket->default_format = flags_get_format(bucket->default_flags);
+    bucket->default_format = cb_flags_get_format(bucket->default_flags);
     return val;
 }
 
     VALUE
 cb_bucket_default_format_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return bucket->default_format;
 }
 
     VALUE
 cb_bucket_default_format_set(VALUE self, VALUE val)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     if (TYPE(val) == T_FIXNUM) {
         switch (FIX2INT(val)) {
-            case FMT_DOCUMENT:
-                val = sym_document;
+            case CB_FMT_DOCUMENT:
+                val = cb_sym_document;
                 break;
-            case FMT_MARSHAL:
-                val = sym_marshal;
+            case CB_FMT_MARSHAL:
+                val = cb_sym_marshal;
                 break;
-            case FMT_PLAIN:
-                val = sym_plain;
+            case CB_FMT_PLAIN:
+                val = cb_sym_plain;
                 break;
         }
     }
-    if (val == sym_document || val == sym_marshal || val == sym_plain) {
+    if (val == cb_sym_document || val == cb_sym_marshal || val == cb_sym_plain) {
         bucket->default_format = val;
-        bucket->default_flags = flags_set_format(bucket->default_flags, val);
+        bucket->default_flags = cb_flags_set_format(bucket->default_flags, val);
     }
 
     return val;
@@ -623,9 +631,9 @@ cb_bucket_default_format_set(VALUE self, VALUE val)
     VALUE
 cb_bucket_on_error_set(VALUE self, VALUE val)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
-    if (rb_respond_to(val, id_call)) {
+    if (rb_respond_to(val, cb_id_call)) {
         bucket->on_error_proc = val;
     } else {
         bucket->on_error_proc = Qnil;
@@ -637,7 +645,7 @@ cb_bucket_on_error_set(VALUE self, VALUE val)
     VALUE
 cb_bucket_on_error_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     if (rb_block_given_p()) {
         return cb_bucket_on_error_set(self, rb_block_proc());
@@ -649,14 +657,14 @@ cb_bucket_on_error_get(VALUE self)
     VALUE
 cb_bucket_timeout_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return ULONG2NUM(bucket->timeout);
 }
 
     VALUE
 cb_bucket_timeout_set(VALUE self, VALUE val)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     VALUE tmval;
 
     bucket->timeout = (uint32_t)NUM2ULONG(val);
@@ -666,20 +674,40 @@ cb_bucket_timeout_set(VALUE self, VALUE val)
     return tmval;
 }
 
+    VALUE
+cb_bucket_default_arithmetic_init_get(VALUE self)
+{
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    return ULL2NUM(bucket->default_arith_init);
+}
+
+    VALUE
+cb_bucket_default_arithmetic_init_set(VALUE self, VALUE val)
+{
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+
+    bucket->default_arith_create = RTEST(val);
+    if (bucket->default_arith_create) {
+        bucket->default_arith_init = NUM2ULL(val);
+    } else {
+        bucket->default_arith_init = 0;
+    }
+    return ULL2NUM(bucket->default_arith_init);
+}
+
     VALUE
 cb_bucket_key_prefix_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return bucket->key_prefix_val;
 }
 
     VALUE
 cb_bucket_key_prefix_set(VALUE self, VALUE val)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
-    bucket->key_prefix = strdup(StringValueCStr(val));
-    bucket->key_prefix_val = STR_NEW_CSTR(bucket->key_prefix);
+    bucket->key_prefix_val = rb_str_dup_frozen(StringValue(val));
 
     return bucket->key_prefix_val;
 }
@@ -693,15 +721,17 @@ cb_bucket_key_prefix_set(VALUE self, VALUE val)
     VALUE
 cb_bucket_hostname_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+
     if (bucket->handle) {
-        xfree(bucket->hostname);
-        bucket->hostname = strdup(lcb_get_host(bucket->handle));
-        if (bucket->hostname == NULL) {
-            rb_raise(eClientNoMemoryError, "failed to allocate memory for Bucket");
+        const char * host = lcb_get_host(bucket->handle);
+        unsigned long len = RSTRING_LEN(bucket->hostname);
+        if (len != strlen(host) || strncmp(RSTRING_PTR(bucket->hostname), host, len) != 0) {
+            bucket->hostname = STR_NEW_CSTR(host);
+            rb_str_freeze(bucket->hostname);
         }
     }
-    return STR_NEW_CSTR(bucket->hostname);
+    return bucket->hostname;
 }
 
 /* Document-method: port
@@ -713,7 +743,7 @@ cb_bucket_hostname_get(VALUE self)
     VALUE
 cb_bucket_port_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     if (bucket->handle) {
         bucket->port = atoi(lcb_get_port(bucket->handle));
     }
@@ -729,18 +759,20 @@ cb_bucket_port_get(VALUE self)
     VALUE
 cb_bucket_authority_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    size_t len;
-
-    (void)cb_bucket_hostname_get(self);
-    (void)cb_bucket_port_get(self);
-    len = strlen(bucket->hostname) + 10;
-    bucket->authority = xcalloc(len, sizeof(char));
-    if (bucket->authority == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for Bucket");
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    VALUE old_hostname = bucket->hostname;
+    uint16_t old_port = bucket->port;
+    VALUE hostname = cb_bucket_hostname_get(self);
+    cb_bucket_port_get(self);
+
+    if (hostname != old_hostname || bucket->port != old_port) {
+        char port_s[8];
+        snprintf(port_s, sizeof(port_s), ":%u", bucket->port);
+        bucket->authority = rb_str_dup(hostname);
+        rb_str_cat2(bucket->authority, port_s);
+        rb_str_freeze(bucket->authority);
     }
-    snprintf(bucket->authority, len, "%s:%u", bucket->hostname, bucket->port);
-    return STR_NEW_CSTR(bucket->authority);
+    return bucket->authority;
 }
 
 /* Document-method: bucket
@@ -752,8 +784,8 @@ cb_bucket_authority_get(VALUE self)
     VALUE
 cb_bucket_bucket_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->bucket);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    return bucket->bucket;
 }
 
 /* Document-method: pool
@@ -765,8 +797,8 @@ cb_bucket_bucket_get(VALUE self)
     VALUE
 cb_bucket_pool_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->pool);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    return bucket->pool;
 }
 
 /* Document-method: username
@@ -779,8 +811,8 @@ cb_bucket_pool_get(VALUE self)
     VALUE
 cb_bucket_username_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->username);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    return bucket->username;
 }
 
 /* Document-method: password
@@ -792,8 +824,8 @@ cb_bucket_username_get(VALUE self)
     VALUE
 cb_bucket_password_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->password);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    return bucket->password;
 }
 
 /* Document-method: environment
@@ -807,7 +839,7 @@ cb_bucket_password_get(VALUE self)
     VALUE
 cb_bucket_environment_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return bucket->environment;
 }
 /* Document-method: num_replicas
@@ -821,7 +853,7 @@ cb_bucket_environment_get(VALUE self)
     VALUE
 cb_bucket_num_replicas_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     int32_t nr = lcb_get_num_replicas(bucket->handle);
     if (nr < 0) {
         return Qnil;
@@ -841,7 +873,7 @@ cb_bucket_num_replicas_get(VALUE self)
     VALUE
 cb_bucket_default_observe_timeout_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     return INT2FIX(bucket->default_observe_timeout);
 }
 
@@ -857,7 +889,7 @@ cb_bucket_default_observe_timeout_get(VALUE self)
     VALUE
 cb_bucket_default_observe_timeout_set(VALUE self, VALUE val)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     bucket->default_observe_timeout = FIX2INT(val);
     return val;
 }
@@ -870,16 +902,16 @@ cb_bucket_default_observe_timeout_set(VALUE self, VALUE val)
     VALUE
 cb_bucket_url_get(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     VALUE str;
 
     (void)cb_bucket_authority_get(self);
     str = rb_str_buf_new2("http://");
-    rb_str_buf_cat2(str, bucket->authority);
+    rb_str_append(str, bucket->authority);
     rb_str_buf_cat2(str, "/pools/");
-    rb_str_buf_cat2(str, bucket->pool);
+    rb_str_append(str, bucket->pool);
     rb_str_buf_cat2(str, "/buckets/");
-    rb_str_buf_cat2(str, bucket->bucket);
+    rb_str_append(str, bucket->bucket);
     rb_str_buf_cat2(str, "/");
     return str;
 }
@@ -896,7 +928,7 @@ cb_bucket_url_get(VALUE self)
 cb_bucket_inspect(VALUE self)
 {
     VALUE str;
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
     char buf[200];
 
     str = rb_str_buf_new2("#<");
@@ -905,11 +937,11 @@ cb_bucket_inspect(VALUE self)
     (void)cb_bucket_authority_get(self);
     rb_str_buf_cat2(str, buf);
     rb_str_buf_cat2(str, "http://");
-    rb_str_buf_cat2(str, bucket->authority);
+    rb_str_append(str, bucket->authority);
     rb_str_buf_cat2(str, "/pools/");
-    rb_str_buf_cat2(str, bucket->pool);
+    rb_str_append(str, bucket->pool);
     rb_str_buf_cat2(str, "/buckets/");
-    rb_str_buf_cat2(str, bucket->bucket);
+    rb_str_append(str, bucket->bucket);
     rb_str_buf_cat2(str, "/");
     snprintf(buf, 150, "\" default_format=:%s, default_flags=0x%x, quiet=%s, connected=%s, timeout=%u",
             rb_id2name(SYM2ID(bucket->default_format)),
@@ -918,7 +950,7 @@ cb_bucket_inspect(VALUE self)
             bucket->handle ? "true" : "false",
             bucket->timeout);
     rb_str_buf_cat2(str, buf);
-    if (bucket->key_prefix) {
+    if (RTEST(bucket->key_prefix_val)) {
         rb_str_buf_cat2(str, ", key_prefix=");
         rb_str_append(str, rb_inspect(bucket->key_prefix_val));
     }
@@ -928,14 +960,14 @@ cb_bucket_inspect(VALUE self)
 }
 
     static void
-do_loop(struct bucket_st *bucket)
+do_loop(struct cb_bucket_st *bucket)
 {
     lcb_wait(bucket->handle);
     bucket->nbytes = 0;
 }
 
     void
-maybe_do_loop(struct bucket_st *bucket)
+cb_maybe_do_loop(struct cb_bucket_st *bucket)
 {
     if (bucket->threshold != 0 && bucket->nbytes > bucket->threshold) {
         do_loop(bucket);
@@ -946,25 +978,25 @@ maybe_do_loop(struct bucket_st *bucket)
 do_run(VALUE *args)
 {
     VALUE self = args[0], opts = args[1], proc = args[2], exc;
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     if (bucket->async) {
-        rb_raise(eInvalidError, "nested #run");
+        rb_raise(cb_eInvalidError, "nested #run");
     }
     bucket->threshold = 0;
     if (opts != Qnil) {
         VALUE arg;
         Check_Type(opts, T_HASH);
-        arg = rb_hash_aref(opts, sym_send_threshold);
+        arg = rb_hash_aref(opts, cb_sym_send_threshold);
         if (arg != Qnil) {
             bucket->threshold = (uint32_t)NUM2ULONG(arg);
         }
     }
     bucket->async = 1;
-    cb_proc_call(proc, 1, self);
+    cb_proc_call(bucket, proc, 1, self);
     do_loop(bucket);
     if (bucket->exception != Qnil) {
         exc = bucket->exception;
@@ -978,7 +1010,7 @@ do_run(VALUE *args)
 ensure_run(VALUE *args)
 {
     VALUE self = args[0];
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     bucket->async = 0;
     return Qnil;
@@ -1059,8 +1091,8 @@ cb_bucket_run(int argc, VALUE *argv, VALUE self)
     VALUE
 cb_bucket_stop(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    bucket->io->stop_event_loop(bucket->io);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    lcb_breakout(bucket->handle);
     return Qnil;
 }
 
@@ -1076,15 +1108,16 @@ cb_bucket_stop(VALUE self)
     VALUE
 cb_bucket_disconnect(VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
+    struct cb_bucket_st *bucket = DATA_PTR(self);
 
     if (bucket->handle) {
         lcb_destroy(bucket->handle);
+        lcb_destroy_io_ops(bucket->io);
         bucket->handle = NULL;
         bucket->io = NULL;
         return Qtrue;
     } else {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
         return Qfalse;
     }
 }