zookeeper 0.9.4-java → 1.0.0.beta.1-java

data/lib/zookeeper.rb

@@ -5,23 +5,27 @@ require 'monitor'
 require 'forwardable'
 require 'logger'
 
-require 'zookeeper/common'
-require 'zookeeper/constants'
-require 'zookeeper/callbacks'
-require 'zookeeper/exceptions'
-require 'zookeeper/stat'
-require 'zookeeper/acls'
+require 'backports'
 
-
-if defined?(::JRUBY_VERSION)
-  $LOAD_PATH.unshift(File.expand_path('../java', File.dirname(__FILE__))).uniq!
-else
-  $LOAD_PATH.unshift(File.expand_path('../ext', File.dirname(__FILE__))).uniq!
+module Zookeeper
+  # establishes the namespace
 end
 
-require 'zookeeper_base'
+require_relative 'zookeeper/acls'
+require_relative 'zookeeper/constants'
+require_relative 'zookeeper/exceptions'
+require_relative 'zookeeper/common'
+require_relative 'zookeeper/callbacks'
+require_relative 'zookeeper/stat'
+require_relative 'zookeeper/client_methods'
+
+# ok, now we construct the client
+
+require_relative 'zookeeper/client'
+
+module Zookeeper
+  include Constants
 
-class Zookeeper < ZookeeperBase
   unless defined?(@@logger)
     @@logger = Logger.new($stderr).tap { |l| l.level = Logger::ERROR } 
   end
@@ -34,167 +38,20 @@ class Zookeeper < ZookeeperBase
     @@logger = logger
   end
 
-  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
+  # @private
+  def self.deprecation_warnings?
+    @deprecation_warnings = true if @deprecation_warnings.nil?
   end
 
-  def connecting?
-    super
+  # set this to false to mute Zookeeper related deprecation warnings...
+  # __AT YOUR PERIL__
+  def self.deprecation_warnings=(v)
+    @deprecation_warnings = v
   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
+  # @private
+  def self.deprecation_warning(warning)
+    Kernel.warn(warning) if deprecation_warnings?
   end
 
   # for expert use only. set the underlying debug level for the C layer, has no
@@ -202,14 +59,14 @@ class Zookeeper < ZookeeperBase
   #
   # @private
   def self.set_debug_level(val)
-    if defined?(::CZookeeper)
+    if defined?(CZookeeper)
       CZookeeper.set_debug_level(val.to_i)
     end
   end
 
   # @private
   def self.get_debug_level
-    if defined?(::CZookeeper)
+    if defined?(CZookeeper)
       CZookeeper.get_debug_level
     end
   end
@@ -221,77 +78,8 @@ class Zookeeper < ZookeeperBase
     # @private
     alias :debug_level :get_debug_level
   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 ZookeeperException::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
 
+# just for first test, get rid of this soon
+require_relative 'zookeeper/compatibility'
+

