zookeeper-ng 1.5

data/lib/zookeeper/common.rb

@@ -0,0 +1,122 @@
+require 'zookeeper/exceptions'
+require 'zookeeper/common/queue_with_pipe'
+
+module Zookeeper
+module Common
+  def event_dispatch_thread?
+    @dispatcher && (@dispatcher == Thread.current)
+  end
+
+private
+  def setup_dispatch_thread!
+    @mutex.synchronize do
+      if @dispatcher
+        logger.debug { "dispatcher already running" }
+        return
+      end
+
+      logger.debug { "starting dispatch thread" }
+
+      @dispatcher = Thread.new(&method(:dispatch_thread_body))
+    end
+  end
+  
+  # this method is part of the reopen/close code, and is responsible for
+  # shutting down the dispatch thread. 
+  #
+  # @dispatcher will be nil when this method exits
+  #
+  def stop_dispatch_thread!(timeout=2)
+    logger.debug { "#{self.class}##{__method__}" }
+
+    if @dispatcher
+      if @dispatcher.join(0)
+        @dispatcher = nil
+        return
+      end
+
+      @mutex.synchronize do
+        event_queue.graceful_close!
+
+        # we now release the mutex so that dispatch_next_callback can grab it
+        # to do what it needs to do while delivering events
+        #
+        @dispatch_shutdown_cond.wait
+
+        # wait for another timeout sec for the thread to join
+        until @dispatcher.join(timeout)
+          logger.error { "Dispatch thread did not join cleanly, waiting" }
+        end
+        @dispatcher = nil
+      end
+    end
+  end
+
+  def get_next_event(blocking=true)
+    @event_queue.pop(!blocking).tap do |event|
+      logger.debug { "#{self.class}##{__method__} delivering event #{event.inspect}" }
+    end
+  rescue ThreadError
+    nil
+  end
+
+  def dispatch_next_callback(hash)
+    return nil unless hash
+
+    logger.debug { "get_next_event returned: #{prettify_event(hash).inspect}" }
+    
+    is_completion = hash.has_key?(:rc)
+    
+    hash[:stat] = Zookeeper::Stat.new(hash[:stat]) if hash.has_key?(:stat)
+    hash[:acl] = hash[:acl].map { |acl| Zookeeper::ACLs::ACL.new(acl) } if hash[:acl]
+    
+    callback_context = @req_registry.get_context_for(hash)
+
+    if callback_context
+      callback = is_completion ? callback_context[:callback] : callback_context[:watcher]
+
+      hash[:context] = callback_context[:context]
+
+      if callback.respond_to?(:call)
+        callback.call(hash)
+      else
+        # puts "dispatch_next_callback found non-callback => #{callback.inspect}"
+      end
+    else
+      logger.warn { "Duplicate event received (no handler for req_id #{hash[:req_id]}, event: #{hash.inspect}" }
+    end
+    true
+  end
+
+  def dispatch_thread_body
+    while true
+      begin
+        dispatch_next_callback(get_next_event(true))
+      rescue QueueWithPipe::ShutdownException
+        logger.info { "dispatch thread exiting, got shutdown exception" }
+        return
+      rescue Exception => e
+        $stderr.puts ["#{e.class}: #{e.message}", e.backtrace.map { |n| "\t#{n}" }.join("\n")].join("\n")
+      end
+    end
+  ensure
+    signal_dispatch_thread_exit!
+  end
+
+  def signal_dispatch_thread_exit!
+    @mutex.synchronize do
+      logger.debug { "dispatch thread exiting!" }
+      @dispatch_shutdown_cond.broadcast
+    end
+  end
+
+  def prettify_event(hash)
+    hash.dup.tap do |h|
+      # pretty up the event display
+      h[:type]    = Zookeeper::Constants::EVENT_TYPE_NAMES.fetch(h[:type]) if h[:type]
+      h[:state]   = Zookeeper::Constants::STATE_NAMES.fetch(h[:state]) if h[:state]
+      h[:req_id]  = :global_session if h[:req_id] == -1
+    end
+  end
+end
+end

data/lib/zookeeper/common/queue_with_pipe.rb

