zk 1.4.2 → 1.5.0

data/lib/zk/install_fork_hooks.rb

@@ -0,0 +1,37 @@
+module ::Kernel
+  def fork_with_zk_hooks(&block)
+    if block
+      new_block = proc do
+        ::ZK::ForkHook.fire_after_child_hooks!
+        block.call
+      end
+
+      ::ZK::ForkHook.fire_prepare_hooks!
+      fork_without_zk_hooks(&new_block).tap do
+        ::ZK::ForkHook.fire_after_parent_hooks!
+      end
+    else
+      ::ZK::ForkHook.fire_prepare_hooks!
+      if pid = fork_without_zk_hooks
+        ::ZK::ForkHook.fire_after_parent_hooks!
+        # we're in the parent
+        return pid
+      else
+        # we're in the child
+        ::ZK::ForkHook.fire_after_child_hooks!
+        return nil
+      end
+    end
+  end
+  module_function :fork_with_zk_hooks
+
+  if defined?(fork_without_zk_hooks)
+    remove_method :fork
+    alias fork fork_without_zk_hooks
+    remove_method :fork_without_zk_hooks
+  end
+
+  alias fork_without_zk_hooks fork
+  alias fork fork_with_zk_hooks
+end
+

data/lib/zk/locker/exclusive_locker.rb

@@ -18,15 +18,13 @@ module ZK
       # obtain an exclusive lock.
       #
       def lock(blocking=false)
-        return true if @locked
+        return true if synchronize { @locked }
         create_lock_path!(EXCLUSIVE_LOCK_PREFIX)
 
         if got_write_lock?
-          @locked = true
+          synchronize { @locked = true }
         elsif blocking
-          in_waiting_status do
-            block_until_write_lock!
-          end
+          block_until_write_lock!
         else
           cleanup_lock_path!
           false
@@ -51,7 +49,7 @@ module ZK
         return true if locked? 
         stat = zk.stat(root_lock_path)
         !stat.exists? or stat.num_children == 0
-      rescue Exceptions::NoNode
+      rescue Exceptions::NoNode   # XXX: is this ever hit? stat shouldn't raise
         true
       end
 
@@ -74,13 +72,19 @@ module ZK
 
         def block_until_write_lock!
           begin
-            path = [root_lock_path, next_lowest_node].join('/')
-            logger.debug { "SharedLocker#block_until_write_lock! path=#{path.inspect}" }
-            @zk.block_until_node_deleted(path)
+            path = "#{root_lock_path}/#{next_lowest_node}"
+            logger.debug { "#{self.class}##{__method__} path=#{path.inspect}" }
+
+            synchronize do
+              @node_deletion_watcher = NodeDeletionWatcher.new(zk, path)
+              @cond.broadcast
+            end
+
+            @node_deletion_watcher.block_until_deleted
           rescue WeAreTheLowestLockNumberException
           end
 
-          @locked = true
+          synchronize { @locked = true }
         end
     end # ExclusiveLocker
   end # Locker

data/lib/zk/locker/locker_base.rb

@@ -53,6 +53,9 @@ module ZK
         @waiting = false
         @lock_path = nil
         @root_lock_path = "#{@root_lock_node}/#{@path.gsub("/", "__")}"
+        @mutex  = Monitor.new
+        @cond   = @mutex.new_cond
+        @node_deletion_watcher = nil
       end
       
       # block caller until lock is aquired, then yield
@@ -78,7 +81,7 @@ module ZK
       # @return [nil] if lock_path is not set
       # @return [String] last path component of our lock path
       def lock_basename
-        lock_path and File.basename(lock_path)
+        synchronize { lock_path and File.basename(lock_path) }
       end
 
       # returns our current idea of whether or not we hold the lock, which does
@@ -91,8 +94,8 @@ module ZK
       # @return [true] if we hold the lock
       # @return [false] if we don't hold the lock
       #
-      def locked?(check_if_any=false)
-        false|@locked 
+      def locked?
+        synchronize { !!@locked }
       end
 
       # * If this instance holds the lock {#locked? is true} we return true (as
@@ -119,12 +122,15 @@ module ZK
       # @return [false] we did not own the lock
       #
       def unlock
-        if @locked
-          cleanup_lock_path!
-          @locked = false
-          true
-        else
-          false # i know, i know, but be explicit
+        synchronize do
+          if @locked
+            cleanup_lock_path!
+            @locked = false
+            @node_deletion_watcher = nil
+            true
+          else
+            false # i know, i know, but be explicit
+          end
         end
       end
 
@@ -161,10 +167,23 @@ module ZK
       end
 
       # returns true if this locker is waiting to acquire lock 
+      # this should be used in tests only. 
       #
       # @private
       def waiting? 
