couchbase-jruby-client 0.1.1

data/lib/couchbase/operations/unlock.rb

@@ -0,0 +1,192 @@
+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

@@ -0,0 +1,44 @@
+module Couchbase::Operations
+  module Utils
+
+    private
+
+    def validate_key(key)
+      if key_prefix
+        "#{key_prefix}key"
+      else
+        key.to_s
+      end
+    end
+
+    def extract_options_hash(args)
+      if args.size > 1 && args.last.respond_to?(:to_hash)
+        args.pop
+      else
+        {}
+      end
+    end
+
+    def sync_block_error
+      raise ArgumentError, "synchronous mode doesn't support callbacks"
+    end
+
+    def not_found_error(error, options = {})
+      if error
+        if options.key?(:quiet)
+          raise Couchbase::Error::NotFound.new if !options[:quiet]
+        elsif !quiet?
+          raise Couchbase::Error::NotFound.new
+        end
+      end
+    end
+
+    def future_cas(future)
+      future.get && future.getCas
+    rescue Java::JavaLang::UnsupportedOperationException
+      # TODO: don't return fake cas
+      1
+    end
+
+  end
+end

data/lib/couchbase/operations.rb

@@ -0,0 +1,27 @@
+require 'couchbase/operations/touch'
+require 'couchbase/operations/store'
+require 'couchbase/operations/get'
+require 'couchbase/operations/delete'
+require 'couchbase/operations/unlock'
+require 'couchbase/operations/arithmetic'
+require 'couchbase/operations/stats'
+require 'couchbase/operations/design_docs'
+require 'couchbase/operations/utils'
+
+module Couchbase
+  module Operations
+
+    def self.included(klass)
+      klass.send(:include, Store)
+      klass.send(:include, Get)
+      klass.send(:include, Touch)
+      klass.send(:include, Delete)
+      klass.send(:include, Unlock)
+      klass.send(:include, Arithmetic)
+      klass.send(:include, Stats)
+      klass.send(:include, DesignDocs)
+      klass.send(:include, Utils)
+    end
+  end
+end
+

data/lib/couchbase/query.rb

@@ -0,0 +1,73 @@
+module Couchbase
+  class Query
+
+    java_import com.couchbase.client.protocol.views.Stale
+
+    METHOD_MAPPING = {
+      :include_docs       => :setIncludeDocs,
+      :descending         => :setDescending,
+      :key                => :setKey,
+      :keys               => :setKeys,
+      :start_key          => :setRangeStart,
+      :startkey           => :setRangeStart,
+      :startkey_docid     => :setStartkeyDocID,
+      :endkey             => :setRangeEnd,
+      :endkey_docid       => :setEndkeyDocID,
+      :inclusive_end      => :setInclusiveEnd,
+      :limit              => :setLimit,
+      :skip               => :setSkip,
+      :reduce             => :setReduce,
+      :group              => :setGroup,
+      :group_level        => :setGroupLevel,
+      :connection_timeout => nil
+    }.freeze
+
+    def initialize(params)
+      @params = params
+    end
+
+    def generate
+      query = Java::ComCouchbaseClientProtocolViews::Query.new
+
+      if stale = @params.delete(:stale)
+        case stale
+        when :after_update
+          query.setStale(Stale::UPDATE_AFTER)
+        when :ok
+          query.setStale(Stale::OK)
+        when false
+          query.setStale(Stale::FALSE)
+        end
+      end
+
+      @params.each_pair do |meth, val|
+        if METHOD_MAPPING.key?(meth)
+          if java_meth = METHOD_MAPPING[meth]
+            query.send(java_meth, val)
+          end
+        else
+          fail ArgumentError, "Query does not support #{meth}"
+        end
+      end
+
+      
+    # @option params [true, false] :quiet (true) Do not raise error if
+    #   associated document not found in the memory. If the parameter +true+
+    #   will use +nil+ value instead.
+    # @option params [String, Symbol] :on_error (:continue) Sets the
+    #   response in the event of an error. Supported values:
+    #   :continue:: Continue to generate view information in the event of an
+    #               error, including the error information in the view
+    #               response stream.
+    #   :stop::     Stop immediately when an error condition occurs. No
+    #               further view information will be returned.
+    # @option params [Fixnum] :connection_timeout (75000) Timeout before the
+    #   view request is dropped (milliseconds)
+
+
+    # @option params [Hash] :body 
+      query
+    end
+
+  end
+end

