zookeeper-ng 1.5.2.1-java

data/lib/zookeeper/client_methods.rb

@@ -0,0 +1,282 @@
+module Zookeeper
+module ClientMethods
+  extend Forwardable
+  include Constants
+  include ACLs
+  include Logger
+
+  # @req_registry is set up in the platform-specific base classes
+  def_delegators :@req_registry, :setup_call
+  private :setup_call
+
+  def reopen(timeout=10, watcher=nil, opts = {})
+    warn "WARN: ZookeeperBase#reopen watcher argument is now ignored" if watcher
+    super
+  end
+
+  def initialize(host, timeout=10, watcher=nil, opts = {})
+    super
+  end
+
+  def add_auth(options = {})
+    assert_open
+    assert_keys(options, 
+                :supported => [:scheme, :cert],
+                :required  => [:scheme, :cert])
+
+    req_id = setup_call(:add_auth, options)
+    rc = super(req_id, options[:scheme], options[:cert])
+
+    { :req_id => req_id, :rc => rc }
+  end
+
+  def get(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :watcher, :watcher_context, :callback, :callback_context],
+                :required   => [:path])
+
+    req_id = setup_call(:get, options)
+    rc, value, stat = super(req_id, options[:path], options[:callback], options[:watcher])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:data => value, :stat => Stat.new(stat))
+  end
+
+  def set(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :data, :version, :callback, :callback_context],
+                :required   => [:path])
+
+    assert_valid_data_size!(options[:data])
+    options[:version] ||= -1
+
+    req_id = setup_call(:set, options)
+    rc, stat = super(req_id, options[:path], options[:data], options[:callback], options[:version])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:stat => Stat.new(stat))
+  end
+
+  def get_children(options = {})
+    assert_open
+    assert_keys(options,
+                :supported => [:path, :callback, :callback_context, :watcher, :watcher_context],
+                :required  => [:path])
+
+    req_id = setup_call(:get_children, options)
+    rc, children, stat = super(req_id, options[:path], options[:callback], options[:watcher])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:children => children, :stat => Stat.new(stat))
+  end
+
+  def stat(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :callback, :callback_context, :watcher, :watcher_context],
+                :required   => [:path])
+
+    req_id = setup_call(:stat, options)
+    rc, stat = exists(req_id, options[:path], options[:callback], options[:watcher])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:stat => Stat.new(stat))
+  end
+
+  def create(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :data, :acl, :ephemeral, :sequence, :callback, :callback_context],
+                :required   => [:path])
+
+    assert_valid_data_size!(options[:data])
+
+    flags = 0
+    flags |= ZOO_EPHEMERAL if options[:ephemeral]
+    flags |= ZOO_SEQUENCE if options[:sequence]
+
+    options[:acl] ||= ZOO_OPEN_ACL_UNSAFE
+
+    req_id = setup_call(:create, options)
+    rc, newpath = super(req_id, options[:path], options[:data], options[:callback], options[:acl], flags)
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:path => newpath)
+  end
+
+  def delete(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :version, :callback, :callback_context],
+                :required   => [:path])
+
+    options[:version] ||= -1
+
+    req_id = setup_call(:delete, options)
+    rc = super(req_id, options[:path], options[:version], options[:callback])
+
+    { :req_id => req_id, :rc => rc }
+  end
+
+  # this method is *only* asynchronous
+  #
+  # @note There is a discrepancy between the zkc and java versions. zkc takes
+  #   a string_callback_t, java takes a VoidCallback. You should most likely use
+  #   the Zookeeper::Callbacks::VoidCallback and not rely on the string value.
+  #
+  def sync(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :callback, :callback_context],
+                :required   => [:path, :callback])
+
+    req_id = setup_call(:sync, options)
+
+    rc = super(req_id, options[:path]) # we don't pass options[:callback] here as this method is *always* async
+
+    { :req_id => req_id, :rc => rc }
+  end
+
+  def set_acl(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :acl, :version, :callback, :callback_context],
+                :required   => [:path, :acl])
+    options[:version] ||= -1
+
+    req_id = setup_call(:set_acl, options)
+    rc = super(req_id, options[:path], options[:acl], options[:callback], options[:version])
+
+    { :req_id => req_id, :rc => rc }
+  end
+
+  def get_acl(options = {})
+    assert_open
+    assert_keys(options,
+                :supported  => [:path, :callback, :callback_context],
+                :required   => [:path])
+
+    req_id = setup_call(:get_acl, options)
+    rc, acls, stat = super(req_id, options[:path], options[:callback])
+
+    rv = { :req_id => req_id, :rc => rc }
+    options[:callback] ? rv : rv.merge(:acl => acls, :stat => Stat.new(stat))
+  end
+
+  # close this client and any underlying connections
+  def close
+    super
+  end
+
+  def state
+    super
+  end
+
+  def connected?
+    super
+  end
+
+  def connecting?
+    super
+  end
+
+  def associating?
+    super
+  end
+  
+  # There are some operations that are dangerous in the context of the event
+  # dispatch thread (because they would block further event delivery). This
+  # method allows clients to know if they're currently executing in the context of an
+  # event.
+  #
+  # @returns [true,false] true if the current thread is the event dispatch thread
+  def event_dispatch_thread?
+    super
+  end
+
+  # DEPRECATED: use the class-level method instead
+  def set_debug_level(val)
+    super
+  end
+
+  # has the underlying connection been closed?
+  def closed?
+    super
+  end
+
+  # is the event delivery system running?
+  def running?
+    super
+  end
+
+  # return the session id of the current connection as an Fixnum
+  def session_id
+    super
+  end
+
+  # Return the passwd portion of this connection's credentials as a String
+  def session_passwd
+    super
+  end
+
+  # stop all underlying threads in preparation for a fork()
+  def pause_before_fork_in_parent
+    super
+  end
+
+  # re-start all underlying threads after performing a fork()
+  def resume_after_fork_in_parent
+    super
+  end
+
+protected
+  # used during shutdown, awaken the event delivery thread if it's blocked
+  # waiting for the next event
+  def wake_event_loop!
+    super
+  end
+  
+  # starts the event delivery subsystem going. after calling this method, running? will be true
+  def setup_dispatch_thread!
+    super
+  end
+
+  # TODO: describe what this does
+  def get_default_global_watcher
+    super
+  end
+
+  def assert_valid_data_size!(data)
+    return if data.nil?
+
+    data = data.to_s
+    if data.length >= 1048576 # one megabyte 
+      raise Zookeeper::Exceptions::DataTooLargeException, "data must be smaller than 1 MiB, your data starts with: #{data[0..32].inspect}"
+    end
+    nil
+  end
+
+private
+  def assert_keys(args, opts={})
+    supported = opts[:supported] || []
+    required  = opts[:required]  || []
+
+    unless (args.keys - supported).empty?
+      raise Zookeeper::Exceptions::BadArguments,
+            "Supported arguments are: #{supported.inspect}, but arguments #{args.keys.inspect} were supplied instead"
+    end
+
+    unless (required - args.keys).empty?
+      raise Zookeeper::Exceptions::BadArguments,
+            "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
+    end
+  end
+  
+  # must be supplied by parent class impl.
+  def assert_open
+    super
+  end
+end # ClientMethods
+end # Zookeeper

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/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/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
+