zk 1.5.0 → 1.5.1

data/Gemfile

@@ -28,10 +28,11 @@ platform :mri_19 do
 end
 
 group :development do
-  gem 'guard',        :require => false
-  gem 'guard-rspec',  :require => false
-  gem 'guard-shell',  :require => false
+  gem 'guard',          :require => false
+  gem 'guard-rspec',    :require => false
+  gem 'guard-shell',    :require => false
   gem 'guard-bundler',  :require => false
+  gem 'growl',          :require => false
 end
 
 group :test do

data/README.markdown

@@ -65,6 +65,12 @@ In addition to all of that, I would like to think that the public API the ZK::Cl
 [zk-eventmachine]: https://github.com/slyphon/zk-eventmachine
 
 ## NEWS ##
+### v1.5.1 ###
+
+* Added a `:retry_duration` option to client constructor which will allows the user to specify for how long in the case of a connection loss, should an operation wait for the connection to be re-established before retrying the operation. This can be set at a global level and overridden on a per-call basis. The default is to not retry (which may change at a later date). Generally speaking, a timeout of > 30s is probably excessive, and care should be taken because during a connection loss, the server-side state may change without you being aware of it (i.e. events will not be delivered). 
+
+* Small fork-hook implementation fix. Previously we were using WeakRefs so that hooks would not prevent an object from being garbage collected. This has been replaced with a finalizer which is more deterministic.
+
 ### v1.5.0 ###
 
 Ok, now seriously this time. I think all of the forking issues are done. 

data/RELEASES.markdown

@@ -1,5 +1,11 @@
 This file notes feature differences and bugfixes contained between releases. 
 
+### v1.5.1 ###
+
+* Added a `:retry_duration` option to client constructor which will allows the user to specify for how long in the case of a connection loss, should an operation wait for the connection to be re-established before retrying the operation. This can be set at a global level and overridden on a per-call basis. The default is to not retry (which may change at a later date). Generally speaking, a timeout of > 30s is probably excessive, and care should be taken because during a connection loss, the server-side state may change without you being aware of it (i.e. events will not be delivered). 
+
+* Small fork-hook implementation fix. Previously we were using WeakRefs so that hooks would not prevent an object from being garbage collected. This has been replaced with a finalizer which is more deterministic.
+
 ### v1.5.0 ###
 
 Ok, now seriously this time. I think all of the forking issues are done. 

data/lib/zk.rb

@@ -12,7 +12,6 @@ require 'monitor'
 require 'set'
 require 'time'
 require 'date'
-require 'weakref'
 
 module ZK
   # just like stdlib Monitor but provides the SAME API AS MUTEX, FFS!

data/lib/zk/client/base.rb

@@ -72,6 +72,8 @@ module ZK
 
       # returns true if the connection has been closed
       def closed?
+        return true if cnx.nil?
+
         # XXX: should this be *our* idea of closed or ZOO_CLOSED_STATE ?
         defined?(::JRUBY_VERSION) ? jruby_closed? : mri_closed?
       end
@@ -600,16 +602,7 @@ module ZK
         h = { :path => path }.merge(opts)
 
         setup_watcher!(:data, h) do
-          rv = cnx.stat(h)
-
-          return rv if opts[:callback] 
-
-          case rv[:rc] 
-          when Zookeeper::ZOK, Zookeeper::ZNONODE
-            rv[:stat]
-          else
-            check_rc(rv, h) # throws the appropriate error
-          end
+          call_and_check_rc(:stat, h.merge(:ignore => :no_node)).fetch(:stat)
         end
       end
 
@@ -1034,6 +1027,9 @@ module ZK
         end
 
         def call_and_check_rc(meth, opts)
+          # TODO: we should not be raising Zookeeper errors, that's not cool.
+          raise Zookeeper::Exceptions::NotConnected if cnx.nil?
+
           scrubbed_opts = opts.dup
           scrubbed_opts.delete(:ignore)
 
@@ -1045,7 +1041,7 @@ module ZK
         # @private
         # XXX: make this actually call the method on cnx
         def check_rc(rv_hash, inputs)
