couchbase-jruby-client 0.1.7-java → 0.1.8-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7e0d408c5e5e7be7aef116504c626b47e3370ca
-  data.tar.gz: 449cc0459b4cca48176034faebc9b1164a8bb7d5
+  metadata.gz: 1c0ea141997ee6f37bc481a1c7eb4d62448440b5
+  data.tar.gz: 218d1e6e80321f9a7a6efc229fca2d8e0d2e4e76
 SHA512:
-  metadata.gz: 631922413e409bad9ebd705a3e08baed7715a697e8426db07c14c86c270f95c4b81b1350e67d2b963569f8fbbb5feefd3dcc3effd1d4eedae56200dc0a760a46
-  data.tar.gz: 86070762df8a647c3968192aeea98a9e5b3703f958d250d1b926be15240a62b8823769974ffd69ba51aaf3e5ce464071a72c4136c35dc5aa28137a3a68bb5a77
+  metadata.gz: 661cc5eec9882f541ad4441a20e9af2c4d92422a388b9dab2e6d1917d074ab47623a2e84beda34ed5f7bed1f775d0227bbc769d5dc3e910c33f2ecd1882c38e3
+  data.tar.gz: 35dadabf6e5238f9926c7b6ff52357253f3d8ccccc68026c89c6a70fabe0c30d6ec9d2ce5ab88183b344d9238164321b4cb60c6cfc93b4e8ce26d1be6ae9196e

data/.gitignore

@@ -15,3 +15,6 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+test/CouchbaseMock.jar
+Vagrantfile
+.vagrant

data/.ruby-version

@@ -1 +1 @@
-jruby-1.7.6
+jruby-1.7.9

data/.travis.yml

@@ -1,11 +1,3 @@
-before_install:
-  # Couchbase Server
-  - sudo service memcached stop
-  - sudo wget http://packages.couchbase.com/releases/2.2.0/couchbase-server-enterprise_2.2.0_x86.deb
-  - sudo dpkg -i couchbase-server-enterprise_2.2.0_x86.deb
-  - sudo service couchbase-server start
-  - /opt/couchbase/bin/couchbase-cli cluster-init -c localhost --cluster-init-username=admin --cluster-init-password=password --cluster-init-ramsize=256
-  - /opt/couchbase/bin/couchbase-cli bucket-create -c localhost --bucket=default --bucket-type=couchbase --bucket-ramsize=256 -u admin -p password
 notifications:
   email:
     - mike@urlgonomics.com

data/Rakefile

@@ -1,10 +1,6 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
+Dir['tasks/*.rake'].sort.each { |f| load f }
 
-task :default => :test
+task :default => :test

data/lib/couchbase/async/callback.rb

@@ -1,14 +1,33 @@
+# 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
   module Async
     class Callback
       include Java::NetSpyMemcachedInternal::OperationCompletionListener
+      include Java::NetSpyMemcachedInternal::GetCompletionListener
 
-      def initialize(operation, &callback)
-        @operation, @callback = operation, callback
+      def initialize(params, &callback)
+        @params   = params
+        @callback = callback
       end
 
       def onComplete(future)
-        result = Couchbase::Result.new(operation: @operation, future: future)
+        result = Couchbase::Result.new(@params.merge(future: future))
         @callback.call(result)
       rescue Exception => e
         result.error = e

data/lib/couchbase/async.rb

@@ -21,137 +21,12 @@ require 'couchbase/async/queue'
 module Couchbase
   module Async
 
