couchbase-jruby-client 0.1.0-java

data/lib/couchbase/cluster.rb

@@ -0,0 +1,105 @@
+# 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 Cluster
+
+    # Establish connection to the cluster for administration
+    #
+    # @param [Hash] options The connection parameter
+    # @option options [String] :username The username
+    # @option options [String] :password The password
+    # @option options [String] :pool ("default") The pool name
+    # @option options [String] :hostname ("localhost") The hostname
+    # @option options [String] :port (8091) The port
+    def initialize(options = {})
+      if options[:username].nil? || options[:password].nil?
+        raise ArgumentError, "username and password mandatory to connect to the cluster"
+      end
+      @connection = Bucket.new(options.merge(:type => :cluster))
+    end
+
+    # Create data bucket
+    #
+    # @param [String] name The name of the bucket
+    # @param [Hash] options The bucket parameters
+    # @option options [String] :bucket_type ("couchbase") The type of the
+    #   bucket. Possible values are "memcached" and "couchbase".
+    # @option options [Fixnum] :ram_quota (100) The RAM quota in megabytes.
+    # @option options [Fixnum] :replica_number (1) The number of replicas of
+    #   each document
+    # @option options [String] :auth_type ("sasl") The authentication type.
+    #   Possible values are "sasl" and "none". Note you should specify free
+    #   port for "none"
+    # @option options [Fixnum] :proxy_port The port for moxi
+    def create_bucket(name, options = {})
+      defaults = {
+        :type => "couchbase",
+        :ram_quota => 100,
+        :replica_number => 1,
+        :auth_type => "sasl",
+        :sasl_password => "",
+        :proxy_port => nil
+      }
+      options = defaults.merge(options)
+      params = {"name" => name}
+      params["bucketType"] = options[:type]
+      params["ramQuotaMB"] = options[:ram_quota]
+      params["replicaNumber"] = options[:replica_number]
+      params["authType"] = options[:auth_type]
+      params["saslPassword"] = options[:sasl_password]
+      params["proxyPort"] = options[:proxy_port]
+      payload = Utils.encode_params(params.reject!{|k, v| v.nil?})
+      request = @connection.make_http_request("/pools/default/buckets",
+                                              :content_type => "application/x-www-form-urlencoded",
+                                              :type => :management,
+                                              :method => :post,
+                                              :extended => true,
+                                              :body => payload)
+      response = nil
+      request.on_body do |r|
+        response = r
+        response.instance_variable_set("@operation", :create_bucket)
+        yield(response) if block_given?
+      end
+      request.continue
+      response
+    end
+
+    # Delete the data bucket
+    #
+    # @param [String] name The name of the bucket
+    # @param [Hash] options
+    def delete_bucket(name, options = {})
+      request = @connection.make_http_request("/pools/default/buckets/#{name}",
+                                              :type => :management,
+                                              :method => :delete,
+                                              :extended => true)
+      response = nil
+      request.on_body do |r|
+        response = r
+        response.instance_variable_set("@operation", :delete_bucket)
+        yield(response) if block_given?
+      end
+      request.continue
+      response
+    end
+
+  end
+
+end

data/lib/couchbase/constants.rb

@@ -0,0 +1,12 @@
+module Couchbase
+  module Constants # :nodoc:
+    S_ID = 'id'.freeze
+    S_DOC = 'doc'.freeze
+    S_VALUE = 'value'.freeze
+    S_META = 'meta'.freeze
+    S_FLAGS = 'flags'.freeze
+    S_CAS = 'cas'.freeze
+    S_KEY = 'key'.freeze
+    S_IS_LAST = Object.new.freeze
+  end
+end

data/lib/couchbase/error.rb

@@ -0,0 +1,28 @@
+
+module Couchbase
+  module Error
+    class Base < Exception
+    end
+
+    class Connect < Base
+    end
+
+    class Auth < Base
+    end
+
+    class Connect < Base
+    end
+
+    class NotFound < Base
+    end
+
+    class Invalid < Base
+    end
+
+    class KeyExists < Base
+    end
+
+    class ValueFormat < Base
+    end
+  end
+end

data/lib/couchbase/jruby/couchbase_client.rb

@@ -0,0 +1,22 @@
+module Couchbase
+  module Jruby
+    class CouchbaseClient < Java::ComCouchbaseClient::CouchbaseClient
+
+      # Futures
+      %w(add set append asyncCAS asyncDecr asyncGet asyncGetAndTouch asyncGetBulk
+        asyncGets asyncIncr delete flush prepend replace set touch).each do |op|
+        define_method(op) do |*|
+          super
+        end
+      end
+
+      def get(*)
+        super
+      end
+
+      VALUE_OPS = %w(
+
+      ).freeze
+    end
+  end
+end