-          code   = rv_hash[:rc]
+          code  = rv_hash[:rc]
 
           if code && (code != Zookeeper::ZOK)
             return rv_hash if ignore_set(inputs[:ignore]).include?(code)

data/lib/zk/client/threaded.rb

@@ -43,6 +43,15 @@ module ZK
 
       DEFAULT_THREADPOOL_SIZE = 1
 
+      # @private
+      module Constants
+        CLI_RUNNING   = :running
+        CLI_PAUSED    = :paused
+        CLI_CLOSE_REQ = :close_requested
+        CLI_CLOSED    = :closed
+      end
+      include Constants
+
       # Construct a new threaded client.
       #
       # Pay close attention to the `:threaded` option, and have a look at the
@@ -84,6 +93,19 @@ module ZK
       #   that does something application specific, and you want to avoid a 
       #   conflict.
       #
+      # @option opts [Fixnum] :retry_duration (nil) for how long (in seconds)
+      #   should we wait to re-attempt a synchronous operation after we receive a
+      #   ZK::Exceptions::Retryable error. This exception (or really, group of
+      #   exceptions) is raised when there has been an unintentional network
+      #   connection or session loss, so retrying an operation in this situation
+      #   is like saying "If we are disconnected, How long should we wait for the
+      #   connection to become available before attempthing this operation?"
+      #
+      #   The default `nil` means automatic retry is not attempted.
+      #
+      #   This is a global option, and will be used for all operations on this
+      #   connection, however it can be overridden for any individual operation.
+      #
       # @option opts [:single,:per_callback] :thread (:single) choose your event
       #   delivery model:
       #
@@ -140,9 +162,14 @@ module ZK
         @reconnect = opts.fetch(:reconnect, true)
 
         @mutex = Monitor.new
-        @cond  = @mutex.new_cond
+        @cond = @mutex.new_cond
 
-        @cli_state = :running # this is to distinguish between *our* state and the underlying connection state
+        @cli_state = CLI_RUNNING # this is to distinguish between *our* state and the underlying connection state
+
+        # this is the last status update we've received from the underlying connection
+        @last_cnx_state = Zookeeper::ZOO_CLOSED_STATE 
+
+        @retry_duration = opts.fetch(:retry_duration, nil).to_i
 
         @fork_subs = [
           ForkHook.prepare_for_fork(method(:pause_before_fork_in_parent)),
@@ -150,22 +177,22 @@ module ZK
           ForkHook.after_fork_in_child(method(:reopen)),
         ]
 
+        ObjectSpace.define_finalizer(self, self.class.finalizer(@fork_subs))
+
         yield self if block_given?
 
-        @mutex.synchronize do
-          connect if opts.fetch(:connect, true)
-        end
+        connect if opts.fetch(:connect, true)
+      end
+
+      def self.finalizer(hooks)
+        proc { hooks.each(&:unregister) }
       end
 
       # @option opts [Fixnum] :timeout how long we will wait for the connection
       #   to be established. If timeout is nil, we will wait forever: *use
       #   carefully*.
        def connect(opts={})
-        @mutex.synchronize do
-          return if @cnx
-          timeout = opts.fetch(:timeout, @connection_timeout)
-          @cnx = create_connection(@host, timeout, @event_handler.get_default_watcher_block)
-        end
+        @mutex.synchronize { unlocked_connect(opts) }
       end
 
       # (see Base#reopen)
@@ -178,9 +205,10 @@ module ZK
 
           logger.debug { "reopening everything, fork detected!" }
 
-          @mutex = Monitor.new
-          @pid = Process.pid
-          @cli_state = :running                     # reset state to running if we were paused
+          @mutex      = Mutex.new
+          @cond       = ConditionVariable.new
+          @pid        = Process.pid
+          @cli_state  = CLI_RUNNING                     # reset state to running if we were paused
 
           old_cnx, @cnx = @cnx, nil
           old_cnx.close! if old_cnx # && !old_cnx.closed?