@@ -0,0 +1,110 @@
+module Zookeeper
+module Common
+  # Ceci n'est pas une pipe
+  class QueueWithPipe
+    extend Forwardable
+    include Logger
+
+    # raised when close has been called, and pop() is performed
+    # 
+    class ShutdownException < StandardError; end
+
+    # @private
+    KILL_TOKEN = Object.new unless defined?(KILL_TOKEN)
+
+    def initialize
+      @array = []
+
+      @mutex    = Mutex.new
+      @cond     = ConditionVariable.new
+      @closed   = false
+      @graceful = false
+    end
+
+    def clear
+      @mutex.lock
+      begin
+        @array.clear
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    def push(obj)
+      @mutex.lock
+      begin
+#         raise ShutdownException if (@closed or @graceful)
+        @array << obj
+        @cond.signal
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    def pop(non_blocking=false)
+      rval = nil
+
+      @mutex.lock
+      begin
+
+        begin
+          raise ShutdownException if @closed  # this may get us in trouble
+
+          rval = @array.shift
+
+          unless rval
+            raise ThreadError if non_blocking     # sigh, ruby's stupid behavior
+            raise ShutdownException if @graceful  # we've processed all the remaining mesages
+
+            @cond.wait(@mutex) until (@closed or @graceful or (@array.length > 0))
+          end
+        end until rval
+
+        return rval
+
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    # close the queue and causes ShutdownException to be raised on waiting threads
+    def graceful_close!
+      @mutex.lock
+      begin
+        return if @graceful or @closed
+        logger.debug { "#{self.class}##{__method__} gracefully closing" }
+        @graceful = true
+        @cond.broadcast
+      ensure
+        @mutex.unlock rescue nil
+      end
+      nil
+    end
+
+    def open
+      @mutex.lock
+      begin
+        @closed = @graceful = false
+        @cond.broadcast
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    def close
+      @mutex.lock
+      begin
+        return if @closed
+        @closed = true
+        @cond.broadcast
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
+    def closed?
+      @mutex.synchronize { !!@closed }
+    end
+  end
+end
+end

data/lib/zookeeper/compatibility.rb

@@ -0,0 +1,138 @@
+module Zookeeper
+  # @private
+  def self.warn_about_compatability_once!
+    return if @warned_about_compatibility
+    @warned_about_compatibility = true
+
+    warn <<-EOS
+
+-----------------------------------------------------------------------------
+
+          NOTICE: ZOOKEEPER BACKWARDS COMPATIBILTY EANBLED!! 
+        
+               THIS WILL NOT BE AUTOMATIC IN 1.1 !!
+
+  There was a major change to the organization of the Zookeeper gem between
+  0.9 and 1.0, breaking backwards compatibility. To ease the transition, 
+  
+  #{__FILE__}
+  
+  is automatically required. This will *not* be the case in 1.1.
+
+-----------------------------------------------------------------------------
+    EOS
+  end
+
+  def self.warned_about_compatability?
+    !!@warned_about_compatability
+  end
+end
+
+# at request of @eric
+#Zookeeper.warn_about_compatability_once!
+
+module Zookeeper
+  module Compatibility
+    def clean_backtrace
+      caller[0..-2].reject {|n| n =~ %r%/rspec/|\(eval\)|const_missing% }.map { |n| "\t#{n}" }.join("\n")
+    end
+  end
+end
+
+module ZookeeperConstants
+  include Zookeeper::Constants
+end
+
+module ZookeeperCallbacks
+  include Zookeeper::Callbacks
+  Callback = Base
+end
+
+module ZookeeperExceptions
+  include Zookeeper::Exceptions
+end
+
+module ZookeeperStat
+  extend Zookeeper::Compatibility
+  def self.const_missing(sym)
+    if sym == :Stat
+      warn "\nZookeeperStat::Stat is now Zookeeper::Stat, please update your code!\n#{clean_backtrace}"
+#       self.const_set(sym, Zookeeper::Stat)
+      Zookeeper::Stat
+    else
+      super
+    end
+  end
+end
+
+module ZookeeperACLs
+  extend Zookeeper::Compatibility
+  def self.const_missing(sym)
+    candidates = [Zookeeper::ACLs, Zookeeper::Constants, Zookeeper::ACLs::Constants]
+
+    candidates.each do |candidate|
+      if candidate.const_defined?(sym)
+        warn "\n#{self.name}::#{sym} is now located in #{candidate}::#{sym}, please update your code!\n#{clean_backtrace}"
+
+        c = candidate.const_get(sym)
+#         self.const_set(sym, c)
+        return c
+      end
+    end
+
+    super
+  end
+end
+
+module ZookeeperCommon
+  include Zookeeper::Common
+  extend Zookeeper::Compatibility
+  
+  def self.const_missing(sym)
+    candidate = Zookeeper::Common
+
+    if candidate.const_defined?(sym)
+      warn "\n#{self.name}::#{sym} is now located in #{candidate}::#{sym}, please update your code!\n#{clean_backtrace}"
+
+      candidate.const_get(sym).tap do |c|
+#         self.const_set(sym, c)
+      end
+    else
+      super
+    end
+  end
+
+end
+
+# module Zookeeper
+#   include ZookeeperConstants
+#   include ZookeeperCallbacks
+#   include ZookeeperExceptions
+#   include ZookeeperCommon
+#   include ZookeeperStat
+#   include ZookeeperACLs
+# end
+
+module Zookeeper
+  extend Zookeeper::Compatibility
+  def self.const_missing(sym)
+    candidate =
+      case sym.to_s
+      when /Callback/
+        Zookeeper::Callbacks
+      end
+
+    super unless candidate
+
+    if candidate.const_defined?(sym)
+      warn "\n#{self.name}::#{sym} is now located in #{candidate}::#{sym}, please update your code!\n#{clean_backtrace}"
+
+      candidate.const_get(sym).tap do |c|
+#         self.const_set(sym, c)
+      end
+    else
+      super
+    end
+  end
+end
+