data/scripts/upgrade-1.0-sed-alike.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+if ARGV.empty?
+  $stderr.puts <<-EOS
+Usage: #{File.basename(__FILE__)} file1 file2 file3
+
+Fix references to Zookeeper classes and modules.
+
+This script acts like sed and edits files in place (not saving backups,
+as you *are* using source control and aren't a complete tool). 
+
+if you have any doubts, *read the script*:
+----------------------------------------------------------------------
+
+#{File.read(__FILE__)}
+
+  EOS
+
+  exit 1
+end
+
+
+require 'tempfile'
+require 'fileutils'
+
+ARGV.each do |path|
+  Tempfile.open(File.basename(path)) do |tmp|
+    File.open(path) do |input|
+      while line = input.gets
+        tmp.puts line.gsub(/\bZookeeperStat::Stat\b/, 'Zookeeper::Stat').
+          gsub(/\bZookeeper::(\w+)Callback\b/, 'Zookeeper::Callbacks::\1Callback').
+          gsub(/\bZookeeperACLs::(ZOO_\w+)\b/, 'Zookeeper::Constants::\1').
+          gsub(/\bZookeeperExceptions::ZookeeperException::(\w+)\b/, 'Zookeeper::Exceptions::\1').
+          gsub(/\bZookeeper(Constants|Exceptions|Common|ACLs|Callbacks)\b/, 'Zookeeper::\1').
+          gsub(/\bZookeeperException::(\w+)\b/, 'Exceptions::\1')
+
+      end
+    end
+
+    tmp.fsync
+    tmp.close
+
+    FileUtils.mv(tmp.path, path)
+  end
+end
+

data/spec/c_zookeeper_spec.rb

@@ -1,8 +1,9 @@
 # tests the CZookeeper, obviously only available when running under MRI
-require 'spec_helper'
 
-if Module.const_defined?(:CZookeeper)
-  describe CZookeeper do
+unless defined?(::JRUBY_VERSION)
+  require 'spec_helper'
+
+  describe Zookeeper::CZookeeper do
     def pop_all_events
       [].tap do |rv|
         begin
@@ -13,13 +14,13 @@ if Module.const_defined?(:CZookeeper)
     end
 
     def wait_until_connected(timeout=2)
-      wait_until(timeout) { @czk.state == ZookeeperConstants::ZOO_CONNECTED_STATE }
+      wait_until(timeout) { @czk.state == Zookeeper::Constants::ZOO_CONNECTED_STATE }
     end
 
     describe do
       before do
-        @event_queue = ZookeeperCommon::QueueWithPipe.new
-        @czk = CZookeeper.new('localhost:2181', @event_queue)
+        @event_queue = Zookeeper::Common::QueueWithPipe.new
+        @czk = Zookeeper::CZookeeper.new(Zookeeper.default_cnx_str, @event_queue)
       end
 
       after do
@@ -39,9 +40,9 @@ if Module.const_defined?(:CZookeeper)
         it %[should have a connection event after being connected] do
           event = wait_until(2) { @event_queue.pop }
           event.should be
-          event[:req_id].should == ZookeeperCommon::ZKRB_GLOBAL_CB_REQ
-          event[:type].should   == ZookeeperConstants::ZOO_SESSION_EVENT
-          event[:state].should  == ZookeeperConstants::ZOO_CONNECTED_STATE
+          event[:req_id].should == Zookeeper::Common::ZKRB_GLOBAL_CB_REQ
+          event[:type].should   == Zookeeper::Constants::ZOO_SESSION_EVENT
+          event[:state].should  == Zookeeper::Constants::ZOO_CONNECTED_STATE
         end
       end
     end

data/spec/chrooted_connection_spec.rb

@@ -6,7 +6,7 @@ describe 'Zookeeper chrooted' do
   let(:data) { "underpants" } 
   let(:chroot_path) { '/slyphon-zookeeper-chroot' }
 
-  let(:connection_string) { "localhost:2181#{chroot_path}" }
+  let(:connection_string) { "#{Zookeeper.default_cnx_str}#{chroot_path}" }
 
   before do
     @zk = Zookeeper.new(connection_string)
@@ -52,7 +52,7 @@ describe 'Zookeeper chrooted' do
         it %[should return ZNONODE] do
           rv = zk.create(:path => '/', :data => '')
           rv[:rc].should_not be_zero
-          rv[:rc].should == ZookeeperExceptions::ZNONODE
+          rv[:rc].should == Zookeeper::Exceptions::ZNONODE
         end
       end
     end

data/spec/default_watcher_spec.rb

@@ -5,18 +5,18 @@ describe Zookeeper do
     before do
       @events = []
       @watch_block = lambda do |hash| 
-        $stderr.puts "watch_block: #{hash.inspect}"
+        logger.debug "watch_block: #{hash.inspect}"
         @events << hash
       end
 
-      @zk = Zookeeper.new('localhost:2181', 10, @watch_block)
+      @zk = Zookeeper.new(Zookeeper.default_cnx_str, 10, @watch_block)
 
       wait_until(2) { @zk.connected? }
       @zk.should be_connected
-      $stderr.puts "connected!"
+      logger.debug "connected!"
 
       wait_until(2) { !@events.empty? }
-      $stderr.puts "got events!"
+      logger.debug "got events!"
     end
 
     after do

data/spec/em_spec.rb

@@ -11,7 +11,7 @@ describe 'ZookeeperEM' do
     default_timeout 3.0
 
     def setup_zk
-      @zk = ZookeeperEM::Client.new('localhost:2181')
+      @zk = ZookeeperEM::Client.new(Zookeeper.default_cnx_str)
       em do
         @zk.on_attached do
           yield