zookeeper 1.2.14 → 1.3.0

data/CHANGELOG

@@ -1,3 +1,10 @@
+v1.3.0 much needed refactor of event and async result delivery
+
+  * event and async blocks were previously mixed in with a bunch of other
+    common code, and shared a Monitor with other unrelated functionality. This
+    code has been gently refactored into its own self-contained class (with its
+    own task-specific lock), which should help with maintenance.
+
 v1.2.14 merge add_auth pull request, reduce chances for ContinuationTimeoutError
 
   * added support for the add_auth call (h/t: @bradhe) see pull req #25

data/ext/zookeeper_base.rb

@@ -20,18 +20,12 @@ class ZookeeperBase
   # @private
   class ClientShutdownException < StandardError; end
 
-  # @private
-  KILL_TOKEN = Object.new unless defined?(KILL_TOKEN)
-
-  ZKRB_GLOBAL_CB_REQ   = -1
-
   # debug levels
   ZOO_LOG_LEVEL_ERROR  = 1
   ZOO_LOG_LEVEL_WARN   = 2
   ZOO_LOG_LEVEL_INFO   = 3
   ZOO_LOG_LEVEL_DEBUG  = 4
 
-
   def_delegators :czk, :get_children, :exists, :delete, :get, :set,
     :set_acl, :get_acl, :client_id, :sync, :add_auth, :wait_until_connected
 
@@ -66,11 +60,8 @@ class ZookeeperBase
   end
   private :reopen_after_fork!
 
-
   def reopen(timeout = 10, watcher=nil)
-    if watcher and (watcher != @default_watcher)
-      raise "You cannot set the watcher to a different value this way anymore!"
-    end
+    raise "You cannot set the watcher to a different value this way anymore!" if watcher
 
     reopen_after_fork! if forked?
 
@@ -79,8 +70,7 @@ class ZookeeperBase
       @czk = CZookeeper.new(@host, @event_queue)
 
       # flushes all outstanding watcher reqs.
-      @watcher_reqs.clear
-      set_default_global_watcher
+      @req_registry.clear_watchers!
       
       @czk.wait_until_connected(timeout)
     end
@@ -90,24 +80,21 @@ class ZookeeperBase
   end
 
   def initialize(host, timeout = 10, watcher=nil)
-    @watcher_reqs = {}
-    @completion_reqs = {}
-
-    @current_req_id = 0
-
-    @dispatcher = @czk = nil
-
-    update_pid!
-    reopen_after_fork!
-    
     # approximate the java behavior of raising java.lang.IllegalArgumentException if the host
     # argument ends with '/'
     raise ArgumentError, "Host argument #{host.inspect} may not end with /" if host.end_with?('/')
 
     @host = host.dup
 
-    @default_watcher = (watcher or get_default_global_watcher)
+    watcher ||= get_default_global_watcher
+
+    @req_registry = RequestRegistry.new(watcher, :chroot_path => chroot_path)
 
+    @dispatcher = @czk = nil
+
+    update_pid!
+    reopen_after_fork!
+    
     yield self if block_given?
 
     reopen(timeout)
@@ -166,7 +153,7 @@ class ZookeeperBase
   def create(*args)
     # since we don't care about the inputs, just glob args
     rc, new_path = czk.create(*args)
-    [rc, strip_chroot_from(new_path)]
+    [rc, @req_registry.strip_chroot_from(new_path)]
   end
 
   def set_debug_level(int)
@@ -176,12 +163,7 @@ class ZookeeperBase
 
   # set the watcher object/proc that will receive all global events (such as session/state events)
   def set_default_global_watcher
-    warn "DEPRECATION WARNING: #{self.class}#set_default_global_watcher ignores block" if block_given?
-
-    @mutex.synchronize do
-#       @default_watcher = block # save this here for reopen() to use
-      @watcher_reqs[ZKRB_GLOBAL_CB_REQ] = { :watcher => @default_watcher, :watcher_context => nil }
-    end
+    raise "NO! YOU CANNOT HAZ set_default_global_watcher"
   end
 
   def state
