slyphon-zookeeper 0.3.0 → 0.8.0.rc.1

data/lib/zookeeper/common.rb

@@ -4,15 +4,18 @@ module ZookeeperCommon
   # sigh, i guess define this here?
   ZKRB_GLOBAL_CB_REQ   = -1
 
+protected
   def get_next_event(blocking=true)
-    return nil if closed? # protect against this happening in a callback after close
-    super(blocking) 
+    @event_queue.pop(!blocking).tap do |event|
+      logger.debug { "#{self.class}##{__method__} delivering event #{event.inspect}" }
+    end
+  rescue ThreadError
+    nil
   end
 
-protected
   def setup_call(meth_name, opts)
     req_id = nil
-    @req_mutex.synchronize {
+    @mutex.synchronize {
       req_id = @current_req_id
       @current_req_id += 1
       setup_completion(req_id, meth_name, opts) if opts[:callback]
@@ -38,20 +41,65 @@ protected
   end
   
   def get_watcher(req_id)
-    @req_mutex.synchronize {
+    @mutex.synchronize {
       (req_id == ZKRB_GLOBAL_CB_REQ) ? @watcher_reqs[req_id] : @watcher_reqs.delete(req_id)
     }
   end
   
   def get_completion(req_id)
-    @req_mutex.synchronize { @completion_reqs.delete(req_id) }
+    @mutex.synchronize { @completion_reqs.delete(req_id) }
+  end
+
+  def setup_dispatch_thread!
+    logger.debug {  "starting dispatch thread" }
+    @dispatcher ||= Thread.new do
+      while true
+        begin
+          dispatch_next_callback(get_next_event(true))
+        rescue QueueWithPipe::ShutdownException
+          logger.info { "dispatch thread exiting, got shutdown exception" }
+          break
+        rescue Exception => e
+          $stderr.puts ["#{e.class}: #{e.message}", e.backtrace.map { |n| "\t#{n}" }.join("\n")].join("\n")
+        end
+      end
+      signal_dispatch_thread_exit!
+    end
   end
+  
+  # this method is part of the reopen/close code, and is responsible for
+  # shutting down the dispatch thread. 
+  #
+  # @dispatcher will be nil when this method exits
+  #
+  def stop_dispatch_thread!
+    logger.debug { "#{self.class}##{__method__}" }
+
+    if @dispatcher
+      @mutex.synchronize do
+        event_queue.graceful_close!
 
-  def dispatch_next_callback(blocking=true)
-    hash = get_next_event(blocking)
-#     Zookeeper.logger.debug { "get_next_event returned: #{hash.inspect}" }
+        # we now release the mutex so that dispatch_next_callback can grab it
+        # to do what it needs to do while delivering events
+        @dispatch_shutdown_cond.wait
 
+        @dispatcher.join
+        @dispatcher = nil
+      end
+    end
+  end
+
+  def signal_dispatch_thread_exit!
+    @mutex.synchronize do
+      logger.debug { "dispatch thread exiting!" }
+      @dispatch_shutdown_cond.broadcast
+    end
+  end
+
+  def dispatch_next_callback(hash)
     return nil unless hash
+
+    Zookeeper.logger.debug { "get_next_event returned: #{prettify_event(hash).inspect}" }
     
     is_completion = hash.has_key?(:rc)
     
@@ -96,4 +144,16 @@ protected
             "Required arguments are: #{required.inspect}, but only the arguments #{args.keys.inspect} were supplied."
     end
   end
+
+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[:req_id]  = :global_session if h[:req_id] == -1
+    end
+  end
 end
+
+require 'zookeeper/common/queue_with_pipe'

data/lib/zookeeper/common/queue_with_pipe.rb

@@ -0,0 +1,78 @@
+module ZookeeperCommon
+  # Ceci n'est pas une pipe
+  class QueueWithPipe
+    extend Forwardable
+
+    def_delegators :@queue, :clear
+    
+    # raised when close has been called, and pop() is performed
+    # 
+    class ShutdownException < StandardError; end
+
+    # @private
+    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
+    end
+
+    def push(obj)
+      logger.debug { "#{self.class}##{__method__} obj: #{obj.inspect}, kill_token? #{obj == KILL_TOKEN}" }
+      @queue.push(obj)
+    end
+
+    def pop(non_blocking=false)
+      raise ShutdownException if closed?  # this may get us in trouble
+
+      rv = @queue.pop(non_blocking)
+
+      if rv == KILL_TOKEN
+        close
+        raise ShutdownException
+      end
+
+      rv
+    end
+
+    # close the queue and causes ShutdownException to be raised on waiting threads
+    def graceful_close!
+      @mutex.synchronize do
+        return if @graceful or @closed
+        logger.debug { "#{self.class}##{__method__} gracefully closing" }
+        @graceful = true
+        push(KILL_TOKEN)
+      end
+      nil
+    end
+
+    def close
+      @mutex.synchronize do
+        return if @closed
+        @closed = true
+      end
+    end
+
+    def closed?
+      @mutex.synchronize { !!@closed }
+    end
+
+    private
+      def clear_reads_on_pop?
+        @clear_reads_on_pop
+      end
+
+      def logger
+        Zookeeper.logger
+      end
+  end
+end

data/lib/zookeeper/constants.rb

@@ -18,6 +18,34 @@ module ZookeeperConstants
   ZOO_CHILD_EVENT        = 4
   ZOO_SESSION_EVENT      = -1
   ZOO_NOTWATCHING_EVENT  = -2
+
+  # only used by the C extension
+  ZOO_LOG_LEVEL_ERROR = 1
+  ZOO_LOG_LEVEL_WARN  = 2
+  ZOO_LOG_LEVEL_INFO  = 3
+  ZOO_LOG_LEVEL_DEBUG = 4
+
+  # used to find the name for a numeric event
+  # @private
+  EVENT_TYPE_NAMES = {
+    1   => :created,
+    2   => :deleted,
+    3   => :changed,
+    4   => :child,
+    -1  => :session,
+    -2  => :notwatching,
+  }
+
+  # used to pretty print the state name
+  # @private
+  STATE_NAMES = {
+    -112 => :expired_session,
+    -113 => :auth_failed,
+    0    => :closed,
+    1    => :connecting,
+    2    => :associating,
+    3    => :connected,
+  }
               
   def print_events
     puts "ZK events:"

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,18 @@ 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!
-      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
-        end
-      end
+    def dispatch_next_callback(hash)
+      EM.schedule { super(hash) }
     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
-
-      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}" }
-    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
+    # this is synchronous, but since the API still allows attaching to on_close, 
+    # we just fake it here
+    def close(&block)
+      on_close(&block).tap do |d|
+        super()
+        d.succeed
       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/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.rc.1'
 
   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
+