zk 0.6.4

data/spec/client_pool_spec.rb

@@ -0,0 +1,329 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+require 'tracer'
+
+describe ZK::Pool do
+  describe :Simple do
+
+    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.should be_open
+      end
+    end
+
+    after do
+      report_realtime("close_all!") do
+        unless @connection_pool.closed?
+          th = Thread.new do
+            @connection_pool.close_all!
+          end
+
+          unless th.join(5) == th
+            logger.warn { "Forcing pool closed!" }
+            @connection_pool.force_close!
+            th.join(5).should == th
+          end
+        end
+      end
+
+      report_realtime("closing") do
+        ZK.open("localhost:#{ZK_TEST_PORT}") do |zk|
+          zk.delete('/test_pool') rescue ZK::Exceptions::NoNode
+        end
+      end
+    end
+
+    it "should allow you to execute commands on a connection" do
+      @connection_pool.with_connection do |zk|
+        zk.create("/test_pool", "", :mode => :ephemeral)
+        zk.exists?("/test_pool").should be_true
+      end
+    end
+
+    describe :method_missing do
+      it %[should allow you to execute commands on the connection pool itself] do
+        @connection_pool.create('/test_pool', '', :mode => :persistent)
+        wait_until(2) { @connection_pool.exists?('/test_pool') }
+        @connection_pool.exists?('/test_pool').should be_true
+      end
+    end
+
+    describe :close_all! do
+      it %[should shutdown gracefully] do
+        release_q  = Queue.new
+
+        @about_to_block = false
+
+        open_th = Thread.new do
+          @connection_pool.with_connection do |cnx|
+            @about_to_block = true
+            # wait for signal to release our connection
+            release_q.pop
+          end
+        end
+
+        wait_until(2) { @about_to_block }
+        @about_to_block.should be_true
+
+        release_q.num_waiting.should == 1
+
+        closing_th = Thread.new do
+          @connection_pool.close_all!
+        end
+
+        wait_until(2) { @connection_pool.closing? }
+        @connection_pool.should be_closing
+
+        lambda { @connection_pool.with_connection { |c| } }.should raise_error(ZK::Exceptions::PoolIsShuttingDownException)
+
+        release_q << :ok_let_go
+
+        open_th.join(2).should == open_th
+
+        wait_until(2) { @connection_pool.closed? }
+        $stderr.puts "@connection_pool.pool_state: #{@connection_pool.pool_state.inspect}"
+        @connection_pool.should be_closed
+
+        lambda do
+          closing_th.join(1).should == closing_th
+          open_th.join(1).should == open_th
+        end.should_not raise_error
+      end
+    end
+
+    describe :force_close! do
+      it %[should raise PoolIsShuttingDownException in a thread blocked waiting for a connection] do
+        @cnx = []
+
+        until @connection_pool.available_size <= 0
+          @cnx << @connection_pool.checkout
+        end
+
+        @cnx.length.should_not be_zero
+        
+        th = Thread.new do
+          @connection_pool.checkout(true)
+        end
+
+        th.join_until { @connection_pool.count_waiters > 0 }
+        @connection_pool.count_waiters.should > 0
+
+        @connection_pool.force_close!
+
+        lambda { th.join(2) }.should raise_error(ZK::Exceptions::PoolIsShuttingDownException)
+      end
+    end
+
+    it "should allow watchers still" do
+      @callback_called = false
+
+      @path = '/_testWatch'
+
+      @connection_pool.with_connection do |zk|
+        zk.delete(@path) rescue ZK::Exceptions::NoNode
+      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
+
+      wait_until(1) { @callback_called }
+
+      @callback_called.should be_true
+    end
+  end # Client
+
+  describe :Bounded do
+    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.should be_open
+    end
+
+    after do
+      @connection_pool.force_close! unless @connection_pool.closed?
+      @connection_pool.should be_closed
+    end
+
+    describe 'initial state' do
+      it %[should have initialized the minimum number of clients] do
+        @connection_pool.size.should == @min_clients
+      end
+    end
+
+    describe 'should grow to max_clients' do
+#       before do
+#         require 'tracer'
+#         Tracer.on
+#       end
+
+#       after do
+#         Tracer.off
+#       end
+
+      it %[should grow if it can] do
+        q1 = Queue.new
+
+        @connection_pool.size.should == 1
+
+        th1 = Thread.new do
+          @connection_pool.with_connection do |cnx|
+            Thread.current[:cnx] = cnx
+            q1.pop  # block here
+          end
+        end
+
+        th1.join_until(2) { th1[:cnx] }
+        th1[:cnx].should_not be_nil
+
+        th2 = Thread.new do
+          @connection_pool.with_connection do |cnx|
+            Thread.current[:cnx] = cnx
+            q1.pop
+          end
+        end
+
+        th2.join_until(2) { th2[:cnx] }
+
+        th2[:cnx].should_not be_nil
+        th2[:cnx].should be_connected
+
+        @connection_pool.size.should == 2
+        @connection_pool.available_size.should be_zero
+
+        2.times { q1.enq(:release_cnx) }
+
+        lambda do
+          th1.join(1).should == th1
+          th2.join(1).should == th2
+        end.should_not raise_error
+
+        @connection_pool.size.should == 2
+        @connection_pool.available_size.should == 2
+      end
+
+      it %[should not grow past max_clients and block] do
+        win_q = Queue.new
+        lose_q = Queue.new
+
+        threads = []
+
+        2.times do
+          threads << Thread.new do
+            @connection_pool.with_connection do |cnx|
+              Thread.current[:cnx] = cnx
+              win_q.pop
+            end
+          end
+        end
+
+        wait_until(2) { threads.all? { |th| th[:cnx] } }
+        threads.each { |th| th[:cnx].should_not be_nil }
+
+        loser = Thread.new do
+          @connection_pool.with_connection do |cnx|
+            Thread.current[:cnx] = cnx
+            lose_q.pop
+          end
+        end
+
+        wait_until(2) { @connection_pool.count_waiters > 0 }
+        @connection_pool.count_waiters.should == 1
+
+        loser[:cnx].should be_nil
+
+        2.times { win_q.enq(:release) }
+
+        lambda { threads.each { |th| th.join(2).should == th } }.should_not raise_error
+
+        loser.join_until(2) { loser[:cnx] }
+
+        loser[:cnx].should_not be_nil
+
+        lose_q.enq(:release)
+
+        lambda { loser.join(2).should == loser }.should_not raise_error
+
+        @connection_pool.count_waiters.should be_zero
+        @connection_pool.available_size.should == 2
+        @connection_pool.size.should == 2
+      end
+    end
+
+    describe 'health checking' do
+      before do
+        @connections = @connection_pool.connections
+        @connections.length.should == 1
+
+        @cnx1 = @connections.first
+      end
+
+      describe 'disconnected client' do
+        before do
+          flexmock(@cnx1) do |m|
+            m.should_receive(:connected?).and_return(false)
+          end
+
+          @cnx2 = nil
+
+          th = Thread.new do
+            @connection_pool.with_connection do |cnx|
+              @cnx2 = cnx
+            end
+          end
+
+          th.join_while { @cnx2.nil? }
+        end
+
+        it %[should create a new client and return it] do
+          @cnx2.should_not be_nil
+          @cnx2.should_not == @cnx1
+        end
+
+        it %[should remove the disconnected client from the pool] do
+          @connection_pool.available_size.should == 1
+        end
+
+        it %[should still have the original client in its array of all connections] do
+          @connections.should include(@cnx1)
+        end
+
+        describe 'when connected event fires' do
+          before do
+            @event = flexmock(:event) do |m|
+              m.should_receive(:type).and_return(-1)
+              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)
+            end
+
+            @cnx1.watcher.process(@event)
+          end
+
+          it %[should add the connection back into the pool] do
+            @connection_pool.available_size.should == 2
+          end
+        end
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,102 @@
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe ZK::Client do
+  before do
+    @zk = ZK.new("localhost:#{ZK_TEST_PORT}")
+    wait_until{ @zk.connected? }
+    @zk.rm_rf('/test')
+  end
+
+  after do
+    @zk.rm_rf('/test')
+    @zk.close!
+
+    wait_until(2) { @zk.closed? }
+  end
+
+  describe :mkdir_p do
+    before(:each) do
+      @path_ary = %w[test mkdir_p path creation]
+      @bogus_path = File.join('/', *@path_ary)
+    end
+    
+    it %[should create all intermediate paths for the path givem] do
+      @zk.should_not be_exists(@bogus_path)
+      @zk.should_not be_exists(File.dirname(@bogus_path))
+      @zk.mkdir_p(@bogus_path)
+      @zk.should be_exists(@bogus_path)
+    end
+  end
+
+  describe :stat do
+    describe 'for a missing node' do
+      before do
+        @missing_path = '/thispathdoesnotexist'
+        @zk.delete(@missing_path) rescue ZK::Exceptions::NoNode
+      end
+
+      it %[should not raise any error] do
+        lambda { @zk.stat(@missing_path) }.should_not raise_error
+      end
+
+      it %[should return a Stat object] do
+        @zk.stat(@missing_path).should be_kind_of(ZookeeperStat::Stat)
+      end
+
+      it %[should return a stat that not exists?] do
+        @zk.stat(@missing_path).should_not be_exists
+      end
+    end
+  end
+
+  describe :block_until_node_deleted do
+    before do
+      @path = '/_bogualkjdhsna'
+    end
+
+    describe 'no node initially' do
+      before do
+        @zk.exists?(@path).should be_false
+      end
+
+      it %[should not block] do
+        @a = false
+
+        th = Thread.new do
+          @zk.block_until_node_deleted(@path)
+          @a = true
+        end
+
+        th.join(2)
+        @a.should be_true
+      end
+    end
+
+    describe 'node exists initially' do
+      before do
+        @zk.create(@path, '', :mode => :ephemeral)
+        @zk.exists?(@path).should be_true
+      end
+
+      it %[should block until the node is deleted] do
+        @a = false
+
+        th = Thread.new do
+          @zk.block_until_node_deleted(@path)
+          @a = true
+        end
+
+        Thread.pass
+        @a.should be_false
+
+        @zk.delete(@path)
+
+        wait_until(2) { @a }
+        @a.should be_true
+      end
+    end
+  end
+end
+
+
+