@@ -233,34 +215,9 @@ class ZookeeperBase
   end
 
 protected
-  # this is a hack: to provide consistency between the C and Java drivers when
-  # using a chrooted connection, we wrap the callback in a block that will
-  # strip the chroot path from the returned path (important in an async create
-  # sequential call). This is the only place where we can hook *just* the C
-  # version. The non-async manipulation is handled in ZookeeperBase#create.
-  # 
-  # TODO: need to move the continuation setup into here, so that it can get 
-  #       added to the callback hash
-  # 
-  def setup_completion(req_id, meth_name, call_opts)
-    if (meth_name == :create) and cb = call_opts[:callback]
-      call_opts[:callback] = lambda do |hash|
-        # in this case the string will be the absolute zookeeper path (i.e.
-        # with the chroot still prepended to the path). Here's where we strip it off
-        hash[:string] = strip_chroot_from(hash[:string])
-
-        # call the original callback
-        cb.call(hash)
-      end
-    end
-
-    # pass this along to the Zookeeper::Common implementation
-    super(req_id, meth_name, call_opts)
-  end
-
   def czk
     rval = @mutex.synchronize { @czk }
-    raise Exceptions::NotConnected unless rval
+    raise Exceptions::NotConnected, "underlying connection was nil" unless rval
     rval
   end
 

data/java/java_base.rb

@@ -186,9 +186,7 @@ class JavaBase
 #     watcher ||= @default_watcher
 
     @mutex.synchronize do
-      # flushes all outstanding watcher reqs.
-      @watcher_reqs.clear
-      set_default_global_watcher
+      @req_registry.clear_watchers!
 
       replace_jzk!
       wait_until_connected
@@ -205,19 +203,19 @@ class JavaBase
   def initialize(host, timeout=10, watcher=nil, options={})
     @host = host
     @event_queue = QueueWithPipe.new
-    @current_req_id = 0
+
+    watcher ||= get_default_global_watcher()
+
+    @req_registry = RequestRegistry.new(watcher)
 
     @mutex = Monitor.new
     @dispatch_shutdown_cond = @mutex.new_cond
     @connected_latch = Latch.new
 
-    @watcher_reqs = {}
-    @completion_reqs = {}
     @_running = nil
     @_closed  = false
     @options = {}
 
-    @default_watcher = (watcher || get_default_global_watcher)
 
     # allows connected-state handlers to be registered before 
     yield self if block_given?
@@ -415,19 +413,6 @@ class JavaBase
     raise NotConnected unless connected?
   end
 
-  # set the watcher object/proc that will receive all global events (such as session/state events)
-  #---
-  # XXX: this code needs to be duplicated from ext/zookeeper_base.rb because
-  # it's called from the initializer, and because of the C impl. we can't have
-  # the two decend from a common base, and a module wouldn't work
-  #
-  # XXX: this is probably a relic?
-  def set_default_global_watcher
-    @mutex.synchronize do
-      @watcher_reqs[ZKRB_GLOBAL_CB_REQ] = { :watcher => @default_watcher, :watcher_context => nil }
-    end
-  end
-
   def session_id
     jzk.session_id
   end

data/lib/zookeeper.rb

