slyphon-zookeeper 0.1.7-java → 0.2.0-java

data/java/zookeeper_base.rb

@@ -59,6 +59,53 @@ class ZookeeperBase
     end
   end
 
+  class QueueWithPipe
+    attr_writer :clear_reads_on_pop
+
+    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
+    end
+
+    def push(obj)
+      rv = @queue.push(obj)
+      @pipe[:write].write('0')
+      logger.debug { "pushed #{obj.inspect} onto queue and wrote to pipe" }
+      rv
+    end
+
+    def pop(non_blocking=false)
+      rv = @queue.pop(non_blocking)
+
+      # if non_blocking is true and an exception is raised, this won't get called
+      @pipe[:read].read(1) if clear_reads_on_pop?
+
+      rv
+    end
+
+    def close
+      @pipe.values.each { |io| io.close unless io.closed? }
+    end
+
+    def selectable_io
+      @pipe[:read]
+    end
+
+    private
+      def clear_reads_on_pop?
+        @clear_reads_on_pop
+      end
+
+      def logger
+        Zookeeper.logger
+      end
+  end
+
   # used for internal dispatching
   module JavaCB #:nodoc:
     class Callback
@@ -78,13 +125,24 @@ class ZookeeperBase
       include JZK::AsyncCallback::DataCallback
 
       def processResult(rc, path, queue, data, stat)
-        queue.push({
+        logger.debug { "#{self.class.name}#processResult rc: #{rc}, req_id: #{req_id}, path: #{path}, queue: #{queue.inspect}, data: #{data.inspect}, stat: #{stat.inspect}" }
+
+        hash = {
           :rc     => rc,
           :req_id => req_id,
           :path   => path,
-          :data   => String.from_java_bytes(data),
-          :stat   => stat.to_hash,
-        })
+          :data   => (data && String.from_java_bytes(data)),
+          :stat   => (stat && stat.to_hash),
+        }
+
+#         if rc == Zookeeper::ZOK
+#           hash.merge!({
+#             :data   => String.from_java_bytes(data),
+#             :stat   => stat.to_hash,
+#           })
+#         end
+
+        queue.push(hash)
       end
     end
 
@@ -92,6 +150,7 @@ class ZookeeperBase
       include JZK::AsyncCallback::StringCallback
 
       def processResult(rc, path, queue, str)
+        logger.debug { "#{self.class.name}#processResult rc: #{rc}, req_id: #{req_id}, path: #{path}, queue: #{queue.inspect}, str: #{str.inspect}" }
         queue.push(:rc => rc, :req_id => req_id, :path => path, :string => str)
       end
     end
@@ -100,7 +159,7 @@ class ZookeeperBase
       include JZK::AsyncCallback::StatCallback
 
       def processResult(rc, path, queue, stat)
-        logger.debug { "StatCallback#processResult rc: #{rc.inspect}, path: #{path.inspect}, queue: #{queue.inspect}, stat: #{stat.inspect}" }
+        logger.debug { "#{self.class.name}#processResult rc: #{rc.inspect}, req_id: #{req_id}, path: #{path.inspect}, queue: #{queue.inspect}, stat: #{stat.inspect}" }
         queue.push(:rc => rc, :req_id => req_id, :stat => (stat and stat.to_hash), :path => path)
       end
     end
@@ -109,7 +168,16 @@ class ZookeeperBase
       include JZK::AsyncCallback::Children2Callback
 
       def processResult(rc, path, queue, children, stat)
-        queue.push(:rc => rc, :req_id => req_id, :path => path, :strings => children.to_a, :stat => stat.to_hash)
+        logger.debug { "#{self.class.name}#processResult rc: #{rc}, req_id: #{req_id}, path: #{path}, queue: #{queue.inspect}, children: #{children.inspect}, stat: #{stat.inspect}" }
+        hash = {
+          :rc       => rc, 
+          :req_id   => req_id, 
+          :path     => path, 
+          :strings  => (children && children.to_a), 
+          :stat     => (stat and stat.to_hash),
+        }
+
+        queue.push(hash)
       end
     end
 
@@ -117,9 +185,9 @@ class ZookeeperBase
       include JZK::AsyncCallback::ACLCallback
       
       def processResult(rc, path, queue, acl, stat)
-        logger.debug { "ACLCallback#processResult #{rc.inspect} #{path.inspect} #{queue.inspect} #{acl.inspect} #{stat.inspect}" }
+        logger.debug { "ACLCallback#processResult rc: #{rc.inspect}, req_id: #{req_id}, path: #{path.inspect}, queue: #{queue.inspect}, acl: #{acl.inspect}, stat: #{stat.inspect}" }
         a = Array(acl).map { |a| a.to_hash }
-        queue.push(:rc => rc, :req_id => req_id, :path => path, :acl => a, :stat => stat.to_hash)
+        queue.push(:rc => rc, :req_id => req_id, :path => path, :acl => a, :stat => (stat && stat.to_hash))
       end
     end
 
@@ -127,6 +195,7 @@ class ZookeeperBase
       include JZK::AsyncCallback::VoidCallback
 
       def processResult(rc, path, queue)
+        logger.debug { "#{self.class.name}#processResult rc: #{rc}, req_id: #{req_id}, queue: #{queue.inspect}" }
         queue.push(:rc => rc, :req_id => req_id, :path => path)
       end
     end
@@ -140,7 +209,7 @@ class ZookeeperBase
       end
 
       def process(event)