@@ -195,11 +223,11 @@ module ZK
             @event_handler.reopen_after_fork!
             @threadpool.reopen_after_fork!          # prune dead threadpool threads after a fork()
 
-            connect
+            unlocked_connect
           end
         else
           @mutex.synchronize do
-            if @cli_state == :paused
+            if @cli_state == CLI_PAUSED
               # XXX: what to do in this case? does it matter?
             end
 
@@ -220,23 +248,32 @@ module ZK
       # before that deadline, or you will have to re-establish your session.
       #
       # @raise [InvalidStateError] when called and not in running? state
+      # @private
       def pause_before_fork_in_parent
         @mutex.synchronize do
-          raise InvalidStateError, "client must be running? when you call #{__method__}" unless running?
-          @cli_state = :paused
+          raise InvalidStateError, "client must be running? when you call #{__method__}" unless (@cli_state == CLI_RUNNING)
+          @cli_state = CLI_PAUSED
+      
+          logger.debug { "#{self.class}##{__method__}" }
+
+          @cond.broadcast
         end
-        logger.debug { "#{self.class}##{__method__}" }
+
         [@event_handler, @threadpool, @cnx].each(&:pause_before_fork_in_parent)
       end
 
+      # @private
       def resume_after_fork_in_parent
         @mutex.synchronize do
-          raise InvalidStateError, "client must be paused? when you call #{__method__}" unless paused?
-          @cli_state = :running
-        end
+          raise InvalidStateError, "client must be paused? when you call #{__method__}" unless (@cli_state == CLI_PAUSED)
+          @cli_state = CLI_RUNNING
+
+          logger.debug { "#{self.class}##{__method__}" }
 
-        logger.debug { "#{self.class}##{__method__}" }
-        [@cnx, @event_handler, @threadpool].each(&:resume_after_fork_in_parent)
+          [@cnx, @event_handler, @threadpool].each(&:resume_after_fork_in_parent)
+
+          @cond.broadcast
+        end
       end
 
       # (see Base#close!)
@@ -250,8 +287,9 @@ module ZK
       def close!
         @mutex.synchronize do 
           return if [:closed, :close_requested].include?(@cli_state)
-#           logger.debug { "moving to :close_requested state" }
-          @cli_state = :close_requested
+          logger.debug { "moving to :close_requested state" }
+          @cli_state = CLI_CLOSE_REQ
+          @cond.broadcast
         end
 
         on_tpool = on_threadpool?
@@ -269,8 +307,9 @@ module ZK
           super
 
           @mutex.synchronize do
-#             logger.debug { "moving to :closed state" }
-            @cli_state = :closed
+            logger.debug { "moving to :closed state" }
+            @cli_state = CLI_CLOSED
+            @cond.broadcast
           end
         end
 
@@ -298,44 +337,43 @@ module ZK
       # @private
       def raw_event_handler(event)
         return unless event.session_event?
+        
+        @mutex.synchronize do
+          @last_cnx_state = event.state
 
-        if event.client_invalid?
-          return unless @reconnect
+          if event.client_invalid? and @reconnect and not dead_or_dying?
+            logger.error { "Got event #{event.state_name}, calling reopen(0)! things may be messed up until this works itself out!" }
 
-          @mutex.synchronize do
-            unless dead_or_dying?  # a legitimate shutdown case
-
-              logger.error { "Got event #{event.state_name}, calling reopen(0)! things may be messed up until this works itself out!" }
-               
-              # reopen(0) means that we don't want to wait for the connection
-              # to reach the connected state before returning as we're on the
-              # event thread.
-              reopen(0)
-            end
+            # reopen(0) means that we don't want to wait for the connection
+            # to reach the connected state before returning as we're on the
+            # event thread.
+            reopen(0)
           end
+
+          @cond.broadcast # wake anyone waiting for a connection state update
         end
       rescue Exception => e
         logger.error { "BUG: Exception caught in raw_event_handler: #{e.to_std_format}" } 
       end
 
       def closed?
