zookeeper 1.1.3 → 1.2.0

data/CHANGELOG

@@ -1,4 +1,13 @@
-v1.1.2 backport change from 1.2.1: make assert_open more sane
+v1.2.0 Stop the World, I Wanna fork()
+
+  * changed pause/resume methods to pause_before_fork_in_parent
+    and resume_after_fork_in_parent to match their ZK counterparts
+
+  * replaced the Queue in QueueWithPipe (really have to change that name)
+    with an Array and Mutex/ConditionVariable pair. This allows us to 
+    have better control over the shutdown signaling, and lets us resume
+    operations after a pause.
+
 
 v1.1.1 Cleanup after code review (h/t @eric)
 

data/Guardfile

@@ -1,6 +1,8 @@
-guard 'rspec' do
+
+guard 'rspec', :version => 2, :cli => '-c -f progress --fail-fast' do
   watch(%r{^spec/.+_spec.rb$})
   watch(%r{^lib/(.+)\.rb$}) { |m| %w[spec/zookeeper_spec.rb spec/chrooted_connection_spec.rb] }
   watch(%r{^ext/zookeeper_c.bundle}) { %w[spec/c_zookeeper_spec.rb] }
+  watch(%r{^ext/zookeeper_base.rb}) { "spec" }
 end
 

data/ext/c_zookeeper.rb

@@ -139,13 +139,13 @@ class CZookeeper
   #
   # requests may still be added during this time, but they will not be
   # processed until you call resume
-  def pause
+  def pause_before_fork_in_parent
     logger.debug { "#{self.class}##{__method__}" }
     @mutex.synchronize { stop_event_thread }
   end
 
   # call this if 'pause' was previously called to start the event loop again
-  def resume
+  def resume_after_fork_in_parent
     logger.debug { "#{self.class}##{__method__}" }
 
     @mutex.synchronize do 
@@ -184,7 +184,7 @@ class CZookeeper
       @reg.lock 
       begin
         if meth == :state
-          @reg.pending.unshift(cnt)
+          @reg.state_check << cnt
         else
           @reg.pending << cnt
         end
@@ -228,7 +228,7 @@ class CZookeeper
         @running_cond.wait(timeout)
         !!@_running
       ensure
-        @mutex.unlock
+        @mutex.unlock rescue nil
       end
     end
 
@@ -314,7 +314,7 @@ class CZookeeper
 
         raise ShuttingDownException if @_shutting_down
       ensure
-        @mutex.unlock
+        @mutex.unlock rescue nil
       end
     end
 
@@ -334,7 +334,7 @@ class CZookeeper
         @_running = true
         @running_cond.broadcast
       ensure
-        @mutex.unlock
+        @mutex.unlock rescue nil
       end
     end
 
@@ -343,7 +343,7 @@ class CZookeeper
       begin
         @connected_cond.broadcast
       ensure
-        @mutex.unlock
+        @mutex.unlock rescue nil
       end
     end
 end

data/ext/zookeeper_base.rb

@@ -32,7 +32,7 @@ class ZookeeperBase
 
 
   def_delegators :@czk, :get_children, :exists, :delete, :get, :set,
-    :set_acl, :get_acl, :client_id, :sync, :wait_until_connected, :pause, :resume
+    :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
@@ -117,7 +117,8 @@ class ZookeeperBase
   # if either of these happen, the user will need to renegotiate a connection via reopen
   def assert_open
     @mutex.synchronize do
-      raise Exceptions::NotConnected if closed?
+      raise Exceptions::SessionExpired if state == ZOO_EXPIRED_SESSION_STATE
+      raise Exceptions::NotConnected   unless connected?
       if forked?
         raise InheritedConnectionError, <<-EOS.gsub(/(?:^|\n)\s*/, ' ').strip
           You tried to use a connection inherited from another process 
@@ -193,6 +194,29 @@ class ZookeeperBase
     @mutex.synchronize { !@czk or @czk.closed? } 
   end
 
