zk 1.1.1 → 1.2.0

data/lib/zk/locker/shared_locker.rb

@@ -3,24 +3,10 @@ module ZK
     class SharedLocker < LockerBase
       include Exceptions
 
+      # (see LockerBase#lock)
       # obtain a shared lock.
       #
-      # @param blocking [true,false] if true we block the caller until we can obtain
-      #   a lock on the resource
-      # 
-      # @return [true] if we're already obtained a shared lock, or if we were able to
-      #   obtain the lock in non-blocking mode.
-      #
-      # @return [false] if we did not obtain the lock in non-blocking mode
-      #
-      # @return [void] if we obtained the lock in blocking mode. 
-      #
-      # @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)
+      def lock(blocking=false)
         return true if @locked
         create_lock_path!(SHARED_LOCK_PREFIX)
 
@@ -38,9 +24,35 @@ module ZK
         end
       end
 
+      # (see LockerBase#assert!)
+      #
+      # checks that we:
+      #
+      # * we have obtained the lock (i.e. {#locked?} is true)
+      # * have a lock path
+      # * our lock path still exists
+      # * there are no exclusive locks with lower numbers than ours
+      # 
+      def assert!
+        super
+      end
+
+      # (see LockerBase#locked?)
+      def locked?
+        false|@locked
+      end
+
+      # (see LockerBase#acquirable?)
+      def acquirable?
+        return true if locked?
+        !lock_children.any? { |n| n.start_with?(EXCLUSIVE_LOCK_PREFIX) }
+      rescue Exceptions::NoNode
+        true
+      end
+
       # @private
       def lock_number
-        @lock_number ||= (lock_path and digit_from(lock_path))
+        lock_path and digit_from(lock_path)
       end
 
       # returns the sequence number of the next lowest write lock node
@@ -69,9 +81,9 @@ module ZK
         ary = ordered_lock_children()
         my_idx = ary.index(lock_basename)   # our idx would be 2
 