@@ -40,6 +40,7 @@ Zookeeper.require_lib(
   'zookeeper/exceptions',
   'zookeeper/continuation',
   'zookeeper/common',
+  'zookeeper/request_registry',
   'zookeeper/callbacks',
   'zookeeper/stat',
   'zookeeper/client_methods'

data/lib/zookeeper/client_methods.rb

@@ -1,9 +1,14 @@
 module Zookeeper
 module ClientMethods
+  extend Forwardable
   include Constants
   include ACLs
   include Logger
 
+  # @req_registry is set up in the platform-specific base classes
+  def_delegators :@req_registry, :setup_call
+  private :setup_call
+
   def reopen(timeout=10, watcher=nil)
     warn "WARN: ZookeeperBase#reopen watcher argument is now ignored" if watcher
     super
@@ -15,8 +20,9 @@ module ClientMethods
 
   def add_auth(options = {})
     assert_open
-    assert_supported_keys(options, [:scheme, :cert])
-    assert_required_keys(options, [:scheme, :cert])
+    assert_keys(options, 
+                :supported => [:scheme, :cert],
+                :required  => [:scheme, :cert])
 
     req_id = setup_call(:add_auth, options)
     rc = super(req_id, options[:scheme], options[:cert])
@@ -26,8 +32,9 @@ module ClientMethods
 
   def get(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :watcher, :watcher_context, :callback, :callback_context])
-    assert_required_keys(options, [:path])
+    assert_keys(options,
+                :supported  => [:path, :watcher, :watcher_context, :callback, :callback_context],
+                :required   => [:path])
 
     req_id = setup_call(:get, options)
     rc, value, stat = super(req_id, options[:path], options[:callback], options[:watcher])
@@ -38,8 +45,10 @@ module ClientMethods
 
   def set(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :data, :version, :callback, :callback_context])
-    assert_required_keys(options, [:path])
+    assert_keys(options,
+                :supported  => [:path, :data, :version, :callback, :callback_context],
+                :required   => [:path])
+
     assert_valid_data_size!(options[:data])
     options[:version] ||= -1
 
@@ -52,8 +61,9 @@ module ClientMethods
 
   def get_children(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :callback, :callback_context, :watcher, :watcher_context])
-    assert_required_keys(options, [:path])
+    assert_keys(options,
+                :supported => [:path, :callback, :callback_context, :watcher, :watcher_context],
+                :required  => [:path])
 
     req_id = setup_call(:get_children, options)
     rc, children, stat = super(req_id, options[:path], options[:callback], options[:watcher])
@@ -64,8 +74,9 @@ module ClientMethods
 
   def stat(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :callback, :callback_context, :watcher, :watcher_context])
-    assert_required_keys(options, [:path])
+    assert_keys(options,
+                :supported  => [:path, :callback, :callback_context, :watcher, :watcher_context],
+                :required   => [:path])
 
     req_id = setup_call(:stat, options)
     rc, stat = exists(req_id, options[:path], options[:callback], options[:watcher])
@@ -76,8 +87,10 @@ module ClientMethods
 
   def create(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :data, :acl, :ephemeral, :sequence, :callback, :callback_context])
-    assert_required_keys(options, [:path])
+    assert_keys(options,
+                :supported  => [:path, :data, :acl, :ephemeral, :sequence, :callback, :callback_context],
+                :required   => [:path])
+
     assert_valid_data_size!(options[:data])
 
     flags = 0
@@ -95,8 +108,10 @@ module ClientMethods
 
   def delete(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :version, :callback, :callback_context])
-    assert_required_keys(options, [:path])
+    assert_keys(options,
+                :supported  => [:path, :version, :callback, :callback_context],
+                :required   => [:path])
+
     options[:version] ||= -1
 
     req_id = setup_call(:delete, options)
@@ -113,8 +128,9 @@ module ClientMethods
   #
   def sync(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :callback, :callback_context])
-    assert_required_keys(options, [:path, :callback])
+    assert_keys(options,
+                :supported  => [:path, :callback, :callback_context],
+                :required   => [:path, :callback])
 
     req_id = setup_call(:sync, options)
 
@@ -125,8 +141,9 @@ module ClientMethods
 
   def set_acl(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :acl, :version, :callback, :callback_context])
-    assert_required_keys(options, [:path, :acl])
+    assert_keys(options,
+                :supported  => [:path, :acl, :version, :callback, :callback_context],
+                :required   => [:path, :acl])
     options[:version] ||= -1
 
     req_id = setup_call(:set_acl, options)
@@ -137,8 +154,9 @@ module ClientMethods
 
   def get_acl(options = {})
     assert_open