-        logger.debug { "WatcherCallback got event: #{event.to_hash}" }
+        logger.debug { "WatcherCallback got event: #{event.to_hash.inspect}" }
         hash = event.to_hash.merge(:req_id => req_id)
         @event_queue.push(hash)
       end
@@ -156,26 +225,32 @@ class ZookeeperBase
       set_default_global_watcher(&watcher)
     end
 
-    @jzk = JZK::ZooKeeper.new(@host, DEFAULT_SESSION_TIMEOUT, JavaCB::WatcherCallback.new(@event_queue))
+    @start_stop_mutex.synchronize do
+      @jzk = JZK::ZooKeeper.new(@host, DEFAULT_SESSION_TIMEOUT, JavaCB::WatcherCallback.new(@event_queue))
 
-    if timeout > 0
-      time_to_stop = Time.now + timeout
-      until connected?
-        break if Time.now > time_to_stop
-        sleep 0.1
+      if timeout > 0
+        time_to_stop = Time.now + timeout
+        until connected?
+          break if Time.now > time_to_stop
+          sleep 0.1
+        end
       end
     end
 
     state
   end
 
-  def initialize(host, timeout=10, watcher=nil)
+  def initialize(host, timeout=10, watcher=nil, options={})
     @host = host
-    @event_queue = Queue.new
+    @event_queue = QueueWithPipe.new
     @current_req_id = 0
     @req_mutex = Monitor.new
     @watcher_reqs = {}
     @completion_reqs = {}
+    @_running = nil
+    @_closed  = false
+    @options = {}
+    @start_stop_mutex = Mutex.new
 
     watcher ||= get_default_global_watcher
 
@@ -184,6 +259,7 @@ class ZookeeperBase
 
     reopen(timeout, watcher)
     return nil unless connected?
+    @_running = true
     setup_dispatch_thread!
   end
 
@@ -203,6 +279,22 @@ class ZookeeperBase
     state == JZK::ZooKeeper::States::ASSOCIATING
   end
 
+  def running?
+    @_running
+  end
+
+  def closed?
+    @_closed
+  end
+
+  def self.set_debug_level(*a)
+    # IGNORED IN JRUBY
+  end
+
+  def set_debug_level(*a)
+    # IGNORED IN JRUBY
+  end
+
   def get(req_id, path, callback, watcher)
     handle_keeper_exception do
       watch_cb = watcher ? create_watcher(req_id, path) : false
@@ -332,20 +424,36 @@ class ZookeeperBase
 
   class DispatchShutdownException < StandardError; end
 
+  def wake_event_loop!
+    @event_queue.push(KILL_TOKEN)    # ignored by dispatch_next_callback
+  end
+
   def close
     @req_mutex.synchronize do
-      if @jzk
-        @jzk.close
-        wait_until { !connected? }
-      end
+      @_running = false if @_running
+    end
+        
+    # XXX: why is wake_event_loop! here?
+    if @dispatcher 
+      wake_event_loop!
+      @dispatcher.join 
+    end
 
-      if @dispatcher 
-        @dispatcher[:running] = false
-        @event_queue.push(KILL_TOKEN)    # ignored by dispatch_next_callback
+    unless @_closed
+      @start_stop_mutex.synchronize do
+        @_closed = true
+        close_handle
       end
+
+      @event_queue.close
     end
+  end
 
-    @dispatcher.join
+  def close_handle
+    if @jzk
+      @jzk.close
+      wait_until { !connected? }
+    end
   end
 
   # set the watcher object/proc that will receive all global events (such as session/state events)
@@ -360,6 +468,23 @@ class ZookeeperBase
     end
   end
 
+  # by accessing this selectable_io you indicate that you intend to clear it
+  # when you have delivered an event by reading one byte per event.
+  #
+  def selectable_io
+    @event_queue.clear_reads_on_pop = false
+    @event_queue.selectable_io
+  end
+
+  def get_next_event(blocking=true)
+    @event_queue.pop(!blocking).tap do |event|
+      logger.debug { "get_next_event delivering event: #{event.inspect}" }
+      raise DispatchShutdownException if event == KILL_TOKEN
+    end
+  rescue ThreadError
+    nil
+  end
+ 
   protected
     def handle_keeper_exception
       yield
@@ -376,28 +501,23 @@ class ZookeeperBase
     end
    
     def create_watcher(req_id, path)
+      logger.debug { "creating watcher for req_id: #{req_id} path: #{path}" }
       lambda do |event|
+        logger.debug { "watcher for req_id #{req_id}, path: #{path} called back" }
         h = { :req_id => req_id, :type => event.type.int_value, :state => event.state.int_value, :path => path }
         @event_queue.push(h)
       end
     end
 
-    def get_next_event
-      @event_queue.pop.tap do |event|
-        raise DispatchShutdownException if event == KILL_TOKEN
-      end
-    end
-    
     # method to wait until block passed returns true or timeout (default is 10 seconds) is reached 
     def wait_until(timeout=10, &block)
       time_to_stop = Time.now + timeout
       until yield do 
         break if Time.now > time_to_stop
-        sleep 0.3
+        sleep 0.1
       end
     end
 
-  protected
     # TODO: Make all global puts configurable
     def get_default_global_watcher
       Proc.new { |args|
@@ -406,13 +526,10 @@ class ZookeeperBase
       }
     end
 
-  private
     def setup_dispatch_thread!
       logger.debug {  "starting dispatch thread" }
       @dispatcher = Thread.new do
-        Thread.current[:running] = true
-
-        while Thread.current[:running]
+        while running?
           begin
             dispatch_next_callback 
           rescue DispatchShutdownException

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/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/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')