zk 1.5.1 → 1.5.2

data/spec/zk/locker/exclusive_locker_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+shared_examples_for 'ZK::Locker::ExclusiveLocker' do
+  let(:locker) { ZK::Locker.exclusive_locker(zk, path) }
+  let(:locker2) { ZK::Locker.exclusive_locker(zk2, path) }
+
+  describe :assert! do
+    it_should_behave_like 'LockerBase#assert!'
+
+    it %[should raise LockAssertionFailedError if there is an exclusive lock with a number lower than ours] do
+      # this should *really* never happen
+      
+      rlp = locker.root_lock_path
+
+      zk.mkdir_p(rlp)
+
+      bogus_path = zk.create("#{rlp}/#{ZK::Locker::EXCLUSIVE_LOCK_PREFIX}", :sequential => true, :ephemeral => true)
+
+      th = Thread.new do
+        locker2.lock(true)
+      end
+
+      logger.debug { "calling wait_until_blocked" }
+      locker2.wait_until_blocked(2)
+      locker2.should be_waiting
+
+      wait_until { zk.exists?(locker2.lock_path) }
+
+      zk.exists?(locker2.lock_path).should be_true
+
+      zk.delete(bogus_path)
+
+      th.join(5).should == th
+
+      locker2.lock_path.should_not == bogus_path
+
+      zk.create(bogus_path, :ephemeral => true)
+
+      lambda { 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)
+      locker.should be_acquirable
+    end
+
+    it %[should check local state of lockedness] do
+      locker.lock.should be_true
+      locker.should be_acquirable
+    end
+
+    it %[should check if any participants would prevent us from acquiring the lock] do
+      locker.lock.should be_true
+      locker2.should_not be_acquirable
+    end
+  end
+
+  describe :lock do
+    describe 'non-blocking' do
+      before do
+        @rval = locker.lock
+        @rval2 = locker2.lock
+      end
+
+      it %[should acquire the first lock] do
+        @rval.should be_true
+      end
+
+      it %[should not acquire the second lock] do
+        @rval2.should be_false
+      end
+
+      it %[should acquire the second lock after the first lock is released] do
+        locker.unlock.should be_true
+        locker2.lock.should be_true
+      end
+    end
+
+    describe 'blocking' do
+      before do
+        zk.mkdir_p(root_lock_path)
+      end
+
+      it %[should block waiting for the lock] do
+        ary = []
+        read_lock_path = zk.create("/_zklocking/#{path}/read", '', :mode => :ephemeral_sequential)
+
+        locker.lock.should be_false
+
+        th = Thread.new do
+          locker.lock(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
+    end # blocking
+  end # lock
+end # ExclusiveLocker
+
+describe do
+  include_context 'locker non-chrooted'
+  it_should_behave_like 'ZK::Locker::ExclusiveLocker'
+end
+
+describe :chrooted => true do
+  include_context 'locker chrooted'
+  it_should_behave_like 'ZK::Locker::ExclusiveLocker'
+end
+

data/spec/zk/locker/locker_basic_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+# this is a remnant of the old Locker class, but a good test of what's expected
+# from ZK::Client#locker
+#
+describe 'ZK::Client#locker' do
+  include_context 'connection opts'
+
+  before(:each) do
+    @zk = ZK.new(*connection_args)
+    @zk2 = ZK.new(*connection_args)
+    @zk3 = ZK.new(*connection_args)
+    @connections = [@zk, @zk2, @zk3]
+    wait_until { @connections.all? { |c| c.connected? } }
+    logger.debug { "all connections connected" }
+    @path_to_lock = "/lock_tester"
+  end
+
+  after(:each) do
+    @zk.close!
+    @zk2.close!
+    @zk3.close!
+    wait_until { @connections.all? { |c| c.closed? } } 
+  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
+  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
+  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
+  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
+    @zk.close!
+    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
+  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
+      end
+      array.length.should == 2
+    end
+
+    array.length.should == 1
+    first_lock.unlock
+    thread.join(10)
+    array.length.should == 2
+  end
+end
+
+

data/spec/zk/locker/shared_exclusive_integration_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+shared_examples_for :shared_exclusive_integration do
+  before do
+    @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
+
+      mutex = Monitor.new
+      cond = mutex.new_cond
+      
+      th = Thread.new do
+        logger.debug { "@ex_lock trying to acquire acquire lock" }
+        @ex_lock.with_lock do
+          th[:got_lock] = @ex_lock.locked?
+          logger.debug { "@ex_lock.locked? #{@ex_lock.locked?}" }
+
+          mutex.synchronize do
+            cond.broadcast
+          end
+        end
+      end
+
+      mutex.synchronize do
+        logger.debug { "unlocking the shared lock" }
+        @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" }
+      end
+
+      th.join(5).should == th
+
+      logger.debug { "thread joined, exclusive lock should be releasd" }
+
+      @ex_lock.should_not be_locked
+    end
+  end
+
+  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
+
+      mutex = Monitor.new
+      cond = mutex.new_cond
+      
+      th = Thread.new do
+        logger.debug { "@ex_lock trying to acquire acquire lock" }
+        @sh_lock.with_lock do
+          th[:got_lock] = @sh_lock.locked?
+          logger.debug { "@sh_lock.locked? #{@sh_lock.locked?}" }
+
+          mutex.synchronize do
+            cond.broadcast
+          end
+        end
+      end
+
+      mutex.synchronize do
+        logger.debug { "unlocking the shared lock" }
+        @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" }
+      end
+
+      th.join(5).should == th
+
+      logger.debug { "thread joined, exclusive lock should be releasd" }
+
+      @sh_lock.should_not be_locked
+    end
+  end
+
+  describe 'shared-exclusive-shared' do
+    before do
+      zk3.should_not be_nil
+      @sh_lock2 = ZK::Locker.shared_locker(zk3, path) 
+    end
+
+    it %[should act something like a queue] do
+      @array = []
+
+      @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.assert!
+          @array << :ex_lock
+        ensure
+          @ex_lock.unlock
+        end
+      end
+
+      logger.debug { "about to wait for @ex_lock to be blocked" }
+
+      @ex_lock.wait_until_blocked(5)
+      @ex_lock.should be_waiting
+
+      logger.debug { "@ex_lock is waiting" }
+
+      @ex_lock.should_not be_locked
+
+      # this is the important one, does the second shared lock get blocked by
+      # the exclusive lock
+      @sh_lock2.lock.should_not be_true
+
+      sh2_th = Thread.new do
+        begin
+          @sh_lock2.lock(true)
+          @sh_lock2.assert!
+          @array << :sh_lock2
+        ensure
+          @sh_lock2.unlock
+        end
+      end
+
+      logger.debug { "about to wait for @sh_lock2 to be blocked" }
+
+      @sh_lock2.wait_until_blocked(5)
+      @sh_lock2.should be_waiting
+
+      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
+      sh2_th.join(5).should == sh2_th
+
+      @array.length.should == 2
+      @array.should == [:ex_lock, :sh_lock2]
+    end
+  end
+end # shared_exclusive_integration
+
+describe do
+  include_context 'locker non-chrooted'
+
+  it_should_behave_like :shared_exclusive_integration
+end
+
+describe :chrooted => true do
+  include_context 'locker chrooted'
+
+  it_should_behave_like :shared_exclusive_integration
+end
+

data/spec/zk/locker/shared_locker_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+shared_examples_for 'ZK::Locker::SharedLocker' do
+  let(:locker)  { ZK::Locker::SharedLocker.new(zk, path) }
+  let(:locker2) { ZK::Locker::SharedLocker.new(zk2, path) }
+
+  describe :assert! do
+    it_should_behave_like 'LockerBase#assert!'
+
+    it %[should raise LockAssertionFailedError if there is an exclusive lock with a number lower than ours] do
+      # this should *really* never happen
+      locker.lock.should be_true
+      shl_path = locker.lock_path
+
+      locker2.lock.should be_true
+
+      locker.unlock.should be_true
+      locker.should_not be_locked
+
+      zk.exists?(shl_path).should be_false
+
+      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 { 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)
+        locker.should be_acquirable
+      end
+
+      it %[should check local state of lockedness] do
+        locker.lock.should be_true
+        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
+        locker.should_not be_acquirable
+      end
+    end
+  end
+
+  describe :lock do
+    describe 'non-blocking success' do
+      before do
+        @rval   = locker.lock
+        @rval2  = locker2.lock
+      end
+
+      it %[should acquire the first lock] do
+        @rval.should be_true
+        locker.should be_locked
+      end
+
+      it %[should acquire the second lock] do
+        @rval2.should be_true
+        locker2.should be_locked
+      end
+    end
+
+    describe 'non-blocking failure' 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 = locker.lock
+      end
+
+      it %[should return false] do
+        @rval.should be_false
+      end
+
+      it %[should not be locked] do
+        locker.should_not be_locked
+      end
+    end
+
+    describe 'blocking success' 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
+      end
+
+      it %[should acquire the lock after the write lock is released] do
+        ary = []
+
+        locker.lock.should be_false
+
+        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
+    end
+  end # lock
+
+  it_should_behave_like 'LockerBase#unlock'
+end   # SharedLocker
+
+
+describe do
+  include_context 'locker non-chrooted'
+
+  it_should_behave_like 'ZK::Locker::SharedLocker'
+end
+
+describe :chrooted => true do
+  include_context 'locker chrooted'
+
+  it_should_behave_like 'ZK::Locker::SharedLocker'
+end
+