-        return true if @mutex.synchronize { @cli_state == :closed }
+        return true if @mutex.synchronize { @cli_state == CLI_CLOSED }
         super
       end
 
       # are we in running (not-paused) state?
       def running?
-        @mutex.synchronize { @cli_state == :running }
+        @mutex.synchronize { @cli_state == CLI_RUNNING }
       end
 
       # are we in paused state?
       def paused?
-        @mutex.synchronize { @cli_state == :paused }
+        @mutex.synchronize { @cli_state == CLI_PAUSED }
       end
 
       # has shutdown time arrived?
       def close_requested?
-        @mutex.synchronize { @cli_state == :close_requested }
+        @mutex.synchronize { @cli_state == CLI_CLOSE_REQ }
       end
 
       protected
@@ -346,13 +384,51 @@ module ZK
           @mutex.synchronize { @cnx }
         end
 
-        # @private
+        def call_and_check_rc(meth, opts)
+          if retry_duration = (opts.delete(:retry_duration) || @retry_duration)
+            begin
+              super(meth, opts)
+            rescue Exceptions::Retryable => e
+              time_to_stop = Time.now + retry_duration
+
+              wait_until_connected_or_dying(retry_duration)
+
+              if (@last_cnx_state != Zookeeper::ZOO_CONNECTED_STATE) || (Time.now > time_to_stop) || (@cli_state != CLI_RUNNING)
+                raise e
+              else
+                retry
+              end
+            end
+          else
+            super
+          end
+        end
+
+        def wait_until_connected_or_dying(timeout)
+          time_to_stop = Time.now + timeout
+
+          @mutex.synchronize do
+            while (@last_cnx_state != Zookeeper::ZOO_CONNECTED_STATE) && (Time.now < time_to_stop) && (@cli_state == CLI_RUNNING)
+              @cond.wait(timeout)
+            end
+
+            logger.debug { "@last_cnx_state: #{@last_cnx_state}, time_left? #{Time.now.to_f < time_to_stop.to_f}, @cli_state: #{@cli_state.inspect}" }
+          end
+        end
+
         def create_connection(*args)
           ::Zookeeper.new(*args)
         end
 
         def dead_or_dying?
-          (@cli_state == :close_requested) || (@cli_state == :closed)
+          (@cli_state == CLI_CLOSE_REQ) || (@cli_state == CLI_CLOSED)
+        end
+
+      private
+        def unlocked_connect(opts={})
+          return if @cnx
+          timeout = opts.fetch(:timeout, @connection_timeout)
+          @cnx = create_connection(@host, timeout, @event_handler.get_default_watcher_block)
         end
     end
   end

data/lib/zk/exceptions.rb

@@ -43,12 +43,15 @@ module ZK
     module InterruptedSession
     end
 
+    # mixed into exceptions that may be retried
+    module Retryable
+    end
+
     class SystemError             < KeeperException; end
     class RunTimeInconsistency    < KeeperException; end
     class DataInconsistency       < KeeperException; end
     class MarshallingError        < KeeperException; end
     class Unimplemented           < KeeperException; end
-    class OperationTimeOut        < KeeperException; end
     class BadArguments            < KeeperException; end
     class ApiError                < KeeperException; end
     class NoNode                  < KeeperException; end
@@ -61,12 +64,18 @@ module ZK
     class InvalidACL              < KeeperException; end
     class AuthFailed              < KeeperException; end
 
+    class OperationTimeOut < KeeperException
+      include Retryable
+    end
+
     class ConnectionLoss < KeeperException
       include InterruptedSession
+      include Retryable
     end
 
     class SessionExpired < KeeperException
       include InterruptedSession
+      include Retryable
     end
 
     # mixes in InterruptedSession, and can be raised on its own

data/lib/zk/extensions.rb

@@ -48,3 +48,9 @@ end
   end
 end
 
+[:NotConnected, :SessionExpired, :ConnectionLoss].each do |class_name|
+  Zookeeper::Exceptions.const_get(class_name).tap do |klass|
+    klass.__send__(:include, ZK::Exceptions::Retryable)
+  end
+end
+