-    def async?
-      !!async
-    end
-
-    def async
-      Thread.current[:bucket_async] ||= @async
-    end
-
-    def async=(val)
-      Thread.current[:bucket_async] = val
-    end
-
-    def running?
-      !!running
-    end
-
-    def running
-      Thread.current[:bucket_running] ||= false
-    end
-
-    def running=(val)
-      Thread.current[:bucket_running] = val
-    end
-
-    def async_queue
-      Thread.current[:bucket_async_queue] ||= Couchbase::Async::Queue.new(self)
-    end
-
-    def end_async_queue
-      Thread.current[:bucket_async_queue] = nil
-    end
-
-    public
-
-    # Run the event loop.
-    #
-    # @since 1.0.0
-    #
-    # @param [Hash] options The options for operation for connection
-    # @option options [Fixnum] :send_threshold (0) if the internal command
-    #   buffer will exceeds this value, then the library will start network
-    #   interaction and block the current thread until all scheduled commands
-    #   will be completed.
-    #
-    # @yieldparam [Bucket] bucket the bucket instance
-    #
-    # @example Use block to run the loop
-    #   c = Couchbase.new
-    #   c.run do
-    #     c.get("foo") {|ret| puts ret.value}
-    #   end
-    #
-    # @example Use lambda to run the loop
-    #   c = Couchbase.new
-    #   operations = lambda do |c|
-    #     c.get("foo") {|ret| puts ret.value}
-    #   end
-    #   c.run(&operations)
-    #
-    # @example Use threshold to send out commands automatically
-    #   c = Couchbase.connect
-    #   sent = 0
-    #   c.run(:send_threshold => 8192) do  # 8Kb
-    #     c.set("foo1", "x" * 100) {|r| sent += 1}
-    #     # 128 bytes buffered, sent is 0 now
-    #     c.set("foo2", "x" * 10000) {|r| sent += 1}
-    #     # 10028 bytes added, sent is 2 now
-    #     c.set("foo3", "x" * 100) {|r| sent += 1}
-    #   end
-    #   # all commands were executed and sent is 3 now
-    #
-    # @example Use {Couchbase::Bucket#run} without block for async connection
-    #   c = Couchbase.new(:async => true)
-    #   c.run      # ensure that instance connected
-    #   c.set("foo", "bar"){|r| puts r.cas}
-    #   c.run
-    #
-    # @return [nil]
-    #
-    # @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
-    #
-    def run(options = {})
-      do_async_setup(block_given?)
-      yield(self)
-      async_queue.join
-
-      # TODO: deal with exceptions
-      nil
-    ensure
-      do_async_ensure
-    end
-
-    def run_async(options = {})
-      do_async_setup(block_given?)
-      yield(self)
-      nil
-    ensure
-      do_async_ensure
-    end
-
     private
 
-    def do_async_setup(block_given)
-      raise LocalJumpError.new('block required for async run') unless block_given
-      # TODO: check for connection
-      raise Error::Invalid.new('nested #run') if running?
-      # TOOD: deal with thresholds
-
-      self.async   = true
-      self.running = true
-    end
-
-    def do_async_ensure
-      self.async   = false
-      self.running = false
-      end_async_queue
-    end
-
-    def register_future(future, options, &block)
-      if async_queue
-        async_queue.add_future(future, options, &block)
-      else
-        register_callback(future, &block)
-      end
-      future
-    end
-
-    def register_callback(future, &block)
-      callback = Couchbase::Callback.new(:set, &block)
+    def register_future(future, params, &block)
+      callback = Callback.new(params, &block)
       future.addListener(callback)
+      future
     end
-
   end
 end

data/lib/couchbase/bucket.rb

@@ -51,7 +51,6 @@ module Couchbase
       password:                  '',
       engine:                    nil,
       default_ttl:               0,
-      async:                     false,
       default_arithmetic_init:   0,
       default_flags:             0,
       default_format:            :document,
@@ -65,7 +64,6 @@ module Couchbase
       destroying:                0,
       connected:                 0,
       on_connect_proc:           nil,
-      async_disconnect_hook_set: 0,
       connected:                 false
     }.freeze
 
@@ -132,11 +130,6 @@ module Couchbase
     #     :libevent     :: libevent IO plugin from libcouchbase (optional)
     #     :libev        :: libev IO plugin from libcouchbase (optional)
     #     :eventmachine :: EventMachine plugin (builtin, but requires EM gem and ruby 1.9+)
