zookeeper-ng 1.5

data/lib/zookeeper/continuation.rb

@@ -0,0 +1,223 @@
+module Zookeeper
+  # @private
+  # sigh, slightly different than the userland callbacks, the continuation
+  # provides sync call semantics around an async api
+  class Continuation
+    include Constants
+    include Logger
+
+    OPERATION_TIMEOUT = 30 # seconds
+
+    # for keeping track of which continuations are pending, and which ones have
+    # been submitted and are awaiting a repsonse
+    # 
+    # `state_check` are high-priority checks that query the connection about
+    # its current state, they always run before other continuations
+    #
+    class Registry < Struct.new(:pending, :state_check, :in_flight)
+      extend Forwardable
+
+      def_delegators :@mutex, :lock, :unlock
+
+      def initialize
+        super([], [], {})
+        @mutex = Mutex.new
+      end
+
+      def synchronize
+        @mutex.lock
+        begin
+          yield self
+        ensure
+          @mutex.unlock rescue nil
+        end
+      end
+
+      # does not lock the mutex, returns true if there are pending jobs
+      def anything_to_do?
+        (pending.length + state_check.length) > 0
+      end
+
+      # returns the pending continuations, resetting the list
+      # this method is synchronized
+      def next_batch()
+        @mutex.lock
+        begin
+          state_check.slice!(0, state_check.length) + pending.slice!(0,pending.length)
+        ensure
+          @mutex.unlock rescue nil
+        end
+      end
+    end # Registry
+
+    # *sigh* what is the index in the *args array of the 'callback' param
+    CALLBACK_ARG_IDX = {
+      :get => 2,
+      :set => 3,
+      :exists => 2,
+      :create => 3,
+      :delete => 3,
+      :get_acl => 2,
+      :set_acl => 3,
+      :get_children => 2,
+      :state => 0,
+      :add_auth => 2
+    }
+
+    # maps the method name to the async return hash keys it should use to
+    # deliver the results
+    METH_TO_ASYNC_RESULT_KEYS = {
+      :get          => [:rc, :data, :stat],
+      :set          => [:rc, :stat],
+      :exists       => [:rc, :stat],
+      :create       => [:rc, :string],
+      :delete       => [:rc],
+      :get_acl      => [:rc, :acl, :stat],
+      :set_acl      => [:rc],
+      :get_children => [:rc, :strings, :stat],
+      :add_auth     => [:rc]
+    }
+
+    attr_accessor :meth, :block, :rval
+
+    attr_reader :args
+
+    def initialize(meth, *args)
+      @meth   = meth
+      @args   = args.freeze
+      @mutex  = Monitor.new
+      @cond   = @mutex.new_cond
+      @rval   = nil
+
+      # make this error reporting more robust if necessary, right now, just set to state
+      @error  = nil
+    end
+
+    # the caller calls this method and receives the response from the async loop
+    # this method has a hard-coded 30 second timeout as a safety feature. No
+    # call should take more than 20s (as the session timeout is set to 20s)
+    # so if any call takes longer than that, something has gone horribly wrong.
+    #
+    # @raise [ContinuationTimeoutError] if a response is not received within 30s
+    #
+    def value
+      time_to_stop = Time.now + OPERATION_TIMEOUT
+      now = nil
+
+      @mutex.synchronize do
+        while true
+          now = Time.now
+          break if @rval or @error or (now > time_to_stop)
+
+          deadline = time_to_stop.to_f - now.to_f
+          @cond.wait(deadline)
+        end
+
+        if (now > time_to_stop) and !@rval and !@error
+          raise Exceptions::ContinuationTimeoutError, "response for meth: #{meth.inspect}, args: #{@args.inspect}, not received within #{OPERATION_TIMEOUT} seconds"
+        end
+
+        case @error
+        when nil
+          # ok, nothing to see here, carry on
+        when :shutdown
+          raise Exceptions::NotConnected, "the connection is shutting down"
+        when ZOO_EXPIRED_SESSION_STATE
+          raise Exceptions::SessionExpired, "connection has expired"
+        else
+          raise Exceptions::NotConnected, "connection state is #{STATE_NAMES[@error]}"
+        end
+
+        case @rval.length
+        when 1
+          return @rval.first
+        else
+          return @rval
+        end
+      end
+    end
+
+    # receive the response from the server, set @rval, notify caller
+    def call(hash)
+      logger.debug { "continuation req_id #{req_id}, got hash: #{hash.inspect}" }
+      @rval = hash.values_at(*METH_TO_ASYNC_RESULT_KEYS.fetch(meth))
+      logger.debug { "delivering result #{@rval.inspect}" }
+      deliver!
+    end
+
+    def user_callback?
+      !!@args.at(callback_arg_idx)
+    end
+
+    # this method is called by the event thread to submit the request
+    # passed the CZookeeper instance, makes the async call and deals with the results
+    #
+    # BTW: in case you were wondering this is a completely stupid
+    # implementation, but it's more important to get *something* working and
+    # passing specs, then refactor to make everything sane
+    # 
+    #
+    def submit(czk)
+      state = czk.zkrb_state    # check the state of the connection
+
+      if @meth == :state        # if the method is a state call
+        @rval = [state]         # we're done, no error
+        return deliver!
+
+      elsif state != ZOO_CONNECTED_STATE  # otherwise, we must be connected
+        @error = state                    # so set the error
+        return deliver!                   # and we're out
+      end
+
+      rc, *_ = czk.__send__(:"zkrb_#{@meth}", *async_args)
+      
+      if user_callback? or (rc != ZOK)  # async call, or we failed to submit it
+        @rval = [rc]                    # create the repsonse
+        deliver!                        # wake the caller and we're out
+      end
+    end
+
+    def req_id
+      @args.first
+    end
+
+    def state_call?
+      @meth == :state
+    end
+
+    # interrupt the sleeping thread with a NotConnected error
+    def shutdown!
+      @mutex.synchronize do
+        return if @rval or @error
+        @error = :shutdown
+        @cond.broadcast
+      end
+    end
+
+    protected
+
+      # an args array with the only difference being that if there's a user
+      # callback provided, we don't handle delivering the end result
+      def async_args
+        return [] if @meth == :state    # special-case :P
+        ary = @args.dup
+
+        logger.debug { "async_args, meth: #{meth} ary: #{ary.inspect}, #{callback_arg_idx}" }
+
+        ary[callback_arg_idx] ||= self
+
+        ary
+      end
+
+      def callback_arg_idx
+        CALLBACK_ARG_IDX.fetch(meth) { raise ArgumentError, "unknown method #{meth.inspect}" } 
+      end
+
+      def deliver!
+        @mutex.synchronize do
+          @cond.signal
+        end
+      end
+  end # Base
+end
+

data/lib/zookeeper/core_ext.rb

@@ -0,0 +1,58 @@
+# @private
+module ::Kernel
+  unless method_defined?(:silence_warnings)
+    def silence_warnings
+      with_warnings(nil) { yield }
+    end
+  end
+
+  unless method_defined?(:with_warnings)
+    def with_warnings(flag)
+      old_verbose, $VERBOSE = $VERBOSE, flag
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end
+
+# @private
+class ::Exception
+  unless method_defined?(:to_std_format)
+    def to_std_format
+      ary = ["#{self.class}: #{message}"]
+      ary.concat(backtrace || [])
+      ary.join("\n\t")
+    end
+  end
+end
+
+# this is borrowed from the excellent Logging gem: https://github.com/TwP/logging
+# @private
+class ::Module
+  # @private
+  # Returns a predictable logger name for the current module or class. If
+  # used within an anonymous class, the first non-anonymous class name will
+  # be used as the logger name. If used within a meta-class, the name of the
+  # actual class will be used as the logger name. If used within an
+  # anonymous module, the string 'anonymous' will be returned.
+  def _zk_logger_name
+    return name unless name.nil? or name.empty?
+
+    # check if this is a metaclass (or eigenclass)
+    if ancestors.include? Class
+      inspect =~ %r/#<Class:([^#>]+)>/
+      return $1
+    end
+
+    # see if we have a superclass
+    if respond_to? :superclass
+      return superclass.logger_name
+    end
+
+    # we are an anonymous module
+    return 'anonymous'
+  end
+end
+
+

data/lib/zookeeper/em_client.rb

@@ -0,0 +1,55 @@
+require 'zookeeper'
+require 'eventmachine'
+
+module ZookeeperEM 
+  class Client < Zookeeper::Client
+    # @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

