zookeeper 0.4.4 → 0.9.3

data/lib/zookeeper/common.rb

@@ -0,0 +1,174 @@
+require 'zookeeper/exceptions'
+
+module ZookeeperCommon
+  # sigh, i guess define this here?
+  ZKRB_GLOBAL_CB_REQ   = -1
+
+  def event_dispatch_thread?
+    @dispatcher && (@dispatcher == Thread.current)
+  end
+
+protected
+  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 setup_call(meth_name, opts)
+    req_id = nil
+    @mutex.synchronize {
+      req_id = @current_req_id
+      @current_req_id += 1
+      setup_completion(req_id, meth_name, opts) if opts[:callback]
+      setup_watcher(req_id, opts) if opts[:watcher]
+    }
+    req_id
+  end
+ 
+  def setup_watcher(req_id, call_opts)
+    @watcher_reqs[req_id] = { :watcher => call_opts[:watcher],
+                              :context => call_opts[:watcher_context] }
+  end
+
+  # as a hack, to provide consistency between the java implementation and the C
+  # implementation when dealing w/ chrooted connections, we override this in
+  # ext/zookeeper_base.rb to wrap the callback in a chroot-path-stripping block.
+  #
+  # we don't use meth_name here, but we need it in the C implementation
+  #
+  def setup_completion(req_id, meth_name, call_opts)
+    @completion_reqs[req_id] = { :callback => call_opts[:callback],
+                                 :context => call_opts[:callback_context] }
+  end
+  
+  def get_watcher(req_id)
+    @mutex.synchronize {
+      (req_id == ZKRB_GLOBAL_CB_REQ) ? @watcher_reqs[req_id] : @watcher_reqs.delete(req_id)
+    }
+  end
+  
+  def get_completion(req_id)
+    @mutex.synchronize { @completion_reqs.delete(req_id) }
+  end
+
+  def setup_dispatch_thread!
+    logger.debug {  "starting dispatch thread" }
+    @dispatcher ||= Thread.new do
+      while true
+        begin
+          dispatch_next_callback(get_next_event(true))
+        rescue QueueWithPipe::ShutdownException
+          logger.info { "dispatch thread exiting, got shutdown exception" }
+          break
+        rescue Exception => e
+          $stderr.puts ["#{e.class}: #{e.message}", e.backtrace.map { |n| "\t#{n}" }.join("\n")].join("\n")
+        end
+      end
+      signal_dispatch_thread_exit!
+    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!
+    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
+        #
+        # wait for a maximum of 2 sec for dispatcher to signal exit (should be
+        # fast)
+        @dispatch_shutdown_cond.wait(2)
+
+        # wait for another 2 sec for the thread to join
+        unless @dispatcher.join(2)
+          logger.error { "Dispatch thread did not join cleanly, continuing" }
+        end
+        @dispatcher = nil
+      end
+    end
+  end
+
+  def signal_dispatch_thread_exit!
+    @mutex.synchronize do
+      logger.debug { "dispatch thread exiting!" }
+      @dispatch_shutdown_cond.broadcast
+    end
+  end
+
+  def dispatch_next_callback(hash)
+    return nil unless hash
+
+    Zookeeper.logger.debug { "get_next_event returned: #{prettify_event(hash).inspect}" }
+    
+    is_completion = hash.has_key?(:rc)
+    
+    hash[:stat] = ZookeeperStat::Stat.new(hash[:stat]) if hash.has_key?(:stat)
+    hash[:acl] = hash[:acl].map { |acl| ZookeeperACLs::ACL.new(acl) } if hash[:acl]
+    
+    callback_context = is_completion ? get_completion(hash[:req_id]) : get_watcher(hash[:req_id])
+
+    # When connectivity to the server has been lost (as indicated by SESSION_EVENT)
+    # we want to rerun the callback at a later time when we eventually do have
+    # a valid response.
+    if hash[:type] == ZookeeperConstants::ZOO_SESSION_EVENT
+      is_completion ? setup_completion(hash[:req_id], callback_context) : setup_watcher(hash[:req_id], callback_context)
+    end
+    if callback_context
+      callback = is_completion ? callback_context[:callback] : callback_context[:watcher]
+
+      hash[:context] = callback_context[:context]
+
+      # TODO: Eventually enforce derivation from Zookeeper::Callback
+      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 assert_supported_keys(args, supported)
+    unless (args.keys - supported).empty?
+      raise ZookeeperExceptions::ZookeeperException::BadArguments,  # this heirarchy is kind of retarded
+            "Supported arguments are: #{supported.inspect}, but arguments #{args.keys.inspect} were supplied instead"
+    end
+  end
+
+  def assert_required_keys(args, required)
+    unless (required - args.keys).empty?
+      raise ZookeeperExceptions::ZookeeperException::BadArguments,
+            "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
+    end
+  end
+
+private
+  def prettify_event(hash)
+    hash.dup.tap do |h|
+      # pretty up the event display
+      h[:type]    = ZookeeperConstants::EVENT_TYPE_NAMES.fetch(h[:type]) if h[:type]
+      h[:state]   = ZookeeperConstants::STATE_NAMES.fetch(h[:state]) if h[:state]
+      h[:req_id]  = :global_session if h[:req_id] == -1
+    end
+  end
+end
+
+require 'zookeeper/common/queue_with_pipe'

data/lib/zookeeper/constants.rb

@@ -6,6 +6,7 @@ module ZookeeperConstants
   # 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
@@ -17,38 +18,40 @@ module ZookeeperConstants
   ZOO_CHILD_EVENT        = 4
   ZOO_SESSION_EVENT      = -1
   ZOO_NOTWATCHING_EVENT  = -2
