zk 1.5.1 → 1.5.2

data/spec/zk/pool_spec.rb

@@ -2,11 +2,12 @@ require 'spec_helper'
 
 describe ZK::Pool do
   describe :Simple do
+    include_context 'connection opts'
 
     before do
       report_realtime('opening pool') do
         @pool_size = 2
-        @connection_pool = ZK::Pool::Simple.new("localhost:#{ZK.test_port}", @pool_size, :watcher => :default)
+        @connection_pool = ZK::Pool::Simple.new(connection_host, @pool_size, :watcher => :default)
         @connection_pool.should be_open
       end
     end
@@ -27,7 +28,7 @@ describe ZK::Pool do
       end
 
       report_realtime("closing") do
-        ZK.open("localhost:#{ZK.test_port}") do |zk|
+        ZK.open(connection_host) do |zk|
           begin
             zk.delete('/test_pool')
           rescue ZK::Exceptions::NoNode
@@ -213,10 +214,12 @@ describe ZK::Pool do
   end # Simple
 
   describe :Bounded do
+    include_context 'connection opts'
+
     before do
       @min_clients = 1
       @max_clients = 2
-      @connection_pool = ZK::Pool::Bounded.new("localhost:#{ZK.test_port}", :min_clients => @min_clients, :max_clients => @max_clients, :timeout => @timeout)
+      @connection_pool = ZK::Pool::Bounded.new(connection_host, :min_clients => @min_clients, :max_clients => @max_clients, :timeout => @timeout)
       @connection_pool.should be_open
       wait_until(2) { @connection_pool.available_size > 0 }
     end

data/spec/zk/watch_spec.rb

@@ -358,7 +358,6 @@ describe ZK do
     describe 'live-fire test' do
       before do
         @event = nil
-        @cnx_str = "localhost:#{ZK.test_port}"
 
         @zk = ZK.new(*connection_args) do |zk|
           @cnx_reg = zk.on_connected { |event| @event = event }

data/spec/zk/zookeeper_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 
 shared_examples_for 'ZK basic' do
   before do
+    logger.debug { "connection_args: #{connection_args.inspect}" } 
     begin
       @zk.create(@base_path)
     rescue ZK::Exceptions::NodeExists
@@ -120,7 +121,7 @@ shared_examples_for 'ZK basic' do
   end
 end
 
-describe 'basic threaded', :threaded => true do
+describe :threaded => true do
   include_context 'threaded client connection'
   it_should_behave_like 'ZK basic'
 end

data/zk.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
   s.summary     = %q{A high-level wrapper around the zookeeper driver}
   s.description = s.summary + "\n"
 
-  s.add_runtime_dependency 'zookeeper', '~> 1.2.3'
+  s.add_runtime_dependency 'zookeeper', '~> 1.2.4'
   s.add_runtime_dependency 'backports', '~> 2.5.1'
   s.add_runtime_dependency 'logging',   '~> 1.7.2'
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zk
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 7
   prerelease: 
   segments: 
   - 1
   - 5
-  - 1
-  version: 1.5.1
+  - 2
+  version: 1.5.2
 platform: ruby
 authors: 
 - Jonathan D. Simms
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-23 00:00:00 Z
+date: 2012-05-24 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: zookeeper
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 25
+        hash: 23
         segments: 
         - 1
         - 2
-        - 3
-        version: 1.2.3
+        - 4
+        version: 1.2.4
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -139,6 +139,8 @@ files:
 - spec/message_queue_spec.rb
 - spec/shared/client_contexts.rb
 - spec/shared/client_examples.rb
+- spec/shared/locker_contexts.rb
+- spec/shared/locker_examples.rb
 - spec/spec_helper.rb
 - spec/support/00_test_port_attr.rb
 - spec/support/bogus_mongoid.rb
@@ -157,7 +159,10 @@ files:
 - spec/zk/client_spec.rb
 - spec/zk/election_spec.rb
 - spec/zk/extensions_spec.rb
-- spec/zk/locker_spec.rb
+- spec/zk/locker/exclusive_locker_spec.rb
+- spec/zk/locker/locker_basic_spec.rb
+- spec/zk/locker/shared_exclusive_integration_spec.rb
+- spec/zk/locker/shared_locker_spec.rb
 - spec/zk/module_spec.rb
 - spec/zk/mongoid_spec.rb
 - spec/zk/node_deletion_watcher_spec.rb
@@ -210,6 +215,8 @@ test_files:
 - spec/message_queue_spec.rb
 - spec/shared/client_contexts.rb
 - spec/shared/client_examples.rb
+- spec/shared/locker_contexts.rb
+- spec/shared/locker_examples.rb
 - spec/spec_helper.rb
 - spec/support/00_test_port_attr.rb
 - spec/support/bogus_mongoid.rb