@@ -0,0 +1,135 @@
+module Zookeeper
+module Exceptions
+  include Constants
+
+  class ZookeeperException < StandardError
+
+    unless defined?(CONST_MISSING_WARNING)
+
+      CONST_MISSING_WARNING = <<-EOS
+
+------------------------------------------------------------------------------------------
+WARNING! THE ZOOKEEPER NAMESPACE HAS CHANGED AS OF 1.0!
+
+Please update your code to use the new hierarchy!
+
+The constant that got you this was ZookeeperExceptions::ZookeeperException::%s
+
+stacktrace: 
+%s
+
+------------------------------------------------------------------------------------------
+
+      EOS
+    end
+
+    # NOTE(slyphon): Since 0.4 all of the ZookeeperException subclasses were
+    #   defined inside of ZookeeperException, which always seemed well, icky.
+    #   if someone references one of these we'll print out a warning and 
+    #   then give them the constant
+    # 
+    def self.const_missing(const)
+      if Zookeeper::Exceptions.const_defined?(const)
+
+        stacktrace = caller[0..-2].reject {|n| n =~ %r%/rspec/% }.map { |n| "\t#{n}" }.join("\n")
+
+        Zookeeper.deprecation_warning(CONST_MISSING_WARNING % [const.to_s, stacktrace])
+
+
+        Zookeeper::Exceptions.const_get(const).tap do |const_val|
+          self.const_set(const, const_val)
+        end
+      else
+        super
+      end
+    end
+  end
+
+
+  class EverythingOk            < ZookeeperException; end
+  class SystemError             < ZookeeperException; end
+  class RunTimeInconsistency    < ZookeeperException; end
+  class DataInconsistency       < ZookeeperException; end
+  class ConnectionLoss          < ZookeeperException; end
+  class MarshallingError        < ZookeeperException; end
+  class Unimplemented           < ZookeeperException; end
+  class OperationTimeOut        < ZookeeperException; end
+  class BadArguments            < ZookeeperException; end
+  class InvalidState            < ZookeeperException; end
+  class ApiError                < ZookeeperException; end
+  class NoNode                  < ZookeeperException; end
+  class NoAuth                  < ZookeeperException; end
+  class BadVersion              < ZookeeperException; end
+  class NoChildrenForEphemerals < ZookeeperException; end
+  class NodeExists              < ZookeeperException; end
+  class NotEmpty                < ZookeeperException; end
+  class SessionExpired          < ZookeeperException; end
+  class InvalidCallback         < ZookeeperException; end
+  class InvalidACL              < ZookeeperException; end
+  class AuthFailed              < ZookeeperException; end
+  class Closing                 < ZookeeperException; end
+  class Nothing                 < ZookeeperException; end
+  class SessionMoved            < ZookeeperException; end
+  
+  # these are Ruby client exceptions
+  class ConnectionClosed        < ZookeeperException; end
+  class NotConnected            < ZookeeperException; end 
+  class ShuttingDownException   < ZookeeperException; end
+  class DataTooLargeException   < ZookeeperException; end
+
+  # raised when an operation is performed on an instance without a valid
+  # zookeeper handle. (C version)
+  class HandleClosedException < ZookeeperException; end
+
+  # maybe use this for continuation
+  class InterruptedException  < ZookeeperException ; end
+
+  # raised when a continuation operation takes more time than is reasonable and
+  # the thread should be awoken. (i.e. prevents a call that never returns)
+  class ContinuationTimeoutError < ZookeeperException; end
+
+  # raised when the user tries to use a connection after a fork()
+  # without calling reopen() in the C client
+  #
+  # (h/t: @pletern http://git.io/zIsq1Q)
+  class InheritedConnectionError < ZookeeperException; end
+
+  # yes, make an alias, this is the way zookeeper refers to it
+  ExpiredSession = SessionExpired unless defined?(ExpiredSession)
+    
+  def self.by_code(code)
+    case code
+      when ZOK then EverythingOk
+      when ZSYSTEMERROR then SystemError
+      when ZRUNTIMEINCONSISTENCY then RunTimeInconsistency
+      when ZDATAINCONSISTENCY then DataInconsistency
+      when ZCONNECTIONLOSS then ConnectionLoss
+      when ZMARSHALLINGERROR then MarshallingError
+      when ZUNIMPLEMENTED then Unimplemented
+      when ZOPERATIONTIMEOUT then OperationTimeOut
+      when ZBADARGUMENTS then BadArguments
+      when ZINVALIDSTATE then InvalidState
+      when ZAPIERROR then ApiError
+      when ZNONODE then NoNode
+      when ZNOAUTH then NoAuth
+      when ZBADVERSION then BadVersion
+      when ZNOCHILDRENFOREPHEMERALS then NoChildrenForEphemerals 
+      when ZNODEEXISTS then NodeExists              
+      when ZNOTEMPTY then NotEmpty                
+      when ZSESSIONEXPIRED then SessionExpired          
+      when ZINVALIDCALLBACK then InvalidCallback         
+      when ZINVALIDACL then InvalidACL
+      when ZAUTHFAILED then AuthFailed
+      when ZCLOSING then Closing
+      when ZNOTHING then Nothing
+      when ZSESSIONMOVED then SessionMoved
+    else ZookeeperException.new("no exception defined for code #{code}")
+    end
+  end
+  
+  def self.raise_on_error(code)
+    exc = self.by_code(code)
+    raise exc unless exc == EverythingOk
+  end
+end # Exceptions
+end # Zookeeper