couchbase-jruby-client 0.1.0-java → 0.1.5-java

data/lib/couchbase/operations/store.rb

@@ -1,6 +1,31 @@
+# Author:: Mike Evans <mike@urlgonomics.com>
+# Copyright:: 2013 Urlgonomics LLC.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 module Couchbase::Operations
   module Store
 
+    STORE_OP_METHODS = {
+      set:     -> client, key, value, ttl, transcoder { client.set(key, ttl, value, transcoder) },
+      add:     -> client, key, value, ttl, transcoder { client.add(key, ttl, value, transcoder) },
+      replace: -> client, key, value, ttl, transcoder { client.replace(key, ttl, value, transcoder) },
+      append:  -> client, key, value, ttl, transcoder { client.append(key, value) },
+      prepend: -> client, key, value, ttl, transcoder { client.prepend(key, value) }
+    }.freeze
+
     # Unconditionally store the object in the Couchbase
     #
     # @since 1.0.0
@@ -94,17 +119,23 @@ module Couchbase::Operations
     #   @example Ensure that the key will be persisted at least on the one node
     #     c.set("foo", "bar", :observe => {:persisted => 1})
     #
-    def set(key, value = nil, options = {}, &block)
-      sync_block_error if !async? && block_given?
-      op, key, value, ttl = store_args_parser(key, value, options)
-
-      if op == :single
-        set_single(key, value, ttl, options, &block)
+    def set(key, value = nil, options = {})
+      if async?
+        if block_given?
+          async_set(key, value, options, &Proc.new)
+        else
+          async_set(key, value, options)
+        end
       else
-        set_multi(key)
+        sync_block_error if block_given?
+        store_op(:set, key, value, options)
       end
     end
 
+    def async_set(key, value, options, &block)
+      async_store_op(:set, key, value, options, &block)
+    end
+
     def []=(key, *args)
       options = args.size > 1 ? args.shift : {}
       value   = args.pop
@@ -161,17 +192,23 @@ module Couchbase::Operations
     #   @example Ensure that the key will be persisted at least on the one node
     #     c.add("foo", "bar", :observe => {:persisted => 1})
     #
-    def add(key, value = nil, options = {}, &block)
-      sync_block_error if !async? && block_given?
-      op, key, value, ttl = store_args_parser(key, value, options)
-
-      if op == :single
-        add_single(key, value, ttl, options, &block)
+    def add(key, value = nil, options = {})
+      if async?
+        if block_given?
+          async_add(key, value, options, &Proc.new)
+        else
+          async_add(key, value, options)
+        end
       else
-        add_multi(key)
+        sync_block_error if block_given?
+        store_op(:add, key, value, options)
       end
     end
 
+    def async_add(key, value, options, &block)
+      async_store_op(:add, key, value, options, &block)
+    end
+
     # Replace the existing object in the database
     #
     # @since 1.0.0
@@ -214,14 +251,22 @@ module Couchbase::Operations
     #     c.replace("foo", "bar", :observe => {:persisted => 1})
     #
     def replace(key, value, options = {})
-      sync_block_error if !async? && block_given?
-      if cas = java_replace(key, value, options[:ttl])
-        cas
+      if async?
+        if block_given?
+          async_replace(key, value, options, &Proc.new)
+        else
+          async_replace(key, value, options)
+        end
       else
-        raise Couchbase::Error::NotFound.new
+        sync_block_error if block_given?
+        store_op(:replace, key, value, options)
       end
     end
 
+    def async_replace(key, value, options, &block)
+      async_store_op(:replace, key, value, options, &block)
+    end
+
     # Append this object to the existing object
     #
     # @since 1.0.0
@@ -296,12 +341,8 @@ module Couchbase::Operations
     #     c.append("foo", "bar", :observe => {:persisted => 1})
     #
     def append(key, value)
-      sync_block_error if !async? && block_given?
-      if cas = java_append(validate_key(key), value)
-        cas
-      else
-        raise Couchbase::Error::NotFound.new
-      end
+      sync_block_error if block_given?
+      store_op(:append, key, value)
     end
 
     # Prepend this object to the existing object
