slyphon-zookeeper 0.3.0-java → 0.8.0-java

data/lib/zookeeper/em_client.rb

@@ -13,6 +13,7 @@ module ZookeeperEM
       @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
@@ -29,152 +30,26 @@ module ZookeeperEM
       @on_attached
     end
 
-    # returns a Deferrable that will be called when the Zookeeper C event loop
-    # has been shut down 
-    #
-    # if a block is given, it will be registered as a callback when the
-    # connection has been closed
-    #
-    def close(&block)
-      on_close(&block)
-
-      logger.debug { "#{self.class.name}: close called, closed? #{closed?} running? #{running?}" }
-
-      if @_running
-        @start_stop_mutex.synchronize do
-          @_running = false
-        end
-
-        if @em_connection
-          EM.next_tick do
-            @em_connection.detach do
-              logger.debug { "#{self.class.name}: connection unbound, continuing with shutdown" }
-              finish_closing
-            end
-          end
-        else
-          logger.debug { "#{self.class.name}: em_connection was never set up, finish closing" }
-          finish_closing
-        end
-      else
-        logger.debug { "#{self.class.name}: we are not running, so returning on_close deferred" }
-      end
-
-      on_close
-    end
-
-    # make this public as the ZKConnection object needs to call it
-    public :dispatch_next_callback
-
-  protected
-    # instead of setting up a dispatch thread here, we instead attach
-    # the #selectable_io to the event loop 
-    def setup_dispatch_thread!
+    def dispatch_next_callback(hash)
       EM.schedule do
         if running? and not closed?
-          begin
-            logger.debug { "adding EM.watch(#{selectable_io.inspect})" }
-            @em_connection = EM.watch(selectable_io, ZKConnection, self) { |cnx| cnx.notify_readable = true }
-          rescue Exception => e
-            $stderr.puts "caught exception from EM.watch(): #{e.inspect}"
-          end
+          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 finish_closing
-      unless @_closed
-        @start_stop_mutex.synchronize do
-          logger.debug { "closing handle" }
-          close_handle
-        end
-
-        unless selectable_io.closed?
-          logger.debug { "calling close on selectable_io: #{selectable_io.inspect}" }
-          selectable_io.close
-        end
-      end
-
+    def close(&block)
+      on_close(&block)
+      super()
       on_close.succeed
     end
-  end
-
-  # this class is handed to EventMachine.watch to handle event dispatching
-  # when the queue has a message waiting. There's a pipe shared between 
-  # the event thread managed by the queue implementation in C. It's made
-  # available to the ruby-space through the Zookeeper#selectable_io method.
-  # When the pipe is readable, that means there's an event waiting. We call
-  # dispatch_next_event and read a single byte off the pipe.
-  #
-  class ZKConnection < EM::Connection
-
-    def initialize(zk_client)
-      @zk_client = zk_client
-    end
 
-    def post_init
-      logger.debug { "post_init called" }
-      @attached = true
-
-      @on_unbind = EM::DefaultDeferrable.new.tap do |d|
-        d.callback do
-          logger.debug { "on_unbind deferred fired" }
-        end
-      end
-
-      # probably because of the way post_init works, unless we fire this
-      # callback in next_tick @em_connection in the client may not be set
-      # (which on_attached callbacks may be relying on)
-      EM.next_tick do 
-        logger.debug { "firing on_attached callback" }
-        @zk_client.on_attached.succeed
-      end
-    end
-    
-    # EM::DefaultDeferrable that will be called back when our em_connection has been detached
-    # and we've completed the close operation
-    def on_unbind(&block)
-      @on_unbind.callback(&block) if block
-      @on_unbind
-    end
-
-    def attached?
-      @attached
-    end
-
-    def unbind
-      on_unbind.succeed
-    end
-
-    def detach(&blk)
-      on_unbind(&blk)
-      return unless @attached
-      @attached = false
-      rval = super()
-      logger.debug { "#{self.class.name}: detached, rval: #{rval.inspect}" }
+    # 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
-
-    # we have an event waiting
-    def notify_readable
-      if @zk_client.running?
-
-        read_io_nb if @zk_client.dispatch_next_callback(false)
-
-      elsif attached?
-        logger.debug { "#{self.class.name}: @zk_client was not running? and attached? #{attached?}, detaching!" }
-        detach
-      end
-    end
-
-    private
-      def read_io_nb(size=1)
-        @io.read_nonblock(1)
-      rescue Errno::EWOULDBLOCK, Errno::EAGAIN, IOError
-      end
-      
-      def logger
-        Zookeeper.logger
-      end
-  end
-end
+  end # Client
+end # ZookeeperEM
 

data/lib/zookeeper/exceptions.rb