+  def pause_before_fork_in_parent
+    @mutex.synchronize do
+      logger.debug { "ZookeeperBase#pause_before_fork_in_parent" }
+
+      # XXX: add anal-retentive state checking 
+      raise "EXPLODERATE! @czk was nil!" unless @czk
+
+      @czk.pause_before_fork_in_parent
+      stop_dispatch_thread!
+    end
+  end
+
+  def resume_after_fork_in_parent
+    @mutex.synchronize do
+      logger.debug { "ZookeeperBase#resume_after_fork_in_parent" }
+
+      raise "EXPLODERATE! @czk was nil!" unless @czk
+
+      event_queue.open
+      setup_dispatch_thread!
+      @czk.resume_after_fork_in_parent
+    end
+  end
 
 protected
   # this is a hack: to provide consistency between the C and Java drivers when

data/java/java_base.rb

@@ -435,6 +435,14 @@ class JavaBase
     @connected_latch.release
   end
 
+  def pause_before_fork_in_parent
+    # this is a no-op in java-land
+  end
+
+  def resume_after_fork_in_parent
+    # this is a no-op in java-land
+  end
+
   protected
     def jzk
       @mutex.synchronize { @jzk }

data/lib/zookeeper/client_methods.rb

@@ -192,6 +192,16 @@ module ClientMethods
     super
   end
 
+  # stop all underlying threads in preparation for a fork()
+  def pause_before_fork_in_parent
+    super
+  end
+
+  # re-start all underlying threads after performing a fork()
+  def resume_after_fork_in_parent
+    super
+  end
+
 protected
   # used during shutdown, awaken the event delivery thread if it's blocked
   # waiting for the next event

data/lib/zookeeper/common.rb

@@ -94,7 +94,7 @@ protected
   #
   # @dispatcher will be nil when this method exits
   #
-  def stop_dispatch_thread!
+  def stop_dispatch_thread!(timeout=2)
     logger.debug { "#{self.class}##{__method__}" }
 
     if @dispatcher
@@ -111,8 +111,8 @@ protected
         #
         @dispatch_shutdown_cond.wait
 
-        # wait for another 2 sec for the thread to join
-        until @dispatcher.join(2)
+        # wait for another timeout sec for the thread to join
+        until @dispatcher.join(timeout)
           logger.error { "Dispatch thread did not join cleanly, waiting" }
         end
         @dispatcher = nil

data/lib/zookeeper/common/queue_with_pipe.rb

@@ -5,8 +5,6 @@ module Common
     extend Forwardable
     include Logger
 
-    def_delegators :@queue, :clear
-    
     # raised when close has been called, and pop() is performed
     # 
     class ShutdownException < StandardError; end
@@ -15,57 +13,98 @@ module Common
     KILL_TOKEN = Object.new unless defined?(KILL_TOKEN)
 
     def initialize
-      @queue = Queue.new
+      @array = []
 
-      @mutex = Mutex.new
-      @closed = false
+      @mutex    = Mutex.new
+      @cond     = ConditionVariable.new
+      @closed   = false
       @graceful = false
     end
 
+    def clear
+      @mutex.lock
+      begin
+        @array.clear
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
     def push(obj)
-      logger.debug { "#{self.class}##{__method__} obj: #{obj.inspect}, kill_token? #{obj == KILL_TOKEN}" }
-      @queue.push(obj)
+      @mutex.lock
+      begin
+#         raise ShutdownException if (@closed or @graceful)
+        @array << obj
+        @cond.signal
+      ensure
+        @mutex.unlock rescue nil
+      end
     end
 
     def pop(non_blocking=false)
-      raise ShutdownException if closed?  # this may get us in trouble
+      rval = nil
 
-      rv = @queue.pop(non_blocking)
+      @mutex.lock
+      begin
 
-      if rv == KILL_TOKEN
-        close
-        raise ShutdownException
-      end
+        begin
+          raise ShutdownException if @closed  # this may get us in trouble
+
+          rval = @array.shift
+
+          unless rval
+            raise ThreadError if non_blocking     # sigh, ruby's stupid behavior
+            raise ShutdownException if @graceful  # we've processed all the remaining mesages
+
+            @cond.wait(@mutex) until (@closed or @graceful or (@array.length > 0))
+          end
+        end until rval
 