@@ -356,111 +397,87 @@ module Couchbase::Operations
     #   @example Ensure that the key will be persisted at least on the one node
     #     c.prepend("foo", "bar", :observe => {:persisted => 1})
     #
-    def prepend(*args)
-      sync_block_error if !async? && block_given?
+    def prepend(key, value)
+      sync_block_error if block_given?
+      store_op(:prepend, key, value)
     end
 
     private
 
     def store_args_parser(key, value, options)
       key = key.to_str if key.respond_to?(:to_str)
-      ttl = options[:ttl] || default_ttl
-
-      op  = case key
-            when String, Symbol
-              :single
-            when Hash
-              raise TypeError.new if !value.nil?
-              :multi
-            else
-              raise TypeError.new
-            end
+      ttl = options.delete(:ttl) || default_ttl
+      transcoder = @transcoders[options.delete(:format)] || self.transcoder
 
-      [op, key, value, ttl]
+      [key, value, ttl, transcoder]
     end
 
-    def set_single(key, value, ttl, options = {}, &block)
-      if async?
-        java_async_set(key, value, ttl, &block)
+    def store_op(op, key, value, options = {})
+      key, value, ttl, transcoder = store_args_parser(key, value, options)
+
+      if key.is_a?(String) || key.is_a?(Symbol)
+        store_by_string(op, key.to_s, value, ttl, transcoder, options)
+      elsif key.is_a?(Hash)
+        store_by_hash(op, key, value)
       else
-        if options[:cas]
-          if java_set_cas(key, value, ttl, options[:cas])
-            get(key, extended: true)[2]
-          else
-            raise Couchbase::Error::KeyExists.new
-          end
-        else
-          if cas = java_set(key, value, ttl)
-            cas
-          else
-            raise Couchbase::Error::KeyExists.new
-          end
-        end
+        fail TypeError.new
       end
     end
 
-    def add_single(key, value, ttl, options = {})
-      if async?
-        java_async_set(key, value, ttl, &Proc.new)
+    def store_by_string(op, key, value, ttl, transcoder, options)
+      if options[:cas] && op == :set
+        client_cas(key, value, ttl, options[:cas], transcoder)
       else
-        if cas = java_add(key, value, ttl)
+        future = client_store_op(op, key, value, ttl, transcoder)
+        if cas = future_cas(future)
           cas
         else
-          raise Couchbase::Error::KeyExists.new
+          fail_store_op(op)
         end
       end
     end
 
-    # TODO:
-    def set_multi(keys)
-      {}.tap do |results|
-        keys.each_pair do |key, value|
-          results[key] = java_set(key, value, default_ttl)
-        end
-      end
+    def store_by_hash(op, key, value)
+      fail TypeError.new if !value.nil?
+      multi_op(op, key)
+    end
+
+    def async_store_op(op, key, value, options, &block)
+      key, value, ttl, transcoder = store_args_parser(key, value, options)
+      future = client_store_op(op, key, value, ttl, transcoder)
+      register_future(future, { op: op }, &block)
     end
 
-    def add_multi(keys)
+    def multi_op(op, keys)
       {}.tap do |results|
         keys.each_pair do |key, value|
-          results[key] = java_add(key, value, default_ttl)
+          results[key] = client.send(op, key, default_ttl, value)
         end
       end
     end
 
-    def java_set(key, value, ttl)
-      future = client.set(key.to_s, ttl, dump(value))
-      future_cas(future)
+    def client_store_op(op, key, value, ttl, transcoder)
+      STORE_OP_METHODS[op].call(self.client, key, value, ttl, transcoder)
     end
 