data/lib/couchbase/result.rb

@@ -0,0 +1,43 @@
+module Couchbase
+  class Result
+
+    attr_accessor :error
+
+    def initialize(attrs = {})
+      @bucket    = attrs[:bucket]
+      @key       = attrs[:key]
+      @operation = attrs[:op]
+      @future    = attrs[:future]
+    end
+
+    def operation
+      @operation
+    end
+
+    def success?
+      @future.get
+    end
+
+    def error
+      @error
+    end
+
+    def key
+      @key || @future.getKey
+    end
+
+    def value
+      @future.get
+    rescue MultiJson::LoadError
+      nil
+    end
+
+    def cas
+      @future.getCas if @future.respond_to?(:getCas)
+    end
+
+    def node
+
+    end
+  end
+end

data/lib/couchbase/transcoder.rb

@@ -0,0 +1,77 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2013 Couchbase, Inc.
+# 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.
+#
+
+require 'multi_json'
+
+module Couchbase
+
+  module Transcoder
+
+    class Base < Java::NetSpyMemcachedTranscoders::SerializingTranscoder
+    end
+
+    class Document < Base
+
+      def decode(d)
+        data = case decoded = super
+               when String
+                 decoded
+               else
+                 decoded.getData.to_s
+               end
+
+        MultiJson.load(data)
+      rescue MultiJson::LoadError
+        ::Marshal.load(data)
+      end
+
+      def encode(o)
+        super MultiJson.dump(o)
+      rescue ArgumentError => e
+        ex = Couchbase::Error::ValueFormat.new
+        ex.inner_exception = e
+        fail ex
+      end
+    end
+
+    class Marshal < Base
+
+      def decode(d)
+        ::Marshal.load super.getData.to_s
+      end
+
+      def encode(o)
+        super ::Marshal.dump(o)
+      end
+    end
+
+    class Plain < Base
+
+      def decode(d)
+        super
+      end
+
+      def encode(o)
+        super(o.to_str)
+      rescue NoMethodError
+        raise Couchbase::Error::ValueFormat
+      end
+    end
+
+  end
+
+end

data/lib/couchbase/utils.rb

@@ -0,0 +1,62 @@
+# Author:: Couchbase <info@couchbase.com>
+# Copyright:: 2011-2012 Couchbase, Inc.
+# 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
+
+  class Utils
+
+    def self.encode_params(params)
+      params.map do |k, v|
+        next if !v && k.to_s == "group"
+        if %w{key keys startkey endkey start_key end_key}.include?(k.to_s)
+          v = MultiJson.dump(v)
+        end
+        if v.class == Array
+          build_query(v.map { |x| [k, x] })
+        else
+          "#{escape(k)}=#{escape(v)}"
+        end
+      end.compact.join("&")
+    end
+
+    def self.build_query(uri, params = nil)
+      uri = uri.dup
+      return uri if params.nil? || params.empty?
+      uri << "?" << encode_params(params)
+    end
+
+    def self.escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/nu) {
+        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+      }.tr(' ', '+')
+    end
+
+    # Return the bytesize of String; uses String#size under Ruby 1.8 and
+    # String#bytesize under 1.9.
+    if ''.respond_to?(:bytesize)
+      def self.bytesize(string)
+        string.bytesize
+      end
+    else
+      def self.bytesize(string)
+        string.size
+      end
+    end
+
+  end
+
+end

data/lib/couchbase/version.rb

@@ -0,0 +1,3 @@
+module Couchbase
+  VERSION = '0.1.1'
+end