-        false|@waiting
+        synchronize do
+          !!(@node_deletion_watcher and @node_deletion_watcher.blocked?)
+        end
+      end
+
+      # blocks the caller until this lock is blocked
+      # @private
+      def wait_until_blocked(timeout=nil)
+        synchronize do
+          @cond.wait_until { @node_deletion_watcher }
+        end
+
+        @node_deletion_watcher.wait_until_blocked(timeout)
       end
 
       # This is for users who wish to check that the assumption is correct
@@ -196,19 +215,18 @@ module ZK
       #   end
       #
       def assert!
-        raise LockAssertionFailedError, "have not obtained the lock yet"            unless locked?
-        raise LockAssertionFailedError, "not connected"                             unless zk.connected?
-        raise LockAssertionFailedError, "lock_path was #{lock_path.inspect}"        unless lock_path
-        raise LockAssertionFailedError, "the lock path #{lock_path} did not exist!" unless zk.exists?(lock_path)
-        raise LockAssertionFailedError, "we do not actually hold the lock"          unless got_lock?
+        synchronize do
+          raise LockAssertionFailedError, "have not obtained the lock yet"            unless locked?
+          raise LockAssertionFailedError, "not connected"                             unless zk.connected?
+          raise LockAssertionFailedError, "lock_path was #{lock_path.inspect}"        unless lock_path
+          raise LockAssertionFailedError, "the lock path #{lock_path} did not exist!" unless zk.exists?(lock_path)
+          raise LockAssertionFailedError, "we do not actually hold the lock"          unless got_lock?
+        end
       end
 
       protected 
-        def in_waiting_status
-          w, @waiting = @waiting, true
-          yield
-        ensure
-          @waiting = w
+        def synchronize
+          @mutex.synchronize { yield }
         end
 
         def digit_from(path)
@@ -245,7 +263,10 @@ module ZK
         # defaults to 'lock'
         #
         def create_lock_path!(prefix='lock')
-          @lock_path = @zk.create("#{root_lock_path}/#{prefix}", "", :mode => :ephemeral_sequential)
+          synchronize do
+            @lock_path = @zk.create("#{root_lock_path}/#{prefix}", "", :mode => :ephemeral_sequential)
+          end
+
           logger.debug { "got lock path #{@lock_path}" }
           @lock_path
         rescue NoNode
@@ -257,11 +278,7 @@ module ZK
           logger.debug { "removing lock path #{@lock_path}" }
           zk.delete(@lock_path)
 
-          begin
-            zk.delete(root_lock_path) 
-          rescue NotEmpty
-          end
-
+          zk.delete(root_lock_path, :ignore => :not_empty) 
           @lock_path = nil
         end
     end # LockerBase

data/lib/zk/locker/shared_locker.rb

@@ -13,9 +13,7 @@ module ZK
         if got_read_lock?      
           @locked = true
         elsif blocking
-          in_waiting_status do
-            block_until_read_lock!
-          end
+          block_until_read_lock!
         else
           # we didn't get the lock, and we're not gonna wait around for it, so
           # clean up after ourselves
@@ -100,13 +98,19 @@ module ZK
           begin
             path = "#{root_lock_path}/#{next_lowest_write_lock_name}"
             logger.debug { "SharedLocker#block_until_read_lock! path=#{path.inspect}" }
-            @zk.block_until_node_deleted(path)
+
+            synchronize do
+              @node_deletion_watcher = NodeDeletionWatcher.new(zk, path)
+              @cond.broadcast
+            end
+
+            @node_deletion_watcher.block_until_deleted
           rescue NoWriteLockFoundException
             # next_lowest_write_lock_name may raise NoWriteLockFoundException,
             # which means we should not block as we have the lock (there is nothing to wait for)
           end
 
-          @locked = true
+          synchronize { @locked = true }
         end
     end # SharedLocker
   end # Locker

data/lib/zk/logging.rb

@@ -1,15 +1,37 @@
 module ZK
+  # use the ZK.logger if non-nil (to allow users to override the logger)
+  # otherwise, use a Loggging logger based on the class name
   module Logging
-    def self.included(mod)
-      mod.extend(ZK::Logging::Methods)
-      mod.send(:include, ZK::Logging::Methods)
+    extend ZK::Concern
+
+    included do
+      def self.logger
+        ::ZK.logger || ::Logging.logger[logger_name]
+      end
     end
-    
-    module Methods
-      def logger
-        ZK.logger
+
+    def self.set_default
+      ::Logging.logger['ZK'].tap do |ch_root|
+        ::Logging.appenders.stderr.tap do |serr|
+          serr.layout = ::Logging.layouts.pattern(
+            :pattern => '%.1l, [%d] %c30.30{2}:  %m\n',
+            :date_pattern => '%Y-%m-%d %H:%M:%S.%6N' 
+          )
+
+          ch_root.add_appenders(serr)
+        end
+
+        ch_root.level = ENV['ZK_DEBUG'] ? :debug : :off
       end
     end