-    def java_add(key, value, ttl)
-      future = client.add(key.to_s, ttl, dump(value))
-      future_cas(future)
-    end
-
-    def java_replace(key, value, ttl)
-      future = if ttl.nil?
-                 client.replace(key.to_s, dump(value))
-               else
-                 client.replace(key.to_s, ttl, dump(value))
-               end
-
-      future_cas(future)
-    end
-
-    def java_append(key, value)
-      future = client.append(key.to_s, dump(value))
-      future_cas(future)
-    end
-
-    def java_set_cas(key, value, ttl, cas)
-      cas_response = client.cas(key.to_s, cas, ttl, dump(value))
-      cas_response.to_s == 'OK'
+    def client_cas(key, value, ttl, cas, transcoder)
+      cas_response = client.cas(key, cas, ttl, value, transcoder)
+      if cas_response.to_s == 'OK'
+        get(key, extended: true)[2]
+      else
+        raise Couchbase::Error::KeyExists.new
+      end
     end
 
-    def java_async_set(key, value, ttl, &block)
-      future = client.set(key.to_s, ttl, dump(value))
-      register_future(future, { op: :set }, &block)
+    def fail_store_op(op)
+      case op
+      when :replace
+        fail Couchbase::Error::NotFound
+      when :append, :prepend
+        fail Couchbase::Error::NotStored
+      else
+        fail Couchbase::Error::KeyExists
+      end
     end
 
   end

data/lib/couchbase/operations/touch.rb

@@ -1,3 +1,20 @@
+# Author:: Mike Evans <mike@urlgonomics.com>
+# Copyright:: 2013 Urlgonomics LLC.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 module Couchbase::Operations
   module Touch
 
@@ -64,22 +81,35 @@ module Couchbase::Operations
     #   @example Touch single value
     #     c.touch("foo" => 10)             #=> true
     #
-    def touch(*args, &block)
+    def touch(*args)
       sync_block_error if !async? && block_given?
-      key, options = expand_touch_args(args)
+      key, ttl, options = expand_touch_args(args)
 
-      if key.respond_to?(:to_hash)
-        multi_touch_hash(key, options)
-      elsif key.respond_to?(:to_ary)
-        multi_touch_array(key, options)
-      else
+      case key
+      when String, Symbol
         if async?
-          java_async_touch(key, options[:ttl], &block)
+          if block_given?
+            async_touch(key, ttl, &Proc.new)
+          else
+            async_touch(key, ttl)
+          end
         else
-          success = java_touch(key, options[:ttl])
+          success = client_touch(key, ttl)
           not_found_error(!success, options)
           success
         end
+      when Hash
+        multi_touch_hash(key, options)
+      when Array
+        multi_touch_array(key, options)
+      end
+    end
+
+    def async_touch(key, ttl)
+      if block_given?
+        register_future(client.touch(key, ttl), { op: :touch }, &Proc.new)
+      else
+        client.touch(key, ttl)
       end
     end
 
@@ -87,16 +117,20 @@ module Couchbase::Operations
 
     def expand_touch_args(args)
       options = extract_options_hash(args)
-      options[:ttl] ||= args.size > 1 ? args.pop : default_ttl
-      key = args.pop
+      ttl = options[:ttl] || if args.size > 1 && args.last.respond_to?(:to_int?)
+                               args.pop
+                             else
+                               default_ttl
+                             end
+      key = args.size > 1 ? args : args.pop
 
-      [key, options]
+      [key, ttl, options]
     end
 
     def multi_touch_hash(keys, options = {})
       {}.tap do |results|
         keys.each_pair do |key, ttl|
-          results[key] = java_touch(key, ttl)
+          results[key] = client_touch(key, ttl)
         end
       end
     end
@@ -106,18 +140,14 @@ module Couchbase::Operations
 
       {}.tap do |results|
         keys.each do |key|
-          results[key] = java_touch(key, ttl)
+          results[key] = client_touch(key, ttl)
         end
       end
     end
 
-    def java_touch(key, ttl, options = {})
+    def client_touch(key, ttl, options = {})
       client.touch(key, ttl).get
     end
 
-    def java_async_touch(key, ttl, &block)
-      register_future(client.touch(key, ttl), { op: :touch }, &block)
-    end
-
   end
 end

data/lib/couchbase/operations/unlock.rb