@@ -228,7 +235,10 @@ test_files:
 - spec/zk/client_spec.rb
 - spec/zk/election_spec.rb
 - spec/zk/extensions_spec.rb
-- spec/zk/locker_spec.rb
+- spec/zk/locker/exclusive_locker_spec.rb
+- spec/zk/locker/locker_basic_spec.rb
+- spec/zk/locker/shared_exclusive_integration_spec.rb
+- spec/zk/locker/shared_locker_spec.rb
 - spec/zk/module_spec.rb
 - spec/zk/mongoid_spec.rb
 - spec/zk/node_deletion_watcher_spec.rb

data/spec/zk/locker_spec.rb

@@ -1,552 +0,0 @@
-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("localhost:#{ZK.test_port}", connection_opts)
-    @zk2 = ZK.new("localhost:#{ZK.test_port}", connection_opts)
-    @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
-
-  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
-
-shared_examples_for 'SharedLocker' do
-  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 'non-blocking success' do
-      before do
-        @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
-      end
-
-      it %[should acquire the second lock] do
-        @rval2.should be_true
-        shared_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 = shared_locker.lock
-      end
-
-      it %[should return false] do
-        @rval.should be_false
-      end
-
-      it %[should not be locked] do
-        shared_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 = []
-
-        shared_locker.lock.should be_false
-
-        th = Thread.new do
-          shared_locker.lock(true)
-          ary << :locked
-        end
-
-        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).should == th
-
-        ary.should_not be_empty
-        ary.length.should == 1
-
-        shared_locker.should be_locked
-      end
-    end
-  end
-end   # SharedLocker
-
-shared_examples_for 'ExclusiveLocker' do
-  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
-      
-      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
-
-      logger.debug { "calling wait_until_blocked" }
-      ex_locker2.wait_until_blocked(2)
-      ex_locker2.should be_waiting
-
-      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 == bogus_path
-
-      zk.create(bogus_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 'non-blocking' do
-      before do
-        @rval = ex_locker.lock
-        @rval2 = ex_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
-        ex_locker.unlock.should be_true
-        ex_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/shlock/read', '', :mode => :ephemeral_sequential)
-
-        ex_locker.lock.should be_false
-
-        th = Thread.new do
-          ex_locker.lock(true)
-          ary << :locked
-        end
-
-        ex_locker.wait_until_blocked(5)
-      
-        ary.should be_empty
-        ex_locker.should_not be_locked
-
-        zk.delete(read_lock_path)
-
-        th.join(2).should == th
-
-        ary.length.should == 1
-        ex_locker.should be_locked
-      end
-    end # blocking
-  end # lock
-end # ExclusiveLocker
-
-shared_examples_for 'shared-exclusive interaction' 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 interaction
-
-describe ZK::Locker do
-  include_context 'connection opts'
-
-  let(:zk)  { ZK.new("localhost:#{ZK.test_port}", connection_opts) }
-  let(:zk2) { ZK.new("localhost:#{ZK.test_port}", connection_opts) }
-  let(:zk3) { ZK.new("localhost:#{ZK.test_port}", connection_opts) }
-
-  let(:connections) { [zk, zk2, zk3] }
-
-  let(:path) { "shlock" }
-  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'
-  it_should_behave_like 'ExclusiveLocker'
-  it_should_behave_like 'shared-exclusive interaction'
-end # ZK::Locker
-
-describe ZK::Locker, :chrooted => true do
-  include_context 'connection opts'
-
-  let(:chroot_path) { '/_zk_chroot_' }
-
-  let(:zk)  { ZK.new("localhost:#{ZK.test_port}#{chroot_path}", connection_opts) }
-
-  describe 'when the chroot exists' do
-    let(:zk2) { ZK.new("localhost:#{ZK.test_port}#{chroot_path}", connection_opts) }
-    let(:zk3) { ZK.new("localhost:#{ZK.test_port}#{chroot_path}", connection_opts) }
-
-    let(:connections) { [zk, zk2, zk3] }
-
-    let(:path) { "shlock" }
-    let(:root_lock_path) { "#{ZK::Locker.default_root_lock_node}/#{path}" }
-
-    before do
-      ZK.open("localhost:#{ZK.test_port}") do |zk|
-        zk.mkdir_p(chroot_path)
-      end
-
-      wait_until{ connections.all?(&:connected?) }
-    end
-
-    after do
-      connections.each { |c| c.close! }
-      wait_until { !connections.any?(&:connected?) }
-
-      ZK.open("localhost:#{ZK.test_port}") do |zk|
-        zk.rm_rf(chroot_path)
-      end
-    end
-
-    it_should_behave_like 'SharedLocker'
-    it_should_behave_like 'ExclusiveLocker'
-    it_should_behave_like 'shared-exclusive interaction'
-  end
-end
-
-