-    #   @option options [true, false] :async (false) If true, the
-    #     connection instance will be considered always asynchronous and
-    #     IO interaction will be occured only when {Couchbase::Bucket#run}
-    #     called. See {Couchbase::Bucket#on_connect} to hook your code
-    #     after the instance will be connected.
     #
     # @example Initialize connection using default options
     #   Couchbase.new
@@ -162,16 +155,7 @@ module Couchbase
     # @return [Bucket]
     #
     def initialize(url = nil, options = {})
-      url_options = if url.is_a? String
-                      fail ArgumentError.new unless url =~ /^http:\/\//
-                      uri = URI.new(url)
-                      { hostname: uri.host, port: uri.port }.
-                        merge(path_to_pool_and_bucket(uri.path))
-                    elsif url.nil?
-                      {}
-                    else
-                      url
-                    end
+      url_options = expand_url_options(url)
 
       options = Couchbase.normalize_connection_options(options)
 
@@ -181,13 +165,15 @@ module Couchbase
         instance_variable_set("@#{key}", value)
       end
 
+      self.password = '' if self.password.nil?
+
       @transcoders = {
         document: Transcoder::Document.new,
         marshal:  Transcoder::Marshal.new,
         plain:    Transcoder::Plain.new
       }
 
-      connect unless async?
+      connect
     end
 
     def quiet?
@@ -199,11 +185,7 @@ module Couchbase
     end
 
     def connect
-      uris = if @node_list
-               Array(@node_list).map { |n| URI.new(n) }
-             else
-               Array(URI.new(base_url))
-             end
+      uris = expand_node_list
 
       begin
         builder = CouchbaseConnectionFactoryBuilder.new
@@ -211,10 +193,10 @@ module Couchbase
         connection_factory = builder.buildCouchbaseConnection(uris, bucket.to_java_string, password.to_java_string)
         @client = CouchbaseClient.new(connection_factory)
         @connected = true
-      rescue Java::ComCouchbaseClientVbucket::ConfigurationException
-        fail Couchbase::Error::Auth, 'Couchbase configurations are incorrect.'
+      rescue Java::ComCouchbaseClientVbucket::ConfigurationException => e
+        fail Couchbase::Error::Auth, "Couchbase configurations are incorrect: #{e.to_s}"
       rescue java.net.ConnectException => e
-        fail Couchbase::Error::Connect
+        fail Couchbase::Error::Connect, e.to_s
       end
 
       self
@@ -238,8 +220,7 @@ module Couchbase
     end
 
     def disconnect
-      if connected?
-        @client.shutdown(3, TimeUnit::SECONDS)
+      if connected? && @client.shutdown(3, TimeUnit::SECONDS)
         @client = nil
         @connection_factory = nil
         @connected = false
@@ -329,17 +310,9 @@ module Couchbase
     #
     # @return [Fixnum] the CAS of new value
     def cas(key, options = {})
-      if async?
-        block = Proc.new
-        get(key) do |ret|
-          val = block.call(ret) # get new value from caller
-          set(ret.key, val, options.merge(:cas => ret.cas, &block))
-        end
-      else
-        val, flags, ver = get(key, :extended => true)
-        val = yield(val) # get new value from caller
-        set(key, val, options.merge(:cas => ver))
-      end
+      val, flags, ver = get(key, :extended => true)
+      val = yield(val) # get new value from caller
+      set(key, val, options.merge(:cas => ver))
     end
     alias :compare_and_swap :cas
 
@@ -369,89 +342,7 @@ module Couchbase
     #     end
     #   end
     def flush