@@ -27,7 +27,7 @@ module ZookeeperExceptions
   ZNOTHING                  = -117
   ZSESSIONMOVED             = -118
 
-  class ZookeeperException < Exception
+  class ZookeeperException < StandardError
     class EverythingOk            < ZookeeperException; end
     class SystemError             < ZookeeperException; end
     class RunTimeInconsistency    < ZookeeperException; end
@@ -58,6 +58,9 @@ module ZookeeperExceptions
     class NotConnected            < ZookeeperException; end 
     class ShuttingDownException   < ZookeeperException; end
     class DataTooLargeException   < ZookeeperException; end
+
+    # yes, make an alias, this is the way zookeeper refers to it
+    ExpiredSession = SessionExpired
     
     def self.by_code(code)
       case code

data/lib/zookeeper.rb

@@ -14,7 +14,6 @@ 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!
-  require 'zookeeper_c'
 end
 
 require 'zookeeper_base'
@@ -33,6 +32,7 @@ class Zookeeper < ZookeeperBase
   end
 
   def reopen(timeout=10, watcher=nil)
+    warn "WARN: ZookeeperBase#reopen watcher argument is now ignored" if watcher
     super
   end
 
@@ -121,6 +121,24 @@ class Zookeeper < ZookeeperBase
     { :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])
@@ -165,12 +183,40 @@ class Zookeeper < ZookeeperBase
   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
 
   # for expert use only. set the underlying debug level for the C layer, has no
   # effect in java
   #
+  # @private
   def self.set_debug_level(val)
-    super
+    if defined?(::CZookeeper)
+      CZookeeper.set_debug_level(val.to_i)
+    end
+  end
+
+  # @private
+  def self.get_debug_level
+    if defined?(::CZookeeper)
+      CZookeeper.get_debug_level
+    end
+  end
+
+  class << self
+    # @private
+    alias :debug_level= :set_debug_level
+    
+    # @private
+    alias :debug_level :get_debug_level
   end
 
   # DEPRECATED: use the class-level method instead
@@ -188,18 +234,6 @@ class Zookeeper < ZookeeperBase
     super
   end
 
-  # returns an IO object that will be readable when an event is ready for dispatching
-  # (for internal use only)
-  def selectable_io
-    super
-  end
-
-  # closes the underlying connection object
-  # (for internal use only)
-  def close_handle
-    super
-  end
-
   # return the session id of the current connection as an Fixnum
   def session_id
     super
@@ -244,8 +278,10 @@ protected
 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)