data/lib/couchbase/jruby/future.rb

@@ -0,0 +1,8 @@
+module Couchbase
+  module Jruby
+    module Future
+
+
+    end
+  end
+end

data/lib/couchbase/operations/arithmetic.rb

@@ -0,0 +1,301 @@
+module Couchbase::Operations
+  module Arithmetic
+
+    # Increment the value of an existing numeric key
+    #
+    # @since 1.0.0
+    #
+    # The increment methods allow you to increase a given stored integer
+    # value. These are the incremental equivalent of the decrement operations
+    # and work on the same basis; updating the value of a key if it can be
+    # parsed to an integer. The update operation occurs on the server and is
+    # provided at the protocol level. This simplifies what would otherwise be a
+    # two-stage get and set operation.
+    #
+    # @note that server values stored and transmitted as unsigned numbers,
+    #   therefore if you try to store negative number and then increment or
+    #   decrement it will cause overflow. (see "Integer overflow" example
+    #   below)
+    #
+    # @overload incr(key, delta = 1, options = {})
+    #   @param key [String, Symbol] Key used to reference the value.
+    #   @param delta [Fixnum] Integer (up to 64 bits) value to increment
+    #   @param options [Hash] Options for operation.
+    #   @option options [true, false] :create (false) If set to +true+, it will
+    #     initialize the key with zero value and zero flags (use +:initial+
+    #     option to set another initial value). Note: it won't increment the
+    #     missing value.
+    #   @option options [Fixnum] :initial (0) Integer (up to 64 bits) value for
+    #     missing key initialization. This option imply +:create+ option is
+    #     +true+.
+    #   @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). This option ignored for existent
+    #     keys.
+    #   @option options [true, false] :extended (false) If set to +true+, the
+    #     operation will return tuple +[value, cas]+, otherwise (by default) it
+    #     returns just value.
+    #
+    #   @yieldparam ret [Result] the result of operation in asynchronous mode
+    #     (valid attributes: +error+, +operation+, +key+, +value+, +cas+).
+    #
+    #   @return [Fixnum] the actual value of the key.
+    #
+    #   @raise [Couchbase::Error::NotFound] if key is missing and +:create+
+    #     option isn't +true+.
+    #
+    #   @raise [Couchbase::Error::DeltaBadval] if the key contains non-numeric
+    #     value
+    #
+    #   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+    #
+    #   @raise [ArgumentError] when passing the block in synchronous mode
+    #
+    #   @example Increment key by one
+    #     c.incr("foo")
+    #
+    #   @example Increment key by 50
+    #     c.incr("foo", 50)
+    #
+    #   @example Increment key by one <b>OR</b> initialize with zero
+    #     c.incr("foo", :create => true)   #=> will return old+1 or 0
+    #
+    #   @example Increment key by one <b>OR</b> initialize with three
+    #     c.incr("foo", 50, :initial => 3) #=> will return old+50 or 3
+    #
+    #   @example Increment key and get its CAS value
+    #     val, cas = c.incr("foo", :extended => true)
+    #
+    #   @example Integer overflow
+    #     c.set("foo", -100)
+    #     c.get("foo")           #=> -100
+    #     c.incr("foo")          #=> 18446744073709551517
+    #
+    #   @example Asynchronous invocation
+    #     c.run do
+    #       c.incr("foo") do |ret|
+    #         ret.operation   #=> :increment
+    #         ret.success?    #=> true
+    #         ret.key         #=> "foo"
+    #         ret.value
+    #         ret.cas
+    #       end
+    #     end
+    #
+    def incr(*args)
+      sync_block_error if !async? && block_given?
+      do_arithmetic(:incr, *args)
+    end
+    alias_method :increment, :incr
+
+    # Decrement the value of an existing numeric key
+    #
+    # @since 1.0.0
+    #
+    # The decrement methods reduce the value of a given key if the
+    # corresponding value can be parsed to an integer value. These operations
+    # are provided at a protocol level to eliminate the need to get, update,
+    # and reset a simple integer value in the database. It supports the use of
+    # an explicit offset value that will be used to reduce the stored value in
+    # the database.
+    #
+    # @note that server values stored and transmitted as unsigned numbers,
+    #   therefore if you try to decrement negative or zero key, you will always
+    #   get zero.
+    #
+    # @overload decr(key, delta = 1, options = {})
+    #   @param key [String, Symbol] Key used to reference the value.
+    #   @param delta [Fixnum] Integer (up to 64 bits) value to decrement
+    #   @param options [Hash] Options for operation.
+    #   @option options [true, false] :create (false) If set to +true+, it will
+    #     initialize the key with zero value and zero flags (use +:initial+
+    #     option to set another initial value). Note: it won't decrement the
+    #     missing value.
+    #   @option options [Fixnum] :initial (0) Integer (up to 64 bits) value for
+    #     missing key initialization. This option imply +:create+ option is
+    #     +true+.
+    #   @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). This option ignored for existent
+    #     keys.
+    #   @option options [true, false] :extended (false) If set to +true+, the
+    #     operation will return tuple +[value, cas]+, otherwise (by default) it
+    #     returns just value.
+    #
+    #   @yieldparam ret [Result] the result of operation in asynchronous mode
+    #     (valid attributes: +error+, +operation+, +key+, +value+, +cas+).
+    #
+    #   @return [Fixnum] the actual value of the key.
+    #
+    #   @raise [Couchbase::Error::NotFound] if key is missing and +:create+
+    #     option isn't +true+.
+    #
+    #   @raise [Couchbase::Error::DeltaBadval] if the key contains non-numeric
+    #     value
+    #
+    #   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+    #
+    #   @raise [ArgumentError] when passing the block in synchronous mode
+    #
+    #   @example Decrement key by one
+    #     c.decr("foo")
+    #
+    #   @example Decrement key by 50
+    #     c.decr("foo", 50)
+    #
+    #   @example Decrement key by one <b>OR</b> initialize with zero
+    #     c.decr("foo", :create => true)   #=> will return old-1 or 0
+    #
+    #   @example Decrement key by one <b>OR</b> initialize with three
+    #     c.decr("foo", 50, :initial => 3) #=> will return old-50 or 3
+    #
+    #   @example Decrement key and get its CAS value
+    #     val, cas = c.decr("foo", :extended => true)
+    #
+    #   @example Decrementing zero
+    #     c.set("foo", 0)
+    #     c.decrement("foo", 100500)   #=> 0
+    #
+    #   @example Decrementing negative value
+    #     c.set("foo", -100)
+    #     c.decrement("foo", 100500)   #=> 0
+    #
+    #   @example Asynchronous invocation
+    #     c.run do
+    #       c.decr("foo") do |ret|
+    #         ret.operation   #=> :decrement
+    #         ret.success?    #=> true
+    #         ret.key         #=> "foo"
+    #         ret.value
+    #         ret.cas
+    #       end
+    #     end
+    #
+    def decr(*args)
+      sync_block_error if !async? && block_given?
+      do_arithmetic(:decr, *args)
+    end
+    alias_method :decrement, :decr
+
+    private
+
+    def do_arithmetic(op, *args)
+      key, delta, options = expand_arithmetic_args(args)
+
+      case key
+      when String, Symbol
+        single_arithmetic(op, key, delta, options)
+      when Array, Hash
+        multi_arithmetic(op, key, delta)
+      else
+        raise # something
+      end
+    end
+
+    def expand_arithmetic_args(args)
+      options = if args.size > 1 && args.last.respond_to?(:to_h)
+                  args.pop
+                else
+                  {}
+                end
+
+      delta   = if args.size > 1 && args.last.respond_to?(:to_int)
+                  args.pop
+                else
+                  options[:delta] || 1
+                end
+
+      key = args.size == 1 ? args.first : args
+
+      [key, delta, options]
+    end
+
+    def single_arithmetic(op, key, delta, options = {})
+      if async?
+        java_async_arithmetic(op, key, delta)
+      else
+        result = java_arithmetic(op, key, delta)
+        set_default_arithmetic_or_raise(key, result, options)
+      end
+    end
+
+    def set_default_arithmetic_or_raise(key, result, options)
+      if result < 0
+        if options[:initial] || options[:create] || set_default_arithmetic_init?
+          value = if options[:initial]
+                    options[:initial]
+                  elsif options[:create]
+                    0
+                  else
+                    default_arithmetic_init_int
+                  end
+
+          set(key, value, options) && value
+        else
+          not_found_error(true)
+        end
+      else
+        result
+      end
+    end
+
+    def set_default_arithmetic_init?
+      default_arithmetic_init == true ||
+        default_arithmetic_init.respond_to?(:to_int) &&
+          default_arithmetic_init > 0
+    end
+
+    def default_arithmetic_init_int
+      default_arithmetic_init == true ? 0 : default_arithmetic_init
+    end
+
+    def multi_arithmetic(op, keys, delta)
+      {}.tap do |results|
+        if keys.respond_to?(:each_pair)
+          keys.each_pair do |k, v|
+            results[k] = single_arithmetic(op, k, v)
+          end
+        else
+          keys.each do |k|
+            results[k] = single_arithmetic(op, k, delta)
+          end
+        end
+      end
+    end
+
+    def java_arithmetic(op, key, delta)
+      case op
+      when :incr
+        java_incr(key, delta)
+      when :decr
+        java_decr(key, delta)
+      end
+    end
+
+    def java_async_arithmetic(op, key, delta)
+      case op
+      when :incr
+        java_async_incr(key, delta)
+      when :decr
+        java_async_decr(key, delta)
+      end
+    end
+
+    def java_incr(key, delta)
+      client.incr(key, delta)
+    end
+
+    def java_async_incr(key, delta)
+      client.asyncIncr(key, delta)
+    end
+
+    def java_decr(key, delta)
+      client.decr(key, delta)
+    end
+
+    def java_async_decr(key, delta)
+      client.asyncDecr(key, delta)
+    end
+
+  end
+end