-      if !async? && block_given?
-        sync_block_error
-      end
-      req = make_http_request("/pools/default/buckets/#{bucket}/controller/doFlush",
-                              :type => :management, :method => :post, :extended => true)
-      res = nil
-      req.on_body do |r|
-        res = r
-        res.instance_variable_set("@operation", :flush)
-        yield(res) if block_given?
-      end
-      req.continue
-      true
-    end
-
-    # Create and register one-shot timer
-    #
-    # @return [Couchbase::Timer]
-    def create_timer(interval, &block)
-      Timer.new(self, interval, &block)
-    end
-
-    # Create and register periodic timer
-    #
-    # @return [Couchbase::Timer]
-    def create_periodic_timer(interval, &block)
-      Timer.new(self, interval, :periodic => true, &block)
-    end
-
-    # Wait for persistence condition
-    #
-    # @since 1.2.0.dp6
-    #
-    # This operation is useful when some confidence needed regarding the
-    # state of the keys. With two parameters +:replicated+ and +:persisted+
-    # it allows to set up the waiting rule.
-    #
-    # @param [String, Symbol, Array, Hash] keys The list of the keys to
-    #   observe. Full form is hash with key-cas value pairs, but there are
-    #   also shortcuts like just Array of keys or single key. CAS value
-    #   needed to when you need to ensure that the storage persisted exactly
-    #   the same version of the key you are asking to observe.
-    # @param [Hash] options The options for operation
-    # @option options [Fixnum] :timeout The timeout in microseconds
-    # @option options [Fixnum] :replicated How many replicas should receive
-    #   the copy of the key.
-    # @option options [Fixnum] :persisted How many nodes should store the
-    #   key on the disk.
-    #
-    # @raise [Couchbase::Error::Timeout] if the given time is up
-    #
-    # @return [Fixnum, Hash<String, Fixnum>] will return CAS value just like
-    #   mutators or pairs key-cas in case of multiple keys.
-    def observe_and_wait(*keys, &block)
-      options = {:timeout => default_observe_timeout}
-      options.update(keys.pop) if keys.size > 1 && keys.last.is_a?(Hash)
-      verify_observe_options(options)
-      if block && !async?
-        raise ArgumentError, "synchronous mode doesn't support callbacks"
-      end
-      if keys.size == 0
-        raise ArgumentError, "at least one key is required"
-      end
-      if keys.size == 1 && keys[0].is_a?(Hash)
-        key_cas = keys[0]
-      else
-        key_cas = keys.flatten.reduce({}) do |h, kk|
-          h[kk] = nil   # set CAS to nil
-          h
-        end
-      end
-      if async?
-        do_observe_and_wait(key_cas, options, &block)
-      else
-        res = do_observe_and_wait(key_cas, options, &block) while res.nil?
-        unless async?
-          if keys.size == 1 && (keys[0].is_a?(String) || keys[0].is_a?(Symbol))
-            return res.values.first
-          else
-            return res
-          end
-        end
-      end
+      @client.flush.get
     end
 
     private
@@ -460,114 +351,26 @@ module Couchbase
       {}
     end
 
-    def verify_observe_options(options)
-      unless num_replicas
-        raise Couchbase::Error::Libcouchbase, "cannot detect number of the replicas"
-      end
-      unless options[:persisted] || options[:replicated]
-        raise ArgumentError, "either :persisted or :replicated option must be set"
-      end
-      if options[:persisted] && !(1..num_replicas + 1).include?(options[:persisted])
-        raise ArgumentError, "persisted number should be in range (1..#{num_replicas + 1})"
-      end
-      if options[:replicated] && !(1..num_replicas).include?(options[:replicated])
-        raise ArgumentError, "replicated number should be in range (1..#{num_replicas})"
+    def expand_url_options(url)
+      if url.is_a? String
+        fail ArgumentError.new unless url =~ /^http:\/\//
+        uri = URI.new(url)
+        { hostname: uri.host, port: uri.port }.merge(path_to_pool_and_bucket(uri.path))
+      elsif url.nil?
+        {}
+      else
+        url
       end
     end
 