-      rv
+        return rval
+
+      ensure
+        @mutex.unlock rescue nil
+      end
     end
 
     # close the queue and causes ShutdownException to be raised on waiting threads
     def graceful_close!
-      @mutex.synchronize do
+      @mutex.lock
+      begin
         return if @graceful or @closed
         logger.debug { "#{self.class}##{__method__} gracefully closing" }
         @graceful = true
-        push(KILL_TOKEN)
+        @cond.broadcast
+      ensure
+        @mutex.unlock rescue nil
       end
       nil
     end
 
+    def open
+      @mutex.lock
+      begin
+        @closed = @graceful = false
+        @cond.broadcast
+      ensure
+        @mutex.unlock rescue nil
+      end
+    end
+
     def close
-      @mutex.synchronize do
+      @mutex.lock
+      begin
         return if @closed
         @closed = true
+        @cond.broadcast
+      ensure
+        @mutex.unlock rescue nil
       end
     end
 
     def closed?
       @mutex.synchronize { !!@closed }
     end
-
-    private
-      def clear_reads_on_pop?
-        @clear_reads_on_pop
-      end
   end
 end
 end

data/lib/zookeeper/continuation.rb

@@ -12,13 +12,13 @@ module Zookeeper
     # `state_check` are high-priority checks that query the connection about
     # its current state, they always run before other continuations
     #
-    class Registry < Struct.new(:pending, :in_flight)
+    class Registry < Struct.new(:pending, :state_check, :in_flight)
       extend Forwardable
 
       def_delegators :@mutex, :lock, :unlock
 
       def initialize
-        super([], {})
+        super([], [], {})
         @mutex = Mutex.new
       end
 
@@ -33,7 +33,7 @@ module Zookeeper
 
       # does not lock the mutex, returns true if there are pending jobs
       def anything_to_do?
-        !pending.empty?
+        (pending.length + state_check.length) > 0
       end
 
       # returns the pending continuations, resetting the list
@@ -41,7 +41,7 @@ module Zookeeper
       def next_batch()
         @mutex.lock
         begin
-          pending.slice!(0,pending.length)
+          state_check.slice!(0, state_check.length) + pending.slice!(0,pending.length)
         ensure
           @mutex.unlock rescue nil
         end
@@ -82,9 +82,6 @@ module Zookeeper
       @mutex  = Mutex.new
       @cond   = ConditionVariable.new
       @rval   = nil
-
-      # make this error reporting more robust if necessary, right now, just set to state
-      @error  = nil
       
       # set to true when an event occurs that would cause the caller to
       # otherwise block forever
@@ -93,17 +90,9 @@ module Zookeeper
 
     # the caller calls this method and receives the response from the async loop
     def value
-      @mutex.synchronize do
-        @cond.wait(@mutex) until @rval or @error
-
-        case @error
-        when nil
-          # ok, nothing to see here, carry on
-        when ZOO_EXPIRED_SESSION_STATE
-          raise Exceptions::SessionExpired, "connection has expired"
-        else
-          raise Exceptions::NotConnected, "connection state is #{STATE_NAMES[@error]}"
-        end
+      @mutex.lock
+      begin
+        @cond.wait(@mutex) until @rval
 
         case @rval.length
         when 1
@@ -111,6 +100,8 @@ module Zookeeper
         else
           return @rval
         end
+      ensure
+        @mutex.unlock rescue nil
       end
     end
 
@@ -133,24 +124,13 @@ module Zookeeper
     # implementation, but it's more important to get *something* working and
     # passing specs, then refactor to make everything sane
     # 
-    #
     def submit(czk)
-      state = czk.zkrb_state    # check the state of the connection
-
-      if @meth == :state        # if the method is a state call
-        @rval = [state]         # we're done, no error
-        return deliver!
-
-      elsif state != ZOO_CONNECTED_STATE  # otherwise, we must be connected
-        @error = state                    # so set the error
-        return deliver!                   # and we're out
-      end
-
       rc, *_ = czk.__send__(:"zkrb_#{@meth}", *async_args)
       