data/lib/zookeeper/constants.rb

@@ -0,0 +1,97 @@
+module Zookeeper
+module Constants
+  include ACLs::Constants
+
+  # file type masks
+  ZOO_EPHEMERAL = 1
+  ZOO_SEQUENCE  = 2
+  
+  # session state
+  ZOO_EXPIRED_SESSION_STATE  = -112
+  ZOO_AUTH_FAILED_STATE      = -113
+  ZOO_CLOSED_STATE           = 0
+  ZOO_CONNECTING_STATE       = 1
+  ZOO_ASSOCIATING_STATE      = 2
+  ZOO_CONNECTED_STATE        = 3
+  
+  # watch types
+  ZOO_CREATED_EVENT      = 1
+  ZOO_DELETED_EVENT      = 2
+  ZOO_CHANGED_EVENT      = 3
+  ZOO_CHILD_EVENT        = 4
+  ZOO_SESSION_EVENT      = -1
+  ZOO_NOTWATCHING_EVENT  = -2
+
+  # only used by the C extension
+  ZOO_LOG_LEVEL_ERROR = 1
+  ZOO_LOG_LEVEL_WARN  = 2
+  ZOO_LOG_LEVEL_INFO  = 3
+  ZOO_LOG_LEVEL_DEBUG = 4
+
+  # exceptions/errors
+  ZOK                    =  0
+  ZSYSTEMERROR           = -1
+  ZRUNTIMEINCONSISTENCY  = -2
+  ZDATAINCONSISTENCY     = -3
+  ZCONNECTIONLOSS        = -4
+  ZMARSHALLINGERROR      = -5
+  ZUNIMPLEMENTED         = -6
+  ZOPERATIONTIMEOUT      = -7
+  ZBADARGUMENTS          = -8
+  ZINVALIDSTATE          = -9
+  
+  # api errors
+  ZAPIERROR                 = -100
+  ZNONODE                   = -101
+  ZNOAUTH                   = -102
+  ZBADVERSION               = -103
+  ZNOCHILDRENFOREPHEMERALS  = -108
+  ZNODEEXISTS               = -110
+  ZNOTEMPTY                 = -111
+  ZSESSIONEXPIRED           = -112
+  ZINVALIDCALLBACK          = -113
+  ZINVALIDACL               = -114
+  ZAUTHFAILED               = -115
+  ZCLOSING                  = -116
+  ZNOTHING                  = -117
+  ZSESSIONMOVED             = -118
+
+  ZKRB_GLOBAL_CB_REQ = -1
+  ZKRB_ASYNC_CONTN_ID = -2
+
+  # @private
+  CONNECTED_EVENT_VALUES = [Constants::ZKRB_GLOBAL_CB_REQ, 
+                            Constants::ZOO_SESSION_EVENT, 
+                            Constants::ZOO_CONNECTED_STATE].freeze
+
+  # used to find the name for a numeric event
+  # @private
+  EVENT_TYPE_NAMES = {
+    1   => 'created',
+    2   => 'deleted',
+    3   => 'changed',
+    4   => 'child',
+    -1  => 'session',
+    -2  => 'notwatching',
+  }
+
+  # used to pretty print the state name
+  # @private
+  STATE_NAMES = {
+    -112 => 'expired_session',
+    -113 => 'auth_failed',
+    0    => 'closed',
+    1    => 'connecting',
+    2    => 'associating',
+    3    => 'connected',
+  }
+              
+  def event_by_value(v)
+    (name = EVENT_TYPE_NAMES[v]) ?  "ZOO_#{name.upcase}_EVENT" : ''
+  end
+
+  def state_by_value(v)
+    (name = STATE_NAMES[v]) ?  "ZOO_#{name.upcase}_STATE" : ''
+  end
+end
+end