slyphon-zookeeper 0.1.7 → 0.2.0

data/lib/zookeeper.rb

@@ -19,6 +19,18 @@ end
 require 'zookeeper_base'
 
 class Zookeeper < ZookeeperBase
+  unless defined?(@@logger)
+    @@logger = Logger.new('/dev/null').tap { |l| l.level = Logger::FATAL } # UNIX: FOR GREAT JUSTICE !!
+  end
+
+  def self.logger
+    @@logger
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
   def reopen(timeout=10, watcher=nil)
     super
   end
@@ -130,6 +142,11 @@ class Zookeeper < ZookeeperBase
     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
@@ -146,6 +163,61 @@ class Zookeeper < ZookeeperBase
     super
   end
 
+  # for expert use only. set the underlying debug level for the C layer, has no
+  # effect in java
+  #
+  def self.set_debug_level(val)
+    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
+
+  # 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
+
+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
+
 private
   def setup_call(opts)
     req_id = nil
@@ -175,6 +247,5 @@ private
   def assert_open
     super
   end
-
 end
 

data/lib/zookeeper/common.rb

@@ -4,18 +4,9 @@ module ZookeeperCommon
   # sigh, i guess define this here?
   ZKRB_GLOBAL_CB_REQ   = -1
 
-  def self.included(mod)
-    mod.extend(ZookeeperCommon::ClassMethods)
-  end
-
-  module ClassMethods
-    def logger
-      @logger ||= Logger.new('/dev/null') # UNIX: YOU MUST USE IT!
-    end
-
-    def logger=(logger)
-      @logger = logger
-    end
+  def get_next_event(blocking=true)
+    return nil if closed? # protect against this happening in a callback after close
+    super(blocking) 
   end
 
 protected
@@ -50,13 +41,12 @@ protected
     @req_mutex.synchronize { @completion_reqs.delete(req_id) }
   end
 
+  def dispatch_next_callback(blocking=true)
+    hash = get_next_event(blocking)
+#     Zookeeper.logger.debug { "get_next_event returned: #{hash.inspect}" }
 
-  def dispatch_next_callback
-    hash = get_next_event
     return nil unless hash
     
-    logger.debug {  "dispatch_next_callback got event: #{hash.inspect}" }
-
     is_completion = hash.has_key?(:rc)
     
     hash[:stat] = ZookeeperStat::Stat.new(hash[:stat]) if hash.has_key?(:stat)
@@ -81,9 +71,9 @@ protected
     else
       logger.warn { "Duplicate event received (no handler for req_id #{hash[:req_id]}, event: #{hash.inspect}" }
     end
+    true
   end
 
-
   def assert_supported_keys(args, supported)
     unless (args.keys - supported).empty?
       raise ZookeeperExceptions::ZookeeperException::BadArguments,  # this heirarchy is kind of retarded
@@ -98,9 +88,5 @@ protected
     end
   end
 
-  # supplied by parent class impl.
-  def logger
-    self.class.logger
-  end
 end
 

data/lib/zookeeper/em_client.rb

@@ -0,0 +1,135 @@
+require 'zookeeper'
+require 'eventmachine'
+
+module ZookeeperEM 
+  class Client < Zookeeper
+    # @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
+      super(*a, &b)
+    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
+
+    # 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 { "close called, closed? #{closed?} running? #{running?}" }
+
+      if @_running
+        @start_stop_mutex.synchronize do
+          @_running = false
+        end
+
+        @em_connection.detach if @em_connection
+        @em_connection = nil
+
+        unless @_closed
+          @start_stop_mutex.synchronize do
+            logger.debug { "closing handle" }
+            close_handle
+          end
+
+          selectable_io.close unless selectable_io.closed?
+        end
+      else
+        logger.debug { "we are not running, so returning on_close deferred" }
+      end
+
+      on_close.succeed
+      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!
+      EM.schedule do
+        if running? and not closed?
+          begin
+            @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
+          on_attached.succeed
+        end
+      end
+    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
+      @attached = true
+    end
+
+    def attached?
+      @attached
+    end
+
+    def detach
+      return unless @attached
+      @attached = false
+      super
+      logger.debug { "#{self.class.name}: detached" }
+    end
+
+    # we have an event waiting
+    def notify_readable
+      if @zk_client.running?
+#         logger.debug { "#{self.class.name}: dispatching events while #{@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
+

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.1.7'
+  s.version     = '0.2.0'
 
   s.authors     = ["Phillip Pearson", "Eric Maland", "Evan Weaver", "Brian Wickman", "Neil Conway", "Jonathan D. Simms"]
   s.email       = ["slyphon@gmail.com"]
@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n")
   s.require_paths = ["lib"]
 
-  if ENV['JAVA_GEM']
+  if ENV['JAVA_GEM'] or defined?(::JRUBY_VERSION)
     s.platform = 'java'
     s.add_runtime_dependency('slyphon-log4j',         '= 1.2.15')
     s.add_runtime_dependency('slyphon-zookeeper_jar', '= 3.3.3')

data/spec/em_spec.rb

@@ -0,0 +1,138 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'zookeeper/em_client'
+
+gem 'evented-spec', '~> 0.4.1'
+require 'evented-spec'
+
+
+describe 'ZookeeperEM' do
+  describe 'Client' do
+    include EventedSpec::SpecHelper
+    default_timeout 3.0
+
+    def setup_zk
+      @zk = ZookeeperEM::Client.new('localhost:2181')
+      em do
+        @zk.on_attached do
+          yield
+        end
+      end
+    end
+
+    def teardown_and_done
+      @zk.close { done }
+    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
+
+      it %[should not be read-ready if there's no event] do
+        pending "get this to work in jruby" if defined?(::JRUBY_VERSION)
+        # there's always an initial event after connect
+        
+        # except in jruby
+#         if defined?(::JRUBY_VERSION)
+#           @zk.get(:path => '/', :callback => @data_cb)
+#         end
+
+        setup_zk do
+          events = 0
+
+          while true
+            r, *_ = IO.select([@zk.selectable_io], [], [], 0.2)
+
+            break unless r
+
+            h = @zk.get_next_event(false)
+            @zk.selectable_io.read(1)
+
+            events += 1
+
+            h.should be_kind_of(Hash)
+          end
+
+          events.should == 1
+
+          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|
+          EM.reactor_thread?.should be_true
+          logger.debug { "called back on the reactor thread? #{EM.reactor_thread?}" }
+          teardown_and_done
+        end
+
+        setup_zk do
+          @zk.on_attached do |*|
+            logger.debug { "on_attached called" }
+            rv = @zk.get(:path => '/', :callback => cb) 
+            logger.debug { "rv from @zk.get: #{rv.inspect}" }
+          end
+        end
+      end
+    end
+
+  end
+end
+
+