data/lib/zk/fork_hook.rb

@@ -16,21 +16,22 @@ module ZK
     # @private
     def fire_prepare_hooks!
       @mutex.lock
+      logger.debug { "#{__method__}" }      
       safe_call(@hooks[:prepare])
     end
 
     # @private
     def fire_after_child_hooks!
-      safe_call(@hooks[:after_child])
-    ensure
       @mutex.unlock rescue nil
+      logger.debug { "#{__method__}" }      
+      safe_call(@hooks[:after_child])
     end
 
     # @private
     def fire_after_parent_hooks!
-      safe_call(@hooks[:after_parent])
-    ensure
       @mutex.unlock rescue nil
+      logger.debug { "#{__method__}" }      
+      safe_call(@hooks[:after_parent])
     end
     
     # @private
@@ -52,15 +53,10 @@ module ZK
     def safe_call(callbacks)
       cbs = callbacks.dup
 
+      # exceptions in these hooks will be raised normally
+
       while cb = cbs.shift
-        begin
-          cb.call
-        rescue WeakRef::RefError
-          # clean weakrefs out of the original callback arrays if they're bad
-          callbacks.delete(cb)
-        rescue Exception => e
-          logger.error { e.to_std_format }
-        end
+        cb.call
       end
     end
 
@@ -76,7 +72,7 @@ module ZK
 
       ForkSubscription.new(hook_type, block).tap do |sub|
         # use a WeakRef so that the original objects can be GC'd
-        @mutex.synchronize { @hooks[hook_type] << WeakRef.new(sub) } 
+        @mutex.synchronize { @hooks[hook_type] << sub } 
       end
     end
 

data/lib/zk/logging.rb

@@ -14,10 +14,13 @@ module ZK
       ::Logging.logger['ZK'].tap do |ch_root|
         ::Logging.appenders.stderr.tap do |serr|
           serr.layout = ::Logging.layouts.pattern(
-            :pattern => '%.1l, [%d] %c30.30{2}:  %m\n',
+            :pattern => '%.1l, [%d #p] %c30.30{2}:  %m\n',
             :date_pattern => '%Y-%m-%d %H:%M:%S.%6N' 
           )
 
+          serr.auto_flushing = 25
+          serr.flush_period = 5
+
           ch_root.add_appenders(serr)
         end
 
@@ -25,12 +28,8 @@ module ZK
       end
     end
 
-    # cache the logger at the instance level, as that's where most of the
-    # logging is done, this means that the user should set up the override
-    # of the ZK.logger early, before creating instances.
-    #
     def logger
-      @logger ||= (::ZK.logger || ::Logging.logger[self.class.logger_name]) # logger_name defined in ::Logging::Utils
+      self.class.logger
     end
   end
 end

data/lib/zk/threaded_callback.rb

@@ -124,6 +124,7 @@ module ZK
 
       def dispatch_thread_body
         Thread.current.abort_on_exception = true
+        Thread.current[:callback] = @callback
         while true
           args = nil
 
@@ -132,7 +133,7 @@ module ZK
             @cond.wait(@mutex) while @array.empty? and @state == :running
 
             if @state != :running
-#               logger.warn { "ThreadedCallback, state is #{@state.inspect}, returning" } 
+              logger.warn { "ThreadedCallback, state is #{@state.inspect}, returning" } 
               return 
             end
 
@@ -147,8 +148,9 @@ module ZK
             logger.error { e.to_std_format }
           end
         end
-#       ensure
-#         logger.debug { "#{self.class}##{__method__} returning" }
+      ensure
+        Thread.current[:callback] = nil
+        logger.debug { "##{__method__} returning" }
       end
   end
 end

data/lib/zk/threadpool.rb

@@ -124,9 +124,9 @@ module ZK
       begin
         raise InvalidStateError, "invalid state, expected to be :running, was #{@state.inspect}" if @state != :running
         return false if @state == :paused
+        threads = @threadpool.slice!(0, @threadpool.length)
         @state = :paused
         @cond.broadcast   # wake threads, let them die