-    assert_supported_keys(options, [:path, :callback, :callback_context])
-    assert_required_keys(options, [:path])
+    assert_keys(options,
+                :supported  => [:path, :callback, :callback_context],
+                :required   => [:path])
 
     req_id = setup_call(:get_acl, options)
     rc, acls, stat = super(req_id, options[:path], options[:callback])
@@ -241,14 +259,19 @@ protected
   end
 
 private
-  # TODO: Sanitize user mistakes by unregistering watchers from ops that
-  # don't return ZOK (except wexists)?  Make users clean up after themselves for now.
-  #
-  # XXX: is this dead code?
-  def unregister_watcher(req_id)
-    @mutex.synchronize {
-      @watcher_reqs.delete(req_id)
-    }
+  def assert_keys(args, opts={})
+    supported = opts[:supported] || []
+    required  = opts[:required]  || []
+
+    unless (args.keys - supported).empty?
+      raise Zookeeper::Exceptions::BadArguments,
+            "Supported arguments are: #{supported.inspect}, but arguments #{args.keys.inspect} were supplied instead"
+    end
+
+    unless (required - args.keys).empty?
+      raise Zookeeper::Exceptions::BadArguments,
+            "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
+    end
   end
   
   # must be supplied by parent class impl.

data/lib/zookeeper/common.rb

@@ -3,59 +3,11 @@ require 'zookeeper/common/queue_with_pipe'
 
 module Zookeeper
 module Common
-  # sigh, i guess define this here?
-  ZKRB_GLOBAL_CB_REQ   = -1
-
   def event_dispatch_thread?
     @dispatcher && (@dispatcher == Thread.current)
   end
 
 private
-  def setup_call(meth_name, opts)
-    req_id = nil
-    @mutex.synchronize {
-      req_id = @current_req_id
-      @current_req_id += 1
-      setup_completion(req_id, meth_name, opts) if opts[:callback]
-      setup_watcher(req_id, opts) if opts[:watcher]
-    }
-    req_id
-  end
-
-  def setup_watcher(req_id, call_opts)
-    @mutex.synchronize do
-      @watcher_reqs[req_id] = { 
-        :watcher => call_opts[:watcher],
-        :context => call_opts[:watcher_context] 
-      }
-    end
-  end
-
-  # as a hack, to provide consistency between the java implementation and the C
-  # implementation when dealing w/ chrooted connections, we override this in
-  # ext/zookeeper_base.rb to wrap the callback in a chroot-path-stripping block.
-  #
-  # we don't use meth_name here, but we need it in the C implementation
-  #
-  def setup_completion(req_id, meth_name, call_opts)
-    @mutex.synchronize do
-      @completion_reqs[req_id] = { 
-        :callback => call_opts[:callback],
-        :context => call_opts[:callback_context]
-      }
-    end
-  end
-  
-  def get_watcher(req_id)
-    @mutex.synchronize {
-      (req_id == ZKRB_GLOBAL_CB_REQ) ? @watcher_reqs[req_id] : @watcher_reqs.delete(req_id)
-    }
-  end
-  
-  def get_completion(req_id)
-    @mutex.synchronize { @completion_reqs.delete(req_id) }
-  end
-
   def setup_dispatch_thread!
     @mutex.synchronize do
       if @dispatcher
@@ -118,31 +70,7 @@ private
     hash[:stat] = Zookeeper::Stat.new(hash[:stat]) if hash.has_key?(:stat)
     hash[:acl] = hash[:acl].map { |acl| Zookeeper::ACLs::ACL.new(acl) } if hash[:acl]
     