+
+    # cache the logger at the instance level, as that's where most of the
+    # logging is done, this means that the user should set up the override
+    # of the ZK.logger early, before creating instances.
+    #
+    def logger
+      @logger ||= (::ZK.logger || ::Logging.logger[self.class.logger_name]) # logger_name defined in ::Logging::Utils
+    end
   end
 end
 

data/lib/zk/node_deletion_watcher.rb

@@ -0,0 +1,167 @@
+module ZK
+  class NodeDeletionWatcher
+    include Zookeeper::Constants
+    include Exceptions
+    include Logging
+
+    # @private
+    module Constants
+      NOT_YET     = :not_yet
+      BLOCKED     = :yes
+      NOT_ANYMORE = :not_anymore
+      INTERRUPTED = :interrupted
+    end
+    include Constants
+
+    attr_reader :zk, :path
+
+    def initialize(zk, path)
+      @zk     = zk
+      @path   = path.dup
+
+      @subs   = []
+
+      @mutex  = Monitor.new # ffs, 1.8.7 compatibility w/ timeouts
+      @cond   = @mutex.new_cond
+
+      @blocked  = :not_yet
+      @result   = nil
+    end
+
+    def done?
+      @mutex.synchronize { !!@result }
+    end
+
+    def blocked?
+      @mutex.synchronize { @blocked == BLOCKED }
+    end
+
+    # this is for testing, allows us to wait until this object has gone into
+    # blocking state.
+    #
+    # avoids the race where if we have already been blocked and released
+    # this will not block the caller
+    #
+    # pass optional timeout to return after that amount of time or nil to block
+    # forever
+    #
+    # @return [true] if we have been blocked previously or are currently blocked,
+    # @return [nil] if we timeout
+    #
+    def wait_until_blocked(timeout=nil)
+      @mutex.synchronize do
+        return true unless @blocked == NOT_YET
+
+        start = Time.now
+        time_to_stop = timeout ? (start + timeout) : nil
+
+        @cond.wait(timeout)
+
+        if (time_to_stop and (Time.now > time_to_stop)) and (@blocked == NOT_YET)
+          return nil
+        end
+
+        (@blocked == NOT_YET) ? nil : true
+      end
+    end
+
+    # cause a thread blocked us to be awakened and have a WakeUpException
+    # raised. 
+    #
+    # if a result has already been delivered, then this does nothing
+    #
+    # if a result has not *yet* been delivered, any thread calling
+    # block_until_deleted will receive the exception immediately
+    #
+    def interrupt!
+      @mutex.synchronize do
+        case @blocked
+        when NOT_YET, BLOCKED
+          @result = INTERRUPTED
+          @cond.broadcast
+        else
+          return
+        end
+      end
+    end
+
+    def block_until_deleted
+      @mutex.synchronize do
+        raise InvalidStateError, "Already fired for #{path}" if @result
+        register_callbacks
+
+        unless zk.exists?(path, :watch => true)
+          # we are done, these are one-shot, so write the results
+          @result = :deleted
+          @blocked = NOT_ANYMORE
+          @cond.broadcast # wake any waiting threads
+          return true
+        end
+
+        logger.debug { "ok, going to block: #{path}" }
+
+        while true # this is probably unnecessary
+          @blocked = BLOCKED
+          @cond.broadcast                 # wake threads waiting for @blocked to change
+          @cond.wait_until { @result }    # wait until we get a result
+          @blocked = NOT_ANYMORE
+
+          case @result
+          when :deleted
+            logger.debug { "path #{path} was deleted" }
+            return true
+          when INTERRUPTED
+            raise ZK::Exceptions::WakeUpException
+          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, result was: #{@result.inspect}"
+          end
+        end
+      end
+    ensure
+      unregister_callbacks
+    end
+
+    private
+      def unregister_callbacks
+        @subs.each(&:unregister)
+      end
+
+      def register_callbacks
+        @subs << zk.register(path, &method(:node_deletion_cb))
+
+        [:expired_session, :connecting, :closed].each do |sym|
+          @subs << zk.event_handler.register_state_handler(sym, &method(:session_cb))
+        end
+      end
+
+      def node_deletion_cb(event)
+        @mutex.synchronize do
+          if event.node_deleted?
+            @result = :deleted
+            @cond.broadcast
+          else
+            unless zk.exists?(path, :watch => true)
+              @result = :deleted
+              @cond.broadcast
+            end
+          end
+        end
+      end
+
+      def session_cb(event)
+        @mutex.synchronize do
+          unless @result
+            @result = event.state
+            @cond.broadcast
+          end
+        end
+      end
+  end
+end
+