-        threads = @threadpool.slice!(0, @threadpool.length)
       ensure
         @mutex.unlock rescue nil
       end

data/lib/zk/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "1.5.0"
+  VERSION = "1.5.1"
 end

data/spec/shared/client_examples.rb

@@ -302,7 +302,9 @@ shared_examples_for 'client' do
         m.should_receive(:reopen).with(0).once
       end
 
-      bogus_event = flexmock(:expired_session_event, :session_event? => true, :client_invalid? => true, :state_name => 'ZOO_EXPIRED_SESSION_STATE')
+      props = { :session_event? => true, :client_invalid? => true, :state_name => 'ZOO_EXPIRED_SESSION_STATE', :state => Zookeeper::ZOO_EXPIRED_SESSION_STATE }
+
+      bogus_event = flexmock(:expired_session_event, props)
 
       @zk.raw_event_handler(bogus_event)
     end

data/spec/spec_helper.rb

@@ -109,4 +109,10 @@ class ::Thread
   end
 end
 
+if RUBY_VERSION == '1.9.3'
+  trap('USR1') do
+    threads = Thread.list.map { |th| { :inspect => th.inspect, :calback => th[:callback], :backtrace => th.backtrace } }
+    pp threads
+  end
+end
 

data/spec/support/client_forker.rb

@@ -12,6 +12,7 @@ class ClientForker
     @cnx_args  = cnx_args
     @base_path = base_path
     @pids_root = "#{@base_path}/pid"
+    @child_latch = Latch.new
   end
 
   LBORDER = ('-' * 35) << '< '
@@ -63,6 +64,13 @@ class ClientForker
     end
   end
 
+  def start_child_exit_thread(pid)
+    @child_exit_thread ||= Thread.new do
+      _, @stat = Process.wait2(pid)
+      @child_latch.release
+    end
+  end
+
   def run
     before
     mark 'BEGIN TEST'
@@ -102,7 +110,6 @@ class ClientForker
 
     @pid = fork do
       Thread.abort_on_exception = true
-      ::Logging.reopen
 
       @zk.wait_until_connected
 
@@ -169,6 +176,8 @@ class ClientForker
       end
     end # forked child
 
+    start_child_exit_thread(@pid)
+
     # replicates deletion watcher inside child
     child_pid_path = "#{@pids_root}/#{@pid}"
 
@@ -188,9 +197,10 @@ class ClientForker
 
     delete_latch.await if @zk.exists?(child_pid_path, :watch => true)
 
-    _, @stat = Process.wait2(@pid)
+    @child_latch.await(30) # if we don't get a response in 30 seconds, then we're *definately* hosed
+    
+    raise "Child did not exit after 30 seconds of waiting, something is very wrong" unless @stat 
 
-#     $stderr.puts "#{@pid} exited with status: #{stat.inspect}"
   ensure
     mark "END TEST"
     kill_child!

data/spec/support/logging.rb