-    callback_context = nil
-
-    @mutex.synchronize do
-      callback_context = is_completion ? get_completion(hash[:req_id]) : get_watcher(hash[:req_id])
-
-      # When connectivity to the server has been lost (as indicated by SESSION_EVENT)
-      # we want to rerun the callback at a later time when we eventually do have
-      # a valid response.
-      #
-      # XXX: this code needs to be refactored, get_completion shouldn't remove the context
-      #      in the case of a session event. this would involve changing the
-      #      platform implementations as well, as the C version does some funky
-      #      stuff to maintain compatibilty w/ java in chrooted envs.
-      #
-      #      The point is that this lock ^^ is unnecessary if the functions above lock internally
-      #      and don't do the wrong thing, requiring us to do the below.
-      #
-      if hash[:type] == Zookeeper::Constants::ZOO_SESSION_EVENT
-        if is_completion 
-          setup_completion(hash[:req_id], callback_context) 
-        else
-          setup_watcher(hash[:req_id], callback_context)
-        end
-      end
-    end
+    callback_context = @req_registry.get_context_for(hash)
 
     if callback_context
       callback = is_completion ? callback_context[:callback] : callback_context[:watcher]
@@ -160,20 +88,6 @@ private
     true
   end
 
-  def assert_supported_keys(args, supported)
-    unless (args.keys - supported).empty?
-      raise Zookeeper::Exceptions::BadArguments,
-            "Supported arguments are: #{supported.inspect}, but arguments #{args.keys.inspect} were supplied instead"
-    end
-  end
-
-  def assert_required_keys(args, required)
-    unless (required - args.keys).empty?
-      raise Zookeeper::Exceptions::BadArguments,
-            "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
-    end
-  end
-
   def dispatch_thread_body
     while true
       begin

data/lib/zookeeper/request_registry.rb

