zk 0.6.5 → 0.7.1

data/lib/z_k/election.rb

@@ -347,6 +347,8 @@ module ZK
           @observing = true
 
           @leader_ack_sub ||= @zk.watcher.register(leader_ack_path) do |event|
+            logger.debug { "leader_ack_callback, event.node_deleted? #{event.node_deleted?}, event.node_created? #{event.node_created?}" }
+
             if event.node_deleted?
               the_king_is_dead 
             elsif event.node_created?
@@ -354,6 +356,7 @@ module ZK
             else
               acked = leader_acked?(true) 
 
+
               # If the current state of the system is not what we think it should be
               # a transition has occurred and we should fire our callbacks
               if (acked and !@leader_alive)

data/lib/z_k/event_handler.rb

@@ -43,7 +43,7 @@ module ZK
     # @see ZooKeeper::WatcherEvent
     # @see ZooKeeper::EventHandlerSubscription
     def register(path, &block)
-      logger.debug { "EventHandler#register path=#{path.inspect}" }
+#       logger.debug { "EventHandler#register path=#{path.inspect}" }
       EventHandlerSubscription.new(self, path, block).tap do |subscription|
         synchronize { @callbacks[path] << subscription }
       end
@@ -94,7 +94,7 @@ module ZK
 
     # called from the client-registered callback when an event fires
     def process(event) #:nodoc:
-      logger.debug { "EventHandler#process dispatching event: #{event.inspect}" } unless event.type == -1
+#       logger.debug { "EventHandler#process dispatching event: #{event.inspect}" }# unless event.type == -1
       event.zk = @zk
 
       cb_key = 
@@ -106,10 +106,12 @@ module ZK
           raise ZKError, "don't know how to process event: #{event.inspect}"
         end
 
+#       logger.debug { "EventHandler#process: cb_key: #{cb_key}" }
+
       cb_ary = synchronize do 
         if event.node_event?
           if watch_type = ZOOKEEPER_WATCH_TYPE_MAP[event.type]
-            logger.debug { "re-allowing #{watch_type.inspect} watches on path #{event.path.inspect}" }
+#             logger.debug { "re-allowing #{watch_type.inspect} watches on path #{event.path.inspect}" }
             
             # we recieved a watch event for this path, now we allow code to set new watchers
             @outstanding_watches[watch_type].delete(event.path)
@@ -161,7 +163,7 @@ module ZK
           opts[:watcher] = watcher_callback 
         else
           # outstanding watch for path and data pair already exists, so ignore
-          logger.debug { "outstanding watch request for path #{path.inspect} and watcher type #{watch_type.inspect}, not re-registering" }
+#           logger.debug { "outstanding watch request for path #{path.inspect} and watcher type #{watch_type.inspect}, not re-registering" }
         end
       end
     end
@@ -188,7 +190,7 @@ module ZK
       end
 
       def safe_call(callbacks, *args)
-        callbacks.each do |cb|
+        while cb = callbacks.shift
           begin
             cb.call(*args) if cb.respond_to?(:call)
           rescue Exception => e

data/lib/z_k/mongoid.rb

@@ -5,7 +5,7 @@ module ZK
     #
     # Before use (in one of your Rails initializers, for example) you should
     # assign either a ZK::Client or ZK::Pool subclass to
-    # ZooKeeperLockMixin.zk_lock_pool.
+    # ZK::Mongoid::Locking.zk_lock_pool.
     #
     # this class assumes the availability of a 'logger' method in the mixee
     #

data/lib/z_k/pool.rb

@@ -6,9 +6,15 @@ module ZK
       def initialize
         @state = :init
 
-        @connections = []
-        @connections.extend(MonitorMixin)
-        @checkin_cond = @connections.new_cond
+        @mutex  = Monitor.new
+        @checkin_cond = @mutex.new_cond
+        
+        @connections = []     # all connections we control
+        @pool = []            # currently available connections
+
+        # this is required for 1.8.7 compatibility
+        @on_connected_subs = {}
+        @on_connected_subs.extend(MonitorMixin)
       end
 
       # has close_all! been called on this ConnectionPool ?
@@ -34,7 +40,7 @@ module ZK
       # close all the connections on the pool
       # @param optional Boolean graceful allow the checked out connections to come back first?
       def close_all!
-        synchronize do 
+        @mutex.synchronize do 
           return unless open?
           @state = :closing
 
@@ -47,7 +53,7 @@ module ZK
       # calls close! on all connection objects, whether or not they're back in the pool
       # this is DANGEROUS!
       def force_close! #:nodoc:
-        synchronize do
+        @mutex.synchronize do
           return if (closed? or forced?)
           @state = :forced
 
@@ -99,7 +105,7 @@ module ZK
       end
 
       def size #:nodoc:
-        @pool.size
+        @connection.synchronize { @pool.size }
       end
 
       def pool_state #:nodoc:
@@ -108,7 +114,7 @@ module ZK
 
       protected
         def synchronize
-          @connections.synchronize { yield }
+          @mutex.synchronize { yield }
         end
 
         def assert_open!
@@ -140,10 +146,9 @@ module ZK
         @max_clients = Integer(opts.delete(:max_clients))
         @connection_timeout = opts.delete(:timeout)
 
-        # for compatibility w/ ClientPool we'll use @connections for synchronization
-        @pool = []            # currently available connections
+        @count_waiters = 0
 
-        synchronize do
+        @mutex.synchronize do
           populate_pool!(@min_clients)
           @state = :open
         end
@@ -152,41 +157,48 @@ module ZK
       # returns the current number of allocated clients in the pool (not
       # available clients)
       def size
-        @connections.length
+        @mutex.synchronize { @connections.length }
       end
 
       # clients available for checkout (at time of call)
       def available_size
-        @pool.length
+        @mutex.synchronize { @pool.length }
       end
 
       def checkin(connection)
-        synchronize do
-          return if @pool.include?(connection)
+        @mutex.synchronize do
+          if @pool.include?(connection)
+            logger.debug { "Pool already contains connection: #{connection.object_id}, @connections.include? #{@connections.include?(connection).inspect}" }
+            return
+          end
+
+          @pool << connection
 
-          @pool.unshift(connection)
           @checkin_cond.signal
         end
       end
 
       # number of threads waiting for connections
       def count_waiters #:nodoc:
-        @checkin_cond.count_waiters
+        @mutex.synchronize { @count_waiters }
       end
 
       def checkout(blocking=true) 
         raise ArgumentError, "checkout does not take a block, use .with_connection" if block_given?
-        synchronize do
+        @mutex.synchronize do
           while true
             assert_open!
 
             if @pool.length > 0
               cnx = @pool.shift
               
-              # if the cnx isn't connected? then remove it from the pool and go
-              # through the loop again. when the cnx's on_connected event fires, it
-              # will add the connection back into the pool
-              next unless cnx.connected?
+              # if the connection isn't connected, then set up an on_connection
+              # handler and try the next one in the pool
+              unless cnx.connected?
+                logger.debug { "connection #{cnx.object_id} is not connected" }
+                handle_checkin_on_connection(cnx)
+                next
+              end
 
               # otherwise we return the cnx
               return cnx
@@ -199,26 +211,57 @@ module ZK
             else
               return false
             end
-          end
+          end # while 
         end
       end
 
+      # @private
+      def can_grow_pool?
+        @mutex.synchronize { @connections.size < @max_clients }
+      end
+
       protected
         def populate_pool!(num_cnx)
           num_cnx.times { add_connection! }
         end
 
         def add_connection!
-          synchronize do
+          @mutex.synchronize do
             cnx = create_connection
             @connections << cnx 
 
-            cnx.on_connected { checkin(cnx) }
-          end
+            handle_checkin_on_connection(cnx)
+          end # synchronize
         end
 
-        def can_grow_pool?
-          synchronize { @connections.size < @max_clients }
+        def handle_checkin_on_connection(cnx)
+          @mutex.synchronize do
+            do_checkin = lambda do
+              checkin(cnx)
+            end
+
+            if cnx.connected?
+              do_checkin.call
+              return
+            else
+              @on_connected_subs.synchronize do
+
+                sub = cnx.on_connected do 
+                  # this synchronization is to prevent a race between setting up the subscription
+                  # and assigning it to the @on_connected_subs hash. It's possible that the callback
+                  # would fire before we had a chance to add the sub to the hash.
+                  @on_connected_subs.synchronize do
+                    if sub = @on_connected_subs.delete(cnx)
+                      sub.unsubscribe
+                      do_checkin.call
+                    end
+                  end
+                end
+
+                @on_connected_subs[cnx] = sub
+              end
+            end
+          end
         end
 
         def create_connection

data/lib/z_k/threadpool.rb

@@ -72,7 +72,9 @@ module ZK
         @threadqueue.clear
         @size.times { @threadqueue << KILL_TOKEN }
 
-        while th = @threadpool.shift
+        threads, @threadpool = @threadpool, []
+
+        while th = threads.shift
           begin
             th.join(timeout)
           rescue Exception => e