-    def do_observe_and_wait(keys, options, &block)
-      acc = Hash.new do |h, k|
-        h[k] = Hash.new(0)
-        h[k][:cas] = [keys[k]] # first position is for master node
-        h[k]
-      end
-      check_condition = lambda do
-        ok = catch :break do
-          acc.each do |key, stats|
-            master = stats[:cas][0]
-            if master.nil?
-              # master node doesn't have the key
-              throw :break
-            end
-            if options[:persisted] && (stats[:persisted] < options[:persisted] ||
-                                       stats[:cas].count(master) != options[:persisted])
-              throw :break
-            end
-            if options[:replicated] && (stats[:replicated] < options[:replicated] ||
-                                        stats[:cas].count(master) != options[:replicated] + 1)
-              throw :break
-            end
-          end
-          true
-        end
-        if ok
-          if async?
-            options[:timer].cancel if options[:timer]
-            keys.each do |k, _|
-              block.call(Result.new(:key => k,
-                                    :cas => acc[k][:cas][0],
-                                    :operation => :observe_and_wait))
-            end
-            return :async
-          else
-            return keys.inject({}){|res, (k, _)| res[k] = acc[k][:cas][0]; res}
-          end
-        else
-          options[:timeout] /= 2
-          if options[:timeout] > 0
-            if async?
-              options[:timer] = create_timer(options[:timeout]) do
-                do_observe_and_wait(keys, options, &block)
-              end
-              return :async
-            else
-              # do wait for timeout
-              run { create_timer(options[:timeout]){} }
-              # return nil to avoid recursive call
-              return nil
-            end
-          else
-            err = Couchbase::Error::Timeout.new("the observe request was timed out")
-            err.instance_variable_set("@operation", :observe_and_wait)
-            if async?
-              keys.each do |k, _|
-                block.call(Result.new(:key => k,
-                                      :cas => acc[k][:cas][0],
-                                      :operation => :observe_and_wait,
-                                      :error => err))
-              end
-              return :async
-            else
-              err.instance_variable_set("@key", keys.keys)
-              raise err
-            end
-          end
-        end
-      end
-      collect = lambda do |results|
-        results.each do |res|
-          if res.completed?
-            check_condition.call if async?
-          else
-            if res.from_master?
-              acc[res.key][:cas][0] = res.cas
-            else
-              acc[res.key][:cas] << res.cas
-            end
-            acc[res.key][res.status] += 1
-            if res.status == :persisted
-              acc[res.key][:replicated] += 1
-            end
-          end
-        end
-      end
-      if async?
-        observe(keys.keys, options, &collect)
+    def expand_node_list
+      if @node_list
+        Array(@node_list).map { |n| URI.new(n) }
       else
-        observe(keys.keys, options).each{|_, v| collect.call(v)}
-        check_condition.call
+        Array(URI.new(base_url))
       end
     end
+
   end
 
 end

data/lib/couchbase/operations/arithmetic.rb

@@ -100,7 +100,6 @@ module Couchbase::Operations
     #     end
     #
     def incr(*args)
-      sync_block_error if !async? && block_given?
       do_arithmetic(:incr, *args)
     end
     alias_method :increment, :incr
@@ -189,7 +188,6 @@ module Couchbase::Operations
     #     end
     #
     def decr(*args)
-      sync_block_error if !async? && block_given?
       do_arithmetic(:decr, *args)
     end
     alias_method :decrement, :decr
@@ -228,31 +226,31 @@ module Couchbase::Operations
     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
+      result = case op
+               when :incr
+                 client.incr(key, delta)
+               when :decr
+                 client.decr(key, delta)
+               end
+
+      set_default_arithmetic_or_raise(key, result, options)
     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
+      return result if result > 0
 
-          set(key, value, options) && value
-        else
-          not_found_error(true)
-        end
+      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
-        result
+        not_found_error(true)
       end
     end
 
@@ -280,39 +278,13 @@ module Couchbase::Operations
       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_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
+    # def java_async_decr(key, delta)
+    #   client.asyncDecr(key, delta)
+    # end
 
   end
 end