couchbase 1.2.0.z.beta5 → 1.2.0

data/couchbase.gemspec

@@ -46,6 +46,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'yard-xml'
   s.add_development_dependency 'mini_portile'
   s.add_development_dependency 'yajl-ruby', '~> 1.1.0'
-  s.add_development_dependency RUBY_VERSION =~ /^1\.9/ ? 'debugger' : 'ruby-debug'
   s.add_development_dependency 'active_support'
 end

data/ext/couchbase_ext/arguments.c

@@ -19,23 +19,37 @@
 
 /* TOUCH */
 
+#define _alloc_data_for_s(type, _type, size, items, ptr) do {\
+    lcb_size_t ii; \
+    \
+    params->cmd.type.num = size; \
+    params->cmd.type.items = calloc(size, sizeof(_type)); \
+    if (params->cmd.type.items == NULL) { \
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments"); \
+    } \
+    params->cmd.type.ptr = calloc(size, sizeof(_type *)); \
+    if (params->cmd.type.ptr == NULL) { \
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments"); \
+    } \
+    for (ii = 0; ii < size; ++ii) { \
+        params->cmd.type.ptr[ii] = params->cmd.type.items + ii; \
+    } \
+} while(0)
+
+#define _alloc_data_for(type, _type) _alloc_data_for_s(type, _type, size, items, ptr)
+
+
+#define _release_data_for_s(type, items, ptr) \
+    free(params->cmd.type.items); \
+    free(params->cmd.type.ptr);
+
+#define _release_data_for(type) _release_data_for_s(type, items, ptr)
+
+
     static void
 cb_params_touch_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.touch.num = size;
-    params->cmd.touch.items = xcalloc(size, sizeof(lcb_touch_cmd_t));
-    if (params->cmd.touch.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.touch.ptr = xcalloc(size, sizeof(lcb_touch_cmd_t *));
-    if (params->cmd.touch.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.touch.ptr[ii] = params->cmd.touch.items + ii;
-    }
+    _alloc_data_for(touch, lcb_touch_cmd_t);
 }
 
     static void
@@ -68,8 +82,9 @@ cb_params_touch_parse_options(struct cb_params_st *params, VALUE options)
     if (tmp != Qnil) {
         params->cmd.touch.ttl = NUM2ULONG(tmp);
     }
-    if (RTEST(rb_funcall(options, cb_id_has_key_p, 1, cb_sym_quiet))) {
-        params->cmd.touch.quiet = RTEST(rb_hash_aref(options, cb_sym_quiet));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.touch.quiet = RTEST(tmp);
     }
 }
 