-        not_found = lambda { raise NoWriteLockFoundException }
-
-        ary[0..my_idx].reverse.find(not_found) { |n| n =~ /^#{EXCLUSIVE_LOCK_PREFIX}/ }
+        ary[0..my_idx].reverse.find { |n| n.start_with?(EXCLUSIVE_LOCK_PREFIX) }.tap do |rv|
+          raise NoWriteLockFoundException if rv.nil?
+        end
       end
 
       # @private
@@ -80,13 +92,13 @@ module ZK
       rescue NoWriteLockFoundException
         true
       end
+      alias got_lock? got_read_lock?
 
       protected
         # TODO: make this generic, can either block or non-block
-        # @private
         def block_until_read_lock!
           begin
-            path = [root_lock_path, next_lowest_write_lock_name].join('/')
+            path = "#{root_lock_path}/#{next_lowest_write_lock_name}"
             logger.debug { "SharedLocker#block_until_read_lock! path=#{path.inspect}" }
             @zk.block_until_node_deleted(path)
           rescue NoWriteLockFoundException

data/lib/zk/stat.rb

@@ -1,5 +1,5 @@
 module ZK
-  # Included in ZookeeperStat::Stat, extends it with some conveniences for 
+  # Included in Zookeeper::Stat, extends it with some conveniences for 
   # dealing with Stat objects. Also provides docuemntation here for the meaning
   # of these values.
   #
@@ -109,7 +109,7 @@ module ZK
   end # Stat
 end # ZK
 
-class ZookeeperStat::Stat
+class Zookeeper::Stat
   include ZK::Stat
 end
 

data/lib/zk/subscription.rb

@@ -0,0 +1,65 @@
+module ZK
+  # Basic pattern for objects that have the concept of a parent (the thing that 
+  # granted this subscription), a callback, and that can unregister (so the
+  # callback no longer receives events). 
+  #
+  # expects the 'parent' to respond_to? the 'unregister' method, and will
+  # be passed the subscription instance 
+  module Subscription
+    class Base
+      include ZK::Logging
+
+      # the object from which we will attempt to #unregister on
+      # XXX: need a better name for this
+      attr_reader :parent
+      
+      # the user-supplied callback block, used to create a ThreadedCallback
+      attr_reader :callable
+
+      def initialize(parent, block)
+        raise ArgumentError, "block must repsond_to?(:call)" unless block.respond_to?(:call)
+        @parent = parent
+        @callable = block
+        @mutex = Monitor.new
+      end
+
+      def unregister
+        parent.unregister(self)
+      end
+      alias unsubscribe unregister
+
+      # @private
+      def call(*args)
+        callable.call(*args)
+      end
+
+      protected
+        def synchronize
+          @mutex.synchronize { yield }
+        end
+    end
+
+    module ActorStyle
+      extend Concern
+
+      included do
+        alias_method_chain :unsubscribe, :threaded_callback
+        alias_method_chain :callable, :threaded_callback_wrapper
+      end
+
+      def unsubscribe_with_threaded_callback
+        synchronize do
+          @threaded_callback.shutdown
+          unsubscribe_without_threaded_callback
+        end
+      end
+    
+      def callable_with_threaded_callback_wrapper(*args)
+        synchronize do 
+          @threaded_callback ||= ThreadedCallback.new(@callable) 
+        end
+      end
+    end
+  end
+end
+

data/lib/zk/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/notes/documentation-notes

@@ -0,0 +1,20 @@
+A Day at the Races
+
+* What are race conditions?
+  * Simple example with changing a node
+  * Simple example with a node being deleted
+* What pattern do we use in ZK to manage this problem?
+
+```ruby
+def block_until_node_deleted(zk, abs_node_path)
+  node_deletion_cb = lambda do |event|
+    if event.node_deleted?
+    queue.enq(:deleted) 
+    else
+    queue.enq(:deleted) unless exists?(abs_node_path, :watch => true)
+    end
+  end
+
+subs << event_handler.register(abs_node_path, &node_deletion_cb)
+```
+

data/notes/voting-notes.txt

@@ -0,0 +1,39 @@
+overall subject of voting is '/blah'
+
+all nodes denote presence create('/blah/nodes/id', '', :ephemeral => true)
+
+coordinator notes children('/blah/nodes/id', watch: true)
+
+if any presence nodes are deleted, the transaction is aborted
+
+nodes children('/blah/tx', watch: true)
+
+coordinator voteseq = create('/blah/tx/vote', 'proposal', sequential: true)              # beginning of election
+
+coordinator children('/blah/tx/voteseq', watch: true)                   # loop until all nodes checked in
+
+nodes children('/blah/tx') 
+nodes children('/blah/tx/voteseq', watch: true)                         # all nodes voted, then commit
+nodes get('/blah/tx/voteseq', watch: true)                              # if data == 'abort' then delete id node
+nodes get('/blah/tx/votes_uuid/result' watch: true)                       # result will be placed here?
+nodes create('/blah/tx/voteseq/id', up_or_down, ephemeral: true)        # any node votes down, abort
+
+# coordinator sees all votes have been cast
+
+# NOTE: is this step necessary? the coordinator confirming?
+
+coordinator create('/blah/tx/voteseq/result', up_or_down, ephemeral: true) 
+
+# nodes tear down
+
+node delete('/blah/tx/voteseq/id')
+
+# when just result node is left
+
+coordinator rm_rf('/blah/tx/voteseq')
+
+
+# at many points we need a timer to see if things are taking too long
+
+
+

data/spec/event_catcher_spec.rb

@@ -4,19 +4,22 @@ require 'spec_helper'
 describe EventCatcher do
   subject { EventCatcher.new }
 
+  let!(:latch) { Latch.new }
+
   describe :wait_for do
     it %[should wake when an event is delivered] do
+
       th = Thread.new do
         subject.synchronize do
           logger.debug { "about to wait for created" }
+          latch.release
           subject.wait_for_created
           logger.debug { "woke up, created must have been delivered" }
         end
         true
       end
 
-      th.run
-      Thread.pass until th.status == 'sleep'
+      latch.await
 
       logger.debug { "th.status: #{th.status}" }
 

data/spec/informal/close-in-event-thread.rb

@@ -8,7 +8,7 @@ ZK.logger = LOG
 Zookeeper.logger = LOG
 
 class CloseInEventThread
-  include ZookeeperConstants
+  include Zookeeper::Constants
 
   def initialize
     @zk = ZK.new

data/spec/shared/client_examples.rb

@@ -116,7 +116,7 @@ shared_examples_for 'client' do
       end
 
       it %[should return a Stat object] do
-        @zk.stat(@missing_path).should be_kind_of(ZookeeperStat::Stat)
+        @zk.stat(@missing_path).should be_kind_of(Zookeeper::Stat)
       end
 
       it %[should return a stat that not exists?] do

data/spec/spec_helper.rb

@@ -1,7 +1,14 @@
 require 'rubygems'
 require 'bundler/setup'
 
-# $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+# not a constant so we don't pollute global namespace
+release_ops_path = File.expand_path('../../releaseops/lib', __FILE__)
+
+if File.exists?(release_ops_path)
+  require File.join(release_ops_path, 'releaseops')
+  ReleaseOps::SimpleCov.maybe_start
+end
+
 
 Bundler.require(:development, :test)
 

data/spec/support/event_catcher.rb

@@ -6,7 +6,7 @@ class EventCatcher
 
   MEMBERS = [:created, :changed, :deleted, :child, :all]
 
-  attr_reader :events
+  attr_reader :events, :mutex
     
   def initialize(*args)
     @mutex = Monitor.new
@@ -64,15 +64,15 @@ class EventCatcher
 
       # waits for an event group to not be empty (up to timeout sec)
       def wait_for_#{name}(timeout=5)
-        cond(:#{name}).wait(timeout)
+        wait_for(:#{name}, timeout)
       end
 
-      def wait_while_#{name}
-        cond(:#{name}).wait_while { yield __send__(:#{name}) }
+      def wait_while_#{name}(&blk)
+        wait_while(:#{name}, &blk)
       end
 
-      def wait_until_#{name}
-        cond(:#{name}).wait_until { yield __send__(:#{name}) }
+      def wait_until_#{name}(&blk)
+        wait_until(:#{name}, &blk)
       end
     EOS
   end

data/spec/support/latch.rb

@@ -0,0 +1,23 @@
+# the much fabled 'latch' that tenderlove and nahi were on about
+
+class Latch
+  def initialize(count = 1)
+    @count = count
+    @mutex = Monitor.new
+    @cond = @mutex.new_cond
+  end
+
+  def release
+    @mutex.synchronize {
+      @count -= 1 if @count > 0
+      @cond.broadcast if @count.zero?
+    }
+  end
+
+  def await
+    @mutex.synchronize {
+      @cond.wait_while { @count > 0 }
+    }
+  end
+end
+

data/spec/support/logging.rb

@@ -21,7 +21,7 @@ module SpecGlobalLogger
   # sets the log level to FATAL for the duration of the block
   def mute_logger
     orig_level, ZK.logger.level = ZK.logger.level, Logger::FATAL
-    orig_zk_level, Zookeeper.debug_level = Zookeeper.debug_level, ZookeeperConstants::ZOO_LOG_LEVEL_ERROR
+    orig_zk_level, Zookeeper.debug_level = Zookeeper.debug_level, Zookeeper::Constants::ZOO_LOG_LEVEL_ERROR
     yield
   ensure
     ZK.logger.level = orig_level

data/spec/watch_spec.rb

@@ -378,7 +378,7 @@ describe ZK do
           m.should_receive(:zk=).with(any())
           m.should_receive(:node_event?).and_return(false)
           m.should_receive(:state_event?).and_return(true)
-          m.should_receive(:state).and_return(ZookeeperConstants::ZOO_CONNECTED_STATE)
+          m.should_receive(:state).and_return(Zookeeper::Constants::ZOO_CONNECTED_STATE)
         end
       end
     end # registered listeners

data/spec/zk/client/locking_and_session_death_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 shared_examples_for 'session death' do
   def deliver_session_event_to(event_num, zk)
     # jeez, Zookeeper callbacks are so frustratingly stupid
-    bogus_event = ZookeeperCallbacks::WatcherCallback.new
+    bogus_event = Zookeeper::Callbacks::WatcherCallback.new
     bogus_event.initialize_context(:type => -1, :state => event_num, :path => '', :context => 'bogustestevent')
     # XXX: this is bad because we're in the wrong thread, but we'll fix this after the next Zookeeper release
     zk.event_handler.process(bogus_event)
@@ -51,22 +51,22 @@ end # session death
 shared_examples_for 'locking and session death' do
   describe 'exceptional conditions' do
     describe 'ZOO_EXPIRED_SESSION_STATE' do
-      let(:zoo_state) { ZookeeperConstants::ZOO_EXPIRED_SESSION_STATE }
-      let(:zoo_error_class) { ZookeeperExceptions::ZookeeperException::SessionExpired }
+      let(:zoo_state) { Zookeeper::Constants::ZOO_EXPIRED_SESSION_STATE }
+      let(:zoo_error_class) { Zookeeper::Exceptions::SessionExpired }
 
       it_behaves_like 'session death'
     end
 
     describe 'ZOO_CONNECTING_STATE' do
-      let(:zoo_state) { ZookeeperConstants::ZOO_CONNECTING_STATE }
-      let(:zoo_error_class) { ZookeeperExceptions::ZookeeperException::NotConnected }
+      let(:zoo_state) { Zookeeper::Constants::ZOO_CONNECTING_STATE }
+      let(:zoo_error_class) { Zookeeper::Exceptions::NotConnected }
 
       it_behaves_like 'session death'
     end
 
     describe 'ZOO_CLOSED_STATE' do
-      let(:zoo_state) { ZookeeperConstants::ZOO_CLOSED_STATE }
-      let(:zoo_error_class) { ZookeeperExceptions::ZookeeperException::ConnectionClosed }
+      let(:zoo_state) { Zookeeper::Constants::ZOO_CLOSED_STATE }
+      let(:zoo_error_class) { Zookeeper::Exceptions::ConnectionClosed }
 
       it_behaves_like 'session death'
     end

data/spec/zk/locker_spec.rb

@@ -23,42 +23,42 @@ describe 'ZK::Client#locker' do
   end
 
   it "should be able to acquire the lock if no one else is locking it" do
-    @zk.locker(@path_to_lock).lock!.should be_true
+    @zk.locker(@path_to_lock).lock.should be_true
   end
 
   it "should not be able to acquire the lock if someone else is locking it" do
-    @zk.locker(@path_to_lock).lock!.should be_true
-    @zk2.locker(@path_to_lock).lock!.should be_false
+    @zk.locker(@path_to_lock).lock.should be_true
+    @zk2.locker(@path_to_lock).lock.should be_false
   end
 
   it "should be able to acquire the lock after the first one releases it" do
     lock1 = @zk.locker(@path_to_lock)
     lock2 = @zk2.locker(@path_to_lock)
     
-    lock1.lock!.should be_true
-    lock2.lock!.should be_false
-    lock1.unlock!
-    lock2.lock!.should be_true
+    lock1.lock.should be_true
+    lock2.lock.should be_false
+    lock1.unlock
+    lock2.lock.should be_true
   end
 
   it "should be able to acquire the lock if the first locker goes away" do
     lock1 = @zk.locker(@path_to_lock)
     lock2 = @zk2.locker(@path_to_lock)
 
-    lock1.lock!.should be_true
-    lock2.lock!.should be_false
+    lock1.lock.should be_true
+    lock2.lock.should be_false
     @zk.close!
-    lock2.lock!.should be_true
+    lock2.lock.should be_true
   end
 
   it "should be able to handle multi part path locks" do
-    @zk.locker("my/multi/part/path").lock!.should be_true
+    @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
+    first_lock.lock.should be_true
     array << :first_lock
 
     thread = Thread.new do
@@ -69,7 +69,7 @@ describe 'ZK::Client#locker' do
     end
 
     array.length.should == 1
-    first_lock.unlock!
+    first_lock.unlock
     thread.join(10)
     array.length.should == 2
   end
@@ -77,26 +77,87 @@ describe 'ZK::Client#locker' do
 end
 
 shared_examples_for 'SharedLocker' do
-  before do
-    @shared_locker  = ZK::Locker.shared_locker(zk, path)
-    @shared_locker2 = ZK::Locker.shared_locker(zk2, path)
+  let(:shared_locker)  { ZK::Locker.shared_locker(zk, path) }
+  let(:shared_locker2) { ZK::Locker.shared_locker(zk2, path) }
+
+  describe :assert! do
+    it %[should raise LockAssertionFailedError if its connection is no longer connected?] do
+      zk.close!
+      lambda { shared_locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+
+    it %[should raise LockAssertionFailedError if locked? is false] do
+      shared_locker.should_not be_locked
+      lambda { shared_locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+
+    it %[should raise LockAssertionFailedError lock_path does not exist] do
+      shared_locker.lock
+      lambda { shared_locker.assert! }.should_not raise_error
+
+      zk.delete(shared_locker.lock_path)
+      lambda { shared_locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+
+    it %[should raise LockAssertionFailedError if there is an exclusive lock with a number lower than ours] do
+      # this should *really* never happen
+      shared_locker.lock.should be_true
+      shl_path = shared_locker.lock_path
+
+      shared_locker2.lock.should be_true
+
+      shared_locker.unlock.should be_true
+      shared_locker.should_not be_locked
+
+      zk.exists?(shl_path).should be_false
+
+      shared_locker2.lock_path.should_not == shl_path
+
+      # convert the first shared lock path into a exclusive one
+
+      exl_path = shl_path.sub(%r%/sh(\d+)\Z%, '/ex\1')
+
+      zk.create(exl_path, :ephemeral => true)
+
+      lambda { shared_locker2.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+  end
+
+  describe :acquirable? do
+    describe %[with default options] do
+      it %[should work if the lock root doesn't exist] do
+        zk.rm_rf(ZK::Locker.default_root_lock_node)
+        shared_locker.should be_acquirable
+      end
+
+      it %[should check local state of lockedness] do
+        shared_locker.lock.should be_true
+        shared_locker.should be_acquirable
+      end
+
+      it %[should check if any participants would prevent us from acquiring the lock] do
+        ex_lock = ZK::Locker.exclusive_locker(zk, path)
+        ex_lock.lock.should be_true
+        shared_locker.should_not be_acquirable
+      end
+    end
   end
 
-  describe :lock! do
+  describe :lock do
     describe 'non-blocking success' do
       before do
-        @rval   = @shared_locker.lock!
-        @rval2  = @shared_locker2.lock!
+        @rval   = shared_locker.lock
+        @rval2  = shared_locker2.lock
       end
 
       it %[should acquire the first lock] do
         @rval.should be_true
-        @shared_locker.should be_locked
+        shared_locker.should be_locked
       end
 
       it %[should acquire the second lock] do
         @rval2.should be_true
-        @shared_locker2.should be_locked
+        shared_locker2.should be_locked
       end
     end
 
@@ -104,11 +165,7 @@ shared_examples_for 'SharedLocker' 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)
-        @rval = @shared_locker.lock!
-      end
-
-      after do
-        zk.rm_rf('/_zklocking')
+        @rval = shared_locker.lock
       end
 
       it %[should return false] do
@@ -116,7 +173,7 @@ shared_examples_for 'SharedLocker' do
       end
 
       it %[should not be locked] do
-        @shared_locker.should_not be_locked
+        shared_locker.should_not be_locked
       end
     end
 
@@ -130,15 +187,15 @@ shared_examples_for 'SharedLocker' do
       it %[should acquire the lock after the write lock is released] do
         ary = []
 
-        @shared_locker.lock!.should be_false
+        shared_locker.lock.should be_false
 
         th = Thread.new do
-          @shared_locker.lock!(true)
+          shared_locker.lock(true)
           ary << :locked
         end
 
         ary.should be_empty
-        @shared_locker.should_not be_locked
+        shared_locker.should_not be_locked
 
         zk.delete(@write_lock_path)
 
@@ -147,23 +204,82 @@ shared_examples_for 'SharedLocker' do
         wait_until(2) { !ary.empty? }
         ary.length.should == 1
 
-        @shared_locker.should be_locked
+        shared_locker.should be_locked
       end
     end
   end
 end   # SharedLocker
 
 shared_examples_for 'ExclusiveLocker' do
-  before do
-    @ex_locker = ZK::Locker.exclusive_locker(zk, path)
-    @ex_locker2 = ZK::Locker.exclusive_locker(zk2, path)
+  let(:ex_locker) { ZK::Locker.exclusive_locker(zk, path) }
+  let(:ex_locker2) { ZK::Locker.exclusive_locker(zk2, path) }
+
+  describe :assert! do
+    it %[should raise LockAssertionFailedError if its connection is no longer connected?] do
+      zk.close!
+      lambda { ex_locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+
+    it %[should raise LockAssertionFailedError if locked? is false] do
+      ex_locker.should_not be_locked
+      lambda { ex_locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+
+    it %[should raise LockAssertionFailedError lock_path does not exist] do
+      ex_locker.lock
+      lambda { ex_locker.assert! }.should_not raise_error
+
+      zk.delete(ex_locker.lock_path)
+      lambda { ex_locker.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+
+    it %[should raise LockAssertionFailedError if there is an exclusive lock with a number lower than ours] do
+      # this should *really* never happen
+      ex_locker.lock.should be_true
+      exl_path = ex_locker.lock_path
+
+      th = Thread.new do
+        ex_locker2.lock(true)
+      end
+
+      wait_until { th.status == 'sleep' }
+
+      ex_locker.unlock.should be_true
+      ex_locker.should_not be_locked
+      zk.exists?(exl_path).should be_false
+
+      th.join(5).should == th
+
+      ex_locker2.lock_path.should_not == exl_path
+
+      zk.create(exl_path, :ephemeral => true)
+
+      lambda { ex_locker2.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
+    end
+  end
+
+  describe :acquirable? do
+    it %[should work if the lock root doesn't exist] do
+      zk.rm_rf(ZK::Locker.default_root_lock_node)
+      ex_locker.should be_acquirable
+    end
+
+    it %[should check local state of lockedness] do
+      ex_locker.lock.should be_true
+      ex_locker.should be_acquirable
+    end
+
+    it %[should check if any participants would prevent us from acquiring the lock] do
+      ex_locker.lock.should be_true
+      ex_locker2.should_not be_acquirable
+    end
   end
 
-  describe :lock! do
+  describe :lock do
     describe 'non-blocking' do
       before do
-        @rval = @ex_locker.lock!
-        @rval2 = @ex_locker2.lock!
+        @rval = ex_locker.lock
+        @rval2 = ex_locker2.lock
       end
 
       it %[should acquire the first lock] do
@@ -175,8 +291,8 @@ shared_examples_for 'ExclusiveLocker' do
       end
 
       it %[should acquire the second lock after the first lock is released] do
-        @ex_locker.unlock!.should be_true
-        @ex_locker2.lock!.should be_true
+        ex_locker.unlock.should be_true
+        ex_locker2.lock.should be_true
       end
     end
 
@@ -189,41 +305,39 @@ shared_examples_for 'ExclusiveLocker' do
       it %[should block waiting for the lock] do
         ary = []
 
-        @ex_locker.lock!.should be_false
+        ex_locker.lock.should be_false
 
         th = Thread.new do
-          @ex_locker.lock!(true)
+          ex_locker.lock(true)
           ary << :locked
         end
 
         th.run
       
         ary.should be_empty
-        @ex_locker.should_not be_locked
+        ex_locker.should_not be_locked
 
         zk.delete(@read_lock_path)
 
         th.join(2)
 
         ary.length.should == 1
-        @ex_locker.should be_locked
+        ex_locker.should be_locked
       end
     end
-
   end
 end # ExclusiveLocker
 
 shared_examples_for 'shared-exclusive interaction' do
   before do
-    zk.rm_rf('/_zklocking')
     @sh_lock = ZK::Locker.shared_locker(zk, path)
     @ex_lock = ZK::Locker.exclusive_locker(zk2, path)
   end
 
   describe 'shared lock acquired first' do
     it %[should block exclusive locks from acquiring until released] do
-      @sh_lock.lock!.should be_true
-      @ex_lock.lock!.should be_false
+      @sh_lock.lock.should be_true
+      @ex_lock.lock.should be_false
 
       mutex = Monitor.new
       cond = mutex.new_cond
@@ -242,7 +356,7 @@ shared_examples_for 'shared-exclusive interaction' do
 
       mutex.synchronize do
         logger.debug { "unlocking the shared lock" }
-        @sh_lock.unlock!.should be_true
+        @sh_lock.unlock.should be_true
         cond.wait_until { th[:got_lock] }   # make sure they actually received the lock (avoid race)
         th[:got_lock].should be_true
         logger.debug { "ok, they got the lock" }
@@ -258,8 +372,8 @@ shared_examples_for 'shared-exclusive interaction' do
 
   describe 'exclusive lock acquired first' do
     it %[should block shared lock from acquiring until released] do
-      @ex_lock.lock!.should be_true
-      @sh_lock.lock!.should be_false
+      @ex_lock.lock.should be_true
+      @sh_lock.lock.should be_false
 
       mutex = Monitor.new
       cond = mutex.new_cond
@@ -278,7 +392,7 @@ shared_examples_for 'shared-exclusive interaction' do
 
       mutex.synchronize do
         logger.debug { "unlocking the shared lock" }
-        @ex_lock.unlock!.should be_true
+        @ex_lock.unlock.should be_true
         cond.wait_until { th[:got_lock] }   # make sure they actually received the lock (avoid race)
         th[:got_lock].should be_true
         logger.debug { "ok, they got the lock" }
@@ -301,16 +415,16 @@ shared_examples_for 'shared-exclusive interaction' do
     it %[should act something like a queue] do
       @array = []
 
-      @sh_lock.lock!.should be_true
+      @sh_lock.lock.should be_true
       @sh_lock.should be_locked
 
       ex_th = Thread.new do
         begin
-          @ex_lock.lock!(true)  # blocking lock
+          @ex_lock.lock(true)  # blocking lock
           Thread.current[:got_lock] = true
           @array << :ex_lock
         ensure
-          @ex_lock.unlock!
+          @ex_lock.unlock
         end
       end
 
@@ -320,22 +434,22 @@ shared_examples_for 'shared-exclusive interaction' do
 
       # this is the important one, does the second shared lock get blocked by
       # the exclusive lock
-      @sh_lock2.lock!.should_not be_true
+      @sh_lock2.lock.should_not be_true
 
       sh2_th = Thread.new do
         begin
-          @sh_lock2.lock!(true)
+          @sh_lock2.lock(true)
           Thread.current[:got_lock] = true
           @array << :sh_lock2
         ensure
-          @sh_lock2.unlock!
+          @sh_lock2.unlock
         end
       end
 
       sh2_th.join_until { @sh_lock2.waiting? }
       @sh_lock2.should be_waiting
 
-      @sh_lock.unlock!.should be_true
+      @sh_lock.unlock.should be_true
 
       ex_th.join_until { ex_th[:got_lock] }
       ex_th[:got_lock].should be_true
@@ -349,7 +463,6 @@ shared_examples_for 'shared-exclusive interaction' do
   end
 end # shared-exclusive interaction
 
-
 describe ZK::Locker do
   include_context 'connection opts'
 
@@ -360,15 +473,17 @@ describe ZK::Locker do
   let(:connections) { [zk, zk2, zk3] }
 
   let(:path) { "shlock" }
-  let(:root_lock_path) { "/_zklocking/#{path}" }
+  let(:root_lock_path) { "#{ZK::Locker.default_root_lock_node}/#{path}" }
 
   before do
     wait_until{ connections.all?(&:connected?) }
+    zk.rm_rf(ZK::Locker.default_root_lock_node)
   end
 
   after do
     connections.each { |c| c.close! }
     wait_until { !connections.any?(&:connected?) }
+    ZK.open("localhost:#{ZK.test_port}") { |z| z.rm_rf(ZK::Locker.default_root_lock_node) }
   end
 
   it_should_behave_like 'SharedLocker'
@@ -376,7 +491,7 @@ describe ZK::Locker do
   it_should_behave_like 'shared-exclusive interaction'
 end # ZK::Locker
 
-describe "ZK::Locker chrooted" do
+describe ZK::Locker, :chrooted => true do
   include_context 'connection opts'
 
   let(:chroot_path) { '/_zk_chroot_' }
@@ -390,7 +505,7 @@ describe "ZK::Locker chrooted" do
     let(:connections) { [zk, zk2, zk3] }
 
     let(:path) { "shlock" }
-    let(:root_lock_path) { "/_zklocking/#{path}" }
+    let(:root_lock_path) { "#{ZK::Locker.default_root_lock_node}/#{path}" }
 
     before do
       ZK.open("localhost:#{ZK.test_port}") do |zk|