-      if user_callback? or (rc != ZOK)  # async call, or we failed to submit it
-        @rval = [rc]                    # create the repsonse
-        deliver!                        # wake the caller and we're out
+      # if this is an state call, async call, or we failed to submit it
+      if (@meth == :state) or user_callback? or (rc != ZOK)
+        @rval = [rc]           # create the repsonse
+        deliver!               # wake the caller and we're out
       end
     end
 
@@ -172,6 +152,9 @@ module Zookeeper
 
         logger.debug { "async_args, meth: #{meth} ary: #{ary.inspect}, #{callback_arg_idx}" }
 
+        # this is not already an async call
+        # so we replace the req_id with the ZKRB_ASYNC_CONTN_ID so the 
+        # event thread knows to dispatch it itself
         ary[callback_arg_idx] ||= self
 
         ary
@@ -182,8 +165,11 @@ module Zookeeper
       end
 
       def deliver!
-        @mutex.synchronize do
+        @mutex.lock
+        begin
           @cond.signal
+        ensure
+          @mutex.unlock rescue nil
         end
       end
   end # Base

data/lib/zookeeper/version.rb

@@ -1,4 +1,4 @@
 module Zookeeper
-  VERSION = '1.1.3'
+  VERSION = '1.2.0'
   DRIVER_VERSION = '3.3.5'
 end

data/spec/forked_connection_spec.rb

@@ -14,8 +14,15 @@ unless defined?(::JRUBY_VERSION)
       false
     end
 
-    before do
+    LBORDER = ('-' * 35) << '< '
+    RBORDER = ' >' << ('-' * 35) 
+
+    def mark(thing)
+      logger << "\n#{LBORDER}#{thing}#{RBORDER}\n\n"
+    end
 
+    before do
+      mark "BEFORE: START"
       if defined?(::Rubinius)
         pending("this test is currently broken in rbx")
 #       elsif ENV['TRAVIS']
@@ -24,11 +31,12 @@ unless defined?(::JRUBY_VERSION)
         @zk = Zookeeper.new(connection_string)
         rm_rf(@zk, path)
       end
-      logger.debug { "----------------< BEFORE: END >-------------------" }
+      mark "BEFORE: END"
     end
 
     after do
-      logger.debug { "----------------< AFTER: BEGIN >-------------------" }
+      mark "AFTER: START"
+
       if @pid and process_alive?(@pid)
         begin
           Process.kill('KILL', @pid)
@@ -39,6 +47,8 @@ unless defined?(::JRUBY_VERSION)
 
       @zk.close if @zk and !@zk.closed?
       with_open_zk(connection_string) { |z| rm_rf(z, path) }
+
+      mark "AFTER: END"
     end
 
     def wait_for_child_safely(pid, timeout=5)
@@ -56,7 +66,8 @@ unless defined?(::JRUBY_VERSION)
     end
 
     it %[should do the right thing and not fail] do
-      logger.debug { "----------------< TEST: BEGIN >-------------------" }
+      mark "TEST: START"
+
       @zk.wait_until_connected
 
       mkdir_p(@zk, pids_root)
@@ -75,9 +86,9 @@ unless defined?(::JRUBY_VERSION)
 
       @zk.stat(:path => "#{pids_root}/child", :watcher => cb)
 
-      logger.debug { "------------------->   FORK   <---------------------------" }
+      @zk.pause_before_fork_in_parent
 
-      @zk.pause
+      mark "FORK"
 
       @pid = fork do
         logger.debug { "reopening connection in child: #{$$}" }
@@ -91,7 +102,7 @@ unless defined?(::JRUBY_VERSION)
         exit!(0)
       end
 
-      @zk.resume
+      @zk.resume_after_fork_in_parent
 
       event_waiter_th = Thread.new do
         @latch.await(5) unless @event 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zookeeper
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 31
   prerelease: 
   segments: 
   - 1
-  - 1
-  - 3
-  version: 1.1.3
+  - 2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Phillip Pearson
@@ -20,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-21 00:00:00 Z
+date: 2012-05-18 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: backports