@@ -9,6 +9,9 @@ layout = Logging.layouts.pattern(
 
 appender = ENV['ZK_DEBUG'] ? Logging.appenders.stderr : Logging.appenders.file(ZK::TEST_LOG_PATH)
 appender.layout = layout
+#appender.immediate_at = "debug,info,warn,error,fatal"
+appender.auto_flushing = 25
+appender.flush_period = 5
 
 %w[ZK ClientForker spec Zookeeper].each do |name|
   ::Logging.logger[name].tap do |log|
@@ -21,7 +24,9 @@ end
 Logging.logger['ZK::EventHandler'].level = :info
 
 Zookeeper.logger = Logging.logger['Zookeeper']
-Zookeeper.logger.level = :info
+Zookeeper.logger.level = ENV['ZOOKEEPER_DEBUG'] ? :debug : :warn
+
+ZK::ForkHook.after_fork_in_child { ::Logging.reopen }
 
 # Zookeeper.logger = ZK.logger.clone_new_log(:progname => 'zoo')
 

data/spec/zk/client_spec.rb

@@ -40,5 +40,79 @@ describe ZK::Client::Threaded do
       end
     end
   end
+
+  describe :retry do
+    include_context 'connection opts'
+
+    before do
+      @zk = ZK::Client::Threaded.new(connection_host, :reconect => false, :connect => false)
+    end
+
+    after do
+      @zk.close! unless @zk.closed?
+    end
+
+    it %[should retry a Retryable operation] do
+      # TODO: this is a terrible test. there is no way to guarantee that this
+      #       has been retried. the join at the end should not raise an error 
+      
+      @zk.should_not be_connected
+
+      th = Thread.new do
+        @zk.stat('/path/to/blah', :retry_duration => 30)
+      end
+
+      th.run
+
+      @zk.connect
+      th.join(5).should == th
+    end
+
+    it %[barfs if the connection is closed before the connected event is received] do
+      @zk.should_not be_connected
+
+      exc = nil
+
+      th = Thread.new do
+        # this nonsense is because 1.8.7 is psychotic
+        begin
+          @zk.stat('/path/to/blah', :retry_duration => 300)
+        rescue Exception
+          exc = $!
+        end
+      end
+
+      th.run
+
+      @zk.close!
+
+      th.join(5).should == th
+
+      exc.should_not be_nil
+      exc.should be_kind_of(ZK::Exceptions::Retryable)
+    end
+
+    it %[should barf if the timeout expires] do
+      @zk.should_not be_connected
+
+      exc = nil
+
+      th = Thread.new do
+        # this nonsense is because 1.8.7 is psychotic
+        begin
+          @zk.stat('/path/to/blah', :retry_duration => 0.001)
+        rescue Exception
+          exc = $!
+        end
+      end
+
+      th.run
+
+      th.join(5).should == th
+
+      exc.should_not be_nil
+      exc.should be_kind_of(ZK::Exceptions::Retryable)
+    end
+  end
 end # ZK::Client::Threaded
 

data/spec/zk/locker_spec.rb

@@ -432,7 +432,7 @@ shared_examples_for 'shared-exclusive interaction' do
       ex_th = Thread.new do
         begin
           @ex_lock.lock(true)  # blocking lock
-          Thread.current[:got_lock] = true
+          @ex_lock.assert!
           @array << :ex_lock
         ensure
           @ex_lock.unlock
@@ -455,7 +455,7 @@ shared_examples_for 'shared-exclusive interaction' do
       sh2_th = Thread.new do
         begin
           @sh_lock2.lock(true)
-          Thread.current[:got_lock] = true
+          @sh_lock2.assert!
           @array << :sh_lock2
         ensure
           @sh_lock2.unlock
@@ -469,13 +469,12 @@ shared_examples_for 'shared-exclusive interaction' do
 
       logger.debug { "@sh_lock2 is waiting" }
 
+      # ok, now unlock the first in the chain
+      @sh_lock.assert!
       @sh_lock.unlock.should be_true
 
       ex_th.join(5).should == ex_th
-      ex_th[:got_lock].should be_true
-
       sh2_th.join(5).should == sh2_th
-      sh2_th[:got_lock].should be_true
 
       @array.length.should == 2
       @array.should == [:ex_lock, :sh_lock2]

data/zk.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.summary     = %q{A high-level wrapper around the zookeeper driver}
   s.description = s.summary + "\n"
 
-  s.add_runtime_dependency 'zookeeper', '~> 1.2.2'
+  s.add_runtime_dependency 'zookeeper', '~> 1.2.3'
   s.add_runtime_dependency 'backports', '~> 2.5.1'
   s.add_runtime_dependency 'logging',   '~> 1.7.2'
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zk
 version: !ruby/object:Gem::Version 
-  hash: 3
+  hash: 1
   prerelease: 
   segments: 
   - 1
   - 5
-  - 0
-  version: 1.5.0
+  - 1
+  version: 1.5.1
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-22 00:00:00 Z
+date: 2012-05-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: zookeeper
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
+        hash: 25
         segments: 
         - 1
         - 2
-        - 2
-        version: 1.2.2
+        - 3
+        version: 1.2.3
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency