zookeeper 1.0.0.beta.1-java → 1.0.0-java

data/Rakefile

@@ -49,7 +49,7 @@ if File.exists?(release_ops_path)
         end
       end
 
-      task :push => :build do
+      task :push do
         gems = FileList['*.gem']
         raise "No gemfiles to push!" if gems.empty?
 

data/ext/c_zookeeper.rb

@@ -8,7 +8,7 @@ require_relative 'zookeeper_c'
 #       when we're garbage collected
 module Zookeeper
 class CZookeeper
-  include Zookeeper::Common
+  include Zookeeper::Forked
   include Zookeeper::Constants
   include Zookeeper::Exceptions
 
@@ -16,6 +16,8 @@ class CZookeeper
 
   class GotNilEventException < StandardError; end
 
+  attr_accessor :original_pid
+
   # assume we're at debug level
   def self.get_debug_level
     @debug_level ||= ZOO_LOG_LEVEL_INFO
@@ -29,6 +31,9 @@ class CZookeeper
   def initialize(host, event_queue, opts={})
     @host = host
     @event_queue = event_queue
+
+    # keep track of the pid that created us
+    update_pid!
     
     # used by the C layer. CZookeeper sets this to true when the init method
     # has completed. once this is set to true, it stays true.
@@ -52,6 +57,9 @@ class CZookeeper
     
     # used to signal that we're running
     @running_cond = @start_stop_mutex.new_cond
+
+    # used to signal we've received the connected event
+    @connected_cond = @start_stop_mutex.new_cond
     
     @event_thread = nil
 
@@ -89,15 +97,21 @@ class CZookeeper
   def close
     return if closed?
 
-    shut_down!
-    stop_event_thread!
-
-    @start_stop_mutex.synchronize do
+    fn_close = proc do
       if !@_closed and @_data
+        logger.debug { "CALLING CLOSE HANDLE!!" }
         close_handle
       end
     end
 
+    if forked?
+      fn_close.call
+    else
+      shut_down!
+      stop_event_thread!
+      @start_stop_mutex.synchronize(&fn_close)
+    end
+
     nil
   end
 
@@ -114,12 +128,9 @@ class CZookeeper
   # if timeout is nil, we never time out, and wait forever for CONNECTED state
   #
   def wait_until_connected(timeout=10)
-    return false unless wait_until_running(timeout)
-
-    time_to_stop = timeout ? (Time.now + timeout) : nil
-
-    until connected? or (time_to_stop and Time.now > time_to_stop)
-      Thread.pass
+    @start_stop_mutex.synchronize do
+      wait_until_running(timeout)
+      @connected_cond.wait(timeout) unless connected?
     end
 
     connected?
@@ -156,7 +167,7 @@ class CZookeeper
 
       logger.debug { "event_thread running: #{@_running}" }
 
-      while true
+      until @_shutting_down
         begin
           _iterate_event_delivery
         rescue GotNilEventException
@@ -169,6 +180,12 @@ class CZookeeper
     def _iterate_event_delivery
       get_next_event(true).tap do |hash|
         raise GotNilEventException if hash.nil?
+
+        # TODO: should push notify_connected! down so that it's common to both java and C impl.
+        if hash.values_at(:req_id, :type, :state) == CONNECTED_EVENT_VALUES
+          notify_connected!
+        end
+
         @event_queue.push(hash)
       end
     end
@@ -212,5 +229,11 @@ class CZookeeper
         @running_cond.broadcast
       end
     end
+
+    def notify_connected!
+      @start_stop_mutex.synchronize do
+        @connected_cond.broadcast
+      end
+    end
 end
 end

data/ext/zookeeper_base.rb

@@ -8,12 +8,15 @@ require 'forwardable'
 module Zookeeper
 class ZookeeperBase
   extend Forwardable
+  include Zookeeper::Forked
   include Zookeeper::Common       # XXX: clean this up, no need to include *everything*
   include Zookeeper::Callbacks
   include Zookeeper::Constants
   include Zookeeper::Exceptions
   include Zookeeper::ACLs
 
+  attr_accessor :original_pid
+
   # @private
   class ClientShutdownException < StandardError; end
 
@@ -50,7 +53,8 @@ class ZookeeperBase
     end
   end
 
