zk 1.4.2 → 1.5.0

data/spec/zk/locker_spec.rb

@@ -12,6 +12,7 @@ describe 'ZK::Client#locker' do
     @zk3 = ZK.new("localhost:#{ZK.test_port}", connection_opts)
     @connections = [@zk, @zk2, @zk3]
     wait_until { @connections.all? { |c| c.connected? } }
+    logger.debug { "all connections connected" }
     @path_to_lock = "/lock_tester"
   end
 
@@ -19,7 +20,7 @@ describe 'ZK::Client#locker' do
     @zk.close!
     @zk2.close!
     @zk3.close!
-    wait_until{ @connections.all? { |c| !c.connected? } } 
+    wait_until { @connections.all? { |c| c.closed? } } 
   end
 
   it "should be able to acquire the lock if no one else is locking it" do
@@ -194,14 +195,16 @@ shared_examples_for 'SharedLocker' do
           ary << :locked
         end
 
-        ary.should be_empty
+        shared_locker.wait_until_blocked(5)
+        shared_locker.should be_waiting
         shared_locker.should_not be_locked
+        ary.should be_empty
 
         zk.delete(@write_lock_path)
 
-        th.join(2)
+        th.join(2).should == th
 
-        wait_until(2) { !ary.empty? }
+        ary.should_not be_empty
         ary.length.should == 1
 
         shared_locker.should be_locked
@@ -235,24 +238,32 @@ shared_examples_for 'ExclusiveLocker' do
 
     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
+      
+      rlp = ex_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
         ex_locker2.lock(true)
       end
 
-      wait_until { th.status == 'sleep' }
+      logger.debug { "calling wait_until_blocked" }
+      ex_locker2.wait_until_blocked(2)
+      ex_locker2.should be_waiting
 
-      ex_locker.unlock.should be_true
-      ex_locker.should_not be_locked
-      zk.exists?(exl_path).should be_false
+      wait_until { zk.exists?(ex_locker2.lock_path) }
+
+      zk.exists?(ex_locker2.lock_path).should be_true
+
+      zk.delete(bogus_path)
 
       th.join(5).should == th
 
-      ex_locker2.lock_path.should_not == exl_path
+      ex_locker2.lock_path.should_not == bogus_path
 
-      zk.create(exl_path, :ephemeral => true)
+      zk.create(bogus_path, :ephemeral => true)
 
       lambda { ex_locker2.assert! }.should raise_error(ZK::Exceptions::LockAssertionFailedError)
     end
@@ -299,11 +310,11 @@ shared_examples_for 'ExclusiveLocker' do
     describe 'blocking' do
       before do
         zk.mkdir_p(root_lock_path)
-        @read_lock_path = zk.create('/_zklocking/shlock/read', '', :mode => :ephemeral_sequential)
       end
 
       it %[should block waiting for the lock] do
         ary = []
+        read_lock_path = zk.create('/_zklocking/shlock/read', '', :mode => :ephemeral_sequential)
 
         ex_locker.lock.should be_false
 
@@ -312,20 +323,20 @@ shared_examples_for 'ExclusiveLocker' do
           ary << :locked
         end
 
-        th.run
+        ex_locker.wait_until_blocked(5)
       
         ary.should be_empty
         ex_locker.should_not be_locked
 
-        zk.delete(@read_lock_path)
+        zk.delete(read_lock_path)
 
-        th.join(2)
+        th.join(2).should == th
 
         ary.length.should == 1
         ex_locker.should be_locked
       end
-    end
-  end
+    end # blocking
+  end # lock
 end # ExclusiveLocker
 
 shared_examples_for 'shared-exclusive interaction' do
@@ -428,8 +439,13 @@ shared_examples_for 'shared-exclusive interaction' do
         end
       end
 
-      ex_th.join_until { @ex_lock.waiting? }
+      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
@@ -446,15 +462,19 @@ shared_examples_for 'shared-exclusive interaction' do
         end
       end
 
-      sh2_th.join_until { @sh_lock2.waiting? }
+      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" }
+
       @sh_lock.unlock.should be_true
 
-      ex_th.join_until { ex_th[:got_lock] }
+      ex_th.join(5).should == ex_th
       ex_th[:got_lock].should be_true
 
-      sh2_th.join_until { sh2_th[:got_lock] }
+      sh2_th.join(5).should == sh2_th
       sh2_th[:got_lock].should be_true
 
       @array.length.should == 2

