couchbase 1.2.3 → 1.3.0

data/ext/couchbase_ext/couchbase_ext.h

@@ -97,7 +97,7 @@ struct cb_bucket_st
     uint8_t connected;       /* non-zero if instance has been connected. it is possible to defer connection with :async option */
     uint8_t running;         /* non-zero if event loop is running */
     uint8_t trigger_connect_cb_on_set; /* if non-zero, the on_connect callback will be triggered immediately after set */
-    VALUE default_format;    /* should update +default_flags+ on change */
+    VALUE transcoder;
     uint32_t default_flags;
     time_t default_ttl;
     time_t default_observe_timeout;
@@ -127,7 +127,8 @@ struct cb_context_st
     VALUE rv;
     VALUE exception;
     VALUE observe_options;
-    VALUE force_format;
+    VALUE transcoder;
+    VALUE transcoder_opts;
     VALUE operation;
     VALUE headers_val;
     int headers_built;
@@ -169,8 +170,10 @@ extern VALUE cb_cTimer;
 /* Modules */
 extern VALUE cb_mCouchbase;
 extern VALUE cb_mError;
+extern VALUE cb_mTranscoder;
+extern VALUE cb_mDocument;
+extern VALUE cb_mPlain;
 extern VALUE cb_mMarshal;
-extern VALUE cb_mMultiJson;
 extern VALUE cb_mURI;
 extern VALUE em_m;
 
@@ -203,6 +206,7 @@ extern ID cb_sym_environment;
 extern ID cb_sym_eventmachine;
 extern ID cb_sym_extended;
 extern ID cb_sym_flags;
+extern ID cb_sym_forced;
 extern ID cb_sym_format;
 extern ID cb_sym_found;
 extern ID cb_sym_get;
@@ -239,6 +243,7 @@ extern ID cb_sym_set;
 extern ID cb_sym_stats;
 extern ID cb_sym_timeout;
 extern ID cb_sym_touch;
+extern ID cb_sym_transcoder;
 extern ID cb_sym_ttl;
 extern ID cb_sym_type;
 extern ID cb_sym_unlock;
@@ -336,10 +341,8 @@ int cb_first_value_i(VALUE key, VALUE value, VALUE arg);
 void cb_build_headers(struct cb_context_st *ctx, const char * const *headers);
 void cb_maybe_do_loop(struct cb_bucket_st *bucket);
 VALUE cb_unify_key(struct cb_bucket_st *bucket, VALUE key, int apply_prefix);
-VALUE cb_encode_value(VALUE val, uint32_t flags);
-VALUE cb_decode_value(VALUE blob, uint32_t flags, VALUE force_format);
-uint32_t cb_flags_set_format(uint32_t flags, ID format);
-ID cb_flags_get_format(uint32_t flags);
+VALUE cb_encode_value(VALUE transcoder, VALUE val, uint32_t *flags, VALUE options);
+VALUE cb_decode_value(VALUE transcoder, VALUE blob, uint32_t flags, VALUE options);
 void cb_async_error_notify(struct cb_bucket_st *bucket, VALUE exc);
 
 
@@ -388,6 +391,8 @@ VALUE cb_bucket_connected_p(VALUE self);
 VALUE cb_bucket_async_p(VALUE self);
 VALUE cb_bucket_quiet_get(VALUE self);
 VALUE cb_bucket_quiet_set(VALUE self, VALUE val);
+VALUE cb_bucket_transcoder_get(VALUE self);
+VALUE cb_bucket_transcoder_set(VALUE self, VALUE val);
 VALUE cb_bucket_default_flags_get(VALUE self);
 VALUE cb_bucket_default_flags_set(VALUE self, VALUE val);
 VALUE cb_bucket_default_format_get(VALUE self);
@@ -488,6 +493,8 @@ struct cb_params_st
             lcb_cas_t cas;
             lcb_datatype_t datatype;
             VALUE observe;
