couchbase-jruby-client 0.1.0-java

data/lib/couchbase/async.rb

@@ -0,0 +1,139 @@
+require 'couchbase/async/callback'
+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
+    end
+
+    def register_callback(future, &block)
+      callback = Couchbase::Callback.new(:set, &block)
+      future.addListener(callback)
+    end
+
+  end
+end