data/spec/zk/node_deletion_watcher_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe ZK::NodeDeletionWatcher do
+  include_context 'threaded client connection'
+
+  before do
+    @path = "#{@base_path}/node_deleteion_watcher_victim"
+
+    @n = ZK::NodeDeletionWatcher.new(@zk, @path)
+  end
+
+  describe %[when the node already exists] do
+    it %[blocks the caller until the node is deleted] do
+      @zk.mkdir_p(@path)
+
+      th = Thread.new { @n.block_until_deleted }
+      
+      @n.wait_until_blocked(5).should be_true
+
+      logger.debug { "wait_until_blocked returned" }
+
+      @n.should be_blocked
+
+      @zk.rm_rf(@path)
+
+      th.join(5).should == th
+      @n.should_not be_blocked
+      @n.should be_done
+    end
+
+    it %[should wake up if interrupt! is called] do
+      @zk.mkdir_p(@path)
+
+      @exc = nil
+
+      th = Thread.new do
+        begin
+          @n.block_until_deleted
+        rescue Exception => e
+          @exc = e
+        end
+      end
+
+      @n.wait_until_blocked(5)
+
+      @n.should be_blocked
+
+      @n.interrupt!
+      th.join(5).should == th
+
+      @exc.should be_kind_of(ZK::Exceptions::WakeUpException)
+    end
+  end
+
+  describe %[when the node doesn't exist] do
+    it %[should not block the caller and be done] do
+      @zk.exists?(@path).should be_false
+
+      th = Thread.new { @n.block_until_deleted }
+
+      @n.wait_until_blocked
+      @n.should_not be_blocked
+      th.join(5).should == th
+      @n.should be_done
+    end
+  end
+end
+
+

data/spec/zk/pool_spec.rb

@@ -55,17 +55,27 @@ describe ZK::Pool do
       it %[should shutdown gracefully] do
         release_q  = Queue.new
 
+        latch = Latch.new
+
         @about_to_block = false
 
+        @mutex = Mutex.new
+        @cond = ConditionVariable.new
+        @cnx = nil
+
         open_th = Thread.new do
-          @cnx = @connection_pool.checkout(true)
-          @about_to_block = true
-          # wait for signal to release our connection
-          release_q.pop
+          @mutex.synchronize do
+            @cnx = @connection_pool.checkout(true)
+            @cond.broadcast
+          end
+          latch.await(30) # don't time out
+        end
+
+        @mutex.synchronize do
+          @cond.wait(@mutex) while @cnx.nil?
         end
 
-        wait_until(5) { @about_to_block }
-        @about_to_block.should be_true
+        @cnx.should_not be_nil
 
         closing_th = Thread.new do
           @connection_pool.close_all!
@@ -75,14 +85,13 @@ describe ZK::Pool do
         @connection_pool.should be_closing
         logger.debug { "connection pool is closing" }
 
-        lambda { @connection_pool.with_connection { |c| } }.should raise_error(ZK::Exceptions::PoolIsShuttingDownException)
+        lambda { @connection_pool.with_connection { |c| c } }.should raise_error(ZK::Exceptions::PoolIsShuttingDownException)
 
-        release_q << :ok_let_go
+        latch.release
 
         open_th.join(5).should == open_th
 
-        wait_until(5) { @connection_pool.closed? }
-#         $stderr.puts "@connection_pool.pool_state: #{@connection_pool.pool_state.inspect}"
+        @connection_pool.wait_until_closed
 
         @connection_pool.should be_closed
 
@@ -94,7 +103,7 @@ describe ZK::Pool do
     end
 
     describe :force_close! do
-      it %[should raise PoolIsShuttingDownException in a thread blocked waiting for a connection] do
+      it %[should raise PoolIsShuttingDownException in a thread blocked waiting for a connection], :mri_187 => :broken do
         @cnx = []
 
         until @connection_pool.available_size <= 0
@@ -103,8 +112,15 @@ describe ZK::Pool do
 
         @cnx.length.should_not be_zero
         
+        # this exc nonsense is because 1.8.7's scheduler is broken
+        @exc = nil
+
         th = Thread.new do
-          @connection_pool.checkout(true)
+          begin
+            @connection_pool.checkout(true)
+          rescue
+            @exc = $!
+          end
         end
 
         # th.join_until { @connection_pool.count_waiters > 0 }
@@ -112,7 +128,10 @@ describe ZK::Pool do
 
         @connection_pool.force_close!
 
-        lambda { th.join(5) }.should raise_error(ZK::Exceptions::PoolIsShuttingDownException)
+        @connection_pool.wait_until_closed
+
+        th.join(5).should == th
+        @exc.should be_kind_of(ZK::Exceptions::PoolIsShuttingDownException)
       end
     end
 
@@ -129,21 +148,16 @@ describe ZK::Pool do
       end
 
       @connection_pool.with_connection do |zk|
-#         $stderr.puts "registering callback"
         zk.watcher.register(@path) do |event|
-#           $stderr.puts "callback fired! event: #{event.inspect}"
 
           @callback_called = true
           event.path.should == @path
-#           $stderr.puts "signaling other waiters"
         end
 
-#         $stderr.puts "setting up watcher"
         zk.exists?(@path, :watch => true).should be_false
       end
 
       @connection_pool.with_connection do |zk|
-#         $stderr.puts "creating path"
         zk.create(@path, "", :mode => :ephemeral).should == @path
       end
 

data/spec/zk/threaded_callback_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe ZK::ThreadedCallback do
+  before do
+    @called = []
+    @called.extend(MonitorMixin)
+    @cond = @called.new_cond
+
+    @callback = proc do |*a|
+      @called.synchronize do
+        @called << a
+        @cond.broadcast
+      end
+    end
+
+    @tcb = ZK::ThreadedCallback.new(@callback)
+  end
+
+  after do
+    @tcb.shutdown.should be_true
+  end
+
+  it %[should have started the thread] do
+    @tcb.should be_alive
+  end
+
+  describe %[pausing for fork] do
+    describe %[when running] do
+      before do
+        @tcb.pause_before_fork_in_parent
+      end
+
+      it %[should stop the thread] do
+        @tcb.should_not be_alive
+      end
+
+      it %[should allow calls] do
+        lambda { @tcb.call(:a) }.should_not raise_error
+      end
+    end
+
+    describe %[when not running] do
+      it %[should barf with InvalidStateError] do
+        @tcb.shutdown.should be_true
+        @tcb.should_not be_alive
+        lambda { @tcb.pause_before_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+      end
+    end
+  end
+
+  describe %[resuming] do
+    describe %[after pause] do
+      before do
+        @tcb.pause_before_fork_in_parent
+        @tcb.should_not be_alive
+      end
+
+      it %[should deliver any calls on resume] do
+        @tcb.call(:a)
+        @tcb.call(:b)
+
+        @tcb.resume_after_fork_in_parent
+
+        start = Time.now
+
+        wait_until { @called.length >= 2 }
+
+        @called.length.should >= 2
+      end
+    end
+
+    describe %[if not paused] do
+      it %[should barf with InvalidStateError] do
+        lambda { @tcb.resume_after_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+      end
+    end
+  end
+end

data/spec/zk/threadpool_spec.rb

@@ -98,5 +98,57 @@ describe ZK::Threadpool do
       @a.first.should be_true
     end
   end
+
+  describe :pause_before_fork_in_parent do
+    it %[should stop all running threads] do
+      @threadpool.should be_running
+      @threadpool.should be_alive
+      @threadpool.pause_before_fork_in_parent
+
+      @threadpool.should_not be_alive
+    end
+
+    it %[should raise InvalidStateError if already paused] do
+      @threadpool.pause_before_fork_in_parent
+      lambda { @threadpool.pause_before_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+    end
+  end
+
+  describe :resume_after_fork_in_parent do
+    before do
+      @threadpool.pause_before_fork_in_parent
+    end
+
+    it %[should start all threads running again] do
+      @threadpool.resume_after_fork_in_parent
+      @threadpool.should be_alive
+    end
+
+    it %[should raise InvalidStateError if not in paused state] do
+      @threadpool.shutdown
+      lambda { @threadpool.resume_after_fork_in_parent }.should raise_error(ZK::Exceptions::InvalidStateError)
+    end
+
+    it %[should run callbacks deferred while paused] do
+      calls = []
+
+      num = 5
+
+      latch = Latch.new(num)
+
+      num.times do |n|
+        @threadpool.defer do
+          calls << n
+          latch.release
+        end
+      end
+
+      @threadpool.resume_after_fork_in_parent
+
+      latch.await(2)
+
+      calls.should_not be_empty
+    end
+  end
 end