@@ -80,6 +82,8 @@ module ZK
             logger.error { e.to_std_format }
           end
         end
+
+        @threadqueue = ::Queue.new
       end
 
       nil
@@ -87,11 +91,12 @@ module ZK
 
     private
       def spawn_threadpool #:nodoc:
-        until @threadpool.size == @size.to_i
+        until @threadpool.size >= @size.to_i
           thread = Thread.new do
             while @running
               begin
                 op = @threadqueue.pop
+#                 $stderr.puts "thread #{Thread.current.inspect} got #{op.inspect}"
                 break if op == KILL_TOKEN
                 op.call
               rescue Exception => e

data/lib/z_k/version.rb

@@ -1,3 +1,3 @@
 module ZK
-  VERSION = "0.6.5"
+  VERSION = "0.7.1"
 end

data/lib/z_k.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'bundler/setup'
 
 require 'logger'
 require 'zookeeper'
@@ -26,7 +25,7 @@ require 'z_k/find'
 module ZK
   ZK_ROOT = File.expand_path('../..', __FILE__)
 
-  KILL_TOKEN = :__kill_token__ #:nodoc:
+  KILL_TOKEN = :__ZK_kILL_tOkEn__ #:nodoc:
 
 
   # The logger used by the ZK library. uses a Logger to +/dev/null+ by default

data/spec/spec_helper.rb

@@ -89,6 +89,7 @@ class ::Thread
 end
 
 def report_realtime(what)
+  return yield
   t = Benchmark.realtime { yield }
   $stderr.puts "#{what}: %0.3f" % [t.to_f]
 end

data/spec/support/logging_progress_bar_formatter.rb

@@ -0,0 +1,14 @@
+require 'rspec/core/formatters/progress_formatter'
+
+module Motionbox
+  # essentially a monkey-patch to the ProgressBarFormatter, outputs 
+  # '== #{example_proxy.description} ==' in the logs before each test.  makes it
+  # easier to match up tests with the SQL they produce
+  class LoggingProgressBarFormatter < RSpec::Core::Formatters::ProgressFormatter
+    def example_started(example)
+      ZK.logger.info(yellow("\n=====<([ #{example.full_description} ])>=====\n"))
+      super
+    end
+  end
+end
+

data/spec/watch_spec.rb

@@ -100,18 +100,36 @@ describe ZK do
   end
 
   describe 'state watcher' do
-    before do
-      @event = nil
-      @cnx_str = "localhost:#{ZK_TEST_PORT}"
+    describe 'live-fire test' do
+      before do
+        @event = nil
+        @cnx_str = "localhost:#{ZK_TEST_PORT}"
+
+        @zk = ZK.new(@cnx_str) do |zk|
+          @cnx_reg = zk.on_connected { |event| @event = event }
+        end
+      end
 
-      @zk = ZK.new(@cnx_str) do |zk|
-        @cnx_reg = zk.on_connected { |event| @event = event }
+      it %[should fire the registered callback] do
+        wait_while { @event.nil? }
+        @event.should_not be_nil
       end
     end
 
-    it %[should fire the registered callback] do
-      wait_while { @event.nil? }
-      @event.should_not be_nil
+    describe 'registered listeners' 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
+      end
+
+      it %[should only fire the callback once] do
+        pending "not sure if this is the behavior we want"
+      end
     end
   end
 end

data/spec/{client_spec.rb → z_k/client_spec.rb}

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), %w[spec_helper])
+require 'spec_helper'
 
 describe ZK::Client do
   before do

data/spec/{election_spec.rb → z_k/election_spec.rb}

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), %w[spec_helper])
+require 'spec_helper'
 
 describe ZK::Election do
   before do
@@ -262,10 +262,9 @@ describe ZK::Election do
       describe 'leadership transition' do
         before do
           @obama.vote!
-          @palin.vote!
-
           wait_until { @obama.leader? }
 
+          @palin.vote!
           @palin.should_not be_leader
 
           @got_life_event = @got_death_event = false

data/spec/{locker_spec.rb → z_k/locker_spec.rb}

@@ -1,4 +1,4 @@
-require File.join(File.dirname(__FILE__), %w[spec_helper])
+require 'spec_helper'
 
 # this is a remnant of the old Locker class, but a good test of what's expected
 # from ZK::Client#locker

data/spec/{mongoid_spec.rb → z_k/mongoid_spec.rb}

@@ -1,4 +1,4 @@
-require File.expand_path('../spec_helper', __FILE__)
+require 'spec_helper'
 
 require 'tracer'