zk 1.7.1 → 1.7.2

data/lib/zk/client/state_mixin.rb

@@ -32,9 +32,12 @@ module ZK
         watcher.register_state_handler(:connecting, &block)
       end
 
-      # register a block to be called when our session has expired. This usually happens
-      # due to a network partitioning event, and means that all callbacks and watches must
-      # be re-registered with the server
+      # register a block to be called when our session has expired. This
+      # usually happens due to a network partitioning event, and means that all
+      # watches must be re-registered with the server (i.e. after the
+      # on_connected event is received). Callbacks set up via #register are
+      # still valid and will respond to events, it's the event delivery you
+      # have to set up again by using :watch.
       #
       # @todo need to come up with a way to test this
       def on_expired_session(&block)

data/lib/zk/locker/exclusive_locker.rb

@@ -54,9 +54,10 @@ module ZK
           elsif lock_opts.blocking?
             block_until_write_lock!(:timeout => lock_opts.timeout)
           else
-            cleanup_lock_path!
             false
           end
+        ensure
+          cleanup_lock_path! unless @mutex.synchronize { @locked }
         end
 
         # the node that is next-lowest in sequence number to ours, the one we
@@ -92,15 +93,6 @@ module ZK
 
             @node_deletion_watcher.block_until_deleted(opts)
           rescue WeAreTheLowestLockNumberException
-          rescue ZK::Exceptions::LockWaitTimeoutError
-            # in the case of a timeout exception, we need to ensure the lock
-            # path is cleaned up, since we're not interested in acquisition
-            # anymore
-            logger.warn { "got ZK::Exceptions::LockWaitTimeoutError, cleaning up lock path" }
-            cleanup_lock_path!
-            raise
-          ensure
-            logger.debug { "block_until_deleted returned" } 
           end
 
           @mutex.synchronize { @locked = true }

data/lib/zk/locker/shared_locker.rb

@@ -91,11 +91,10 @@ module ZK
           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
+        ensure
+          cleanup_lock_path! unless @mutex.synchronize { @locked }
         end
 
         def block_until_read_lock!(opts={})
@@ -109,12 +108,6 @@ module ZK
             end
 
             @node_deletion_watcher.block_until_deleted(opts)
-          rescue ZK::Exceptions::LockWaitTimeoutError
-            # in the case of a timeout exception, we need to ensure the lock
-            # path is cleaned up, since we're not interested in acquisition
-            # anymore
-            cleanup_lock_path!
-            raise
           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)

data/lib/zk/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "1.7.1"
+  VERSION = "1.7.2"
 end

data/spec/zk/locker/exclusive_locker_spec.rb

@@ -15,31 +15,32 @@ shared_examples_for 'ZK::Locker::ExclusiveLocker' do
       zk.mkdir_p(rlp)
 
       bogus_path = zk.create("#{rlp}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", :sequential => true, :ephemeral => true)
+      logger.debug { "bogus_path: #{bogus_path.inspect}" } 
 
       th = Thread.new do
-        locker2.lock(true)
+        locker.lock(true)
       end
 
       th.run
 
       logger.debug { "calling wait_until_blocked" }
-      proc { locker2.wait_until_blocked(2) }.should_not raise_error
+      proc { locker.wait_until_blocked(5) }.should_not raise_error
       logger.debug { "wait_until_blocked returned" }
-      locker2.should be_waiting
+      locker.should be_waiting
 
-      wait_until { zk.exists?(locker2.lock_path) }
+      wait_until { zk.exists?(locker.lock_path) }
 
-      zk.exists?(locker2.lock_path).should be_true
+      zk.exists?(locker.lock_path).should be_true
 
       zk.delete(bogus_path)
 
       th.join(5).should == th
 
-      locker2.lock_path.should_not == bogus_path
+      locker.lock_path.should_not == bogus_path
 
       zk.create(bogus_path, :ephemeral => true)
 
-      lambda { locker2.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+      lambda { locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zk
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 15
   prerelease: 
   segments: 
   - 1
   - 7
-  - 1
-  version: 1.7.1
+  - 2
+  version: 1.7.2
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-22 00:00:00 Z
+date: 2012-10-08 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: zookeeper