zk 1.4.2 → 1.5.0

data/lib/zk/client/unixisms.rb

@@ -127,51 +127,11 @@ module ZK
       #   a deleted event. Includes the {InterruptedSession} module.
       #
       def block_until_node_deleted(abs_node_path)
-        subs = []
-
         assert_we_are_not_on_the_event_dispatch_thread!
 
         raise ArgumentError, "argument must be String-ish, not: #{abs_node_path.inspect}" unless abs_node_path
 
-        queue = Queue.new
-
-        node_deletion_cb = lambda do |event|
-          if event.node_deleted?
-            queue.enq(:deleted) 
-          else
-            queue.enq(:deleted) unless exists?(abs_node_path, :watch => true)
-          end
-        end
-
-        subs << event_handler.register(abs_node_path, &node_deletion_cb)
-
-        # NOTE: this pattern may be necessary for other features with blocking semantics!
-
-        session_cb = lambda do |event|
-          queue.enq(event.state)
-        end
-
-        [:expired_session, :connecting, :closed].each do |sym|
-          subs << event_handler.register_state_handler(sym, &session_cb)
-        end
-        
-        # set up the callback, but bail if we don't need to wait
-        return true unless exists?(abs_node_path, :watch => true)  
-
-        case queue.pop
-        when :deleted
-          true
-        when ZOO_EXPIRED_SESSION_STATE
-          raise Zookeeper::Exceptions::SessionExpired
-        when ZOO_CONNECTING_STATE
-          raise Zookeeper::Exceptions::NotConnected
-        when ZOO_CLOSED_STATE
-          raise Zookeeper::Exceptions::ConnectionClosed
-        else
-          raise "Hit unexpected case in block_until_node_deleted"
-        end
-      ensure
-        subs.each(&:unregister)
+        NodeDeletionWatcher.new(self, abs_node_path).block_until_deleted
       end
     end
   end

data/lib/zk/core_ext.rb

@@ -99,4 +99,32 @@ class ::Module
   end
 end
 
+require 'logger'
+
+# lets you clone a a Logger instance but change properties, this is 
+# used by the test suite to change the progname for different components
+# @private
+class ::Logger
+  unless method_defined?(:clone_new_log)
+    attr_writer :logdev
+
+    def clone_new_log(opts={})
+      self.class.new(nil).tap do |noo_log|
+        noo_log.progname  = opts.fetch(:progname, self.progname)
+        noo_log.formatter = opts.fetch(:formatter, self.formatter)
+        noo_log.level     = opts.fetch(:level, self.level)
+        noo_log.logdev    = @logdev
+      end
+    end
+  end
+
+  def debug_pp(title)
+    debug do 
+      str = "---< #{title} >---\n"
+      require 'pp'
+      str << PP.pp(yield, '') 
+    end
+  end
+end
+
 

data/lib/zk/election.rb

@@ -1,7 +1,5 @@
 module ZK
-  # NOTE: this module should be considered experimental. there are several
-  # specs that have recently started failing under 1.9.2 (didn't fail under
-  # 1.8.7 or jruby 1.6) that need fixing. 
+  # NOTE: this module should be considered experimental.
   #
   # ==== Overview
   #
@@ -72,6 +70,14 @@ module ZK
         opts = DEFAULT_OPTS.merge(opts)
         @root_election_node = opts[:root_election_node]
         @mutex = Monitor.new
+        @closed = false
+      end
+
+      def close
+        @mutex.synchronize do
+          return if @closed
+          @closed = true
+        end
       end
 
       # holds the ephemeral nodes of this election
@@ -109,6 +115,7 @@ module ZK
       # role. 
       def on_leader_ack(&block)
         creation_sub = @zk.register(leader_ack_path, :only => [:created, :changed]) do |event|
+          return if @closed
           begin
             logger.debug { "in #{leader_ack_path} watcher, got creation event, notifying" }
             safe_call(block)
@@ -119,6 +126,7 @@ module ZK
 
         deletion_sub = @zk.register(leader_ack_path, :only => [:deleted, :child]) do |event|
           if @zk.exists?(leader_ack_path, :watch => true)
+            return if @closed
             begin
               logger.debug { "in #{leader_ack_path} watcher, node created behind our back, notifying" }
               safe_call(block)
@@ -269,12 +277,15 @@ module ZK
         end
 
         def handle_winning_election
+          @mutex.synchronize { return if @closed }
           @leader = true  
           fire_winning_callbacks!
           acknowledge_win!
         end
 
         def handle_losing_election(our_idx, ballots)
+          @mutex.synchronize { return if @closed }
+
           @leader = false
 
           on_leader_ack do