-    @req_mutex.synchronize {
+    @mutex.synchronize {
       @watcher_reqs.delete(req_id)
     }
   end

data/slyphon-zookeeper.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "slyphon-zookeeper"
-  s.version     = '0.3.0'
+  s.version     = '0.8.0'
 
   s.authors     = ["Phillip Pearson", "Eric Maland", "Evan Weaver", "Brian Wickman", "Neil Conway", "Jonathan D. Simms"]
   s.email       = ["slyphon@gmail.com"]

data/spec/c_zookeeper_spec.rb

@@ -0,0 +1,50 @@
+# tests the CZookeeper, obviously only available when running under MRI
+require 'spec_helper'
+
+if Module.const_defined?(:CZookeeper)
+  describe CZookeeper do
+    def pop_all_events
+      [].tap do |rv|
+        begin
+          rv << @event_queue.pop(non_blocking=true)
+        rescue ThreadError
+        end
+      end
+    end
+
+    def wait_until_connected(timeout=2)
+      wait_until(timeout) { @czk.state == ZookeeperConstants::ZOO_CONNECTED_STATE }
+    end
+
+    describe do
+      before do
+        @event_queue = ZookeeperCommon::QueueWithPipe.new
+        @czk = CZookeeper.new('localhost:2181', @event_queue)
+      end
+
+      after do
+        @czk.close rescue Exception
+        @event_queue.close rescue Exception
+      end
+
+      it %[should be in connected state within a reasonable amount of time] do
+        wait_until_connected.should be_true
+      end
+
+      describe :after_connected do
+        before do
+          wait_until_connected.should be_true
+        end
+
+        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
+        end
+      end
+    end
+  end
+end
+

data/spec/chrooted_connection_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'shared/connection_examples'
+
+describe 'Zookeeper chrooted' do
+  let(:path) { "/_zkchroottest_" }
+  let(:data) { "underpants" } 
+  let(:chroot_path) { '/slyphon-zookeeper-chroot' }
+
+  let(:connection_string) { "localhost:2181#{chroot_path}" }
+
+  before do
+    @zk = Zookeeper.new(connection_string)
+  end
+
+  after do
+    @zk and @zk.close
+  end
+
+
+  def zk
+    @zk
+  end
+
+  def with_open_zk(host='localhost:2181')
+    z = Zookeeper.new(host)
+    yield z
+  ensure
+    z.close
+
+    wait_until do 
+      begin
+        !z.connected?
+      rescue RuntimeError
+        true
+      end
+    end
+  end
+
+  # this is not as safe as the one in ZK, just to be used to clean up
+  # when we're the only one adjusting a particular path
+  def rm_rf(z, path)
+    z.get_children(:path => path).tap do |h|
+      if h[:rc].zero?
+        h[:children].each do |child|
+          rm_rf(z, File.join(path, child))
+        end
+      elsif h[:rc] == ZookeeperExceptions::ZNONODE
+        # no-op
+      else
+        raise "Oh noes! unexpected return value! #{h.inspect}"
+      end
+    end
+
+    rv = z.delete(:path => path)
+
+    unless (rv[:rc].zero? or rv[:rc] == ZookeeperExceptions::ZNONODE)
+      raise "oh noes! failed to delete #{path}" 
+    end
+
+    path
+  end
+
+  describe 'non-existent' do
+    describe 'with existing parent' do
+      let(:chroot_path) { '/one-level' }
+
+      describe 'create' do
+        before do
+          with_open_zk do |z|
+            rm_rf(z, chroot_path)
+          end
+        end
+
+        it %[should successfully create the path] do
+          rv = zk.create(:path => '/', :data => '')
+          rv[:rc].should be_zero
+          rv[:path].should == ''
+        end
+      end
+    end
+
+    describe 'with missing parent' do
+      let(:chroot_path) { '/deeply/nested/path' }
+
+      describe 'create' do
+        before do
+          with_open_zk do |z|
+            rm_rf(z, chroot_path)
+          end
+        end
+
+        it %[should return ZNONODE] do
+          rv = zk.create(:path => '/', :data => '')
+          rv[:rc].should_not be_zero
+          rv[:rc].should == ZookeeperExceptions::ZNONODE
+        end
+      end
+    end
+  end
+
+
+  describe do
+    before :all do
+      Zookeeper.logger.warn "running before :all"
+
+      with_open_zk do |z|
+        z.create(:path => chroot_path, :data => '')
+      end
+    end
+
+    after :all do
+      with_open_zk do |z|
+        rm_rf(z, chroot_path)
+      end
+    end
+
+    it_should_behave_like "connection"
+  end
+end
+
+

data/spec/em_spec.rb

@@ -28,66 +28,6 @@ describe 'ZookeeperEM' do
       end
     end
 
-    describe 'selectable_io' do
-      it %[should return an IO object] do
-        setup_zk do
-          @zk.selectable_io.should be_instance_of(IO)
-          teardown_and_done
-        end
-      end
-
-      it %[should not be closed] do
-        setup_zk do
-          @zk.selectable_io.should_not be_closed
-          teardown_and_done
-        end
-      end
-
-      before do
-        @data_cb = ZookeeperCallbacks::DataCallback.new do
-          logger.debug { "cb called: #{@data_cb.inspect}" }
-        end
-      end
-
-      it %[should be read-ready if there's an event waiting] do
-        setup_zk do
-          @zk.get(:path => "/", :callback => @data_cb)
-
-          r, *_ = IO.select([@zk.selectable_io], [], [], 2)
-
-          r.should be_kind_of(Array)
-
-          teardown_and_done
-        end
-      end
-    end
-
-    describe 'em_connection' do
-      before do
-        @zk = ZookeeperEM::Client.new('localhost:2181')
-      end
-
-      it %[should be nil before the reactor is started] do
-        @zk.em_connection.should be_nil
-
-        em do
-          teardown_and_done
-        end
-      end
-
-      it %[should fire off the on_attached callbacks once the reactor is managing us] do
-        @zk.on_attached do |*|
-          @zk.em_connection.should_not be_nil
-          @zk.em_connection.should be_instance_of(ZookeeperEM::ZKConnection)
-          teardown_and_done
-        end
-
-        em do
-          EM.reactor_running?.should be_true
-        end
-      end
-    end
-
     describe 'callbacks' do
       it %[should be called on the reactor thread] do
         cb = lambda do |h|
@@ -105,7 +45,6 @@ describe 'ZookeeperEM' do
         end
       end
     end
-
   end
 end
 

data/spec/shared/all_success_return_values.rb

@@ -0,0 +1,10 @@
+shared_examples_for "all success return values" do
+  it %[should have a return code of Zookeeper::ZOK] do
+    @rv[:rc].should == Zookeeper::ZOK
+  end
+
+  it %[should have a req_id integer] do
+    @rv[:req_id].should be_kind_of(Integer)
+  end
+end
+