slyphon-zookeeper 0.3.0 → 0.8.0.rc.1

data/ext/zookeeper_lib.h

@@ -105,7 +105,6 @@ void           zkrb_queue_free(zkrb_queue_t *queue);
 zkrb_event_t * zkrb_event_alloc(void);
 void           zkrb_event_free(zkrb_event_t *ptr);
 
-/* push/pop is a misnomer, this is a queue */
 void                 zkrb_enqueue(zkrb_queue_t *queue, zkrb_event_t *elt);
 zkrb_event_t *       zkrb_peek(zkrb_queue_t *queue);
 zkrb_event_t *       zkrb_dequeue(zkrb_queue_t *queue, int need_lock);

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 = {}
+      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.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])
@@ -169,8 +187,26 @@ class Zookeeper < ZookeeperBase
   # 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 +224,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 +268,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