@@ -0,0 +1,209 @@
+# Author:: Mike Evans <mike@urlgonomics.com>
+# Copyright:: 2013 Urlgonomics LLC.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Couchbase::Operations
+  module Unlock
+
+    # Unlock key
+    #
+    # @since 1.2.0
+    #
+    # The +unlock+ method allow you to unlock key once locked by {Bucket#get}
+    # with +:lock+ option.
+    #
+    # @overload unlock(key, options = {})
+    #   @param key [String, Symbol] Key used to reference the value.
+    #   @param options [Hash] Options for operation.
+    #   @option options [Fixnum] :cas The CAS value must match the current one
+    #     from the storage.
+    #   @option options [true, false] :quiet (self.quiet) If set to +true+, the
+    #     operation won't raise error for missing key, it will return +nil+.
+    #
+    #   @return [true, false] +true+ if the operation was successful and +false+
+    #     otherwise.
+    #
+    #   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+    #
+    #   @raise [ArgumentError] when passing the block in synchronous mode
+    #
+    #   @raise [Couchbase::Error::NotFound] if key(s) not found in the storage
+    #
+    #   @raise [Couchbase::Error::TemporaryFail] if either the key wasn't
+    #      locked or given CAS value doesn't match to actual in the storage
+    #
+    #   @example Unlock the single key
+    #     val, _, cas = c.get("foo", :lock => true, :extended => true)
+    #     c.unlock("foo", :cas => cas)
+    #
+    # @overload unlock(keys)
+    #   @param keys [Hash] The Hash where keys represent the keys in the
+    #     database, values -- the CAS for corresponding key.
+    #
+    #   @yieldparam ret [Result] the result of operation for each key in
+    #     asynchronous mode (valid attributes: +error+, +operation+, +key+).
+    #
+    #   @return [Hash] Mapping keys to result of unlock operation (+true+ if the
+    #     operation was successful and +false+ otherwise)
+    #
+    #   @example Unlock several keys
+    #     c.unlock("foo" => cas1, :bar => cas2) #=> {"foo" => true, "bar" => true}
+    #
+    #   @example Unlock several values in async mode
+    #     c.run do
+    #       c.unlock("foo" => 10, :bar => 20) do |ret|
+    #          ret.operation   #=> :unlock
+    #          ret.success?    #=> true
+    #          ret.key         #=> "foo" and "bar" in separate calls
+    #       end
+    #     end
+    #
+
+    def unlock(key, options = {})
+      cas = options.respond_to?(:to_hash) ? options[:cas] : options
+      if client.unlock(key.to_s, cas)
+        true
+      else
+        raise Couchbase::Error::TemporaryFail.new
+      end
+    end
+
+    def async_unlock(key, options = {})
+
+    end
+
+  end
+end
+
+__END__
+
+/*
+ * Unlock key
+ *
+ * @since 1.2.0
+ *
+ * The +unlock+ method allow you to unlock key once locked by {Bucket#get}
+ * with +:lock+ option.
+ *
+ * @overload unlock(key, options = {})
+ *   @param key [String, Symbol] Key used to reference the value.
+ *   @param options [Hash] Options for operation.
+ *   @option options [Fixnum] :cas The CAS value must match the current one
+ *     from the storage.
+ *   @option options [true, false] :quiet (self.quiet) If set to +true+, the
+ *     operation won't raise error for missing key, it will return +nil+.
+ *
+ *   @return [true, false] +true+ if the operation was successful and +false+
+ *     otherwise.
+ *
+ *   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+ *
+ *   @raise [ArgumentError] when passing the block in synchronous mode
+ *
+ *   @raise [Couchbase::Error::NotFound] if key(s) not found in the storage
+ *
+ *   @raise [Couchbase::Error::TemporaryFail] if either the key wasn't
+ *      locked or given CAS value doesn't match to actual in the storage
+ *
+ *   @example Unlock the single key
+ *     val, _, cas = c.get("foo", :lock => true, :extended => true)
+ *     c.unlock("foo", :cas => cas)
+ *
+ * @overload unlock(keys)
+ *   @param keys [Hash] The Hash where keys represent the keys in the
+ *     database, values -- the CAS for corresponding key.
+ *
+ *   @yieldparam ret [Result] the result of operation for each key in
+ *     asynchronous mode (valid attributes: +error+, +operation+, +key+).
+ *
+ *   @return [Hash] Mapping keys to result of unlock operation (+true+ if the
+ *     operation was successful and +false+ otherwise)
+ *
+ *   @example Unlock several keys
+ *     c.unlock("foo" => cas1, :bar => cas2) #=> {"foo" => true, "bar" => true}
+ *
+ *   @example Unlock several values in async mode
+ *     c.run do
+ *       c.unlock("foo" => 10, :bar => 20) do |ret|
+ *          ret.operation   #=> :unlock
+ *          ret.success?    #=> true
+ *          ret.key         #=> "foo" and "bar" in separate calls
+ *       end
+ *     end
+ *
+ */
+   VALUE
+cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
+{
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
+    VALUE rv, proc, exc;
+    lcb_error_t err;
+    struct cb_params_st params;
+
+    if (!cb_bucket_connected_bang(bucket, cb_sym_unlock)) {
+        return Qnil;
+    }
+
+    memset(&params, 0, sizeof(struct cb_params_st));
+    rb_scan_args(argc, argv, "0*&", &params.args, &proc);
+    if (!bucket->async && proc != Qnil) {
+        rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
+    }
+    rb_funcall(params.args, cb_id_flatten_bang, 0);
+    params.type = cb_cmd_unlock;
+    params.bucket = bucket;
+    cb_params_build(&params);
+    ctx = cb_context_alloc_common(bucket, proc, params.cmd.unlock.num);
+    ctx->quiet = params.cmd.unlock.quiet;
+    err = lcb_unlock(bucket->handle, (const void *)ctx,
+            params.cmd.unlock.num, params.cmd.unlock.ptr);
+    cb_params_destroy(&params);
+    exc = cb_check_error(err, "failed to schedule unlock request", Qnil);
+    if (exc != Qnil) {
+        cb_context_free(ctx);
+        rb_exc_raise(exc);
+    }
+    bucket->nbytes += params.npayload;
+    if (bucket->async) {
+        cb_maybe_do_loop(bucket);
+        return Qnil;
+    } else {
+        if (ctx->nqueries > 0) {
+            /* we have some operations pending */
+            lcb_wait(bucket->handle);
+        }
+        exc = ctx->exception;
+        rv = ctx->rv;
+        cb_context_free(ctx);
+        if (exc != Qnil) {
+            rb_exc_raise(exc);
+        }
+        exc = bucket->exception;
+        if (exc != Qnil) {
+            bucket->exception = Qnil;
+            rb_exc_raise(exc);
+        }
+        if (params.cmd.unlock.num > 1) {
+            return rv;  /* return as a hash {key => true, ...} */
+        } else {
+            VALUE vv = Qnil;
+            rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
+            return vv;
+        }
+    }
+}
+

data/lib/couchbase/operations/utils.rb

@@ -1,3 +1,20 @@
+# Author:: Mike Evans <mike@urlgonomics.com>
+# Copyright:: 2013 Urlgonomics LLC.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 module Couchbase::Operations
   module Utils
 
@@ -26,23 +43,18 @@ module Couchbase::Operations
     def not_found_error(error, options = {})
       if error
         if options.key?(:quiet)
-          raise Error::NotFound.new if !options[:quiet]
+          raise Couchbase::Error::NotFound.new if !options[:quiet]
         elsif !quiet?
-          raise Error::NotFound.new
+          raise Couchbase::Error::NotFound.new
         end
       end
     end
 
     def future_cas(future)
       future.get && future.getCas
-    end
-
-    def dump(obj)
-      transcoder.dump(obj)
-    end
-
-    def load(blob)
-      transcoder.load(blob)
+    rescue Java::JavaLang::UnsupportedOperationException
+      # TODO: don't return fake cas
+      1
     end
 
   end