-              
-  def print_events
-    puts "ZK events:"
-    ZookeeperConstants::constants.each do |c|
-      puts "\t #{c}" if c =~ /^ZOO..*EVENT$/
-    end
-  end
 
-  def print_states
-    puts "ZK states:"
-    ZookeeperConstants::constants.each do |c|
-      puts "\t #{c}" if c =~ /^ZOO..*STATE$/
-    end
-  end
+  # 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
+
+  # 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)
-    return unless v
-    ZookeeperConstants::constants.each do |c|
-      next unless c =~ /^ZOO..*EVENT$/
-      if eval("ZookeeperConstants::#{c}") == v
-        return c
-      end
-    end
+    (name = EVENT_TYPE_NAMES[v]) ?  "ZOO_#{name.upcase}_EVENT" : ''
   end
-  
+
   def state_by_value(v)
-    return unless v
-    ZookeeperConstants::constants.each do |c|
-      next unless c =~ /^ZOO..*STATE$/
-      if eval("ZookeeperConstants::#{c}") == v
-        return c
-      end
-    end
+    (name = STATE_NAMES[v]) ?  "ZOO_#{name.upcase}_STATE" : ''
   end
 end

data/lib/zookeeper/em_client.rb

@@ -0,0 +1,55 @@
+require 'zookeeper'
+require 'eventmachine'
+
+module ZookeeperEM 
+  class Client < Zookeeper
+    # @private
+    # the EM Connection instance we receive once we call EM.watch on our selectable_io
+    attr_reader :em_connection
+
+    def initialize(*a, &b)
+      @on_close       = EM::DefaultDeferrable.new
+      @on_attached    = EM::DefaultDeferrable.new
+      @em_connection  = nil
+      logger.debug { "ZookeeperEM::Client obj_id %x: init" % [object_id] }
+      super(*a, &b)
+      on_attached.succeed
+    end
+
+    # EM::DefaultDeferrable that will be called back when our em_connection has been detached
+    # and we've completed the close operation
+    def on_close(&block)
+      @on_close.callback(&block) if block
+      @on_close
+    end
+
+    # called after we've successfully registered our selectable_io to be
+    # managed by the EM reactor
+    def on_attached(&block)
+      @on_attached.callback(&block) if block
+      @on_attached
+    end
+
+    def dispatch_next_callback(hash)
+      EM.schedule do
+        if running? and not closed?
+          logger.debug { "#{self.class}##{__method__} dispatch_next_callback: #{hash.inspect}: reactor_thread? #{EM.reactor_thread?}, running? #{running?}, closed? #{closed?}" }
+          super(hash) 
+        end
+      end
+    end
+
+    def close(&block)
+      on_close(&block)
+      super()
+      on_close.succeed
+    end
+
+    # Because eventmachine is single-threaded, and events are dispatched on the
+    # reactor thread we just delegate this to EM.reactor_thread?
+    def event_dispatch_thread?
+      EM.reactor_thread?
+    end
+  end # Client
+end # ZookeeperEM
+

data/lib/zookeeper/exceptions.rb

@@ -27,7 +27,7 @@ module ZookeeperExceptions
   ZNOTHING                  = -117
   ZSESSIONMOVED             = -118
 
-  class ZookeeperException < Exception
+  class ZookeeperException < StandardError
     class EverythingOk            < ZookeeperException; end
     class SystemError             < ZookeeperException; end
     class RunTimeInconsistency    < ZookeeperException; end
@@ -52,7 +52,15 @@ module ZookeeperExceptions
     class Closing                 < ZookeeperException; end
     class Nothing                 < ZookeeperException; end
     class SessionMoved            < ZookeeperException; end
-    class ConnectionClosed        < ZookeeperException; end  # this is a Ruby client exception
+    
+    # these are Ruby client exceptions
+    class ConnectionClosed        < ZookeeperException; end
+    class NotConnected            < ZookeeperException; end 
+    class ShuttingDownException   < ZookeeperException; end
+    class DataTooLargeException   < ZookeeperException; end
+
+    # yes, make an alias, this is the way zookeeper refers to it
+    ExpiredSession = SessionExpired
     
     def self.by_code(code)
       case code

data/lib/zookeeper/stat.rb

@@ -1,12 +1,21 @@
 module ZookeeperStat
   class Stat
-    attr_reader :version, :exists, :czxid, :mzxid, :ctime, :mtime, :cverzion, :aversion, :ephemeralOwner, :dataLength, :numChildren, :pzxid
+    attr_reader :version, :exists, :czxid, :mzxid, :ctime, :mtime, :cversion, :aversion, :ephemeralOwner, :dataLength, :numChildren, :pzxid
+
+    alias :ephemeral_owner :ephemeralOwner
+    alias :num_children :numChildren
+    alias :data_length :dataLength
+
     def initialize(val)
       @exists = !!val
       @czxid, @mzxid, @ctime, @mtime, @version, @cversion, @aversion,
           @ephemeralOwner, @dataLength, @numChildren, @pzxid = val if val.is_a?(Array)
       val.each { |k,v| instance_variable_set "@#{k}", v } if val.is_a?(Hash)
-      raise ArgumentError unless (val.is_a?(Hash) or val.is_a?(Array) or val == nil)
+      raise ArgumentError unless (val.is_a?(Hash) or val.is_a?(Array) or val.nil?)
+    end
+
+    def exists?
+      @exists
     end
   end
 end

data/lib/zookeeper/version.rb

@@ -0,0 +1,6 @@
+# this "namespacing" is retarded. fix this in 1.0
+# @private
+module ZookeeperVersion
+  VERSION = '0.9.3'
+  DRIVER_VERSION = '3.3.5'
+end