+            VALUE transcoder;
+            VALUE transcoder_opts;
         } store;
         struct {
             /* number of items */
@@ -509,7 +516,8 @@ struct cb_params_st
             /* arguments given in form of hash key-ttl to "get and touch" */
             unsigned int gat : 1;
             lcb_time_t ttl;
-            VALUE forced_format;
+            VALUE transcoder;
+            VALUE transcoder_opts;
             VALUE keys_ary;
         } get;
         struct {
@@ -526,7 +534,8 @@ struct cb_params_st
             lcb_uint64_t initial;
             lcb_uint64_t delta;
             int sign;
-            VALUE format;
+            VALUE transcoder;
+            VALUE transcoder_opts;
             lcb_datatype_t datatype;
         } arith;
         struct {

data/ext/couchbase_ext/get.c

@@ -22,7 +22,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
 {
     struct cb_context_st *ctx = (struct cb_context_st *)cookie;
     struct cb_bucket_st *bucket = ctx->bucket;
-    VALUE key, val, flags, cas, exc = Qnil, res;
+    VALUE key, val, flags, cas, exc = Qnil, res, raw;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
@@ -38,22 +38,17 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
 
     flags = ULONG2NUM(resp->v.v0.flags);
     cas = ULL2NUM(resp->v.v0.cas);
-    val = Qnil;
-    if (resp->v.v0.nbytes != 0) {
-        VALUE raw = STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes);
-        val = cb_decode_value(raw, resp->v.v0.flags, ctx->force_format);
-        if (rb_obj_is_kind_of(val, rb_eStandardError)) {
-            VALUE exc_str = rb_funcall(val, cb_id_to_s, 0);
-            VALUE msg = rb_funcall(rb_mKernel, cb_id_sprintf, 3,
-                    rb_str_new2("unable to convert value for key '%s': %s"), key, exc_str);
-            ctx->exception = rb_exc_new3(cb_eValueFormatError, msg);
-            rb_ivar_set(ctx->exception, cb_id_iv_operation, cb_sym_get);
-            rb_ivar_set(ctx->exception, cb_id_iv_key, key);
-            rb_ivar_set(ctx->exception, cb_id_iv_inner_exception, val);
-            val = raw;
-        }
-    } else if (cb_flags_get_format(resp->v.v0.flags) == cb_sym_plain) {
-        val = cb_vStrEmpty;
+    raw = STR_NEW((const char*)resp->v.v0.bytes, resp->v.v0.nbytes);
+    val = cb_decode_value(ctx->transcoder, raw, resp->v.v0.flags, ctx->transcoder_opts);
+    if (rb_obj_is_kind_of(val, rb_eStandardError)) {
+        VALUE exc_str = rb_funcall(val, cb_id_to_s, 0);
+        VALUE msg = rb_funcall(rb_mKernel, cb_id_sprintf, 3,
+                rb_str_new2("unable to convert value for key \"%s\": %s"), key, exc_str);
+        ctx->exception = rb_exc_new3(cb_eValueFormatError, msg);
+        rb_ivar_set(ctx->exception, cb_id_iv_operation, cb_sym_get);
+        rb_ivar_set(ctx->exception, cb_id_iv_key, key);
+        rb_ivar_set(ctx->exception, cb_id_iv_inner_exception, val);
+        val = Qnil;
     }
     if (bucket->async) { /* asynchronous */
         if (ctx->proc != Qnil) {
@@ -96,8 +91,8 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
  *   @param keys [String, Symbol, Array] One or several keys to fetch
  *   @param options [Hash] Options for operation.
  *   @option options [true, false] :extended (false) If set to +true+, the
- *     operation will return tuple +[value, flags, cas]+, otherwise (by
- *     default) it returns just value.
+ *     operation will return a tuple +[value, flags, cas]+, otherwise (by
+ *     default) it returns just the value.
  *   @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
  *     Values larger than 30*24*60*60 seconds (30 days) are interpreted as
  *     absolute times (from the epoch).
@@ -128,7 +123,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
  *     +cas+).
  *
  *   @return [Object, Array, Hash] the value(s) (or tuples in extended mode)
- *     assiciated with the key.
+ *     associated with the key.
  *
  *   @raise [Couchbase::Error::NotFound] if the key is missing in the
  *     bucket.
@@ -137,7 +132,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
  *
  *   @raise [ArgumentError] when passing the block in synchronous mode
  *
- *   @example Get single value in quite mode (the default)
+ *   @example Get single value in quiet mode (the default)
  *     c.get("foo")     #=> the associated value or nil
  *
  *   @example Use alternative hash-like syntax
@@ -199,7 +194,7 @@ cb_get_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_g
  *   @param options [Hash] Options for operation. (see options definition
  *     above)
  *
- *   @return [Hash] the values (or tuples in extended mode) assiciated with
+ *   @return [Hash] the values (or tuples in extended mode) associated with
  *     the keys.
  *
  *   @example Get and touch multiple keys
@@ -239,7 +234,8 @@ cb_bucket_get(int argc, VALUE *argv, VALUE self)
     ctx = cb_context_alloc_common(bucket, proc, params.cmd.get.num);
     ctx->extended = params.cmd.get.extended;
     ctx->quiet = params.cmd.get.quiet;
-    ctx->force_format = params.cmd.get.forced_format;
+    ctx->transcoder = params.cmd.get.transcoder;
+    ctx->transcoder_opts = params.cmd.get.transcoder_opts;
     if (params.cmd.get.replica) {
         err = lcb_get_replica(bucket->handle, (const void *)ctx,
                 params.cmd.get.num, params.cmd.get.ptr_gr);

data/ext/couchbase_ext/store.c

@@ -201,7 +201,7 @@ cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
  *   @option options [Symbol] :format (self.default_format) The
  *     representation for storing the value in the bucket. For more info see
  *     {Bucket#default_format}.
- *   @option options [Fixnum] :cas The CAS value for an object. This value
+ *   @option options [Fixnum] :cas The CAS value for an object. This value is
  *     created on the server and is guaranteed to be unique for each value of
  *     a given key. This value is used to provide simple optimistic
  *     concurrency control when multiple clients or threads try to update an

data/ext/couchbase_ext/utils.c

@@ -360,89 +360,33 @@ cb_check_error(lcb_error_t rc, const char *msg, VALUE key)
     return cb_check_error_with_status(rc, msg, key, 0);
 }
 
-
-    uint32_t
-cb_flags_set_format(uint32_t flags, ID format)
-{
-    flags &= ~((uint32_t)CB_FMT_MASK); /* clear format bits */
-
-    if (format == cb_sym_document) {
-        return flags | CB_FMT_DOCUMENT;
-    } else if (format == cb_sym_marshal) {
-        return flags | CB_FMT_MARSHAL;
-    } else if (format == cb_sym_plain) {
-        return flags | CB_FMT_PLAIN;
-    }
-    return flags; /* document is the default */
-}
-
-    ID
-cb_flags_get_format(uint32_t flags)
-{
-    flags &= CB_FMT_MASK; /* select format bits */
-
-    switch (flags) {
-        case CB_FMT_DOCUMENT:
-            return cb_sym_document;
-        case CB_FMT_MARSHAL:
-            return cb_sym_marshal;
-        case CB_FMT_PLAIN:
-            /* fall through */
-        default:
-            /* all other formats treated as plain */
-            return cb_sym_plain;
-    }
-}
-
-
     static VALUE
 do_encode(VALUE *args)
 {
     VALUE val = args[0];
-    uint32_t flags = ((uint32_t)args[1] & CB_FMT_MASK);
-
-    switch (flags) {
-        case CB_FMT_DOCUMENT:
-            return rb_funcall(cb_mMultiJson, cb_id_dump, 1, val);
-        case CB_FMT_MARSHAL:
-            return rb_funcall(cb_mMarshal, cb_id_dump, 1, val);
-        case CB_FMT_PLAIN:
-            /* fall through */
-        default:
-            /* all other formats treated as plain */
-            return val;
+    uint32_t *flags = (uint32_t *)args[1];
+    VALUE transcoder = args[2];
+    VALUE options = args[3];
+    VALUE ret;
+
+    ret = rb_funcall(transcoder, cb_id_dump, 3, val, ULONG2NUM(*flags), options);
+    Check_Type(ret, T_ARRAY);
+    if (RARRAY_LEN(ret) != 2) {
+        rb_raise(rb_eArgError, "#dump method of transcoder should return two items");
     }
+    *flags = NUM2ULONG(RARRAY_PTR(ret)[1]);
+    return RARRAY_PTR(ret)[0];
 }
 
     static VALUE
 do_decode(VALUE *args)
 {
     VALUE blob = args[0];
-    VALUE force_format = args[2];
-
-    if (TYPE(force_format) == T_SYMBOL) {
-        if (force_format == cb_sym_document) {
-            return rb_funcall(cb_mMultiJson, cb_id_load, 1, blob);
-        } else if (force_format == cb_sym_marshal) {
-            return rb_funcall(cb_mMarshal, cb_id_load, 1, blob);
-        } else { /* cb_sym_plain and any other cb_symbol */
-            return blob;
-        }
-    } else {
-        uint32_t flags = ((uint32_t)args[1] & CB_FMT_MASK);
-
-        switch (flags) {
-            case CB_FMT_DOCUMENT:
-                return rb_funcall(cb_mMultiJson, cb_id_load, 1, blob);
-            case CB_FMT_MARSHAL:
-                return rb_funcall(cb_mMarshal, cb_id_load, 1, blob);
-            case CB_FMT_PLAIN:
-                /* fall through */
-            default:
-                /* all other formats treated as plain */
-                return blob;
-        }
-    }
+    VALUE transcoder = args[2];
+    VALUE flags = args[1];
+    VALUE options = args[3];
+
+    return rb_funcall(transcoder, cb_id_load, 3, blob, ULONG2NUM(flags), options);
 }
 
     static VALUE
@@ -453,20 +397,27 @@ coding_failed(VALUE unused, VALUE exc)
 }
 
     VALUE
-cb_encode_value(VALUE val, uint32_t flags)
+cb_encode_value(VALUE transcoder, VALUE val, uint32_t *flags, VALUE options)
 {
-    VALUE blob, args[2];
+    VALUE args[4];
 
     args[0] = val;
     args[1] = (VALUE)flags;
-    blob = rb_rescue(do_encode, (VALUE)args, coding_failed, 0);
-    return blob; /* bytestring or exception object */
+    args[2] = transcoder;
+    args[3] = options;
+
+    /* if nil, just pass value through */
+    if (NIL_P(args[2])) {
+        return val;
+    }
+    /* bytestring or exception object */
+    return rb_rescue(do_encode, (VALUE)args, coding_failed, 0);
 }
 
     VALUE
-cb_decode_value(VALUE blob, uint32_t flags, VALUE force_format)
+cb_decode_value(VALUE transcoder, VALUE blob, uint32_t flags, VALUE options)
 {
-    VALUE val, args[3];
+    VALUE args[4];
 
     /* first it must be bytestring */
     if (TYPE(blob) != T_STRING) {
@@ -474,9 +425,15 @@ cb_decode_value(VALUE blob, uint32_t flags, VALUE force_format)
     }
     args[0] = blob;
     args[1] = (VALUE)flags;
-    args[2] = (VALUE)force_format;
-    val = rb_rescue(do_decode, (VALUE)args, coding_failed, 0);
-    return val; /* the value or exception object */
+    args[2] = transcoder;
+    args[3] = options;
+
+    /* if nil, just pass blob through */
+    if (NIL_P(args[2])) {
+        return blob;
+    }
+    /* the value or exception object */
+    return rb_rescue(do_decode, (VALUE)args, coding_failed, 0);
 }
 
     void

data/lib/active_support/cache/couchbase_store.rb

@@ -55,9 +55,15 @@ module ActiveSupport
         options[:default_ttl] ||= options.delete(:expires_in)
         options[:default_format] ||= :marshal
         options[:key_prefix] ||= options.delete(:namespace)
+        options[:connection_pool] ||= options.delete(:connection_pool)
         args.push(options)
-        @data = ::Couchbase::Bucket.new(*args)
-        @lock = Monitor.new
+
+        if options[:connection_pool]
+          @data = ::Couchbase::ConnectionPool.new(options[:connection_pool], *args)
+        else
+          @data = ::Couchbase::Bucket.new(*args)
+          @data.extend(Threadsafe)
+        end
       end
 
       # Fetches data from the cache, using the given key.
@@ -184,9 +190,7 @@ module ActiveSupport
           options[:format] = :plain
         end
         instrument(:read_multi, names, options) do
-          @lock.synchronize do
-            @data.get(names, options)
-          end
+          @data.get(names, options)
         end
       rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
@@ -247,9 +251,7 @@ module ActiveSupport
         options[:create] = true
         instrument(:increment, name, options) do |payload|
           payload[:amount] = amount if payload
-          @lock.synchronize do
-            @data.incr(name, amount, options)
-          end
+          @data.incr(name, amount, options)
         end
       rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
@@ -281,9 +283,7 @@ module ActiveSupport
         options[:create] = true
         instrument(:decrement, name, options) do |payload|
           payload[:amount] = amount if payload
-          @lock.synchronize do
-            @data.decr(name, amount, options)
-          end
+          @data.decr(name, amount, options)
         end
       rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
@@ -297,18 +297,14 @@ module ActiveSupport
       #
       # @return [Hash]
       def stats(*arg)
-        @lock.synchronize do
-          @data.stats(*arg)
-        end
+        @data.stats(*arg)
       end
 
       protected
 
       # Read an entry from the cache.
       def read_entry(key, options) # :nodoc:
-        @lock.synchronize do
-          @data.get(key, options)
-        end
+        @data.get(key, options)
       rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
@@ -325,9 +321,7 @@ module ActiveSupport
         if ttl = options.delete(:expires_in)
           options[:ttl] ||= ttl
         end
-        @lock.synchronize do
-          @data.send(method, key, value, options)
-        end
+        @data.send(method, key, value, options)
       rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
@@ -336,9 +330,7 @@ module ActiveSupport
 
       # Delete an entry from the cache.
       def delete_entry(key, options) # :nodoc:
-        @lock.synchronize do
-          @data.delete(key, options)
-        end
+        @data.delete(key, options)
       rescue ::Couchbase::Error::Base => e
         logger.error("#{e.class}: #{e.message}") if logger
         raise if @raise_errors
@@ -367,6 +359,51 @@ module ActiveSupport
         key.respond_to?(:to_param) ? key.to_param : key
       end
 
+      module Threadsafe
+        def self.extended(obj)
+          obj.init_threadsafe
+        end
+
+        def get(*)
+          @lock.synchronize do
+            super
+          end
+        end
+
+        def send(*)
+          @lock.synchronize do
+            super
+          end
+        end
+
+        def delete(*)
+          @lock.synchronize do
+            super
+          end
+        end
+
+        def incr(*)
+          @lock.synchronize do
+            super
+          end
+        end
+
+        def decr(*)
+          @lock.synchronize do
+            super
+          end
+        end
+
+        def stats(*)
+          @lock.synchronize do
+            super
+          end
+        end
+
+        def init_threadsafe
+          @lock = Monitor.new
+        end
+      end
     end
   end
 end