zk 0.6.4

data/spec/election_spec.rb

@@ -0,0 +1,301 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe ZK::Election do
+  before do
+    ZK.open('localhost:2181') do |cnx| 
+      ZK.logger.debug { "REMOVING /_zkelection" }
+      cnx.rm_rf('/_zkelection')
+    end
+
+    @zk = ZK.new('localhost:2181')
+    @zk2 = ZK.new('localhost:2181')
+    @election_name = '2012'
+    @data1 = 'obama'
+    @data2 = 'palin'
+  end
+
+  after do
+    @zk.close!
+    @zk2.close!
+
+    ZK.open('localhost:2181') { |cnx| cnx.rm_rf('/_zkelection') }
+  end
+
+  describe 'Candidate', 'following next_node' do
+    before do
+      @obama = ZK::Election::Candidate.new(@zk, @election_name, :data => @data1)
+      @palin = ZK::Election::Candidate.new(@zk2, @election_name, :data => @data2)
+    end
+
+    describe 'vote!' do
+      describe 'loser' do
+        it %[should wait until the leader has acked before firing loser callbacks] do
+          queue = Queue.new
+          @do_ack = false
+
+          @obama_won = nil
+          @palin_lost = nil
+
+          @obama_waiting = nil
+
+          @obama.on_winning_election do
+            @obama_waiting = true
+
+            # wait for us to signal
+            queue.pop
+
+            $stderr.puts "obama on_winning_election entered"
+            @obama_won = true
+          end
+
+          @palin.on_losing_election do
+            @obama_won.should be_true
+            @palin.leader_acked?.should be_true
+            @palin_lost = true
+          end
+
+          oth = Thread.new do
+            @obama.vote!
+            @palin.vote!
+          end
+          oth.run
+
+          wait_until { @obama_waiting }
+          @obama_waiting.should be_true
+
+          # palin's callbacks haven't fired
+          @palin_lost.should be_nil
+
+          queue << :ok
+
+          wait_until { @obama_won }
+          @obama_won.should be_true
+
+          lambda { oth.join(1).should == oth }.should_not raise_error
+
+          wait_until { @palin_lost }
+
+          @palin_lost.should be_true
+        end
+      end
+
+      describe do
+        before do
+          @obama_won = @obama_lost = @palin_won = @palin_lost = nil
+
+          @obama.on_winning_election do 
+            logger.debug { "obama on_winning_election fired" }
+            @obama_won = true
+          end
+
+          @obama.on_losing_election do
+            logger.debug { "obama on_losing_election fired" }
+            @obama_lost = true
+          end
+
+          @palin.on_winning_election do
+            logger.debug { "palin on_winning_election fired" }
+            @palin_won = true
+          end
+
+          @palin.on_losing_election do
+            logger.debug { "palin on_losing_election fired" }
+            @palin_lost = true
+          end
+          
+          @obama.vote!
+          @palin.vote!
+
+          wait_until { @obama_won }
+          wait_until { @palin_lost }
+        end
+
+        describe 'winner' do
+          it %[should fire the on_winning_election callbacks] do
+            @obama_won.should be_true
+          end
+
+          it %[should not fire the on_losing_election callbacks] do
+            @obama_lost.should be_nil
+          end
+
+          it %[should acknowledge completion of winning callbacks] do
+            @zk.exists?(@obama.leader_ack_path).should be_true
+          end
+
+          it %[should write its data to the leader_ack node] do
+            @zk.get(@obama.leader_ack_path).first.should == @data1
+          end
+
+          it %[should know it's the leader] do
+            @obama.should be_leader
+          end
+        end
+
+        describe 'loser' do # gets a talk show on Fox News? I KEED! I KEED!
+          it %[should know it isn't the leader] do
+            @palin.should_not be_leader
+          end
+
+          it %[should not fire the winning callbacks] do
+            @palin_won.should_not be_true
+          end
+
+          it %[should fire the losing callbacks] do
+            @palin_lost.should be_true
+          end
+
+          it %[should take over as leader when the current leader goes away] do
+            @obama.zk.close!
+            wait_until { @palin_won }
+
+            @palin_won.should be_true # god forbid
+
+            wait_until { @zk2.exists?(@palin.leader_ack_path) }
+
+            @zk2.exists?(@palin.leader_ack_path).should be_true
+
+            @zk2.get(@palin.leader_ack_path).first.should == @data2
+          end
+
+          it %[should remain leader if the original leader comes back] do
+            @obama.zk.close!
+            wait_until { @palin_won }
+
+            zk = ZK.new('localhost:2181')
+            newbama = ZK::Election::Candidate.new(zk, @election_name, :data => @data1)
+
+            win_again = false
+
+            newbama.on_winning_election do
+              win_again = true
+            end
+
+            newbama.vote!
+            wait_until { newbama.voted? }
+
+            newbama.should be_voted
+            win_again.should be_false
+            newbama.should_not be_leader
+          end
+        end
+      end
+    end
+  end
+
+  describe :Observer do
+    before do
+      @zk3 = ZK.new('localhost:2181')
+
+      @zk3.exists?('/_zkelection/2012/leader_ack').should be_false
+
+      @obama = ZK::Election::Candidate.new(@zk, @election_name, :data => @data1)
+      @palin = ZK::Election::Candidate.new(@zk2, @election_name, :data => @data2)
+
+      @zk3.exists?('/_zkelection/2012/leader_ack').should be_false
+
+      @observer = ZK::Election::Observer.new(@zk3, @election_name)
+    end
+
+    after do
+      @zk3.close!
+    end
+
+    describe 'initial state' do
+      describe 'no leader' do
+        before do
+          @events = []
+
+          @observer.on_leaders_death { @events << :death }
+          @observer.on_new_leader { @events << :life }
+
+          @observer.observe!
+          wait_until { !@observer.leader_alive.nil? }
+          @observer.leader_alive.should_not be_nil
+          @zk3.exists?(@observer.root_election_node).should be_false
+        end
+
+        it %[should set leader_alive to false] do
+          @observer.leader_alive.should be_false
+        end
+
+        it %[should fire death callbacks] do
+          @events.length.should == 1
+          @events.first.should == :death
+        end
+      end
+
+      describe 'leader exists before' do
+        before do
+          @obama.vote!
+          @palin.vote!
+
+          wait_until { @obama.leader? }
+
+          @got_life_event = @got_death_event = false
+
+          @observer.on_leaders_death { @got_death_event = true }
+          @observer.on_new_leader { @got_life_event = true }
+
+          @observer.observe!
+
+          wait_until { !@observer.leader_alive.nil? }
+        end
+
+        it %[should be obama that won] do
+          @obama.should be_leader
+        end
+
+        it %[should be palin that lost] do
+          @palin.should_not be_leader
+        end
+
+        it %[should set leader_alive to true] do
+          @observer.leader_alive.should be_true
+        end
+
+        it %[should fire the new leader callbacks] do
+          @got_life_event.should be_true
+        end
+      end
+
+      describe 'leadership transition' do
+        before do
+          @obama.vote!
+          @palin.vote!
+
+          wait_until { @obama.leader? }
+
+          @palin.should_not be_leader
+
+          @got_life_event = @got_death_event = false
+
+          @observer.on_leaders_death { @got_death_event = true }
+          @observer.on_new_leader { @got_life_event = true }
+
+          @observer.observe!
+
+          wait_until { !@observer.leader_alive.nil? }
+
+          @observer.leader_alive.should be_true
+          @zk.close!
+          wait_until { !@zk.connected? && @palin.leader? && @palin.leader_acked? }
+        end
+
+        it %[should be palin who is leader] do
+          @palin.should be_leader
+        end
+
+        it %[should have seen both the death and life events] do
+          @got_life_event.should be_true
+          @got_death_event.should be_true
+        end
+
+        it %[should see the data of the new leader] do
+          @observer.leader_data.should == 'palin'
+        end
+      end
+    end
+  end
+end
+

data/spec/locker_spec.rb

@@ -0,0 +1,386 @@
+require File.join(File.dirname(__FILE__), %w[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
+
+  before(:each) do
+    @zk = ZK.new("localhost:#{ZK_TEST_PORT}")
+    @zk2 = ZK.new("localhost:#{ZK_TEST_PORT}")
+    @zk3 = ZK.new("localhost:#{ZK_TEST_PORT}")
+    @connections = [@zk, @zk2, @zk3]
+    wait_until { @connections.all? { |c| c.connected? } }
+    @path_to_lock = "/lock_tester"
+  end
+
+  after(:each) do
+    @zk.close!
+    @zk2.close!
+    @zk3.close!
+    wait_until{ @connections.all? { |c| !c.connected? } } 
+  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
+
+describe ZK::Locker do
+  before do
+    @zk = ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default)
+    @zk2 = ZK.new("localhost:#{ZK_TEST_PORT}", :watcher => :default)
+    @zk3 = ZK.new("localhost:#{ZK_TEST_PORT}")
+    @connections = [@zk, @zk2, @zk3]
+
+    wait_until{ @connections.all? {|c| c.connected?} }
+
+    @path = "shlock"
+    @root_lock_path = "/_zklocking/#{@path}"
+  end
+
+  after do
+    @connections.each { |c| c.close! }
+    wait_until { @connections.all? { |c| !c.connected? } }
+  end
+
+
+  describe :SharedLocker do
+    before do
+      @shared_locker  = ZK::Locker.shared_locker(@zk, @path)
+      @shared_locker2 = ZK::Locker.shared_locker(@zk2, @path)
+    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
+
+        after do
+          @zk.rm_rf('/_zklocking')
+        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
+
+          ary.should be_empty
+          @shared_locker.should_not be_locked
+
+          @zk.delete(@write_lock_path)
+
+          th.join(2)
+
+          wait_until(2) { !ary.empty? }
+          ary.length.should == 1
+
+          @shared_locker.should be_locked
+        end
+      end
+    end
+  end   # SharedLocker
+
+  describe :ExclusiveLocker do
+    before do
+      @ex_locker = ZK::Locker.exclusive_locker(@zk, @path)
+      @ex_locker2 = ZK::Locker.exclusive_locker(@zk2, @path)
+    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)
+          @read_lock_path = @zk.create('/_zklocking/shlock/read', '', :mode => :ephemeral_sequential)
+        end
+
+        it %[should block waiting for the lock] do
+          ary = []
+
+          @ex_locker.lock!.should be_false
+
+          th = Thread.new do
+            @ex_locker.lock!(true)
+            ary << :locked
+          end
+
+          th.run
+        
+          ary.should be_empty
+          @ex_locker.should_not be_locked
+
+          @zk.delete(@read_lock_path)
+
+          th.join(2)
+
+          ary.length.should == 1
+          @ex_locker.should be_locked
+        end
+      end
+    end
+  end   # WriteLocker
+
+  describe 'read/write 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
+        q1 = Queue.new
+        q2 = Queue.new
+
+        th1 = Thread.new do
+          @sh_lock.with_lock do
+            q1.enq(:got_lock)
+            Thread.current[:got_lock] = true
+            q2.pop
+          end
+        end
+
+        th2 = Thread.new do
+          q1.pop # wait for th1 to get the shared lock
+
+          Thread.current[:acquiring_lock] = true
+
+          @ex_lock.with_lock do
+            Thread.current[:got_lock] = true
+          end
+        end
+
+        th1.join_until { th1[:got_lock] }
+        th1[:got_lock].should be_true
+
+        th2.join_until { th2[:acquiring_lock] }
+        th2[:acquiring_lock].should be_true
+
+        q2.num_waiting.should > 0
+        q2.enq(:release)
+
+        th1.join_until { q2.size == 0 }
+        q2.size.should == 0
+
+        th1.join(2).should == th1
+
+        th2.join_until { th2[:got_lock] }
+        th2[:got_lock].should be_true
+
+        th2.join(2).should == th2
+      end
+    end
+
+    describe 'exclusive lock acquired first' do
+      it %[should block shared lock from acquiring until released] do
+        # same test as above but with the thread's locks switched, 
+        # th1 is the exclusive locker
+
+        q1 = Queue.new
+        q2 = Queue.new
+
+        th1 = Thread.new do
+          @ex_lock.with_lock do
+            q1.enq(:got_lock)
+            Thread.current[:got_lock] = true
+            q2.pop
+          end
+        end
+
+        th2 = Thread.new do
+          q1.pop # wait for th1 to get the shared lock
+
+          Thread.current[:acquiring_lock] = true
+
+          @sh_lock.with_lock do
+            Thread.current[:got_lock] = true
+          end
+        end
+
+        th1.join_until { th1[:got_lock] }
+        th1[:got_lock].should be_true
+
+        th2.join_until { th2[:acquiring_lock] }
+        th2[:acquiring_lock].should be_true
+
+        q2.num_waiting.should > 0
+        q2.enq(:release)
+
+        th1.join_until { q2.size == 0 }
+        q2.size.should == 0
+
+        th1.join(2).should == th1
+
+        th2.join_until { th2[:got_lock] }
+        th2[:got_lock].should be_true
+
+        th2.join(2).should == th2
+      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
+            Thread.current[:got_lock] = true
+            @array << :ex_lock
+          ensure
+            @ex_lock.unlock!
+          end
+        end
+
+        ex_th.join_until { @ex_lock.waiting? }
+        @ex_lock.should be_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)
+            Thread.current[:got_lock] = true
+            @array << :sh_lock2
+          ensure
+            @sh_lock2.unlock!
+          end
+        end
+
+        sh2_th.join_until { @sh_lock2.waiting? }
+        @sh_lock2.should be_waiting
+
+        @sh_lock.unlock!.should be_true
+
+        ex_th.join_until { ex_th[:got_lock] }
+        ex_th[:got_lock].should be_true
+
+        sh2_th.join_until { sh2_th[:got_lock] }
+        sh2_th[:got_lock].should be_true
+
+        @array.length.should == 2
+        @array.should == [:ex_lock, :sh_lock2]
+      end
+    end
+  end
+end
+

data/spec/log4j.properties

@@ -0,0 +1,17 @@
+log4j.rootLogger        = DEBUG,S
+
+log4j.appender.S        = org.apache.log4j.FileAppender
+log4j.appender.S.File   = /tmp/zk-test.log
+
+log4j.appender.S.layout = org.apache.log4j.PatternLayout
+log4j.appender.S.layout.ConversionPattern  = %5p [%t] (%c:%F:%L) - %m%n
+
+log4j.appender.C        = org.apache.log4j.FileAppender
+log4j.appender.C.File   = /tmp/zk-test-client.log
+
+log4j.appender.C.layout = org.apache.log4j.PatternLayout
+log4j.appender.C.layout.ConversionPattern  = %5p [%t] (%c:%F:%L) - %m%n
+
+log4j.org.apache.zookeeper.ZooKeeper = DEBUG,C
+log4j.org.apache.zookeeper.server    = DEBUG,S
+