data/lib/zk/event_handler.rb

@@ -33,6 +33,8 @@ module ZK
     def initialize(zookeeper_client, opts={})
       @zk = zookeeper_client
 
+      @orig_pid = Process.pid
+
       @thread_opt = opts.fetch(:thread, :single)
       EventHandlerSubscription.class_for_thread_option(@thread_opt) # this is side-effecty, will raise an ArgumentError if given a bad value. 
 
@@ -48,42 +50,17 @@ module ZK
 
       reopen_after_fork!
     end
-
-    # stops the dispatching of events. already in-flight callbacks may still be running, but
-    # no new events will be dispatched until {#start} is called
-    #
-    # any events that are delivered while we are stopped will be lost
-    #
-    def stop
-      synchronize do
-        return if @state == :stopped
-        @state = :stopped
-      end
-    end
-
-    # called to re-enable event delivery
-    def start
-      synchronize do
-        return if @state == :running
-        @state = :running
-      end
-    end
-
-    def running?
-      synchronize { @state == :running }
-    end
-
-    def stopped?
-      synchronize { @state == :stopped }
-    end
-    
+   
     # do not call this method. it is inteded for use only when we've forked and 
     # all other threads are dead.
     #
     # @private
     def reopen_after_fork!
+#       logger.debug { "#{self.class}##{__method__}" }
       @mutex = Monitor.new
       # XXX: need to test this w/ actor-style callbacks
+      
+      @state = :running
       @callbacks.values.flatten.each { |cb| cb.reopen_after_fork! if cb.respond_to?(:reopen_after_fork!) }
       @outstanding_watches.values.each { |set| set.clear }
       nil
@@ -164,7 +141,7 @@ module ZK
     end
     alias :unsubscribe :unregister
 
-    # called from the client-registered callback when an event fires
+    # called from the Client registered callback when an event fires
     #
     # @note this is *ONLY* dealing with asynchronous callbacks! watchers
     #   and session events go through here, NOT anything else!!
@@ -173,7 +150,7 @@ module ZK
     def process(event)
       @zk.raw_event_handler(event)
 
-#       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_keys = 
@@ -185,8 +162,6 @@ 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 
         clear_watch_restrictions(event)
 
@@ -235,10 +210,34 @@ module ZK
     def close
       synchronize do
         @callbacks.values.flatten.each(&:close)
+        @state = :closed
         clear!
       end
     end
 
+    # @private
+    def pause_before_fork_in_parent
+      synchronize do
+        raise InvalidStateError, "invalid state, expected to be :running, was #{@state.inspect}" if @state != :running
+        return false if @state == :paused
+        @state = :paused
+      end
+      logger.debug { "#{self.class}##{__method__}" }
+
+      @callbacks.values.flatten.each(&:pause_before_fork_in_parent)
+    end
+
+    # @private
+    def resume_after_fork_in_parent
+      synchronize do
+        raise InvalidStateError, "expected :paused, was #{@state.inspect}" if @state != :paused
+        @state = :running
+      end
+      logger.debug { "#{self.class}##{__method__}" }
+
+      @callbacks.values.flatten.each(&:resume_after_fork_in_parent)
+    end
+
     # @private
     def synchronize
       @mutex.synchronize { yield }
@@ -329,16 +328,16 @@ module ZK
 
       # @private
       def safe_call(callbacks, *args)
-        # oddly, a `while cb = callbacks.shift` here will have thread safety issues
-        # as cb will be nil when the defer block is called on the threadpool
-        
         callbacks.each do |cb|
           next unless cb.respond_to?(:call)
 
           if cb.async?
             cb.call(*args)
           else
-            zk.defer { cb.call(*args) }
+            zk.defer do 
+              logger.debug { "called #{cb.inspect} with #{args.inspect} on threadpool" }
+              cb.call(*args)
+            end
           end
         end
       end

data/lib/zk/event_handler_subscription/actor.rb

@@ -16,15 +16,50 @@ module ZK
     # guarantees), just perhaps at different times.
     #
     class Actor < Base
-      include Subscription::ActorStyle
+      # @private
+      attr_reader :threaded_callback
+
+      def initialize(parent, path, callback, opts={})
+        super
+        @threaded_callback = ThreadedCallback.new(@callable)
+      end
 
       def async?
         true
       end
 
+      def call(*args)
+        @threaded_callback.call(*args)
+      end
+      
       # calls unsubscribe and shuts down 
       def close
