zookeeper 0.9.4 → 1.0.0.beta.1

data/lib/zookeeper/client.rb

@@ -0,0 +1,30 @@
+# figure out what platform we're on
+# this way there's no ambiguity about which file to include
+# or which class we're subclassing.
+
+if defined?(::JRUBY_VERSION)
+  require_relative('../../java/java_base')
+else
+  require_relative('../../ext/zookeeper_base')
+end
+
+
+module Zookeeper
+  if defined?(::JRUBY_VERSION)
+    class Client < Zookeeper::JavaBase
+    end
+  else
+    class Client < Zookeeper::ZookeeperBase
+    end
+  end
+
+  def self.new(*a, &b)
+    Zookeeper::Client.new(*a, &b)
+  end
+end
+
+
+Zookeeper::Client.class_eval do
+  include Zookeeper::ClientMethods
+end
+

data/lib/zookeeper/client_methods.rb

@@ -0,0 +1,241 @@
+module Zookeeper
+module ClientMethods
+  include Constants
+  include ACLs
+
+  def reopen(timeout=10, watcher=nil)
+    warn "WARN: ZookeeperBase#reopen watcher argument is now ignored" if watcher
+    super
+  end
+
+  def initialize(host, timeout=10, watcher=nil)
+    super
+  end
+
+  def get(options = {})
+    assert_open
+    assert_supported_keys(options, [:path, :watcher, :watcher_context, :callback, :callback_context])
+    assert_required_keys(options, [: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_supported_keys(options, [:path, :data, :version, :callback, :callback_context])
+    assert_required_keys(options, [: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_supported_keys(options, [:path, :callback, :callback_context, :watcher, :watcher_context])
+    assert_required_keys(options, [: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_supported_keys(options, [:path, :callback, :callback_context, :watcher, :watcher_context])
+    assert_required_keys(options, [: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_supported_keys(options, [:path, :data, :acl, :ephemeral, :sequence, :callback, :callback_context])
+    assert_required_keys(options, [: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_supported_keys(options, [:path, :version, :callback, :callback_context])
+    assert_required_keys(options, [: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 ZookeeperCallbacks::VoidCallback and not rely on the string value.
+  #
+  def sync(options = {})
+    assert_open
+    assert_supported_keys(options, [:path, :callback, :callback_context])
+    assert_required_keys(options, [: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_supported_keys(options, [:path, :acl, :version, :callback, :callback_context])
+    assert_required_keys(options, [: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_supported_keys(options, [:path, :callback, :callback_context])
+    assert_required_keys(options, [: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 underyling 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
+
+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 logger
+    Zookeeper.logger
+  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
+  # TODO: Sanitize user mistakes by unregistering watchers from ops that
+  # don't return ZOK (except wexists)?  Make users clean up after themselves for now.
+  #
+  # XXX: is this dead code?
+  def unregister_watcher(req_id)
+    @mutex.synchronize {
+      @watcher_reqs.delete(req_id)
+    }
+  end
+  
+  # must be supplied by parent class impl.
+  def assert_open
+    super
+  end
+end # ClientMethods
+end # Zookeeper

data/lib/zookeeper/common.rb

@@ -1,6 +1,8 @@
 require 'zookeeper/exceptions'
+require 'zookeeper/common/queue_with_pipe'
 
-module ZookeeperCommon
+module Zookeeper
+module Common
   # sigh, i guess define this here?
   ZKRB_GLOBAL_CB_REQ   = -1
 
@@ -27,7 +29,7 @@ protected
     }
     req_id
   end
- 
+
   def setup_watcher(req_id, call_opts)
     @watcher_reqs[req_id] = { :watcher => call_opts[:watcher],
                               :context => call_opts[:watcher_context] }
@@ -41,7 +43,7 @@ protected
   #
   def setup_completion(req_id, meth_name, call_opts)
     @completion_reqs[req_id] = { :callback => call_opts[:callback],
-                                 :context => call_opts[:callback_context] }
+                                :context => call_opts[:callback_context] }
   end
   
   def get_watcher(req_id)
@@ -118,15 +120,15 @@ protected
     
     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]
+    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 = 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
+    if hash[:type] == Zookeeper::Constants::ZOO_SESSION_EVENT
       is_completion ? setup_completion(hash[:req_id], callback_context) : setup_watcher(hash[:req_id], callback_context)
     end
     if callback_context
@@ -148,14 +150,14 @@ protected
 
   def assert_supported_keys(args, supported)
     unless (args.keys - supported).empty?
-      raise ZookeeperExceptions::ZookeeperException::BadArguments,  # this heirarchy is kind of retarded
+      raise Zookeeper::Exceptions::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,
+      raise Zookeeper::Exceptions::BadArguments,
             "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
     end
   end
@@ -164,11 +166,10 @@ 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[: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
-
-require 'zookeeper/common/queue_with_pipe'
+end

data/lib/zookeeper/common/queue_with_pipe.rb

@@ -1,4 +1,5 @@
-module ZookeeperCommon
+module Zookeeper
+module Common
   # Ceci n'est pas une pipe
   class QueueWithPipe
     extend Forwardable
@@ -13,14 +14,8 @@ module ZookeeperCommon
     KILL_TOKEN = Object.new unless defined?(KILL_TOKEN)
 
     def initialize
-#       r, w = IO.pipe
-#       @pipe = { :read => r, :write => w }
       @queue = Queue.new
 
-      # with the EventMachine client, we want to let EM handle clearing the
-      # event pipe, so we set this to false
-#       @clear_reads_on_pop = true
-
       @mutex = Mutex.new
       @closed = false
       @graceful = false
@@ -76,3 +71,4 @@ module ZookeeperCommon
       end
   end
 end
+end

data/lib/zookeeper/compatibility.rb

@@ -0,0 +1,135 @@
+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
+
+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
+
+    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
+