-  synchronized_delegation :@czk, :get_children, :exists, :delete, :get, :set, :set_acl, :get_acl, :client_id, :sync
+  synchronized_delegation :@czk, :get_children, :exists, :delete, :get, :set,
+    :set_acl, :get_acl, :client_id, :sync, :wait_until_connected
 
   # some state methods need to be more paranoid about locking to ensure the correct
   # state is returned
@@ -73,12 +77,10 @@ class ZookeeperBase
     if watcher and (watcher != @default_watcher)
       raise "You cannot set the watcher to a different value this way anymore!"
     end
-    
-    @mutex.synchronize do
-      # keep track of what process we were in to protect
-      # against reuse after fork()
-      @pid = Process.pid
 
+    reopen_after_fork! if forked?
+
+    @mutex.synchronize do
       # flushes all outstanding watcher reqs.
       @watcher_reqs.clear
       set_default_global_watcher
@@ -98,11 +100,13 @@ class ZookeeperBase
     @watcher_reqs = {}
     @completion_reqs = {}
 
-    @mutex = Monitor.new
-    @dispatch_shutdown_cond = @mutex.new_cond
+    update_pid!  # from Forked
 
     @current_req_id = 0
-    @event_queue = QueueWithPipe.new
+
+    # set up state that also needs to be re-setup after a fork()
+    reopen_after_fork!
+    
     @czk = nil
     
     # approximate the java behavior of raising java.lang.IllegalArgumentException if the host
@@ -117,13 +121,13 @@ class ZookeeperBase
 
     reopen(timeout)
   end
- 
+
   # if either of these happen, the user will need to renegotiate a connection via reopen
   def assert_open
     @mutex.synchronize do
       raise Exceptions::SessionExpired if state == ZOO_EXPIRED_SESSION_STATE
       raise Exceptions::NotConnected   unless connected?