data/lib/couchbase/operations/delete.rb

@@ -0,0 +1,104 @@
+module Couchbase::Operations
+  module Delete
+
+    # Delete the specified key
+    #
+    # @since 1.0.0
+    #
+    # @overload delete(key, options = {})
+    #   @param key [String, Symbol] Key used to reference the value.
+    #   @param options [Hash] Options for operation.
+    #   @option options [true, false] :quiet (self.quiet) If set to +true+, the
+    #     operation won't raise error for missing key, it will return +nil+.
+    #     Otherwise it will raise error in synchronous mode. In asynchronous
+    #     mode this option ignored.
+    #   @option options [Fixnum] :cas The CAS value for an object. This value
+    #     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/delete an item simultaneously.
+    #
+    #   @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
+    #   @raise [ArgumentError] when passing the block in synchronous mode
+    #   @raise [Couchbase::Error::KeyExists] on CAS mismatch
+    #   @raise [Couchbase::Error::NotFound] if key is missing in verbose mode
+    #
+    #   @return [true, false, Hash<String, Boolean>] the result of the
+    #     operation
+    #
+    #   @example Delete the key in quiet mode (default)
+    #     c.set("foo", "bar")
+    #     c.delete("foo")        #=> true
+    #     c.delete("foo")        #=> false
+    #
+    #   @example Delete the key verbosely
+    #     c.set("foo", "bar")
+    #     c.delete("foo", :quiet => false)   #=> true
+    #     c.delete("foo", :quiet => true)    #=> nil (default behaviour)
+    #     c.delete("foo", :quiet => false)   #=> will raise Couchbase::Error::NotFound
+    #
+    #   @example Delete the key with version check
+    #     ver = c.set("foo", "bar")          #=> 5992859822302167040
+    #     c.delete("foo", :cas => 123456)    #=> will raise Couchbase::Error::KeyExists
+    #     c.delete("foo", :cas => ver)       #=> true
+    #
+    def delete(*args, &block)
+      sync_block_error if !async? && block_given?
+      key, options = expand_get_args(args)
+      key, cas     = delete_args_parser(key)
+
+      if key.respond_to?(:to_ary)
+        delete_multi(key, options)
+      else
+        delete_single(key, cas, options, &block)
+      end
+    end
+
+    private
+
+    def delete_args_parser(args)
+      if args.respond_to?(:to_str)
+        [args, nil]
+      else
+        cas = if args.size > 1 &&
+                 args.last.respond_to?(:to_int)
+                args.pop
+              else
+                nil
+              end
+
+        key = args.size == 1 ? args.first : args
+
+        [key, cas]
+      end
+    end
+
+    def delete_single(key, cas, options, &block)
+      if async?
+        java_async_delete(key, &block)
+      else
+        cas = java_delete(key)
+        not_found_error(!cas, options)
+        cas
+      end
+    end
+
+    def delete_multi(keys, options = {})
+      {}.tap do |results|
+        keys.each do |key|
+          results[key] = delete_single(key, nil, options)
+        end
+      end
+    end
+
+    def java_delete(key)
+      future = client.delete(key)
+      future_cas(future)
+    end
+
+    def java_async_delete(key, &block)
+      future = client.delete(key)
+      register_future(future, { op: :delete }, &block)
+    end
+  end
+end