@@ -0,0 +1,153 @@
+module Zookeeper
+  class RequestRegistry
+    include Constants
+    include Logger
+
+    # @param [Hash] opts
+    # @option opts [String] :chroot_path (nil) if given, will be used to
+    #   correct a discrepancy between the C and Java clients when using a
+    #   chrooted connection. If given, the chroot path will be stripped from
+    #   the string returned by a `create`. It should be an absolute path.
+    #
+    def initialize(watcher, opts={})
+      @mutex = Monitor.new
+
+      @default_watcher  = watcher
+
+      @current_req_id   = 0
+      @watcher_reqs     = {}
+      @completion_reqs  = {}
+
+      @chroot_path = opts[:chroot_path]
+    end
+
+    def default_watcher
+      @mutex.synchronize { @default_watcher }
+    end
+
+    def default_watcher=(blk)
+      @mutex.synchronize { @default_watcher = blk }
+    end
+
+    def setup_call(meth_name, opts)
+      req_id = nil
+      @mutex.synchronize {
+        req_id = @current_req_id
+        @current_req_id += 1
+        setup_completion(req_id, meth_name, opts) if opts[:callback]
+        setup_watcher(req_id, opts)               if opts[:watcher]
+      }
+      req_id
+    end
+
+    def get_context_for(hash)
+      return nil unless hash
+
+      is_session_event  = (hash[:type] == ZOO_SESSION_EVENT)
+
+      req_id  = hash.fetch(:req_id)
+
+      if hash.has_key?(:rc)
+        get_completion(req_id, :keep => is_session_event)
+      else
+        get_watcher(req_id, :keep => is_session_event)
+      end
+    end
+
+    def clear_watchers!
+      @mutex.synchronize { @watcher_reqs.clear }
+    end
+    
+    # if we're chrooted, this method will strip the chroot prefix from +path+
+    def strip_chroot_from(path)
+      return path unless (chrooted? and path and path.start_with?(@chroot_path))
+      path[@chroot_path.length..-1]
+    end
+
+    private
+      def get_completion(req_id, opts={})
+        @mutex.synchronize do
+          if opts[:keep] 
+            @completion_reqs[req_id]
+          else
+            @completion_reqs.delete(req_id)
+          end
+        end
+      end
+
+      # Return the watcher hash associated with the req_id. If the req_id
+      # is the ZKRB_GLOBAL_CB_REQ, then does not clear the req from the internal
+      # store, otherwise the req_id is removed.
+      #
+      def get_watcher(req_id, opts={})
+        @mutex.synchronize do
+          if Constants::ZKRB_GLOBAL_CB_REQ == req_id
+            { :watcher => @default_watcher, :watcher_context => nil }
+          elsif opts[:keep]
+            @watcher_reqs[req_id]
+          else
+            @watcher_reqs.delete(req_id)
+          end
+        end
+      end
+
+
+      def setup_watcher(req_id, call_opts)
+        @mutex.synchronize do
+          @watcher_reqs[req_id] = { 
+            :watcher => call_opts[:watcher],
+            :context => call_opts[:watcher_context] 
+          }
+        end
+      end
+
+      # as a hack, to provide consistency between the java implementation and the C
+      # implementation when dealing w/ chrooted connections, we override this in
+      # ext/zookeeper_base.rb to wrap the callback in a chroot-path-stripping block.
+      #
+      # we don't use meth_name here, but we need it in the C implementation
+      #
+      def setup_completion(req_id, meth_name, call_opts)
+        @mutex.synchronize do
+          @completion_reqs[req_id] = { 
+            :callback => maybe_wrap_callback(meth_name, call_opts[:callback]),
+            :context  => call_opts[:callback_context]
+          }
+        end
+      end
+
+      # this is a hack: to provide consistency between the C and Java drivers when
+      # using a chrooted connection, we wrap the callback in a block that will
+      # strip the chroot path from the returned path (important in an async create
+      # sequential call). This is the only place where we can hook *just* the C
+      # version. The non-async manipulation is handled in ZookeeperBase#create.
+      # 
+      # TODO: need to move the continuation setup into here, so that it can get 
+      #       added to the callback hash
+      #
+      def maybe_wrap_callback(meth_name, cb)
+        return cb unless cb and chrooted? and (meth_name == :create)
+
+        lambda do |hash|
+          # in this case the string will be the absolute zookeeper path (i.e.
+          # with the chroot still prepended to the path). Here's where we strip it off
+          hash[:string] = strip_chroot_from(hash[:string])
+
+          # call the original callback
+          cb.call(hash)
+        end
+      end
+      
+      def chrooted?
+        @chroot_path && !@chroot_path.empty?
+      end
+
+      def default_watcher_proc
+        Proc.new { |args|
+          logger.debug { "Ruby ZK Global CB called type=#{event_by_value(args[:type])} state=#{state_by_value(args[:state])}" }
+          true
+        }
+      end
+  end
+end
+

data/lib/zookeeper/version.rb

@@ -1,4 +1,4 @@
 module Zookeeper
-  VERSION = '1.2.14'
+  VERSION = '1.3.0'
   DRIVER_VERSION = '3.3.5'
 end

data/spec/c_zookeeper_spec.rb

@@ -40,7 +40,7 @@ unless defined?(::JRUBY_VERSION)
         it %[should have a connection event after being connected] do
           event = wait_until(2) { @event_queue.pop }
           event.should be
-          event[:req_id].should == Zookeeper::Common::ZKRB_GLOBAL_CB_REQ
+          event[:req_id].should == Zookeeper::Constants::ZKRB_GLOBAL_CB_REQ
           event[:type].should   == Zookeeper::Constants::ZOO_SESSION_EVENT
           event[:state].should  == Zookeeper::Constants::ZOO_CONNECTED_STATE
         end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zookeeper
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 27
   prerelease: 
   segments: 
   - 1
-  - 2
-  - 14
-  version: 1.2.14
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - Phillip Pearson
@@ -20,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-15 00:00:00 Z
+date: 2012-08-17 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: logging
@@ -103,6 +103,7 @@ files:
 - lib/zookeeper/logger.rb
 - lib/zookeeper/monitor.rb
 - lib/zookeeper/rake_tasks.rb
+- lib/zookeeper/request_registry.rb
 - lib/zookeeper/stat.rb
 - lib/zookeeper/version.rb
 - notes.txt