-      unless Process.pid == @pid
+      if forked?
         raise InheritedConnectionError, <<-EOS.gsub(/(?:^|\n)\s*/, ' ').strip
           You tried to use a connection inherited from another process [#{@pid}]
           You need to call reopen() after forking
@@ -132,6 +136,15 @@ class ZookeeperBase
     end
   end
 
+  # do not lock, do not mutex, just close the underlying handle this is
+  # potentially dangerous and should only be called after a fork() to close
+  # this instance
+  def close!
+    @czk && @czk.close
+  end
+
+  # close the connection normally, stops the dispatch thread and closes the
+  # underlying connection cleanly
   def close
     shutdown_thread = Thread.new do
       @mutex.synchronize do
@@ -189,6 +202,24 @@ class ZookeeperBase
   end
  
 protected
+  # this method may be called in either the fork case, or from the constructor
+  # to set up this state initially (so all of this is in one location). we rely
+  # on the forked? method to determine which it is
+  def reopen_after_fork!
+    logger.debug { "#{self.class}##{__method__}" }
+    @mutex = Monitor.new
+    @dispatch_shutdown_cond = @mutex.new_cond
+    @event_queue = QueueWithPipe.new
+
+    if @dispatcher and not @dispatcher.alive?
+      logger.debug { "#{self.class}##{__method__} re-starting dispatch thread" }
+      @dispatcher = nil
+      setup_dispatch_thread!
+    end
+
+    update_pid!
+  end
+
   # this is a hack: to provide consistency between the C and Java drivers when
   # using a chrooted connection, we wrap the callback in a block that will
   # strip the chroot path from the returned path (important in an async create

data/ext/zookeeper_c.c

@@ -38,6 +38,7 @@ struct zkrb_instance_data {
   clientid_t          myid;
   zkrb_queue_t      *queue;
   long              object_id; // the ruby object this instance data is associated with
+  pid_t             orig_pid;
 };
 
 typedef enum {
@@ -159,7 +160,6 @@ static VALUE method_zkrb_init(int argc, VALUE* argv, VALUE self) {
     zoo_set_debug_level((int)log_level);
   }
 
-
   VALUE data;
   struct zkrb_instance_data *zk_local_ctx;
   data = Data_Make_Struct(CZookeeper, struct zkrb_instance_data, 0, free_zkrb_instance_data, zk_local_ctx);
@@ -189,6 +189,8 @@ static VALUE method_zkrb_init(int argc, VALUE* argv, VALUE self) {
     rb_raise(rb_eRuntimeError, "error connecting to zookeeper: %d", errno);
   }
 
+  zk_local_ctx->orig_pid = getpid();
+
   rb_iv_set(self, "@_data", data);
   rb_funcall(self, rb_intern("zkc_set_running_and_notify!"), 0);
 

data/ext/zookeeper_lib.c

@@ -44,25 +44,31 @@ pthread_mutex_t zkrb_q_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 
 void zkrb_enqueue(zkrb_queue_t *q, zkrb_event_t *elt) {
-  GLOBAL_MUTEX_LOCK("zkrb_enqueue");
+  if (q == NULL) {
+    zkrb_debug("zkrb_enqueue, queue ptr was NULL");
+    return;
+  }
+
+  if (q->tail == NULL) {
+    zkrb_debug("zkrb_enqeue, q->tail was NULL");
+    return;
+  }
 
-  check_debug(q != NULL && q->tail != NULL,  "zkrb_enqueue: queue ptr or tail was NULL\n");
+  pthread_mutex_lock(&q->mutex);
 
   q->tail->event = elt;
   q->tail->next = (zkrb_event_ll_t *) malloc(sizeof(zkrb_event_ll_t));
   q->tail = q->tail->next;
   q->tail->event = NULL;
   q->tail->next = NULL;
-  ssize_t ret = write(q->pipe_write, "0", 1);   /* Wake up Ruby listener */
 
-  // XXX(slyphon): can't raise a ruby exception here as we may not be calling
-  // this from a ruby thread. Calling into the interpreter from a non-ruby
-  // thread is bad, mm'kay?
+  ssize_t ret = write(q->pipe_write, "0", 1);   /* Wake up Ruby listener */
 
-  check(ret != -1, "write to queue (%p) pipe failed!\n", q);
+  pthread_mutex_unlock(&q->mutex);
 
-error:
-  GLOBAL_MUTEX_UNLOCK("zkrb_enqueue");
+  if (ret < 0) {
+    log_err("write to queue (%p) pipe failed!\n", q);
+  }
 }
 
 // NOTE: the zkrb_event_t* returned *is* the same pointer that's part of the
@@ -73,13 +79,16 @@ error:
 zkrb_event_t * zkrb_peek(zkrb_queue_t *q) {
   zkrb_event_t *event = NULL;
 
-  GLOBAL_MUTEX_LOCK("zkrb_peek");
+  if (!q) return NULL;
+
+  pthread_mutex_lock(&q->mutex);
 
   if (q != NULL && q->head != NULL && q->head->event != NULL) {
     event = q->head->event;
   }
 
-  GLOBAL_MUTEX_UNLOCK("zkrb_peek");
+  pthread_mutex_unlock(&q->mutex);
+
   return event;
 }
 
@@ -90,7 +99,7 @@ zkrb_event_t* zkrb_dequeue(zkrb_queue_t *q, int need_lock) {
   zkrb_event_ll_t *old_root = NULL;
     
   if (need_lock)
-    GLOBAL_MUTEX_LOCK("zkrb_dequeue");
+    pthread_mutex_lock(&q->mutex);
 
   if (!ZKRB_QUEUE_EMPTY(q)) {
     old_root = q->head;
@@ -99,19 +108,21 @@ zkrb_event_t* zkrb_dequeue(zkrb_queue_t *q, int need_lock) {
   }
 
   if (need_lock)
-    GLOBAL_MUTEX_UNLOCK("zkrb_dequeue");
+    pthread_mutex_unlock(&q->mutex);
 
   free(old_root);
   return rv;
 }
 
 void zkrb_signal(zkrb_queue_t *q) {
-  GLOBAL_MUTEX_LOCK("zkrb_signal");
+  if (!q) return;
+
+  pthread_mutex_lock(&q->mutex);
 
   if (!write(q->pipe_write, "0", 1))      /* Wake up Ruby listener */
     log_err("zkrb_signal: write to pipe failed, could not wake");
 
-  GLOBAL_MUTEX_UNLOCK("zkrb_signal");
+  pthread_mutex_unlock(&q->mutex);
 }
 
 zkrb_event_ll_t *zkrb_event_ll_t_alloc(void) {
@@ -126,10 +137,6 @@ zkrb_event_ll_t *zkrb_event_ll_t_alloc(void) {
 }
 
 zkrb_queue_t *zkrb_queue_alloc(void) {
-  // some of the locking is a little coarse, but it 
-  // eases the logic of releasing in case of error.
-  GLOBAL_MUTEX_LOCK("zkrb_queue_alloc"); 
-
   int pfd[2];
   zkrb_queue_t *rq = NULL;
  
@@ -138,6 +145,10 @@ zkrb_queue_t *zkrb_queue_alloc(void) {
   rq = malloc(sizeof(zkrb_queue_t));
   check_mem(rq);
 
+  rq->orig_pid = getpid();
+
+  check(pthread_mutex_init(&rq->mutex, NULL) == 0, "pthread_mutex_init failed");
+
   rq->head = zkrb_event_ll_t_alloc();
   check_mem(rq->head);
 
@@ -145,30 +156,28 @@ zkrb_queue_t *zkrb_queue_alloc(void) {
   rq->pipe_read = pfd[0];
   rq->pipe_write = pfd[1];
 
-  GLOBAL_MUTEX_UNLOCK("zkrb_queue_alloc");
   return rq;
 
 error:
-  GLOBAL_MUTEX_UNLOCK("zkrb_queue_alloc");
   free(rq);
   return NULL;
 }
 
 void zkrb_queue_free(zkrb_queue_t *queue) {
-  GLOBAL_MUTEX_LOCK("zkrb_queue_free");
-  check_debug(queue != NULL, "zkrb_queue_free: queue was NULL");
+  if (!queue) return;
 
   zkrb_event_t *elt;
   while ((elt = zkrb_dequeue(queue, 0)) != NULL) {
     zkrb_event_free(elt);
   }
+
   free(queue->head);
   close(queue->pipe_read);
   close(queue->pipe_write);
-  free(queue);
 
-error:
-  GLOBAL_MUTEX_UNLOCK("zkrb_queue_free");
+  pthread_mutex_destroy(&queue->mutex);
+
+  free(queue);
 }
 
 zkrb_event_t *zkrb_event_alloc(void) {

data/ext/zookeeper_lib.h

@@ -6,6 +6,7 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 
 #define ZK_TRUE 1
 #define ZK_FALSE 0
@@ -103,8 +104,10 @@ typedef struct zkrb_event_ll zkrb_event_ll_t;
 typedef struct {
   zkrb_event_ll_t *head;
   zkrb_event_ll_t *tail;
-  int                     pipe_read;
-  int                     pipe_write;
+  int             pipe_read;
+  int             pipe_write;
+  pthread_mutex_t mutex;
+  pid_t           orig_pid;
 } zkrb_queue_t;
 
 zkrb_queue_t * zkrb_queue_alloc(void);

data/java/java_base.rb

@@ -61,7 +61,8 @@ class JavaBase
   end
 
   # used for internal dispatching
-  module JavaCB #:nodoc:
+  # @private
+  module JavaCB
     class Callback
       attr_reader :req_id
 
@@ -156,14 +157,25 @@ class JavaBase
 
     class WatcherCallback < Callback
       include JZK::Watcher
+      include Zookeeper::Constants
 
-      def initialize(event_queue)
+      attr_reader :client
+
+      def initialize(event_queue, opts={})
         @event_queue = event_queue
-        super(Zookeeper::Constants::ZKRB_GLOBAL_CB_REQ)
+        @client = opts[:client]
+        super(ZKRB_GLOBAL_CB_REQ)
       end
 
       def process(event)
-        logger.debug { "WatcherCallback got event: #{event.to_hash.inspect}" }
+        hash = event.to_hash
+        logger.debug { "WatcherCallback got event: #{hash.inspect}" }
+
+        if client && (hash[:type] == ZOO_SESSION_EVENT) && (hash[:state] == ZOO_CONNECTED_STATE)
+          logger.debug { "#{self.class}##{__method__} notifying client of connected state!" }
+          client.notify_connected! 
+        end
+        
         hash = event.to_hash.merge(:req_id => req_id)
         @event_queue.push(hash)
       end
@@ -188,12 +200,7 @@ class JavaBase
   end
 
   def wait_until_connected(timeout=10)
-    time_to_stop = timeout ? (Time.now + timeout) : nil
-
-    until connected? or (time_to_stop and Time.now > time_to_stop)
-      Thread.pass
-    end
-
+    @connected_latch.await(timeout) unless connected?
     connected?
   end
 
@@ -204,6 +211,7 @@ class JavaBase
 
     @mutex = Monitor.new
     @dispatch_shutdown_cond = @mutex.new_cond
+    @connected_latch = Latch.new
 
     @watcher_reqs = {}
     @completion_reqs = {}
@@ -407,6 +415,8 @@ class JavaBase
   # 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
+  #
+  # XXX: this is probably a relic?
   def set_default_global_watcher
     @mutex.synchronize do
       @watcher_reqs[ZKRB_GLOBAL_CB_REQ] = { :watcher => @default_watcher, :watcher_context => nil }
@@ -421,6 +431,12 @@ class JavaBase
     jzk.session_passwd.to_s
   end
 
+  # called from watcher when we are connected
+  # @private
+  def notify_connected!
+    @connected_latch.release
+  end
+
   protected
     def jzk
       @mutex.synchronize { @jzk }
@@ -443,22 +459,15 @@ class JavaBase
     def create_watcher(req_id, path)
       logger.debug { "creating watcher for req_id: #{req_id} path: #{path}" }
       lambda do |event|
+        ev_type, ev_state = event.type.int_value, event.state.int_value
+
         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
 
-    # 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.1
+        h = { :req_id => req_id, :type => ev_type, :state => ev_state, :path => path }
+        event_queue.push(h)
       end
     end
 
-    # TODO: Make all global puts configurable
     def get_default_global_watcher
       Proc.new { |args|
         logger.debug { "Ruby ZK Global CB called type=#{event_by_value(args[:type])} state=#{state_by_value(args[:state])}" }
@@ -469,7 +478,7 @@ class JavaBase
   private
     def replace_jzk!
       orig_jzk = @jzk
-      @jzk = JZK::ZooKeeper.new(@host, DEFAULT_SESSION_TIMEOUT, JavaCB::WatcherCallback.new(event_queue))
+      @jzk = JZK::ZooKeeper.new(@host, DEFAULT_SESSION_TIMEOUT, JavaCB::WatcherCallback.new(event_queue, :client => self))
     ensure
       orig_jzk.close if orig_jzk
     end

data/lib/zookeeper.rb

@@ -11,6 +11,8 @@ module Zookeeper
   # establishes the namespace
 end
 
+require_relative 'zookeeper/forked'
+require_relative 'zookeeper/latch'
 require_relative 'zookeeper/acls'
 require_relative 'zookeeper/constants'
 require_relative 'zookeeper/exceptions'
@@ -27,7 +29,7 @@ module Zookeeper
   include Constants
 
   unless defined?(@@logger)
-    @@logger = Logger.new($stderr).tap { |l| l.level = Logger::ERROR } 
+    @@logger = Logger.new($stderr).tap { |l| l.level = ENV['ZOOKEEPER_DEBUG'] ? Logger::DEBUG : Logger::ERROR } 
   end
 
   def self.logger
@@ -83,3 +85,7 @@ end
 # just for first test, get rid of this soon
 require_relative 'zookeeper/compatibility'
 
+if ENV['ZKRB_DEBUG']
+  Zookeeper.debug_level = Zookeeper::Constants::ZOO_LOG_LEVEL_DEBUG
+end
+

data/lib/zookeeper/common.rb

@@ -31,8 +31,12 @@ protected
   end
 
   def setup_watcher(req_id, call_opts)
-    @watcher_reqs[req_id] = { :watcher => call_opts[:watcher],
-                              :context => call_opts[:watcher_context] }
+    @mutex.synchronize do
+      @watcher_reqs[req_id] = { 
+        :watcher => call_opts[:watcher],
+        :context => call_opts[:watcher_context] 
+      }
+    end
   end
 
   # as a hack, to provide consistency between the java implementation and the C
@@ -42,8 +46,12 @@ protected
   # we don't use meth_name here, but we need it in the C implementation
   #
   def setup_completion(req_id, meth_name, call_opts)
-    @completion_reqs[req_id] = { :callback => call_opts[:callback],
-                                :context => call_opts[:callback_context] }
+    @mutex.synchronize do
+      @completion_reqs[req_id] = { 
+        :callback => call_opts[:callback],
+        :context => call_opts[:callback_context]
+      }
+    end
   end
   
   def get_watcher(req_id)
@@ -57,19 +65,27 @@ protected
   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")
+    @mutex.synchronize do
+      if @dispatcher
+        logger.debug { "dispatcher already running" }
+        return
+      end
+
+      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
-      signal_dispatch_thread_exit!
     end
   end
   
@@ -93,13 +109,11 @@ protected
         # we now release the mutex so that dispatch_next_callback can grab it
         # to do what it needs to do while delivering events
         #
-        # wait for a maximum of 2 sec for dispatcher to signal exit (should be
-        # fast)
-        @dispatch_shutdown_cond.wait(2)
+        @dispatch_shutdown_cond.wait
 
         # wait for another 2 sec for the thread to join
-        unless @dispatcher.join(2)
-          logger.error { "Dispatch thread did not join cleanly, continuing" }
+        until @dispatcher.join(2)
+          logger.error { "Dispatch thread did not join cleanly, waiting" }
         end
         @dispatcher = nil
       end

data/lib/zookeeper/compatibility.rb

@@ -28,7 +28,8 @@ module Zookeeper
   end
 end
 
-Zookeeper.warn_about_compatability_once!
+# at request of @eric
+#Zookeeper.warn_about_compatability_once!
 
 module Zookeeper
   module Compatibility

data/lib/zookeeper/constants.rb

@@ -58,6 +58,11 @@ module Constants
 
   ZKRB_GLOBAL_CB_REQ = -1
 
+  # @private
+  CONNECTED_EVENT_VALUES = [Constants::ZKRB_GLOBAL_CB_REQ, 
+                            Constants::ZOO_SESSION_EVENT, 
+                            Constants::ZOO_CONNECTED_STATE].freeze
+
   # used to find the name for a numeric event
   # @private
   EVENT_TYPE_NAMES = {

data/lib/zookeeper/forked.rb

@@ -0,0 +1,19 @@
+module Zookeeper
+  module Forked
+    # the includer provides an 'original_pid' method, which is set
+    # when the original 'owning' process creates the object. 
+    #
+    # @return [true] if the current PID differs from the original_pid value
+    # @return [false] if the current PID matches the original_pid value
+    #
+    def forked?
+      Process.pid != original_pid
+    end
+
+    # sets the `original_pid` to the current value
+    def update_pid!
+      self.original_pid = Process.pid
+    end
+  end
+end
+

data/lib/zookeeper/latch.rb

@@ -0,0 +1,34 @@
+module Zookeeper
+  # a cross-thread gate of sorts.
+  class Latch
+    def initialize(count = 1)
+      @count = count
+      @mutex = Monitor.new
+      @cond = @mutex.new_cond
+    end
+
+    def release
+      @mutex.synchronize {
+        @count -= 1 if @count > 0
+        @cond.broadcast if @count.zero?
+      }
+    end
+
+    def await(timeout=nil)
+      @mutex.synchronize do
+        if timeout
+          time_to_stop = Time.now + timeout
+
+          while @count > 0
+            @cond.wait(timeout)
+            
+            break if (Time.now > time_to_stop)
+          end
+        else
+          @cond.wait_while { @count > 0 }
+        end
+      end
+    end
+  end
+end
+

data/lib/zookeeper/version.rb

@@ -1,4 +1,4 @@
 module Zookeeper
-  VERSION = '1.0.0.beta.1'
+  VERSION = '1.0.0'
   DRIVER_VERSION = '3.3.5'
 end

data/spec/default_watcher_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path('../spec_helper', __FILE__) 
+require 'spec_helper'
 
 describe Zookeeper do
   describe :initialize, 'with watcher block' do

data/spec/forked_connection_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+unless defined?(::JRUBY_VERSION)
+  describe %[forked connection] do
+    let(:path) { "/_zktest_" }
+    let(:pids_root) { "#{path}/pids" }
+    let(:data) { "underpants" } 
+    let(:connection_string) { Zookeeper.default_cnx_str }
+
+    def process_alive?(pid)
+      Process.kill(0, @pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    before do
+      if defined?(::Rubinius)
+        pending("this test is currently broken in rbx")
+      elsif ENV['TRAVIS']
+        pending("this test is currently hanging in travis")
+      else
+        @zk = Zookeeper.new(connection_string)
+        rm_rf(@zk, path)
+      end
+    end
+
+    after do
+      if @pid and process_alive?(@pid)
+        Process.kill('TERM', @pid)
+        p Process.wait2(@pid)
+      end
+
+      @zk.close if @zk and !@zk.closed?
+      with_open_zk(connection_string) { |z| rm_rf(z, path) }
+    end
+
+    it %[should do the right thing and not fail] do
+      @zk.wait_until_connected
+
+      mkdir_p(@zk, pids_root)
+
+      # the parent's pid path
+      @zk.create(:path => "#{pids_root}/#{$$}", :data => $$.to_s)
+
+      @latch = Zookeeper::Latch.new
+      @event = nil
+
+      cb = proc do |h|
+        logger.debug { "watcher called back: #{h.inspect}" }
+        @event = h
+        @latch.release
+      end
+
+      @zk.stat(:path => "#{pids_root}/child", :watcher => cb)
+
+      @pid = fork do
+        logger.debug { "reopening connection in child: #{$$}" }
+        @zk.reopen
+        logger.debug { "creating path" }
+        rv = @zk.create(:path => "#{pids_root}/child", :data => $$.to_s)
+        logger.debug { "created path #{rv}" }
+        @zk.close
+
+        logger.debug { "close finished" }
+        exit!(0)
+      end
+
+      logger.debug { "waiting on child #{@pid}" }
+
+      @latch.await until @event 
+      p @event
+
+      _, status = Process.wait2(@pid)
+
+      status.should be_success
+    end
+  end
+end
+

data/spec/latch_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+# this is a simple sanity check of my timeout addition
+
+describe Zookeeper::Latch do
+  subject { described_class.new }
+
+  describe %[await] do
+    describe %[with timeout] do
+      it %[should return after waiting until timeout if not released] do
+        other_latch = described_class.new
+
+        th = Thread.new do
+          subject.await(0.01)
+          other_latch.release
+        end
+
+        other_latch.await
+        th.join(1).should == th
+      end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -32,8 +32,8 @@ end
 
 RSpec.configure do |config|
   config.mock_with :rspec
-  config.include ZookeeperSpecHeleprs
-  config.extend ZookeeperSpecHeleprs
+  config.include Zookeeper::SpecHeleprs
+  config.extend Zookeeper::SpecHeleprs
 
   if Zookeeper.spawn_zookeeper?
     require 'zk-server'

data/spec/support/zookeeper_spec_helpers.rb

@@ -1,84 +1,99 @@
-module ZookeeperSpecHeleprs
-  class TimeoutError < StandardError; end
+module Zookeeper
+  module SpecHeleprs
+    class TimeoutError < StandardError; end
+    include Zookeeper::Constants
 
-  def logger
-    Zookeeper.logger
-  end
+    def logger
+      Zookeeper.logger
+    end
 
-  def ensure_node(zk, path, data)
-    return if zk.closed?
-    if zk.stat(:path => path)[:stat].exists?
-      zk.set(:path => path, :data => data)
-    else
-      zk.create(:path => path, :data => data)
+    def ensure_node(zk, path, data)
+      return if zk.closed?
+      if zk.stat(:path => path)[:stat].exists?
+        zk.set(:path => path, :data => data)
+      else
+        zk.create(:path => path, :data => data)
+      end
     end
-  end
 
-  def with_open_zk(host=nil)
-    z = Zookeeper.new(Zookeeper.default_cnx_str)
-    yield z
-  ensure
-    if z
-      unless z.closed?
-        z.close
+    def with_open_zk(host=nil)
+      z = Zookeeper.new(Zookeeper.default_cnx_str)
+      yield z
+    ensure
+      if z
+        unless z.closed?
+          z.close
 
-        wait_until do 
-          begin
-            !z.connected?
-          rescue RuntimeError
-            true
+          wait_until do 
+            begin
+              !z.connected?
+            rescue RuntimeError
+              true
+            end
           end
         end
       end
     end
-  end
 
-  # this is not as safe as the one in ZK, just to be used to clean up
-  # when we're the only one adjusting a particular path
-  def rm_rf(z, path)
-    z.get_children(:path => path).tap do |h|
-      if h[:rc].zero?
-        h[:children].each do |child|
-          rm_rf(z, File.join(path, child))
+    # this is not as safe as the one in ZK, just to be used to clean up
+    # when we're the only one adjusting a particular path
+    def rm_rf(z, path)
+      z.get_children(:path => path).tap do |h|
+        if h[:rc].zero?
+          h[:children].each do |child|
+            rm_rf(z, File.join(path, child))
+          end
+        elsif h[:rc] == ZNONODE
+          # no-op
+        else
+          raise "Oh noes! unexpected return value! #{h.inspect}"
         end
-      elsif h[:rc] == Zookeeper::Exceptions::ZNONODE
-        # no-op
-      else
-        raise "Oh noes! unexpected return value! #{h.inspect}"
       end
-    end
 
-    rv = z.delete(:path => path)
+      rv = z.delete(:path => path)
 
-    unless (rv[:rc].zero? or rv[:rc] == Zookeeper::Exceptions::ZNONODE)
-      raise "oh noes! failed to delete #{path}" 
-    end
+      unless (rv[:rc].zero? or rv[:rc] == ZNONODE)
+        raise "oh noes! failed to delete #{path}" 
+      end
 
-    path
-  end
+      path
+    end
 
+    def mkdir_p(zk, path)
+      while true # loop because we can't retry
+        h = zk.create(:path => path, :data => '')
+        case h[:rc]
+        when ZOK, ZNODEEXISTS
+          return
+        when ZNONODE
+          parent = File.dirname(path)
+          raise "WTF? we wound up trying to create '/', something is screwed!" if parent == '/'
+          mkdir_p(zk, parent)
+        end
+      end
+    end
 
-  # method to wait until block passed returns true or timeout (default is 10 seconds) is reached 
-  # raises TiemoutError on timeout
-  def wait_until(timeout=10)
-    time_to_stop = Time.now + timeout
-    while true
-      rval = yield
-      return rval if rval
-      raise TimeoutError, "timeout of #{timeout}s exceeded" if Time.now > time_to_stop
-      Thread.pass
+    # method to wait until block passed returns true or timeout (default is 10 seconds) is reached 
+    # raises TiemoutError on timeout
+    def wait_until(timeout=10)
+      time_to_stop = Time.now + timeout
+      while true
+        rval = yield
+        return rval if rval
+        raise TimeoutError, "timeout of #{timeout}s exceeded" if Time.now > time_to_stop
+        Thread.pass
+      end
     end
-  end
 
-  # inverse of wait_until
-  def wait_while(timeout=10)
-    time_to_stop = Time.now + timeout
-    while true
-      rval = yield
-      return rval unless rval
-      raise TimeoutError, "timeout of #{timeout}s exceeded" if Time.now > time_to_stop
-      Thread.pass
+    # inverse of wait_until
+    def wait_while(timeout=10)
+      time_to_stop = Time.now + timeout
+      while true
+        rval = yield
+        return rval unless rval
+        raise TimeoutError, "timeout of #{timeout}s exceeded" if Time.now > time_to_stop
+        Thread.pass
+      end
     end
   end
 end
-

metadata

@@ -1,15 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zookeeper
 version: !ruby/object:Gem::Version 
-  hash: 1547489243
-  prerelease: 6
+  hash: 23
+  prerelease: 
   segments: 
   - 1
   - 0
   - 0
-  - beta
-  - 1
-  version: 1.0.0.beta.1
+  version: 1.0.0
 platform: java
 authors: 
 - Phillip Pearson
@@ -22,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-07 00:00:00 Z
+date: 2012-05-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: backports
@@ -126,6 +124,8 @@ files:
 - lib/zookeeper/constants.rb
 - lib/zookeeper/em_client.rb
 - lib/zookeeper/exceptions.rb
+- lib/zookeeper/forked.rb
+- lib/zookeeper/latch.rb
 - lib/zookeeper/rake_tasks.rb
 - lib/zookeeper/stat.rb
 - lib/zookeeper/version.rb
@@ -135,6 +135,8 @@ files:
 - spec/chrooted_connection_spec.rb
 - spec/default_watcher_spec.rb
 - spec/em_spec.rb
+- spec/forked_connection_spec.rb
+- spec/latch_spec.rb
 - spec/log4j.properties
 - spec/shared/all_success_return_values.rb
 - spec/shared/connection_examples.rb
@@ -165,14 +167,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version 
-      hash: 25
+      hash: 3
       segments: 
-      - 1
-      - 3
-      - 1
-      version: 1.3.1
+      - 0
+      version: "0"
 requirements: []
 
 rubyforge_project: 
@@ -185,6 +185,8 @@ test_files:
 - spec/chrooted_connection_spec.rb
 - spec/default_watcher_spec.rb
 - spec/em_spec.rb
+- spec/forked_connection_spec.rb
+- spec/latch_spec.rb
 - spec/log4j.properties
 - spec/shared/all_success_return_values.rb
 - spec/shared/connection_examples.rb