zookeeper-ng 1.5.2.1-java

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

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

data/lib/zookeeper/forked.rb

@@ -0,0 +1,19 @@
+module Zookeeper
+  module Forked
+    # the includer provides an 'original_pid' method, which is set
+    # when the original 'owning' process creates the object. 
+    #
+    # @return [true] if the current PID differs from the original_pid value
+    # @return [false] if the current PID matches the original_pid value
+    #
+    def forked?
+      Process.pid != original_pid
+    end
+
+    # sets the `original_pid` to the current value
+    def update_pid!
+      self.original_pid = Process.pid
+    end
+  end # Forked
+end # Zookeeper
+

data/lib/zookeeper/latch.rb

@@ -0,0 +1,34 @@
+module Zookeeper
+  # a cross-thread gate of sorts.
+  class Latch
+    def initialize(count = 1)
+      @count = count
+      @mutex = Monitor.new
+      @cond = @mutex.new_cond
+    end
+
+    def release
+      @mutex.synchronize {
+        @count -= 1 if @count > 0
+        @cond.broadcast if @count.zero?
+      }
+    end
+
+    def await(timeout=nil)
+      @mutex.synchronize do
+        if timeout
+          time_to_stop = Time.now + timeout
+
+          while @count > 0
+            @cond.wait(timeout)
+            
+            break if (Time.now > time_to_stop)
+          end
+        else
+          @cond.wait_while { @count > 0 }
+        end
+      end
+    end
+  end
+end
+

data/lib/zookeeper/logger/forwarding_logger.rb

@@ -0,0 +1,84 @@
+module Zookeeper
+  module Logger
+    # h/t _eric and Papertrail
+    # @private
+    class ForwardingLogger
+      attr_accessor :level, :formatter
+
+      @@mutex = Monitor.new unless defined?(@@mutex)
+      @@loggers = {} unless defined?(@@loggers)
+
+      def self.for(logger, name)
+        @@mutex.synchronize do
+          @@loggers.fetch(name) do |k|
+            @@loggers[k] = new(logger, :formatter => lambda { |m| "%25.25s: %s" % [k, m] })
+          end
+        end
+      end
+
+      def initialize(logger, options = {})
+        @level     = ::Logger::DEBUG
+        @logger    = logger
+        @formatter = options[:formatter]
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        severity ||= ::Logger::UNKNOWN
+        if !@logger || severity < @level
+          return true
+        end
+        
+        message = (message || (block && block.call) || progname).to_s
+        
+        if @formatter && @formatter.respond_to?(:call)
+          message = @formatter.call(message)
+        end
+
+        # If a newline is necessary then create a new message ending with a newline.
+        # Ensures that the original message is not mutated.
+        # message = "#{message}\n" unless message[-1] == ?\n
+        
+        @logger.add(severity, message)
+      end
+
+      def <<(msg); @logger << msg; end
+      def write(msg); @logger.write(msg); end
+      
+      def debug(progname = nil, &block)
+        add(::Logger::DEBUG, nil, progname, &block)
+      end
+      
+      def info(progname = nil, &block)
+        add(::Logger::INFO, nil, progname, &block)
+      end
+      
+      def warn(progname = nil, &block)
+        add(::Logger::WARN, nil, progname, &block)
+      end
+      
+      def error(progname = nil, &block)
+        add(::Logger::ERROR, nil, progname, &block)
+      end
+
+      def fatal(progname = nil, &block)
+        add(::Logger::FATAL, nil, progname, &block)
+      end
+
+      def unknown(progname = nil, &block)
+        add(::Logger::UNKNOWN, nil, progname, &block)
+      end
+      
+      def debug?; @level <= DEBUG; end
+
+      def info?; @level <= INFO; end
+
+      def warn?; @level <= WARN; end
+
+      def error?; @level <= ERROR; end
+
+      def fatal?; @level <= FATAL; end
+    end # ForwardingLogger
+  end # Logger
+end # Zookeeper
+
+