zk 1.6.5 → 1.7.0

data/README.markdown

@@ -65,41 +65,49 @@ 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.6.4 ###
+### v1.7.0 ###
 
-* Remove unnecessary dependency on backports gem
-* *Fix for use in resque!* A small bug was preventing resque from activating the fork hook.
+* Added Locker timeout feature for blocking calls. (issue #40)
 
-### v1.6.2 ###
+Previously, when dealing with locks, there were only two options: blocking or non-blocking. In order to come up with a time-limited lock, you had to poll every so often until you acquired the lock. This is, needless to say, both inefficient and doesn't allow for fair acquisition. 
 
-* Change state call to reduce the chances of deadlocks
+A timeout option has been added so that when blocking waiting for a lock, you can specify a deadline by which the lock should have been acquired. 
 
-One of the problems I've been seeing is that during some kind of shutdown event, some method will call `closed?` or `connected?` which will acquire a mutex and make a call on the underlying connection at the *exact* moment necessary to cause a deadlock. In order to help prevent this, and building on some changes from 1.5.3, we now treat our cached `@last_cnx_state` as the current state of the connection and don't touch the underlying connection object (except in the case of the java driver, which is safe).
+```ruby
+zk = ZK.new
 
-### v1.6.0 ###
+locker = zk.locker('lock name')
 
-* Locker cleanup code!
+begin
+  locker.lock(:wait => 5.0)   # wait up to 5.0 seconds to acquire the lock
+rescue ZK::Exceptions::LockWaitTimeoutError
+  $stderr.puts "could not acquire the lock in time"
+end
+```
 
-When a session is lost, it's likely that the locker's node name was left behind. so for `zk.locker('foo')` if the session is interrupted, it's very likely that the `/_zklocking/foo` znode has been left behind. A method has been added to allow you to safely clean up these stale znodes:
+Also available when using the convenience `#with_lock` methods
 
 ```ruby
-ZK.open('localhost:2181') do |zk|
-  ZK::Locker.cleanup(zk)
-end
-```
 
-Will go through your locker nodes one by one and try to lock and unlock them. If it succeeds, the lock is naturally cleaned up (as part of the normal teardown code), if it doesn't acquire the lock, then no harm, it knows that lock is still in use.
+zk = ZK.new
 
-* Added `create('/path', 'data', :or => :set)` which will create a node (and all parent paths) with the given data or set its contents if it already exists. It's intended as a convenience when you just want a node to exist with a particular value.
+begin
+  zk.with_lock('lock name', :wait => 5.0) do |lock|
+    # do stuff while holding lock
+  end
+rescue ZK::Exceptions::LockWaitTimeoutError
+  $stderr.puts "could not acquire the lock in time"
+end
 
-* Added a bunch of shorter aliases on `ZK::Event`, so you can say `event.deleted?`, `event.changed?`, etc.
+```
 
-### v1.5.3 ###
+### v1.6.4 ###
 
-* Fixed reconnect code. There was an occasional race/deadlock condition caused because the reopen call was done on the underlying connection's dispatch thread. Closing the dispatch thread is part of reopen, so this would cause a deadlock in real-world use. Moved the reconnect logic to a separate, single-purpose thread on ZK::Client::Threaded that watches for connection state changes. 
+* Remove unnecessary dependency on backports gem
+* *Fix for use in resque!* A small bug was preventing resque from activating the fork hook.
 
-* 'private' is not 'protected'. I've been writing ruby for several years now, and apparently I'd forgotten that 'protected' does not work like how it does in java. The visibility of these methods has been corrected, and all specs pass, so I don't expect issues...but please report if this change causes any bugs in user code.
 
+See the [RELEASES][] page for more info on features and bugfixes in each release.
 
 ## Caveats
 

data/RELEASES.markdown

@@ -1,5 +1,42 @@
 This file notes feature differences and bugfixes contained between releases. 
 
+### v1.7.0 ###
+
+* Added Locker timeout feature for blocking calls. (issue #40)
+
+Previously, when dealing with locks, there were only two options: blocking or non-blocking. In order to come up with a time-limited lock, you had to poll every so often until you acquired the lock. This is, needless to say, both inefficient and doesn't allow for fair acquisition. 
+
+A timeout option has been added so that when blocking waiting for a lock, you can specify a deadline by which the lock should have been acquired. 
+
+```ruby
+zk = ZK.new
+
+locker = zk.locker('lock name')
+
+begin
+  locker.lock(:wait => 5.0)   # wait up to 5.0 seconds to acquire the lock
+rescue ZK::Exceptions::LockWaitTimeoutError
+  $stderr.puts "could not acquire the lock in time"
+end
+```
+
+Also available when using the convenience `#with_lock` methods
+
+```ruby
+
+zk = ZK.new
+
+begin
+  zk.with_lock('lock name', :wait => 5.0) do |lock|
+    # do stuff while holding lock
+  end
+rescue ZK::Exceptions::LockWaitTimeoutError
+  $stderr.puts "could not acquire the lock in time"
+end
+
+```
+
+
 ### v1.6.4 ###
 
 * Remove unnecessary dependency on backports gem

data/lib/zk/client/conveniences.rb

@@ -66,6 +66,9 @@ module ZK
       # will block the caller until the lock is acquired, and release the lock
       # when the block is exited.
       #
+      # Options are the same as for {Locker::LockerBase#lock #lock} with the addition of
+      # `:mode`, documented below.
+      #
       # @param name (see #locker)
       #
       # @option opts [:shared,:exclusive] :mode (:exclusive) the type of lock
@@ -73,25 +76,40 @@ module ZK
       #
       # @return the return value of the given block
       #
-      # @yield calls the block once the lock has been acquired
+      # @yield [lock] calls the block once the lock has been acquired with the
+      #   lock instance
       #
       # @example
       #
-      #   zk.with_lock('foo') do
+      #   zk.with_lock('foo') do |lock|
       #     # this code is executed while holding the lock
       #   end
       #
+      # @example with timeout
+      #
+      #   begin
+      #     zk.with_lock('foo', :wait => 5.0) do |lock|
+      #       # this code is executed while holding the lock
+      #     end
+      #   rescue ZK::Exceptions::LockWaitTimeoutError
+      #     $stderr.puts "we didn't acquire the lock in time"
+      #   end
+      #
       # @raise [ArgumentError] if `opts[:mode]` is not one of the expected values
       #
+      # @raise [ZK::Exceptions::LockWaitTimeoutError] if :wait timeout is
+      #   exceeded without acquiring the lock
+      #
       def with_lock(name, opts={}, &b)
-        mode = opts[:mode] || :exclusive
+        opts = opts.dup
+        mode = opts.delete(:mode) { |_| :exclusive }
 
         raise ArgumentError, ":mode option must be either :shared or :exclusive, not #{mode.inspect}" unless [:shared, :exclusive].include?(mode)
 
         if mode == :shared
-          shared_locker(name).with_lock(&b)
+          shared_locker(name).with_lock(opts, &b)
         else
-          locker(name).with_lock(&b)
+          locker(name).with_lock(opts, &b)
         end
       end
 

data/lib/zk/exceptions.rb

@@ -141,6 +141,7 @@ module ZK
     # called when the client is reopened, resumed, or paused when in an invalid state
     class InvalidStateError < ZKError; end
 
+    # Raised when a NodeDeletionWatcher is interrupted by another thread
     class WakeUpException < ZKError; end
 
     # raised when a chrooted conection is requested but the root doesn't exist
@@ -155,6 +156,9 @@ module ZK
         super("Chroot strings must start with a '/' you provided: #{erroneous_string.inspect}")
       end
     end
+
+    # raised when we are blocked waiting on a lock and the timeout expires
+    class LockWaitTimeoutError < ZKError; end
   end
 end
 

data/lib/zk/locker.rb

@@ -160,6 +160,7 @@ module ZK
   end # Locker
 end # ZK
 
+require 'zk/locker/lock_options'
 require 'zk/locker/locker_base'
 require 'zk/locker/shared_locker'
 require 'zk/locker/exclusive_locker'

data/lib/zk/locker/exclusive_locker.rb

@@ -17,18 +17,8 @@ module ZK
       # (see LockerBase#lock)
       # obtain an exclusive lock.
       #
-      def lock(blocking=false)
-        return true if synchronize { @locked }
-        create_lock_path!(EXCLUSIVE_LOCK_PREFIX)
-
-        if got_write_lock?
-          synchronize { @locked = true }
-        elsif blocking
-          block_until_write_lock!
-        else
-          cleanup_lock_path!
-          false
-        end
+      def lock(opts={})
+        super
       end
 
       # (see LockerBase#assert!)
@@ -54,6 +44,21 @@ module ZK
       end
 
       private
+        def lock_with_opts_hash(opts)
+          create_lock_path!(EXCLUSIVE_LOCK_PREFIX)
+
+          lock_opts = LockOptions.new(opts)
+
+          if got_write_lock?
+            @mutex.synchronize { @locked = true }
+          elsif lock_opts.blocking?
+            block_until_write_lock!(:timeout => lock_opts.timeout)
+          else
+            cleanup_lock_path!
+            false
+          end
+        end
+
         # the node that is next-lowest in sequence number to ours, the one we
         # watch for updates to
         def next_lowest_node
@@ -70,7 +75,7 @@ module ZK
         end
         alias got_lock? got_write_lock?
 
-        def block_until_write_lock!
+        def block_until_write_lock!(opts={})
           begin
             path = "#{root_lock_path}/#{next_lowest_node}"
             logger.debug { "#{self.class}##{__method__} path=#{path.inspect}" }
@@ -85,7 +90,7 @@ module ZK
             logger.debug { "calling block_until_deleted" }
             Thread.pass
 
-            @node_deletion_watcher.block_until_deleted
+            @node_deletion_watcher.block_until_deleted(opts)
           rescue WeAreTheLowestLockNumberException
           ensure
             logger.debug { "block_until_deleted returned" } 

data/lib/zk/locker/lock_options.rb

@@ -0,0 +1,36 @@
+module ZK
+  module Locker
+    # @private
+    class LockOptions
+      attr_reader :wait, :now, :timeout
+
+      def initialize(opts={})
+        @timeout = nil
+        @now = Time.now
+
+        raise "BLAH!" if opts.has_key?(:block)
+
+        if opts.has_key?(:timeout)
+          raise ArgumentError, ":timeout is an invalid option, use :wait with a numeric argument"
+        end
+
+        case w = opts[:wait]
+        when TrueClass, FalseClass, nil
+          @wait = false|w
+        when Numeric
+          if w < 0
+            raise ArgumentError, ":wait must be a positive float or integer, or zero, not: #{w.inspect}" 
+          end
+          @wait = true
+          @timeout = w.to_f
+        else
+          raise ArgumentError, ":wait must be true, false, nil, or Numeric, not #{w.inspect}" 
+        end
+      end
+
+      def blocking?
+        @wait
+      end
+    end
+  end
+end

data/lib/zk/locker/locker_base.rb

@@ -65,9 +65,24 @@ module ZK
       #
       # there is no non-blocking version of this method
       #
-      def with_lock
-        lock(true)
-        yield
+      # @yield [lock] calls the block with the lock instance when acquired
+      #
+      # @option opts [Numeric,true] :wait (nil) if non-nil, the amount of time to
+      #   wait for the lock to be acquired. since with_lock is only blocking,
+      #   `false` isn't a valid option. `true` is ignored (as it is the default).
+      #   If a Numeric (float or integer) option is given, maximum amount of time
+      #   to wait for lock acquisition.
+      #
+      # @raise [LockWaitTimeoutError] if the :wait timeout is exceeded
+      # @raise [ArgumentError] if :wait is false (since you can't do non-blocking)
+      def with_lock(opts={})
+        if opts[:wait].kind_of?(FalseClass)
+          raise ArgumentError, ":wait cannot be false, with_lock is only used in blocking mode"
+        end
+
+        opts = { :wait => true }.merge(opts)
+        lock(opts)
+        yield self
       ensure
         unlock
       end
@@ -148,8 +163,20 @@ module ZK
         unlock
       end
 
-      # @param blocking [true,false] if true we block the caller until we can obtain
-      #   a lock on the resource
+      # @overload lock(blocking=false)
+      #   @param blocking [true,false] if true we block the caller until we can
+      #     obtain a lock on the resource
+      #   
+      #   @deprecated in favor of the options hash style
+      #
+      # @overload lock(opts={})
+      #   @option opts [true,false,Numeric] :wait (false) If true we block the
+      #     caller until we obtain a lock on the resource. If false, we do not
+      #     block. If a Numeric, the number of seconds we should wait for the
+      #     lock to be acquired. Will raise LockWaitTimeoutError if we exceed
+      #     the timeout.
+      #
+      #   @since 1.7
       # 
       # @return [true] if we're already obtained a shared lock, or if we were able to
       #   obtain the lock in non-blocking mode.
@@ -161,16 +188,27 @@ module ZK
       # @raise [InterruptedSession] raised when blocked waiting for a lock and
       #   the underlying client's session is interrupted. 
       #
-      # @see ZK::Client::Unixisms#block_until_node_deleted more about possible execptions
-      def lock(blocking=false)
-        raise NotImplementedError
+      # @raise [LockWaitTimeoutError] if the given timeout is exceeded waiting
+      #   for the lock to be acquired
+      #
+      # @see ZK::Client::Unixisms#block_until_node_deleted for more about possible execptions
+      def lock(opts={})
+        return true if @mutex.synchronize { @locked }
+
+        case opts
+        when TrueClass, FalseClass      # old style boolean argument
+          opts = { :wait => opts }
+        end
+
+        lock_with_opts_hash(opts)
       end
 
-      # (see #lock)
+      # delegates to {#lock}
+      #
       # @deprecated the use of lock! is deprecated and may be removed or have
       #   its semantics changed in a future release
-      def lock!(blocking=false)
-        lock(blocking)
+      def lock!(opts={})
+        lock(opts)
       end
 
       # returns true if this locker is waiting to acquire lock 
@@ -243,6 +281,10 @@ module ZK
       end
 
       private
+        def lock_with_opts_hash(opts={})
+          raise NotImplementedError
+        end
+
         def synchronize
           @mutex.synchronize { yield }
         end

data/lib/zk/locker/shared_locker.rb

@@ -6,20 +6,8 @@ module ZK
       # (see LockerBase#lock)
       # obtain a shared lock.
       #
-      def lock(blocking=false)
-        return true if @locked
-        create_lock_path!(SHARED_LOCK_PREFIX)
-
-        if got_read_lock?      
-          @locked = true
-        elsif blocking
-          block_until_read_lock!
-        else
-          # we didn't get the lock, and we're not gonna wait around for it, so
-          # clean up after ourselves
-          cleanup_lock_path!
-          false
-        end
+      def lock(opts={})
+        super
       end
 
       # (see LockerBase#assert!)
@@ -93,24 +81,40 @@ module ZK
       alias got_lock? got_read_lock?
 
       private
-        # TODO: make this generic, can either block or non-block
-        def block_until_read_lock!
+        def lock_with_opts_hash(opts)
+          create_lock_path!(SHARED_LOCK_PREFIX)
+
+          lock_opts = LockOptions.new(opts)
+
+          if got_read_lock?
+            @mutex.synchronize { @locked = true }
+          elsif lock_opts.blocking?
+            block_until_read_lock!(:timeout => lock_opts.timeout)
+          else
+            # we didn't get the lock, and we're not gonna wait around for it, so
+            # clean up after ourselves
+            cleanup_lock_path!
+            false
+          end
+        end
+
+        def block_until_read_lock!(opts={})
           begin
             path = "#{root_lock_path}/#{next_lowest_write_lock_name}"
             logger.debug { "SharedLocker#block_until_read_lock! path=#{path.inspect}" }
 
-            synchronize do
+            @mutex.synchronize do
               @node_deletion_watcher = NodeDeletionWatcher.new(zk, path)
               @cond.broadcast
             end
 
-            @node_deletion_watcher.block_until_deleted
+            @node_deletion_watcher.block_until_deleted(opts)
           rescue NoWriteLockFoundException
             # next_lowest_write_lock_name may raise NoWriteLockFoundException,
             # which means we should not block as we have the lock (there is nothing to wait for)
           end
 
-          synchronize { @locked = true }
+          @mutex.synchronize { @locked = true }
         end
     end # SharedLocker
   end # Locker

data/lib/zk/node_deletion_watcher.rb

@@ -10,6 +10,7 @@ module ZK
       BLOCKED     = :yes
       NOT_ANYMORE = :not_anymore
       INTERRUPTED = :interrupted
+      TIMED_OUT   = :timed_out
     end
     include Constants
 
@@ -36,6 +37,10 @@ module ZK
       @mutex.synchronize { @blocked == BLOCKED }
     end
 
+    def timed_out?
+      @mutex.synchronize { @result == TIMED_OUT }
+    end
+
     # this is for testing, allows us to wait until this object has gone into
     # blocking state.
     #
@@ -66,7 +71,7 @@ module ZK
       end
     end
 
-    # cause a thread blocked us to be awakened and have a WakeUpException
+    # cause a thread blocked by us to be awakened and have a WakeUpException
     # raised. 
     #
     # if a result has already been delivered, then this does nothing
@@ -86,7 +91,13 @@ module ZK
       end
     end
 
-    def block_until_deleted
+    # @option opts [Numeric] :timeout (nil) if a positive integer, represents a duration in
+    #   seconds after which, if we have not acquired the lock, a LockWaitTimeoutError will
+    #   be raised in all waiting threads
+    #
+    def block_until_deleted(opts={})
+      timeout = opts[:timeout]
+
       @mutex.synchronize do
         raise InvalidStateError, "Already fired for #{path}" if @result
         register_callbacks
@@ -103,13 +114,19 @@ module ZK
 
         @blocked = BLOCKED
         @cond.broadcast                 # wake threads waiting for @blocked to change
-        @cond.wait_until { @result }    # wait until we get a result
+
+        wait_for_result(timeout)
+
         @blocked = NOT_ANYMORE
 
+        logger.debug { "got result for path: #{path}, result: #{@result.inspect}" } 
+
         case @result
         when :deleted
           logger.debug { "path #{path} was deleted" }
           return true
+        when TIMED_OUT
+          raise ZK::Exceptions::LockWaitTimeoutError, "timed out waiting for #{timeout.inspect} seconds for deletion of path: #{path.inspect}" 
         when INTERRUPTED
           raise ZK::Exceptions::WakeUpException
         when ZOO_EXPIRED_SESSION_STATE
@@ -127,6 +144,29 @@ module ZK
     end
 
     private
+      # this method must be synchronized on @mutex, obviously
+      def wait_for_result(timeout)
+        # do the deadline maths
+        time_to_stop = timeout ? (Time.now + timeout) : nil # slight time slippage between here
+                                                            #
+        until @result                                       #
+          if timeout                                        # and here
+            now = Time.now
+
+            if @result
+              return
+            elsif (now >= time_to_stop)
+              @result = TIMED_OUT
+              return
+            end
+
+            @cond.wait(time_to_stop.to_f - now.to_f)
+          else
+            @cond.wait_until { @result }
+          end
+        end
+      end
+
       def unregister_callbacks
         @subs.each(&:unregister)
       end
@@ -141,6 +181,8 @@ module ZK
 
       def node_deletion_cb(event)
         @mutex.synchronize do
+          return if @result
+
           if event.node_deleted?
             @result = :deleted
             @cond.broadcast
@@ -155,10 +197,9 @@ module ZK
 
       def session_cb(event)
         @mutex.synchronize do
-          unless @result
-            @result = event.state
-            @cond.broadcast
-          end
+          return if @result
+          @result = event.state
+          @cond.broadcast
         end
       end
   end

data/lib/zk/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "1.6.5"
+  VERSION = "1.7.0"
 end

data/spec/zk/locker/exclusive_locker_spec.rb

@@ -82,13 +82,16 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
     end
 
     describe 'blocking' do
+      let(:read_lock_path_template) { "/_zklocking/#{path}/#{ZK::Locker::SHARED_LOCK_PREFIX}" }
+
       before do
         zk.mkdir_p(root_lock_path)
+        @read_lock_path = zk.create(read_lock_path_template, '', :mode => :ephemeral_sequential)
+        @exc = nil
       end
 
-      it %[should block waiting for the lock] do
+      it %[should block waiting for the lock with old style lock semantics] do
         ary = []
-        read_lock_path = zk.create("/_zklocking/#{path}/read", '', :mode => :ephemeral_sequential)
 
         locker.lock.should be_false
 
@@ -102,13 +105,62 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
         ary.should be_empty
         locker.should_not be_locked
 
-        zk.delete(read_lock_path)
+        zk.delete(@read_lock_path)
+
+        th.join(2).should == th
+
+        ary.length.should == 1
+        locker.should be_locked
+      end
+
+      it %[should block waiting for the lock with new style lock semantics] do
+        ary = []
+
+        locker.lock.should be_false
+
+        th = Thread.new do
+          locker.lock(:wait => true)
+          ary << :locked
+        end
+
+        locker.wait_until_blocked(5)
+      
+        ary.should be_empty
+        locker.should_not be_locked
+
+        zk.delete(@read_lock_path)
 
         th.join(2).should == th
 
         ary.length.should == 1
         locker.should be_locked
       end
+
+      it %[should time out waiting for the lock] do
+        ary = []
+
+        locker.lock.should be_false
+
+        th = Thread.new do
+          begin
+            locker.lock(:wait => 0.01)
+            ary << :locked
+          rescue Exception => e
+            @exc = e
+          end
+        end
+
+        locker.wait_until_blocked(5)
+      
+        ary.should be_empty
+        locker.should_not be_locked
+
+        th.join(2).should == th
+
+        ary.should be_empty
+        @exc.should_not be_nil
+        @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+      end
     end # blocking
   end # lock
 end # ExclusiveLocker

data/spec/zk/locker/locker_basic_spec.rb

@@ -56,24 +56,90 @@ describe 'ZK::Client#locker' do
     @zk.locker("my/multi/part/path").lock.should be_true
   end
 
-  it "should blocking lock" do
-    array = []
-    first_lock = @zk.locker("mylock")
-    first_lock.lock.should be_true
-    array << :first_lock
-
-    thread = Thread.new do
-      @zk.locker("mylock").with_lock do
-        array << :second_lock
+  describe :with_lock do
+    # TODO: reorganize these tests so Convenience testing is done somewhere saner
+    #
+    # this tests ZK::Client::Conveniences, maybe shouldn't be *here*
+    describe 'Client::Conveniences' do
+      it %[should yield the lock instance to the block] do
+        @zk.with_lock(@path_to_lock) do |lock|
+          lock.should_not be_nil
+          lock.should be_kind_of(ZK::Locker::LockerBase)
+          lambda { lock.assert! }.should_not raise_error
+        end
+      end
+
+      it %[should yield a shared lock when :mode => shared given] do
+        @zk.with_lock(@path_to_lock, :mode => :shared) do |lock|
+          lock.should_not be_nil
+          lock.should be_kind_of(ZK::Locker::SharedLocker)
+          lambda { lock.assert! }.should_not raise_error
+        end
+      end
+
+      it %[should take a timeout] do
+        first_lock = @zk.locker(@path_to_lock)
+        first_lock.lock.should be_true
+
+        thread = Thread.new do
+          begin
+            @zk.with_lock(@path_to_lock, :wait => 0.01) do |lock|
+              raise "NO NO NO!! should not have called the block!!"
+            end
+          rescue Exception => e
+            @exc = e
+          end
+        end
+
+        thread.join(2).should == thread
+        @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
       end
-      array.length.should == 2
     end
 
-    array.length.should == 1
-    first_lock.unlock
-    thread.join(10)
-    array.length.should == 2
-  end
+    describe 'LockerBase' do
+      it "should blocking lock" do
+        array = []
+        first_lock = @zk.locker("mylock")
+        first_lock.lock.should be_true
+        array << :first_lock
+
+        thread = Thread.new do
+          @zk.locker("mylock").with_lock do
+            array << :second_lock
+          end
+          array.length.should == 2
+        end
+
+        array.length.should == 1
+        first_lock.unlock
+        thread.join(10)
+        array.length.should == 2
+      end
+
+      it %[should accept a :wait option] do
+        array = []
+        first_lock = @zk.locker("mylock")
+        first_lock.lock.should be_true
+
+        second_lock = @zk.locker("mylock")
+
+        thread = Thread.new do
+          begin
+            second_lock.with_lock(:wait => 0.01) do
+              array << :second_lock
+            end
+          rescue Exception => e
+            @exc = e
+          end
+        end
+
+        array.should be_empty
+        thread.join(2).should == thread
+        @exc.should_not be_nil
+        @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+      end
+    end
+  end # with_lock
 end
 
 

data/spec/zk/locker/shared_locker_spec.rb

@@ -85,38 +85,93 @@ shared_examples_for 'ZK::Locker::SharedLocker' do
       end
     end
 
-    describe 'blocking success' do
+    context do
       before do
         zk.mkdir_p(root_lock_path)
         @write_lock_path = zk.create("#{root_lock_path}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", '', :mode => :ephemeral_sequential)
-        $stderr.sync = true
+        @exc = nil
       end
 
-      it %[should acquire the lock after the write lock is released] do
-        ary = []
+      describe 'blocking success' do
+        it %[should acquire the lock after the write lock is released old-style] do
+          ary = []
 
-        locker.lock.should be_false
+          locker.lock.should be_false
 
-        th = Thread.new do
-          locker.lock(true)
-          ary << :locked
+          th = Thread.new do
+            locker.lock(true)
+            ary << :locked
+          end
+
+          locker.wait_until_blocked(5)
+          locker.should be_waiting
+          locker.should_not be_locked
+          ary.should be_empty
+
+          zk.delete(@write_lock_path)
+
+          th.join(2).should == th
+
+          ary.should_not be_empty
+          ary.length.should == 1
+
+          locker.should be_locked
         end
 
-        locker.wait_until_blocked(5)
-        locker.should be_waiting
-        locker.should_not be_locked
-        ary.should be_empty
+        it %[should acquire the lock after the write lock is released new-style] do
+          ary = []
 
-        zk.delete(@write_lock_path)
+          locker.lock.should be_false
 
-        th.join(2).should == th
+          th = Thread.new do
+            locker.lock(:wait => true)
+            ary << :locked
+          end
 
-        ary.should_not be_empty
-        ary.length.should == 1
+          locker.wait_until_blocked(5)
+          locker.should be_waiting
+          locker.should_not be_locked
+          ary.should be_empty
 
-        locker.should be_locked
+          zk.delete(@write_lock_path)
+
+          th.join(2).should == th
+
+          ary.should_not be_empty
+          ary.length.should == 1
+
+          locker.should be_locked
+        end
       end
-    end
+
+      describe 'blocking timeout' do
+        it %[should raise LockWaitTimeoutError] do
+          ary = []
+
+          locker.lock.should be_false
+
+          th = Thread.new do
+            begin
+              locker.lock(:wait => 0.01)
+              ary << :locked
+            rescue Exception => e
+              @exc = e
+            end
+          end
+
+          locker.wait_until_blocked(5)
+          locker.should be_waiting
+          locker.should_not be_locked
+          ary.should be_empty
+
+          th.join(2).should == th
+
+          ary.should be_empty
+          @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+        end
+
+      end
+    end # context
   end # lock
 
   it_should_behave_like 'LockerBase#unlock'

data/spec/zk/node_deletion_watcher_spec.rb

@@ -7,6 +7,7 @@ describe ZK::NodeDeletionWatcher do
     @path = "#{@base_path}/node_deleteion_watcher_victim"
 
     @n = ZK::NodeDeletionWatcher.new(@zk, @path)
+    @exc = nil
   end
 
   describe %[when the node already exists] do
@@ -31,8 +32,7 @@ describe ZK::NodeDeletionWatcher do
     it %[should wake up if interrupt! is called] do
       @zk.mkdir_p(@path)
 
-      @exc = nil
-
+      # see _eric!! i had to do this because of 1.8.7!
       th = Thread.new do
         begin
           @n.block_until_deleted
@@ -50,6 +50,28 @@ describe ZK::NodeDeletionWatcher do
 
       @exc.should be_kind_of(ZK::Exceptions::WakeUpException)
     end
+
+    it %[should raise LockWaitTimeoutError if we time out waiting for a node to be deleted] do
+      @zk.mkdir_p(@path)
+
+      th = Thread.new do
+        begin
+          @n.block_until_deleted(:timeout => 0.02)
+        rescue Exception => e
+          @exc = e
+        end
+      end
+
+      @n.wait_until_blocked(5).should be_true
+
+      logger.debug { "wait_until_blocked returned" }
+
+      th.join(5).should == th
+      
+      @exc.should be_kind_of(ZK::Exceptions::LockWaitTimeoutError)
+      @n.should be_done
+      @n.should be_timed_out
+    end
   end
 
   describe %[when the node doesn't exist] do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zk
 version: !ruby/object:Gem::Version 
-  hash: 5
+  hash: 11
   prerelease: 
   segments: 
   - 1
-  - 6
-  - 5
-  version: 1.6.5
+  - 7
+  - 0
+  version: 1.7.0
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-21 00:00:00 Z
+date: 2012-08-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: zookeeper
@@ -99,6 +99,7 @@ files:
 - lib/zk/install_fork_hooks.rb
 - lib/zk/locker.rb
 - lib/zk/locker/exclusive_locker.rb
+- lib/zk/locker/lock_options.rb
 - lib/zk/locker/locker_base.rb
 - lib/zk/locker/shared_locker.rb
 - lib/zk/logging.rb