couchbase 1.1.2 → 1.1.3

data/HISTORY.markdown

@@ -1,3 +1,11 @@
+## 1.1.3 / 2012-07-27
+
+* RCBC-59 Replicate flags in Bucket#cas operation
+* calloc -> xcalloc, free -> xfree
+* RCBC-64 Fix Couchbase::Bucket#dup
+* Make object_space GC protector per-bucket object
+* RCBC-60 Protect exceptions from GC
+
 ## 1.1.2 / 2012-06-05
 
 * Upgrade libcouchbase dependency up to 1.0.4

data/ext/couchbase_ext/couchbase_ext.c

@@ -64,6 +64,7 @@ typedef struct
     uint32_t timeout;
     VALUE exception;        /* error delivered by error_callback */
     VALUE on_error_proc;    /* is using to deliver errors in async mode */
+    VALUE object_space;
 } bucket_t;
 
 typedef struct
@@ -93,7 +94,6 @@ struct key_traits
 };
 
 static VALUE mCouchbase, mError, mJSON, mURI, mMarshal, cBucket, cResult;
-static VALUE object_space;
 
 static ID  sym_add,
            sym_append,
@@ -142,6 +142,7 @@ static ID  sym_add,
            id_iv_node,
            id_iv_operation,
            id_iv_value,
+           id_dup,
            id_load,
            id_match,
            id_parse,
@@ -183,6 +184,18 @@ static VALUE eTimeoutError;            /*LIBCOUCHBASE_ETIMEDOUT = 0x16*/
 static VALUE eConnectError;            /*LIBCOUCHBASE_CONNECT_ERROR = 0x17*/
 static VALUE eBucketNotFoundError;     /*LIBCOUCHBASE_BUCKET_ENOENT = 0x18*/
 
+    static void
+cb_gc_protect(bucket_t *bucket, VALUE val)
+{
+    rb_hash_aset(bucket->object_space, val|1, val);
+}
+
+    static void
+cb_gc_unprotect(bucket_t *bucket, VALUE val)
+{
+    rb_hash_delete(bucket->object_space, val|1);
+}
+
     static VALUE
 cb_proc_call(VALUE recv, int argc, ...)
 {
@@ -504,18 +517,18 @@ cb_args_scan_keys(long argc, VALUE argv, bucket_t *bucket, struct key_traits *tr
         if (nn == 1 && TYPE(keys_ptr[0]) == T_HASH) {
             /* hash of key-ttl pairs */
             nn = RHASH_SIZE(keys_ptr[0]);
-            traits->keys = calloc(nn, sizeof(char *));
-            traits->lens = calloc(nn, sizeof(size_t));
+            traits->keys = xcalloc(nn, sizeof(char *));
+            traits->lens = xcalloc(nn, sizeof(size_t));
             traits->explicit_ttl = 1;
             traits->mgat = 1;
-            traits->ttls = calloc(nn, sizeof(time_t));
+            traits->ttls = xcalloc(nn, sizeof(time_t));
             rb_hash_foreach(keys_ptr[0], cb_extract_keys_i, (VALUE)traits);
         } else {
             /* the list of keys */
             traits->nkeys = nn;
-            traits->keys = calloc(nn, sizeof(char *));
-            traits->lens = calloc(nn, sizeof(size_t));
-            traits->ttls = calloc(nn, sizeof(time_t));
+            traits->keys = xcalloc(nn, sizeof(char *));
+            traits->lens = xcalloc(nn, sizeof(size_t));
+            traits->ttls = xcalloc(nn, sizeof(time_t));
             for (ii = 0; ii < nn; ii++) {
                 key = unify_key(keys_ptr[ii]);
                 rb_ary_push(traits->keys_ary, key);
@@ -577,6 +590,7 @@ storage_callback(libcouchbase_t handle, const void *cookie,
         rb_ivar_set(exc, id_iv_operation, o);
         if (NIL_P(ctx->exception)) {
             ctx->exception = exc;
+            cb_gc_protect(bucket, ctx->exception);
         }
     }
     if (bucket->async) { /* asynchronous */
@@ -594,7 +608,7 @@ storage_callback(libcouchbase_t handle, const void *cookie,
 
     if (bucket->seqno == 0) {
         bucket->io->stop_event_loop(bucket->io);
-        rb_hash_delete(object_space, ctx->proc|1);
+        cb_gc_unprotect(bucket, ctx->proc);
     }
     (void)handle;
 }
@@ -617,6 +631,7 @@ delete_callback(libcouchbase_t handle, const void *cookie,
             rb_ivar_set(exc, id_iv_operation, sym_delete);
             if (NIL_P(ctx->exception)) {
                 ctx->exception = exc;
+                cb_gc_protect(bucket, ctx->exception);
             }
         }
     }
@@ -633,7 +648,7 @@ delete_callback(libcouchbase_t handle, const void *cookie,
     }
     if (bucket->seqno == 0) {
         bucket->io->stop_event_loop(bucket->io);
-        rb_hash_delete(object_space, ctx->proc|1);
+        cb_gc_unprotect(bucket, ctx->proc);
     }
     (void)handle;
 }
@@ -658,26 +673,27 @@ get_callback(libcouchbase_t handle, const void *cookie,
             rb_ivar_set(exc, id_iv_operation, sym_get);
             if (NIL_P(ctx->exception)) {
                 ctx->exception = exc;
+                cb_gc_protect(bucket, ctx->exception);
             }
         }
     }
 
     f = ULONG2NUM(flags);
     c = ULL2NUM(cas);
+    v = Qnil;
     if (nbytes != 0) {
         v = decode_value(rb_str_new((const char*)bytes, nbytes), flags, ctx->force_format);
         if (v == Qundef) {
+            if (ctx->exception != Qnil) {
+                cb_gc_unprotect(bucket, ctx->exception);
+            }
             ctx->exception = rb_exc_new2(eValueFormatError, "unable to convert value");
             rb_ivar_set(ctx->exception, id_iv_operation, sym_get);
             rb_ivar_set(ctx->exception, id_iv_key, k);
-            v = Qnil;
-        }
-    } else {
-        if (flags_get_format(flags) == sym_plain) {
-            v = rb_str_new2("");
-        } else {
-            v = Qnil;
+            cb_gc_protect(bucket, ctx->exception);
         }
+    } else if (flags_get_format(flags) == sym_plain) {
+        v = rb_str_new2("");
     }
     if (bucket->async) { /* asynchronous */
         if (ctx->proc != Qnil) {
@@ -702,7 +718,7 @@ get_callback(libcouchbase_t handle, const void *cookie,
 
     if (bucket->seqno == 0) {
         bucket->io->stop_event_loop(bucket->io);
-        rb_hash_delete(object_space, ctx->proc|1);
+        cb_gc_unprotect(bucket, ctx->proc);
     }
     (void)handle;
 }
@@ -721,6 +737,7 @@ flush_callback(libcouchbase_t handle, const void* cookie,
         rb_ivar_set(exc, id_iv_operation, sym_flush);
         if (NIL_P(ctx->exception)) {
             ctx->exception = exc;
+            cb_gc_protect(bucket, ctx->exception);
         }
         success = Qfalse;
     }
@@ -744,7 +761,7 @@ flush_callback(libcouchbase_t handle, const void* cookie,
         bucket->seqno--;
         if (bucket->seqno == 0) {
             bucket->io->stop_event_loop(bucket->io);
-            rb_hash_delete(object_space, ctx->proc|1);
+            cb_gc_unprotect(bucket, ctx->proc);
         }
     }
 
@@ -766,6 +783,7 @@ version_callback(libcouchbase_t handle, const void *cookie,
         rb_ivar_set(exc, id_iv_operation, sym_flush);
         if (NIL_P(ctx->exception)) {
             ctx->exception = exc;
+            cb_gc_protect(bucket, ctx->exception);
         }
     }
 
@@ -789,7 +807,7 @@ version_callback(libcouchbase_t handle, const void *cookie,
         bucket->seqno--;
         if (bucket->seqno == 0) {
             bucket->io->stop_event_loop(bucket->io);
-            rb_hash_delete(object_space, ctx->proc|1);
+            cb_gc_unprotect(bucket, ctx->proc);
         }
     }
 
@@ -812,6 +830,7 @@ stat_callback(libcouchbase_t handle, const void* cookie,
         rb_ivar_set(exc, id_iv_operation, sym_stats);
         if (NIL_P(ctx->exception)) {
             ctx->exception = exc;
+            cb_gc_protect(bucket, ctx->exception);
         }
     }
     if (authority) {
@@ -841,7 +860,7 @@ stat_callback(libcouchbase_t handle, const void* cookie,
         bucket->seqno--;
         if (bucket->seqno == 0) {
             bucket->io->stop_event_loop(bucket->io);
-            rb_hash_delete(object_space, ctx->proc|1);
+            cb_gc_unprotect(bucket, ctx->proc);
         }
     }
     (void)handle;
@@ -864,6 +883,7 @@ touch_callback(libcouchbase_t handle, const void *cookie,
             rb_ivar_set(exc, id_iv_operation, sym_touch);
             if (NIL_P(ctx->exception)) {
                 ctx->exception = exc;
+                cb_gc_protect(bucket, ctx->exception);
             }
         }
     }
@@ -884,7 +904,7 @@ touch_callback(libcouchbase_t handle, const void *cookie,
     }
     if (bucket->seqno == 0) {
         bucket->io->stop_event_loop(bucket->io);
-        rb_hash_delete(object_space, ctx->proc|1);
+        cb_gc_unprotect(bucket, ctx->proc);
     }
     (void)handle;
 }
@@ -920,6 +940,7 @@ arithmetic_callback(libcouchbase_t handle, const void *cookie,
         }
         if (NIL_P(ctx->exception)) {
             ctx->exception = exc;
+            cb_gc_protect(bucket, ctx->exception);
         }
     }
     v = ULL2NUM(value);
@@ -944,7 +965,7 @@ arithmetic_callback(libcouchbase_t handle, const void *cookie,
     }
     if (bucket->seqno == 0) {
         bucket->io->stop_event_loop(bucket->io);
-        rb_hash_delete(object_space, ctx->proc|1);
+        cb_gc_unprotect(bucket, ctx->proc);
     }
     (void)handle;
 }
@@ -980,13 +1001,13 @@ cb_bucket_free(void *ptr)
         if (bucket->handle) {
             libcouchbase_destroy(bucket->handle);
         }
-        free(bucket->authority);
-        free(bucket->hostname);
-        free(bucket->pool);
-        free(bucket->bucket);
-        free(bucket->username);
-        free(bucket->password);
-        free(bucket);
+        xfree(bucket->authority);
+        xfree(bucket->hostname);
+        xfree(bucket->pool);
+        xfree(bucket->bucket);
+        xfree(bucket->username);
+        xfree(bucket->password);
+        xfree(bucket);
     }
 }
 
@@ -998,6 +1019,7 @@ cb_bucket_mark(void *ptr)
     if (bucket) {
         rb_gc_mark(bucket->exception);
         rb_gc_mark(bucket->on_error_proc);
+        rb_gc_mark(bucket->object_space);
     }
 }
 
@@ -1026,7 +1048,7 @@ do_scan_connection_options(bucket_t *bucket, int argc, VALUE *argv)
 
             arg = rb_funcall(uri_obj, id_user, 0);
             if (arg != Qnil) {
-                free(bucket->username);
+                xfree(bucket->username);
                 bucket->username = strdup(RSTRING_PTR(arg));
                 if (bucket->username == NULL) {
                     rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
@@ -1035,7 +1057,7 @@ do_scan_connection_options(bucket_t *bucket, int argc, VALUE *argv)
 
             arg = rb_funcall(uri_obj, id_password, 0);
             if (arg != Qnil) {
-                free(bucket->password);
+                xfree(bucket->password);
                 bucket->password = strdup(RSTRING_PTR(arg));
                 if (bucket->password == NULL) {
                     rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
@@ -1043,7 +1065,7 @@ do_scan_connection_options(bucket_t *bucket, int argc, VALUE *argv)
             }
             arg = rb_funcall(uri_obj, id_host, 0);
             if (arg != Qnil) {
-                free(bucket->hostname);
+                xfree(bucket->hostname);
                 bucket->hostname = strdup(RSTRING_PTR(arg));
                 if (bucket->hostname == NULL) {
                     rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
@@ -1059,45 +1081,45 @@ do_scan_connection_options(bucket_t *bucket, int argc, VALUE *argv)
             re = rb_reg_new(path_re, sizeof(path_re) - 1, 0);
             match = rb_funcall(re, id_match, 1, arg);
             arg = rb_reg_nth_match(2, match);
-            free(bucket->pool);
+            xfree(bucket->pool);
             bucket->pool = strdup(NIL_P(arg) ? "default" : RSTRING_PTR(arg));
             arg = rb_reg_nth_match(4, match);
-            free(bucket->bucket);
+            xfree(bucket->bucket);
             bucket->bucket = strdup(NIL_P(arg) ? "default" : RSTRING_PTR(arg));
         }
         if (TYPE(opts) == T_HASH) {
             arg = rb_hash_aref(opts, sym_hostname);
             if (arg != Qnil) {
                 if (bucket->hostname) {
-                    free(bucket->hostname);
+                    xfree(bucket->hostname);
                 }
                 bucket->hostname = strdup(StringValueCStr(arg));
             }
             arg = rb_hash_aref(opts, sym_pool);
             if (arg != Qnil) {
                 if (bucket->pool) {
-                    free(bucket->pool);
+                    xfree(bucket->pool);
                 }
                 bucket->pool = strdup(StringValueCStr(arg));
             }
             arg = rb_hash_aref(opts, sym_bucket);
             if (arg != Qnil) {
                 if (bucket->bucket) {
-                    free(bucket->bucket);
+                    xfree(bucket->bucket);
                 }
                 bucket->bucket = strdup(StringValueCStr(arg));
             }
             arg = rb_hash_aref(opts, sym_username);
             if (arg != Qnil) {
                 if (bucket->username) {
-                    free(bucket->username);
+                    xfree(bucket->username);
                 }
                 bucket->username = strdup(StringValueCStr(arg));
             }
             arg = rb_hash_aref(opts, sym_password);
             if (arg != Qnil) {
                 if (bucket->password) {
-                    free(bucket->password);
+                    xfree(bucket->password);
                 }
                 bucket->password = strdup(StringValueCStr(arg));
             }
@@ -1146,9 +1168,9 @@ do_scan_connection_options(bucket_t *bucket, int argc, VALUE *argv)
     }
     len = strlen(bucket->hostname) + 10;
     if (bucket->authority) {
-        free(bucket->authority);
+        xfree(bucket->authority);
     }
-    bucket->authority = calloc(len, sizeof(char));
+    bucket->authority = xcalloc(len, sizeof(char));
     if (bucket->authority == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
     }
@@ -1208,15 +1230,8 @@ do_connect(bucket_t *bucket)
     }
 }
 
-/*
- * Create and initialize new Bucket.
- *
- * @return [Bucket] new instance
- *
- * @see Bucket#initialize
- */
     static VALUE
-cb_bucket_new(int argc, VALUE *argv, VALUE klass)
+cb_bucket_alloc(VALUE klass)
 {
     VALUE obj;
     bucket_t *bucket;
@@ -1224,7 +1239,6 @@ cb_bucket_new(int argc, VALUE *argv, VALUE klass)
     /* allocate new bucket struct and set it to zero */
     obj = Data_Make_Struct(klass, bucket_t, cb_bucket_mark, cb_bucket_free,
             bucket);
-    rb_obj_call_init(obj, argc, argv);
     return obj;
 }
 
@@ -1295,6 +1309,7 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
     bucket->default_format = sym_document;
     bucket->on_error_proc = Qnil;
     bucket->timeout = 0;
+    bucket->object_space = rb_hash_new();
 
     do_scan_connection_options(bucket, argc, argv);
     do_connect(bucket);
@@ -1302,6 +1317,60 @@ cb_bucket_init(int argc, VALUE *argv, VALUE self)
     return self;
 }
 
+/*
+ * Initialize copy
+ *
+ * Initializes copy of the object, used by {Couchbase::Bucket#dup}
+ *
+ * @param orig [Couchbase::Bucket] the source for copy
+ *
+ * @return [Couchbase::Bucket]
+ */
+static VALUE
+cb_bucket_init_copy(VALUE copy, VALUE orig)
+{
+    bucket_t *copy_b;
+    bucket_t *orig_b;
+
+    if (copy == orig)
+        return copy;
+
+    if (TYPE(orig) != T_DATA || TYPE(copy) != T_DATA ||
+            RDATA(orig)->dfree != (RUBY_DATA_FUNC)cb_bucket_free) {
+        rb_raise(rb_eTypeError, "wrong argument type");
+    }
+
+    copy_b = DATA_PTR(copy);
+    orig_b = DATA_PTR(orig);
+
+    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);
+    }
+    copy_b->async = orig_b->async;
+    copy_b->quiet = orig_b->quiet;
+    copy_b->seqno = orig_b->seqno;
+    copy_b->default_format = orig_b->default_format;
+    copy_b->default_flags = orig_b->default_flags;
+    copy_b->default_ttl = orig_b->default_ttl;
+    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);
+    }
+
+    do_connect(copy_b);
+
+    return copy;
+}
+
 /*
  * Reconnect the bucket
  *
@@ -1492,7 +1561,7 @@ cb_bucket_hostname_get(VALUE self)
     bucket_t *bucket = DATA_PTR(self);
     if (bucket->handle) {
         if (bucket->hostname) {
-            free(bucket->hostname);
+            xfree(bucket->hostname);
             bucket->hostname = NULL;
         }
         bucket->hostname = strdup(libcouchbase_get_host(bucket->handle));
@@ -1528,7 +1597,7 @@ cb_bucket_authority_get(VALUE self)
     (void)cb_bucket_hostname_get(self);
     (void)cb_bucket_port_get(self);
     len = strlen(bucket->hostname) + 10;
-    bucket->authority = calloc(len, sizeof(char));
+    bucket->authority = xcalloc(len, sizeof(char));
     if (bucket->authority == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for Bucket");
     }
@@ -1691,7 +1760,7 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
     k = unify_key(k);
     key = RSTRING_PTR(k);
     nkey = RSTRING_LEN(k);
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     ctx->quiet = bucket->quiet;
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
@@ -1710,7 +1779,7 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
         }
     }
     ctx->proc = proc;
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     rv = rb_ary_new();
     ctx->rv = &rv;
     ctx->bucket = bucket;
@@ -1721,7 +1790,7 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
             (const void *)key, nkey, cas);
     exc = cb_check_error(err, "failed to schedule delete request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -1732,8 +1801,9 @@ cb_bucket_delete(int argc, VALUE *argv, VALUE self)
             bucket->io->run_event_loop(bucket->io);
         }
         exc = ctx->exception;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         return rv;
@@ -1791,7 +1861,7 @@ cb_bucket_store(libcouchbase_storage_t cmd, int argc, VALUE *argv, VALUE self)
     }
     bytes = RSTRING_PTR(v);
     nbytes = RSTRING_LEN(v);
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
@@ -1799,7 +1869,7 @@ cb_bucket_store(libcouchbase_storage_t cmd, int argc, VALUE *argv, VALUE self)
     ctx->rv = &rv;
     ctx->bucket = bucket;
     ctx->proc = proc;
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     ctx->exception = Qnil;
     seqno = bucket->seqno;
     bucket->seqno++;
@@ -1807,7 +1877,7 @@ cb_bucket_store(libcouchbase_storage_t cmd, int argc, VALUE *argv, VALUE self)
             (const void *)key, nkey, bytes, nbytes, flags, exp, cas);
     exc = cb_check_error(err, "failed to schedule set request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -1818,8 +1888,9 @@ cb_bucket_store(libcouchbase_storage_t cmd, int argc, VALUE *argv, VALUE self)
             bucket->io->run_event_loop(bucket->io);
         }
         exc = ctx->exception;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         if (bucket->exception != Qnil) {
@@ -1851,7 +1922,7 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
     k = unify_key(k);
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
@@ -1885,7 +1956,7 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
     ctx->rv = &rv;
     ctx->bucket = bucket;
     ctx->proc = proc;
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     ctx->exception = Qnil;
     ctx->arithm = sign;
     seqno = bucket->seqno;
@@ -1894,7 +1965,7 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
             (const void *)key, nkey, delta, exp, create, initial);
     exc = cb_check_error(err, "failed to schedule arithmetic request", k);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -1905,8 +1976,9 @@ cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
             bucket->io->run_event_loop(bucket->io);
         }
         exc = ctx->exception;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         return rv;
@@ -2197,16 +2269,16 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
     rb_funcall(args, id_flatten_bang, 0);
-    traits = calloc(1, sizeof(struct key_traits));
+    traits = xcalloc(1, sizeof(struct key_traits));
     nn = cb_args_scan_keys(RARRAY_LEN(args), args, bucket, traits);
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
     mgat = traits->mgat;
     keys = traits->keys_ary;
     ctx->proc = proc;
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     ctx->bucket = bucket;
     ctx->extended = traits->extended;
     ctx->quiet = traits->quiet;
@@ -2219,13 +2291,13 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     err = libcouchbase_mget(bucket->handle, (const void *)ctx,
             traits->nkeys, (const void * const *)traits->keys,
             traits->lens, (traits->explicit_ttl) ? traits->ttls : NULL);
-    free(traits->keys);
-    free(traits->lens);
-    free(traits->ttls);
-    free(traits);
+    xfree(traits->keys);
+    xfree(traits->lens);
+    xfree(traits->ttls);
+    xfree(traits);
     exc = cb_check_error(err, "failed to schedule get request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -2237,8 +2309,9 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
         }
         exc = ctx->exception;
         extended = ctx->extended;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         if (bucket->exception != Qnil) {
@@ -2344,14 +2417,14 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
     rb_funcall(args, id_flatten_bang, 0);
-    traits = calloc(1, sizeof(struct key_traits));
+    traits = xcalloc(1, sizeof(struct key_traits));
     nn = cb_args_scan_keys(RARRAY_LEN(args), args, bucket, traits);
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
     ctx->proc = proc;
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     ctx->bucket = bucket;
     rv = rb_hash_new();
     ctx->rv = &rv;
@@ -2361,12 +2434,12 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
     err = libcouchbase_mtouch(bucket->handle, (const void *)ctx,
             traits->nkeys, (const void * const *)traits->keys,
             traits->lens, traits->ttls);
-    free(traits->keys);
-    free(traits->lens);
-    free(traits);
+    xfree(traits->keys);
+    xfree(traits->lens);
+    xfree(traits);
     exc = cb_check_error(err, "failed to schedule touch request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -2377,8 +2450,9 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
             bucket->io->run_event_loop(bucket->io);
         }
         exc = ctx->exception;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         if (bucket->exception != Qnil) {
@@ -2433,7 +2507,7 @@ cb_bucket_flush(VALUE self)
     if (!bucket->async && rb_block_given_p()) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
@@ -2446,13 +2520,13 @@ cb_bucket_flush(VALUE self)
     } else {
         ctx->proc = Qnil;
     }
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     seqno = bucket->seqno;
     bucket->seqno++;
     err = libcouchbase_flush(bucket->handle, (const void *)ctx);
     exc = cb_check_error(err, "failed to schedule flush request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -2463,8 +2537,9 @@ cb_bucket_flush(VALUE self)
             bucket->io->run_event_loop(bucket->io);
         }
         exc = ctx->exception;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         return rv;
@@ -2511,7 +2586,7 @@ cb_bucket_version(VALUE self)
     if (!bucket->async && rb_block_given_p()) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
@@ -2524,13 +2599,13 @@ cb_bucket_version(VALUE self)
     } else {
         ctx->proc = Qnil;
     }
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     seqno = bucket->seqno;
     bucket->seqno++;
     err = libcouchbase_server_versions(bucket->handle, (const void *)ctx);
     exc = cb_check_error(err, "failed to schedule version request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -2541,8 +2616,9 @@ cb_bucket_version(VALUE self)
             bucket->io->run_event_loop(bucket->io);
         }
         exc = ctx->exception;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         return rv;
@@ -2608,7 +2684,7 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
 
-    ctx = calloc(1, sizeof(context_t));
+    ctx = xcalloc(1, sizeof(context_t));
     if (ctx == NULL) {
         rb_raise(eNoMemoryError, "failed to allocate memory for context");
     }
@@ -2616,7 +2692,7 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
     ctx->rv = &rv;
     ctx->bucket = bucket;
     ctx->proc = proc;
-    rb_hash_aset(object_space, ctx->proc|1, ctx->proc);
+    cb_gc_protect(bucket, ctx->proc);
     ctx->exception = Qnil;
     if (arg != Qnil) {
         arg = unify_key(arg);
@@ -2632,7 +2708,7 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
             key, nkey);
     exc = cb_check_error(err, "failed to schedule stat request", Qnil);
     if (exc != Qnil) {
-        free(ctx);
+        xfree(ctx);
         rb_exc_raise(exc);
     }
     if (bucket->async) {
@@ -2643,8 +2719,9 @@ cb_bucket_stats(int argc, VALUE *argv, VALUE self)
             bucket->io->run_event_loop(bucket->io);
         }
         exc = ctx->exception;
-        free(ctx);
+        xfree(ctx);
         if (exc != Qnil) {
+            cb_gc_unprotect(bucket, exc);
             rb_exc_raise(exc);
         }
         if (bucket->exception != Qnil) {
@@ -3250,9 +3327,6 @@ Init_couchbase_ext(void)
      * This class in charge of all stuff connected to communication with
      * Couchbase. */
     cBucket = rb_define_class_under(mCouchbase, "Bucket", rb_cObject);
-    object_space = rb_hash_new();
-    /* @private Hack to avoid GC in some cases */
-    rb_define_const(cBucket, "OBJECT_SPACE", object_space);
 
     /* 0x03: Bitmask for flag bits responsible for format */
     rb_define_const(cBucket, "FMT_MASK", INT2FIX(FMT_MASK));
@@ -3272,9 +3346,9 @@ Init_couchbase_ext(void)
      * http://dustin.github.com/2011/02/17/memcached-set.html */
     rb_define_const(cBucket, "FMT_PLAIN", INT2FIX(FMT_PLAIN));
 
-    rb_define_singleton_method(cBucket, "new", cb_bucket_new, -1);
-
+    rb_define_alloc_func(cBucket, cb_bucket_alloc);
     rb_define_method(cBucket, "initialize", cb_bucket_init, -1);
+    rb_define_method(cBucket, "initialize_copy", cb_bucket_init_copy, 1);
     rb_define_method(cBucket, "inspect", cb_bucket_inspect, 0);
 
     /* Document-method: seqno
@@ -3441,6 +3515,7 @@ Init_couchbase_ext(void)
     id_arity = rb_intern("arity");
     id_call = rb_intern("call");
     id_dump = rb_intern("dump");
+    id_dup = rb_intern("dup");
     id_flatten_bang = rb_intern("flatten!");
     id_has_key_p = rb_intern("has_key?");
     id_host = rb_intern("host");

data/lib/couchbase/bucket.rb

@@ -57,12 +57,12 @@ module Couchbase
       if async?
         get(key, options) do |ret|
           val = yield(ret) # get new value from caller
-          set(ret.key, val, :cas => ret.cas)
+          set(ret.key, val, :cas => ret.cas, :flags => ret.flags)
         end
       else
         val, flags, ver = get(key, options)
         val = yield(val) # get new value from caller
-        set(key, val, :cas => ver)
+        set(key, val, :cas => ver, :flags => flags)
       end
     end
     alias :compare_and_swap :cas

data/lib/couchbase/version.rb

@@ -17,5 +17,5 @@
 
 # Couchbase ruby client
 module Couchbase
-  VERSION = "1.1.2"
+  VERSION = "1.1.3"
 end

data/test/test_cas.rb

@@ -56,4 +56,12 @@ class TestCas < MiniTest::Unit::TestCase
     assert_equal expected, val
   end
 
+  def test_flags_replication
+    connection = Couchbase.new(:hostname => @mock.host, :port => @mock.port,
+                               :default_format => :document)
+    connection.set(uniq_id, "bar", :flags => 0x100)
+    connection.cas(uniq_id) { "baz" }
+    _, flags, _ = connection.get(uniq_id, :extended => true)
+    assert_equal 0x100, flags
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: couchbase
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-05 00:00:00.000000000 Z
+date: 2012-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
@@ -198,7 +198,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3642413217279850203
+      hash: 4020867822083884443
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -207,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3642413217279850203
+      hash: 4020867822083884443
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24