-        unsubscribe
+        unregister
+      end
+
+      def unregister
+        super
+        @threaded_callback.shutdown
+      end
+
+      def reopen_after_fork!
+        logger.debug { "#{self.class}##{__method__}" }
+        super
+        @threaded_callback.reopen_after_fork!
+      end
+
+      def pause_before_fork_in_parent
+        synchronize do
+          logger.debug { "#{self.class}##{__method__}" }
+          @threaded_callback.pause_before_fork_in_parent
+          super
+        end
+      end
+
+      def resume_after_fork_in_parent
+        super
+        logger.debug { "#{self.class}##{__method__}" }
+        @threaded_callback.resume_after_fork_in_parent
       end
     end
   end

data/lib/zk/event_handler_subscription/base.rb

@@ -43,6 +43,15 @@ module ZK
       def close
       end
 
+      # stop anything non-fork-safe in parent
+      def pause_before_fork_in_parent
+      end
+      
+      # take any action necessary to deliver events after a fork
+      # in the parent
+      def resume_after_fork_in_parent
+      end
+
       protected
         def prep_interests(a)
 #           logger.debug { "prep_interests: #{a.inspect}" }

data/lib/zk/exceptions.rb

@@ -129,6 +129,11 @@ module ZK
     # raised when someone calls lock.assert! but they do not hold the lock
     class LockAssertionFailedError < ZKError; end
 
+    # called when the client is reopened, resumed, or paused when in an invalid state
+    class InvalidStateError < ZKError; end
+
+    class WakeUpException < ZKError; end
+
     # raised when a chrooted conection is requested but the root doesn't exist
     class ChrootPathDoesNotExistError < NoNode
       def initialize(host_string, chroot_path)

data/lib/zk/fork_hook.rb

@@ -0,0 +1,112 @@
+module ZK
+  module ForkHook
+    include ZK::Logging
+    extend self
+
+    @mutex = Mutex.new unless @mutex
+
+    @hooks = {
+      :prepare      => [],
+      :after_child  => [],
+      :after_parent => [],
+    } unless @hooks
+
+    attr_reader :hooks, :mutex
+
+    # @private
+    def fire_prepare_hooks!
+      @mutex.lock
+      safe_call(@hooks[:prepare])
+    end
+
+    # @private
+    def fire_after_child_hooks!
+      safe_call(@hooks[:after_child])
+    ensure
+      @mutex.unlock rescue nil
+    end
+
+    # @private
+    def fire_after_parent_hooks!
+      safe_call(@hooks[:after_parent])
+    ensure
+      @mutex.unlock rescue nil
+    end
+    
+    # @private
+    def clear!
+      @mutex.synchronize { @hooks.values(&:clear) }
+    end
+
+    # @private
+    def unregister(sub)
+      @mutex.synchronize do
+        @hooks.fetch(sub.hook_type, []).delete(sub)
+      end
+    end
+
+    # do :call on each of callbacks. if a WeakRef::RefError
+    # is caught, modify `callbacks` by removing the dud reference
+    #
+    # @private
+    def safe_call(callbacks)
+      cbs = callbacks.dup
+
+      while cb = cbs.shift
+        begin
+          cb.call
+        rescue WeakRef::RefError
+          # clean weakrefs out of the original callback arrays if they're bad
+          callbacks.delete(cb)
+        rescue Exception => e
+          logger.error { e.to_std_format }
+        end
+      end
+    end
+
+    # @private
+    def register(hook_type, block)
+      unless hooks.has_key?(hook_type)
+        raise "Invalid hook type specified: #{hook.inspect}" 
+      end
+
+      unless block.respond_to?(:call)
+        raise ArgumentError, "You must provide either a callable an argument or a block"
+      end
+
+      ForkSubscription.new(hook_type, block).tap do |sub|
+        # use a WeakRef so that the original objects can be GC'd
+        @mutex.synchronize { @hooks[hook_type] << WeakRef.new(sub) } 
+      end
+    end
+
+    # Register a block that will be called in the parent process before a fork() occurs
+    def prepare_for_fork(callable=nil, &blk)
+      register(:prepare, callable || blk)
+    end
+
+    # register a block that will be called after the fork happens in the parent process
+    def after_fork_in_parent(callable=nil, &blk)
+      register(:after_parent, callable || blk)
+    end
+
+    # register a block that will be called after the fork happens in the child process
+    def after_fork_in_child(callable=nil, &blk)
+      register(:after_child, callable || blk)
+    end
+
+    class ForkSubscription < Subscription::Base
+      attr_reader :hook_type
+
+      def initialize(hook_type, block)
+        super(ForkHook, block)
+
+        @hook_type = hook_type
+      end
+    end # ForkSubscription
+  end # ForkHook
+
+  def self.install_fork_hook
+    require 'zk/install_fork_hooks'
+  end
+end # ZK