@@ -118,20 +133,7 @@ cb_params_touch_parse_arguments(struct cb_params_st *params, int argc, VALUE arg
     static void
 cb_params_remove_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.remove.num = size;
-    params->cmd.remove.items = xcalloc(size, sizeof(lcb_remove_cmd_t));
-    if (params->cmd.remove.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.remove.ptr = xcalloc(size, sizeof(lcb_remove_cmd_t *));
-    if (params->cmd.remove.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.remove.ptr[ii] = params->cmd.remove.items + ii;
-    }
+    _alloc_data_for(remove, lcb_remove_cmd_t);
 }
 
     static void
@@ -160,8 +162,9 @@ cb_params_remove_parse_options(struct cb_params_st *params, VALUE options)
     if (NIL_P(options)) {
         return;
     }
-    if (RTEST(rb_funcall(options, cb_id_has_key_p, 1, cb_sym_quiet))) {
-        params->cmd.remove.quiet = RTEST(rb_hash_aref(options, cb_sym_quiet));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.remove.quiet = RTEST(tmp);
     }
     tmp = rb_hash_aref(options, cb_sym_cas);
     if (tmp != Qnil) {
@@ -213,20 +216,7 @@ cb_params_remove_parse_arguments(struct cb_params_st *params, int argc, VALUE ar
     static void
 cb_params_store_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.store.num = size;
-    params->cmd.store.items = xcalloc(size, sizeof(lcb_store_cmd_t));
-    if (params->cmd.store.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.store.ptr = xcalloc(size, sizeof(lcb_store_cmd_t *));
-    if (params->cmd.store.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.store.ptr[ii] = params->cmd.store.items + ii;
-    }
+    _alloc_data_for(store, lcb_store_cmd_t);
 }
 
     static void
@@ -345,33 +335,10 @@ cb_params_store_parse_arguments(struct cb_params_st *params, int argc, VALUE arg
     static void
 cb_params_get_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.get.num = size;
     if (params->cmd.get.replica) {
-        params->cmd.get.items = xcalloc(size, sizeof(lcb_get_replica_cmd_t));
-        if (params->cmd.get.items_gr == NULL) {
-            rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        params->cmd.get.ptr = xcalloc(size, sizeof(lcb_get_replica_cmd_t *));
-        if (params->cmd.get.ptr_gr == NULL) {
-            rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        for (ii = 0; ii < size; ++ii) {
-            params->cmd.get.ptr_gr[ii] = params->cmd.get.items_gr + ii;
-        }
+        _alloc_data_for_s(get, lcb_get_replica_cmd_t, size, items_gr, ptr_gr);
     } else {
-        params->cmd.get.items = xcalloc(size, sizeof(lcb_get_cmd_t));
-        if (params->cmd.get.items == NULL) {
-            rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        params->cmd.get.ptr = xcalloc(size, sizeof(lcb_get_cmd_t *));
-        if (params->cmd.get.ptr == NULL) {
-            rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-        }
-        for (ii = 0; ii < size; ++ii) {
-            params->cmd.get.ptr[ii] = params->cmd.get.items + ii;
-        }
+        _alloc_data_for(get, lcb_get_cmd_t);
     }
 }
 
@@ -413,8 +380,9 @@ cb_params_get_parse_options(struct cb_params_st *params, VALUE options)
     params->cmd.get.replica = RTEST(rb_hash_aref(options, cb_sym_replica));
     params->cmd.get.extended = RTEST(rb_hash_aref(options, cb_sym_extended));
     params->cmd.get.assemble_hash = RTEST(rb_hash_aref(options, cb_sym_assemble_hash));
-    if (RTEST(rb_funcall(options, cb_id_has_key_p, 1, cb_sym_quiet))) {
-        params->cmd.get.quiet = RTEST(rb_hash_aref(options, cb_sym_quiet));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.get.quiet = RTEST(tmp);
     }
     tmp = rb_hash_aref(options, cb_sym_format);
     if (tmp != Qnil) {
@@ -485,20 +453,7 @@ cb_params_get_parse_arguments(struct cb_params_st *params, int argc, VALUE argv)
     static void
 cb_params_arith_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.arith.num = size;
-    params->cmd.arith.items = xcalloc(size, sizeof(lcb_arithmetic_cmd_t));
-    if (params->cmd.arith.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.arith.ptr = xcalloc(size, sizeof(lcb_arithmetic_cmd_t *));
-    if (params->cmd.arith.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.arith.ptr[ii] = params->cmd.arith.items + ii;
-    }
+    _alloc_data_for(arith, lcb_arithmetic_cmd_t);
 }
 
     static void
@@ -602,20 +557,7 @@ cb_params_arith_parse_arguments(struct cb_params_st *params, int argc, VALUE arg
     static void
 cb_params_stats_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.stats.num = size;
-    params->cmd.stats.items = xcalloc(size, sizeof(lcb_server_stats_cmd_t));
-    if (params->cmd.stats.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.stats.ptr = xcalloc(size, sizeof(lcb_server_stats_cmd_t *));
-    if (params->cmd.stats.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.stats.ptr[ii] = params->cmd.stats.items + ii;
-    }
+    _alloc_data_for(stats, lcb_server_stats_cmd_t);
 }
 
     static void
@@ -667,20 +609,7 @@ cb_params_stats_parse_arguments(struct cb_params_st *params, int argc, VALUE arg
     static void
 cb_params_observe_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.observe.num = size;
-    params->cmd.observe.items = xcalloc(size, sizeof(lcb_observe_cmd_t));
-    if (params->cmd.observe.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.observe.ptr = xcalloc(size, sizeof(lcb_observe_cmd_t *));
-    if (params->cmd.observe.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.observe.ptr[ii] = params->cmd.observe.items + ii;
-    }
+    _alloc_data_for(observe, lcb_observe_cmd_t);
 }
 
     static void
@@ -730,20 +659,7 @@ cb_params_observe_parse_arguments(struct cb_params_st *params, int argc, VALUE a
     static void
 cb_params_unlock_alloc(struct cb_params_st *params, lcb_size_t size)
 {
-    lcb_size_t ii;
-
-    params->cmd.unlock.num = size;
-    params->cmd.unlock.items = xcalloc(size, sizeof(lcb_unlock_cmd_t));
-    if (params->cmd.unlock.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.unlock.ptr = xcalloc(size, sizeof(lcb_unlock_cmd_t *));
-    if (params->cmd.unlock.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    for (ii = 0; ii < size; ++ii) {
-        params->cmd.unlock.ptr[ii] = params->cmd.unlock.items + ii;
-    }
+    _alloc_data_for(unlock, lcb_unlock_cmd_t);
 }
 
     static void
@@ -776,8 +692,9 @@ cb_params_unlock_parse_options(struct cb_params_st *params, VALUE options)
     if (tmp != Qnil) {
         params->cmd.unlock.cas = NUM2ULL(tmp);
     }
-    if (RTEST(rb_funcall(options, cb_id_has_key_p, 1, cb_sym_quiet))) {
-        params->cmd.unlock.quiet = RTEST(rb_hash_aref(options, cb_sym_quiet));
+    tmp = rb_hash_lookup2(options, cb_sym_quiet, Qundef);
+    if (tmp != Qundef) {
+        params->cmd.unlock.quiet = RTEST(tmp);
     }
 }
 
@@ -808,15 +725,7 @@ cb_params_unlock_parse_arguments(struct cb_params_st *params, int argc, VALUE ar
 cb_params_version_alloc(struct cb_params_st *params)
 {
     params->cmd.version.num = 1;
-    params->cmd.version.items = xcalloc(1, sizeof(lcb_server_version_cmd_t));
-    if (params->cmd.version.items == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.version.ptr = xcalloc(1, sizeof(lcb_server_version_cmd_t *));
-    if (params->cmd.version.ptr == NULL) {
-        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for arguments");
-    }
-    params->cmd.version.ptr[0] = params->cmd.version.items;
+    _alloc_data_for_s(version, lcb_server_version_cmd_t, 1, items, ptr);
 }
 
 
@@ -824,15 +733,10 @@ cb_params_version_alloc(struct cb_params_st *params)
     void
 cb_params_destroy(struct cb_params_st *params)
 {
-#define _release_data_for(type) \
-    xfree(params->cmd.type.items); \
-    xfree(params->cmd.type.ptr);
-
     switch (params->type) {
         case cb_cmd_get:
             _release_data_for(get);
-            xfree(params->cmd.get.items_gr);
-            xfree(params->cmd.get.ptr_gr);
+            _release_data_for_s(get, items_gr, ptr_gr);
             break;
         case cb_cmd_touch:
             _release_data_for(touch);
@@ -859,7 +763,6 @@ cb_params_destroy(struct cb_params_st *params)
             _release_data_for(unlock);
             break;
     }
-#undef _release_data_for
 }
 
 struct build_params_st

data/ext/couchbase_ext/arithmetic.c

@@ -35,18 +35,7 @@ cb_arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, cons
     if (exc != Qnil) {
         rb_ivar_set(exc, cb_id_iv_cas, cas);
         rb_ivar_set(exc, cb_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);
-        }
+        ctx->exception = cb_gc_protect(bucket, exc);
     }
     val = ULL2NUM(resp->v.v0.value);
     if (bucket->async) {    /* asynchronous */
@@ -57,7 +46,7 @@ cb_arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, cons
             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(ctx->proc, 1, res);
+            cb_proc_call(bucket, ctx->proc, 1, res);
         }
     } else {                /* synchronous */
         if (NIL_P(exc)) {
@@ -71,7 +60,7 @@ cb_arithmetic_callback(lcb_t handle, const void *cookie, lcb_error_t error, cons
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
         if (bucket->async) {
-            xfree(ctx);
+            free(ctx);
         }
     }
     (void)handle;
@@ -98,7 +87,7 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
     params.bucket = bucket;
     params.cmd.arith.sign = sign;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct cb_context_st));
+    ctx = calloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
         rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
@@ -113,7 +102,7 @@ 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;
@@ -126,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

@@ -36,15 +36,8 @@ cb_bucket_free(void *ptr)
             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
@@ -53,6 +46,12 @@ cb_bucket_mark(void *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);
@@ -64,7 +63,7 @@ cb_bucket_mark(void *ptr)
 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) {
@@ -85,28 +84,16 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
 
             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(cb_eClientNoMemoryError, "failed to allocate memory for Bucket");
-                }
+                bucket->username = rb_str_dup_frozen(StringValue(arg));
             }
 
             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(cb_eClientNoMemoryError, "failed to allocate memory for Bucket");
-                }
+                bucket->password = rb_str_dup_frozen(StringValue(arg));
             }
             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(cb_eClientNoMemoryError, "failed to allocate memory for Bucket");
-                }
+                bucket->hostname = rb_str_dup_frozen(StringValue(arg));
             } else {
                 rb_raise(rb_eArgError, "invalid URI: missing hostname");
             }
@@ -118,11 +105,11 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
             re = rb_reg_new(path_re, sizeof(path_re) - 1, 0);
             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, cb_sym_type);
@@ -135,43 +122,37 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
             }
             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, 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, 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, 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, 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, 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, cb_sym_port);
             if (arg != Qnil) {
                 bucket->port = (uint16_t)NUM2UINT(arg);
             }
-            if (RTEST(rb_funcall(opts, cb_id_has_key_p, 1, cb_sym_quiet))) {
-                bucket->quiet = RTEST(rb_hash_aref(opts, cb_sym_quiet));
+            arg = rb_hash_lookup2(opts, cb_sym_quiet, Qundef);
+            if (arg != Qundef) {
+                bucket->quiet = RTEST(arg);
             }
             arg = rb_hash_aref(opts, cb_sym_timeout);
             if (arg != Qnil) {
@@ -217,9 +198,7 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
             }
             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) {
@@ -232,19 +211,16 @@ do_scan_connection_options(struct cb_bucket_st *bucket, int argc, VALUE *argv)
             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(cb_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
@@ -259,7 +235,21 @@ do_connect(struct cb_bucket_st *bucket)
         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));
     }
@@ -267,10 +257,10 @@ do_connect(struct cb_bucket_st *bucket)
     memset(&create_opts, 0, sizeof(struct lcb_create_st));
     create_opts.version = 1;
     create_opts.v.v1.type = bucket->type;
-    create_opts.v.v1.host = bucket->node_list ? bucket-> node_list : bucket->authority;
-    create_opts.v.v1.user = bucket->username;
-    create_opts.v.v1.passwd = bucket->password;
-    create_opts.v.v1.bucket = bucket->bucket;
+    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) {
@@ -416,10 +406,14 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
     bucket->self = self;
     bucket->exception = Qnil;
     bucket->type = LCB_TYPE_BUCKET;
-    bucket->hostname = strdup("localhost");
+    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;
@@ -429,11 +423,9 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
     bucket->on_error_proc = Qnil;
     bucket->timeout = 0;
     bucket->environment = cb_sym_production;
-    bucket->key_prefix = NULL;
     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);
@@ -469,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;
@@ -493,9 +478,7 @@ cb_bucket_init_copy(VALUE copy, VALUE orig)
     if (orig_b->on_error_proc != Qnil) {
         copy_b->on_error_proc = rb_funcall(orig_b->on_error_proc, cb_id_dup, 0);
     }
-    if (orig_b->key_prefix_val != Qnil) {
-        copy_b->key_prefix_val = rb_funcall(orig_b->key_prefix_val, cb_id_dup, 0);
-    }
+    copy_b->key_prefix_val = orig_b->key_prefix_val;
 
     do_connect(copy_b);
 
@@ -724,8 +707,7 @@ cb_bucket_key_prefix_set(VALUE self, VALUE val)
 {
     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;
 }
@@ -740,14 +722,16 @@ cb_bucket_key_prefix_set(VALUE self, VALUE val)
 cb_bucket_hostname_get(VALUE 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(cb_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
@@ -776,17 +760,19 @@ cb_bucket_port_get(VALUE self)
 cb_bucket_authority_get(VALUE self)
 {
     struct cb_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(cb_eClientNoMemoryError, "failed to allocate memory for Bucket");
+    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
@@ -799,7 +785,7 @@ cb_bucket_authority_get(VALUE self)
 cb_bucket_bucket_get(VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->bucket);
+    return bucket->bucket;
 }
 
 /* Document-method: pool
@@ -812,7 +798,7 @@ cb_bucket_bucket_get(VALUE self)
 cb_bucket_pool_get(VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->pool);
+    return bucket->pool;
 }
 
 /* Document-method: username
@@ -826,7 +812,7 @@ cb_bucket_pool_get(VALUE self)
 cb_bucket_username_get(VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->username);
+    return bucket->username;
 }
 
 /* Document-method: password
@@ -839,7 +825,7 @@ cb_bucket_username_get(VALUE self)
 cb_bucket_password_get(VALUE self)
 {
     struct cb_bucket_st *bucket = DATA_PTR(self);
-    return STR_NEW_CSTR(bucket->password);
+    return bucket->password;
 }
 
 /* Document-method: environment
@@ -921,11 +907,11 @@ cb_bucket_url_get(VALUE self)
 
     (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;
 }
@@ -951,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)),
@@ -964,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));
     }
@@ -1010,7 +996,7 @@ do_run(VALUE *args)
         }
     }
     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;