slyphon-zookeeper 0.3.0-java → 0.8.0-java

data/java/zookeeper_base.rb

@@ -59,53 +59,6 @@ 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
@@ -216,43 +169,48 @@ class ZookeeperBase
     end
   end
 
+  attr_reader :event_queue
+
   def reopen(timeout=10, watcher=nil)
-    watcher ||= @default_watcher
+#     watcher ||= @default_watcher
 
-    @req_mutex.synchronize do
+    @mutex.synchronize do
       # flushes all outstanding watcher reqs.
-      @watcher_req = {}
-      set_default_global_watcher(&watcher)
+      @watcher_reqs.clear
+      set_default_global_watcher
+
+      replace_jzk!
+      wait_until_connected
     end
 
-    @start_stop_mutex.synchronize do
-      @jzk = JZK::ZooKeeper.new(@host, DEFAULT_SESSION_TIMEOUT, JavaCB::WatcherCallback.new(@event_queue))
+    state
+  end
+
+  def wait_until_connected(timeout=10)
+    time_to_stop = timeout ? (Time.now + timeout) : nil
 
-      if timeout > 0
-        time_to_stop = Time.now + timeout
-        until connected?
-          break if Time.now > time_to_stop
-          sleep 0.1
-        end
-      end
+    until connected? or (time_to_stop and Time.now > time_to_stop)
+      Thread.pass
     end
 
-    state
+    connected?
   end
 
   def initialize(host, timeout=10, watcher=nil, options={})
     @host = host
     @event_queue = QueueWithPipe.new
     @current_req_id = 0
-    @req_mutex = Monitor.new
+
+    @mutex = Monitor.new
+    @dispatch_shutdown_cond = @mutex.new_cond
+
     @watcher_reqs = {}
     @completion_reqs = {}
     @_running = nil
     @_closed  = false
     @options = {}
-    @start_stop_mutex = Mutex.new
 
-    watcher ||= get_default_global_watcher
+    @default_watcher = (watcher || get_default_global_watcher)
 
     # allows connected-state handlers to be registered before 
     yield self if block_given?
@@ -263,8 +221,19 @@ class ZookeeperBase
     setup_dispatch_thread!
   end
 
+  def close
+    @mutex.synchronize do
+      return if @_closed
+      @_closed = true    # these are probably unnecessary
+      @_running = false
+
+      stop_dispatch_thread!
+      @jzk.close if @jzk
+    end
+  end
+
   def state
-    @jzk.state
+    @mutex.synchronize { @jzk.state }
   end
 
   def connected?
@@ -300,11 +269,11 @@ class ZookeeperBase
       watch_cb = watcher ? create_watcher(req_id, path) : false
 
       if callback
-        @jzk.getData(path, watch_cb, JavaCB::DataCallback.new(req_id), @event_queue)
+        jzk.getData(path, watch_cb, JavaCB::DataCallback.new(req_id), event_queue)
         [Code::Ok, nil, nil]    # the 'nil, nil' isn't strictly necessary here
       else # sync
         stat = JZKD::Stat.new
-        data = String.from_java_bytes(@jzk.getData(path, watch_cb, stat))
+        data = String.from_java_bytes(jzk.getData(path, watch_cb, stat))
 
         [Code::Ok, data, stat.to_hash]
       end
@@ -316,10 +285,10 @@ class ZookeeperBase
       version ||= ANY_VERSION
 
       if callback
-        @jzk.setData(path, data.to_java_bytes, version, JavaCB::StatCallback.new(req_id), @event_queue)
+        jzk.setData(path, data.to_java_bytes, version, JavaCB::StatCallback.new(req_id), event_queue)
         [Code::Ok, nil]
       else
-        stat = @jzk.setData(path, data.to_java_bytes, version).to_hash
+        stat = jzk.setData(path, data.to_java_bytes, version).to_hash
         [Code::Ok, stat]
       end
     end
@@ -330,11 +299,11 @@ class ZookeeperBase
       watch_cb = watcher ? create_watcher(req_id, path) : false
 
       if callback
-        @jzk.getChildren(path, watch_cb, JavaCB::Children2Callback.new(req_id), @event_queue)
+        jzk.getChildren(path, watch_cb, JavaCB::Children2Callback.new(req_id), event_queue)
         [Code::Ok, nil, nil]
       else
         stat = JZKD::Stat.new
-        children = @jzk.getChildren(path, watch_cb, stat)
+        children = jzk.getChildren(path, watch_cb, stat)
         [Code::Ok, children.to_a, stat.to_hash]
       end
     end
@@ -348,21 +317,28 @@ class ZookeeperBase
       data ||= ''
 
       if callback
-        @jzk.create(path, data.to_java_bytes, acl, mode, JavaCB::StringCallback.new(req_id), @event_queue)
+        jzk.create(path, data.to_java_bytes, acl, mode, JavaCB::StringCallback.new(req_id), event_queue)
         [Code::Ok, nil]
       else
-        new_path = @jzk.create(path, data.to_java_bytes, acl, mode)
+        new_path = jzk.create(path, data.to_java_bytes, acl, mode)
         [Code::Ok, new_path]
       end
     end
   end
 
+  def sync(req_id, path)
+    handle_keeper_exception do
+      jzk.sync(path, JavaCB::VoidCallback.new(req_id), event_queue)
+      Code::Ok
+    end
+  end
+
   def delete(req_id, path, version, callback)
     handle_keeper_exception do
       if callback
-        @jzk.delete(path, version, JavaCB::VoidCallback.new(req_id), @event_queue)
+        jzk.delete(path, version, JavaCB::VoidCallback.new(req_id), event_queue)
       else
-        @jzk.delete(path, version)
+        jzk.delete(path, version)
       end
 
       Code::Ok
@@ -376,9 +352,9 @@ class ZookeeperBase
       logger.debug { "set_acl: converted #{acl.inspect}" }
 
       if callback
-        @jzk.setACL(path, acl, version, JavaCB::ACLCallback.new(req_id), @event_queue)
+        jzk.setACL(path, acl, version, JavaCB::ACLCallback.new(req_id), event_queue)
       else
-        @jzk.setACL(path, acl, version)
+        jzk.setACL(path, acl, version)
       end
 
       Code::Ok
@@ -390,10 +366,10 @@ class ZookeeperBase
       watch_cb = watcher ? create_watcher(req_id, path) : false
 
       if callback
-        @jzk.exists(path, watch_cb, JavaCB::StatCallback.new(req_id), @event_queue)
+        jzk.exists(path, watch_cb, JavaCB::StatCallback.new(req_id), event_queue)
         [Code::Ok, nil, nil]
       else
-        stat = @jzk.exists(path, watch_cb)
+        stat = jzk.exists(path, watch_cb)
         [Code::Ok, (stat and stat.to_hash)]
       end
     end
@@ -405,10 +381,10 @@ class ZookeeperBase
 
       if callback
         logger.debug { "calling getACL, path: #{path.inspect}, stat: #{stat.inspect}" } 
-        @jzk.getACL(path, stat, JavaCB::ACLCallback.new(req_id), @event_queue)
+        jzk.getACL(path, stat, JavaCB::ACLCallback.new(req_id), event_queue)
         [Code::Ok, nil, nil]
       else
-        acls = @jzk.getACL(path, stat).map { |a| a.to_hash }
+        acls = jzk.getACL(path, stat).map { |a| a.to_hash }
         
         [Code::Ok, Array(acls).map{|m| m.to_hash}, stat.to_hash]
       end
@@ -420,80 +396,30 @@ class ZookeeperBase
     raise ZookeeperException::NotConnected unless connected?
   end
 
-  KILL_TOKEN = :__kill_token__
-
-  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
-      @_running = false if @_running
-    end
-        
-    # XXX: why is wake_event_loop! here?
-    if @dispatcher 
-      wake_event_loop!
-      @dispatcher.join 
-    end
-
-    unless @_closed
-      @start_stop_mutex.synchronize do
-        @_closed = true
-        close_handle
-      end
-
-      @event_queue.close
-    end
-  end
-
-  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)
   #---
   # XXX: this code needs to be duplicated from ext/zookeeper_base.rb because
   # it's called from the initializer, and because of the C impl. we can't have
   # the two decend from a common base, and a module wouldn't work
-  def set_default_global_watcher(&block)
-    @req_mutex.synchronize do
-      @default_watcher = block
+  def set_default_global_watcher
+    @mutex.synchronize do
       @watcher_reqs[ZKRB_GLOBAL_CB_REQ] = { :watcher => @default_watcher, :watcher_context => nil }
     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 session_id
-    @jzk.session_id
+    jzk.session_id
   end
 
   def session_passwd
-    @jzk.session_passwd.to_s
+    jzk.session_passwd.to_s
   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 jzk
+      @mutex.synchronize { @jzk }
+    end
+
     def handle_keeper_exception
       yield
     rescue JZK::KeeperException => e
@@ -513,7 +439,7 @@ class ZookeeperBase
       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)
+        event_queue.push(h)
       end
     end
 
@@ -534,20 +460,12 @@ class ZookeeperBase
       }
     end
 
-    def setup_dispatch_thread!
-      logger.debug {  "starting dispatch thread" }
-      @dispatcher = Thread.new do
-        while running?
-          begin
-            dispatch_next_callback 
-          rescue DispatchShutdownException
-            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
-      end
+  private
+    def replace_jzk!
+      orig_jzk = @jzk
+      @jzk = JZK::ZooKeeper.new(@host, DEFAULT_SESSION_TIMEOUT, JavaCB::WatcherCallback.new(event_queue))
+    ensure
+      orig_jzk.close if orig_jzk
     end
 end
 

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/common.rb

@@ -4,15 +4,22 @@ module ZookeeperCommon
   # sigh, i guess define this here?
   ZKRB_GLOBAL_CB_REQ   = -1
 
-  def get_next_event(blocking=true)
-    return nil if closed? # protect against this happening in a callback after close
-    super(blocking) 
+  def event_dispatch_thread?
+    @dispatcher && (@dispatcher == Thread.current)
   end
 
 protected
+  def get_next_event(blocking=true)
+    @event_queue.pop(!blocking).tap do |event|
+      logger.debug { "#{self.class}##{__method__} delivering event #{event.inspect}" }
+    end
+  rescue ThreadError
+    nil
+  end
+
   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 +45,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 dispatch_next_callback(blocking=true)
-    hash = get_next_event(blocking)
-#     Zookeeper.logger.debug { "get_next_event returned: #{hash.inspect}" }
+  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!
+
+        # 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 +148,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/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:"