slyphon-zookeeper 0.3.0 → 0.8.0.rc.1

data/Rakefile

@@ -15,10 +15,15 @@ gemset_name = 'zookeeper'
 %w[1.8.7 1.9.2 1.9.3 jruby].each do |rvm_ruby|
   ruby_with_gemset = "#{rvm_ruby}@#{gemset_name}"
 
-  clobber_task_name = "mb:#{rvm_ruby}:clobber"
-  build_task_name   = "mb:#{rvm_ruby}:build"
-  bundle_task_name  = "mb:#{rvm_ruby}:bundle_install"
-  rspec_task_name   = "mb:#{rvm_ruby}:run_rspec"
+  create_gemset_name  = "mb:#{rvm_ruby}:create_gemset"
+  clobber_task_name   = "mb:#{rvm_ruby}:clobber"
+  build_task_name     = "mb:#{rvm_ruby}:build"
+  bundle_task_name    = "mb:#{rvm_ruby}:bundle_install"
+  rspec_task_name     = "mb:#{rvm_ruby}:run_rspec"
+
+  task create_gemset_name do
+    sh "rvm #{rvm_ruby} do rvm gemset create #{gemset_name}"
+  end
 
   task clobber_task_name do
     unless rvm_ruby == 'jruby'
@@ -28,7 +33,7 @@ gemset_name = 'zookeeper'
     end
   end
 
-  task build_task_name => clobber_task_name do
+  task build_task_name => [create_gemset_name, clobber_task_name] do
     unless rvm_ruby == 'jruby'
       cd 'ext' do
         sh "rvm #{ruby_with_gemset} do rake build"
@@ -48,4 +53,19 @@ gemset_name = 'zookeeper'
   task "mb:test_all_rubies" => rspec_task_name
 end
 
+namespace :build do
+  task :clean do
+    cd 'ext' do
+      sh 'rake clean'
+    end
+
+    Rake::Task['build'].invoke
+  end
+end
+
+task :build do
+  cd 'ext' do
+    sh "rake"
+  end
+end
 

data/ext/c_zookeeper.rb

@@ -0,0 +1,214 @@
+require 'zookeeper/constants'
+require File.expand_path('../zookeeper_c', __FILE__)
+
+# TODO: see if we can get the destructor to handle thread/event queue teardown
+#       when we're garbage collected
+class CZookeeper
+  include ZookeeperCommon
+  include ZookeeperConstants
+  include ZookeeperExceptions
+
+  DEFAULT_SESSION_TIMEOUT_MSEC = 10000
+
+  class GotNilEventException < StandardError; end
+
+  # assume we're at debug level
+  def self.get_debug_level
+    @debug_level ||= ZOO_LOG_LEVEL_INFO
+  end
+
+  def self.set_debug_level(value)
+    @debug_level = value
+    set_zkrb_debug_level(value)
+  end
+
+  def initialize(host, event_queue, opts={})
+    @host = host
+    @event_queue = event_queue
+    
+    # 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.
+    #
+    # you should grab the @start_stop_mutex before messing with this flag
+    @_running = nil
+
+    # This is set to true after destroy_zkrb_instance has been called and all
+    # CZookeeper state has been cleaned up
+    @_closed = false  # also used by the C layer
+
+    # set by the ruby side to indicate we are in shutdown mode used by method_get_next_event
+    @_shutting_down = false
+
+    # the actual C data is stashed in this ivar. never *ever* touch this
+    @_data = nil
+
+    @_session_timeout_msec = DEFAULT_SESSION_TIMEOUT_MSEC
+
+    @start_stop_mutex = Monitor.new
+    
+    # used to signal that we're running
+    @running_cond = @start_stop_mutex.new_cond
+    
+    @event_thread = nil
+
+    setup_event_thread!
+
+    zkrb_init(@host)
+
+    logger.debug { "init returned!" }
+  end
+
+  def closed?
+    @start_stop_mutex.synchronize { !!@_closed }
+  end
+
+  def running?
+    @start_stop_mutex.synchronize { !!@_running }
+  end
+
+  def shutting_down?
+    @start_stop_mutex.synchronize { !!@_shutting_down }
+  end
+
+  def connected?
+    state == ZOO_CONNECTED_STATE
+  end
+
+  def connecting?
+    state == ZOO_CONNECTING_STATE
+  end
+
+  def associating?
+    state == ZOO_ASSOCIATING_STATE
+  end
+
+  def close
+    return if closed?
+
+    shut_down!
+    stop_event_thread!
+
+    @start_stop_mutex.synchronize do
+      if !@_closed and @_data
+        close_handle
+      end
+    end
+
+    nil
+  end
+
+  def state
+    return ZOO_CLOSED_STATE if closed?
+    zkrb_state
+  end
+
+  # this implementation is gross, but i don't really see another way of doing it
+  # without more grossness
+  #
+  # returns true if we're connected, false if we're not
+  #
+  # 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
+    end
+
+    connected?
+  end
+
+  private
+    # will wait until the client has entered the running? state
+    # or until timeout seconds have passed.
+    #
+    # returns true if we're running, false if we timed out
+    def wait_until_running(timeout=5)
+      @start_stop_mutex.synchronize do
+        return true if @_running
+        @running_cond.wait(timeout)
+        !!@_running
+      end
+    end
+
+    def setup_event_thread!
+      @event_thread ||= Thread.new do
+        Thread.current.abort_on_exception = true   # remove this once this is confirmed to work
+
+        logger.debug { "event_thread waiting until running: #{@_running}" }
+
+        @start_stop_mutex.synchronize do
+          @running_cond.wait_until { @_running }
+
+          if @_shutting_down
+            logger.error { "event thread saw @_shutting_down, bailing without entering loop" }
+            return
+          end
+        end
+
+        logger.debug { "event_thread running: #{@_running}" }
+
+        while true
+          begin
+            _iterate_event_delivery
+          rescue GotNilEventException
+            logger.debug { "#{self.class}##{__method__}: event delivery thread is exiting" }
+            break
+          end
+        end
+
+        # TODO: should we try iterating events after this point? to see if any are left?
+      end
+    end
+
+    def _iterate_event_delivery
+      get_next_event(true).tap do |hash|
+        raise GotNilEventException if hash.nil?
+        @event_queue.push(hash)
+      end
+    end
+
+    # use this method to set the @_shutting_down flag to true
+    def shut_down!
+      logger.debug { "#{self.class}##{__method__}" }
+
+      @start_stop_mutex.synchronize do
+        @_shutting_down = true
+      end
+    end
+
+    # this method is part of the reopen/close code, and is responsible for
+    # shutting down the dispatch thread. 
+    #
+    # @dispatch will be nil when this method exits
+    #
+    def stop_event_thread!
+      logger.debug { "#{self.class}##{__method__}" }
+
+      if @event_thread
+        unless @_closed
+          wake_event_loop! # this is a C method
+        end
+        @event_thread.join 
+        @event_thread = nil
+      end
+    end
+
+    def logger
+      Zookeeper.logger
+    end
+
+    # called by underlying C code to signal we're running
+    def zkc_set_running_and_notify!
+      logger.debug { "#{self.class}##{__method__}" }
+
+      @start_stop_mutex.synchronize do
+        @_running = true
+        @running_cond.broadcast
+      end
+    end
+end
+

data/ext/dbg.h

@@ -22,16 +22,32 @@
 
 #define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%d) " M "\n", __FILE__, __LINE__, ##__VA_ARGS__) 
 
+// acts to assert that A is true
 #define check(A, M, ...) if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto error; } 
 
+// like check, but provide an explicit goto label name
+#define check_goto(A, L, M, ...) if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto L; } 
+
+// like check, but implicit jump to 'unlock' label
+#define check_unlock(A, M, ...) check_goto(A, unlock, M, ##__VA_ARGS__)
+
 #define sentinel(M, ...)  { log_err(M, ##__VA_ARGS__); errno=0; goto error; } 
 
 #define check_mem(A) check((A), "Out of memory.")
 
-#define check_debug(A, M, ...) if(!(A)) { debug(M, ##__VA_ARGS__); errno=0; goto error; } 
+// checks the condition A, if not true, logs the message M given using zkrb_debug
+// then does a goto to the label L 
+#define check_debug_goto(A, L, M, ...) if(!(A)) { zkrb_debug(M, ##__VA_ARGS__); errno=0; goto L; } 
+
+// check_debug_goto with implicit 'unlock' label
+#define check_debug_unlock(A, M, ...) check_debug_goto(A, unlock, M, ##__VA_ARGS__) 
+
+// like check_debug_goto, but the label is implicitly 'error'
+#define check_debug(A, M, ...) check_debug_goto(A, error, M, ##__VA_ARGS__) 
 
-#define zkrb_debug(M, ...) if (ZKRBDebugging) fprintf(stderr, "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#define zkrb_debug(M, ...) if (ZKRBDebugging) fprintf(stderr, "DEBUG %p:%s:%d: " M "\n", pthread_self(), __FILE__, __LINE__, ##__VA_ARGS__)
 #define zkrb_debug_inst(O, M, ...) zkrb_debug("obj_id: %lx, " M, FIX2LONG(rb_obj_id(O)), ##__VA_ARGS__)
 
+// __dbg_h__
 #endif
 

data/ext/depend

@@ -1,4 +1,3 @@
-zookeeper_c.c:	zookeeper_lib.c dbg.h
-
 zookeeper_lib.c:	zookeeper_lib.h
+zookeeper_c.c:	zookeeper_lib.c zookeeper_lib.h dbg.h
 

data/ext/zookeeper_base.rb

@@ -1,6 +1,10 @@
+require File.expand_path('../c_zookeeper', __FILE__)
+require 'forwardable'
+
 # The low-level wrapper-specific methods for the C lib
 # subclassed by the top-level Zookeeper class
-class ZookeeperBase < CZookeeper
+class ZookeeperBase
+  extend Forwardable
   include ZookeeperCommon
   include ZookeeperCallbacks
   include ZookeeperConstants
@@ -8,6 +12,11 @@ class ZookeeperBase < CZookeeper
   include ZookeeperACLs
   include ZookeeperStat
 
+  # @private
+  class ClientShutdownException < StandardError; end
+
+  # @private
+  KILL_TOKEN = Object.new unless defined?(KILL_TOKEN)
 
   ZKRB_GLOBAL_CB_REQ   = -1
 
@@ -17,38 +26,54 @@ class ZookeeperBase < CZookeeper
   ZOO_LOG_LEVEL_INFO   = 3
   ZOO_LOG_LEVEL_DEBUG  = 4
 
- 
-  def reopen(timeout = 10, watcher=nil)
-    watcher ||= @default_watcher
+  def_delegators :czk, 
+    :get_children, :exists, :delete, :get, :set, :set_acl, :get_acl, :client_id, :sync, :selectable_io
 
-    @req_mutex.synchronize do
-      # flushes all outstanding watcher reqs.
-      @watcher_req = {}
-      set_default_global_watcher(&watcher)
+  # some state methods need to be more paranoid about locking to ensure the correct
+  # state is returned
+  # 
+  def self.threadsafe_inquisitor(*syms)
+    syms.each do |sym|
+      class_eval(<<-EOM, __FILE__, __LINE__+1)
+        def #{sym}
+          false|@mutex.synchronize { @czk and @czk.#{sym} }
+        end
+      EOM
     end
+  end
 
-    @start_stop_mutex.synchronize do
-#       $stderr.puts "%s: calling init, self.obj_id: %x" % [self.class, object_id]
-      init(@host)
+  threadsafe_inquisitor :connected?, :connecting?, :associating?, :running?
 
-      # XXX: replace this with a callback
-      if timeout > 0
-        time_to_stop = Time.now + timeout
-        until state == Zookeeper::ZOO_CONNECTED_STATE
-          break if Time.now > time_to_stop
-          sleep 0.1
-        end
-      end
+  attr_reader :event_queue
+ 
+  def reopen(timeout = 10, watcher=nil)
+    if watcher and (watcher != @default_watcher)
+      raise "You cannot set the watcher to a different value this way anymore!"
+    end
+    
+    @mutex.synchronize do
+      # flushes all outstanding watcher reqs.
+      @watcher_reqs.clear
+      set_default_global_watcher
+
+      @czk = CZookeeper.new(@host, @event_queue)
+      @czk.wait_until_connected(timeout)
     end
 
+    setup_dispatch_thread!
     state
   end
 
   def initialize(host, timeout = 10, watcher=nil)
     @watcher_reqs = {}
     @completion_reqs = {}
-    @req_mutex = Monitor.new
-    @current_req_id = 1
+
+    @mutex = Monitor.new
+    @dispatch_shutdown_cond = @mutex.new_cond
+
+    @current_req_id = 0
+    @event_queue = QueueWithPipe.new
+    @czk = nil
     
     # approximate the java behavior of raising java.lang.IllegalArgumentException if the host
     # argument ends with '/'
@@ -56,18 +81,17 @@ class ZookeeperBase < CZookeeper
 
     @host = host
 
-    @start_stop_mutex = Monitor.new
-
-    watcher ||= get_default_global_watcher
-
-    @_running = nil   # used by the C layer
-    @_closed = false  # also used by the C layer
+    @default_watcher = (watcher or get_default_global_watcher)
 
     yield self if block_given?
 
-    reopen(timeout, watcher)
-    return nil unless connected?
-    setup_dispatch_thread!
+    reopen(timeout)
+  end
+
+  # synchronized accessor to the @czk instance
+  # @private
+  def czk
+    @mutex.synchronize { @czk }
   end
   
   # if either of these happen, the user will need to renegotiate a connection via reopen
@@ -76,41 +100,10 @@ class ZookeeperBase < CZookeeper
     raise ZookeeperException::NotConnected   unless connected?
   end
 
-  def connected?
-    state == ZOO_CONNECTED_STATE
-  end
-
-  def connecting?
-    state == ZOO_CONNECTING_STATE
-  end
-
-  def associating?
-    state == ZOO_ASSOCIATING_STATE
-  end
-
   def close
-    @start_stop_mutex.synchronize do
-      @_running = false if @_running
-    end
-
-    if @dispatcher
-      unless @_closed
-        wake_event_loop! 
-      end
-      @dispatcher.join 
-    end
-
-    @start_stop_mutex.synchronize do
-      unless @_closed
-        close_handle
-      end
-    end
-        
-    # this is set up in the C init method, but it's easier to 
-    # do the teardown here
-    begin
-      @selectable_io.close if @selectable_io
-    rescue IOError
+    @mutex.synchronize do
+      stop_dispatch_thread!
+      @czk.close
     end
   end
 
@@ -118,7 +111,7 @@ class ZookeeperBase < CZookeeper
   # is pretty damn annoying. this is used to clean things up.
   def create(*args)
     # since we don't care about the inputs, just glob args
-    rc, new_path = super(*args)
+    rc, new_path = czk.create(*args)
     [rc, strip_chroot_from(new_path)]
   end
 
@@ -128,34 +121,33 @@ class ZookeeperBase < CZookeeper
   end
 
   # set the watcher object/proc that will receive all global events (such as session/state events)
-  def set_default_global_watcher(&block)
-    @req_mutex.synchronize do
-      @default_watcher = block # save this here for reopen() to use
+  def set_default_global_watcher
+    warn "DEPRECATION WARNING: #{self.class}#set_default_global_watcher ignores block" if block_given?
+
+    @mutex.synchronize do
+#       @default_watcher = block # save this here for reopen() to use
       @watcher_reqs[ZKRB_GLOBAL_CB_REQ] = { :watcher => @default_watcher, :watcher_context => nil }
     end
   end
 
-  def closed?
-    @start_stop_mutex.synchronize { false|@_closed }
-  end
-
-  def running?
-    @start_stop_mutex.synchronize { false|@_running }
-  end
-
   def state
     return ZOO_CLOSED_STATE if closed?
-    super
+    czk.state
   end
 
   def session_id
-    client_id.session_id
+    cid = client_id and cid.session_id
   end
 
   def session_passwd
-    client_id.passwd
+    cid = client_id and cid.passwd
   end
 
+  # we are closed if there is no @czk instance or @czk.closed?
+  def closed?
+    @mutex.synchronize { !@czk or @czk.closed? } 
+  end
+ 
 protected
   # 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
@@ -164,7 +156,6 @@ protected
   # version. The non-async manipulation is handled in ZookeeperBase#create.
   # 
   def setup_completion(req_id, meth_name, call_opts)
-
     if (meth_name == :create) and cb = call_opts[:callback]
       call_opts[:callback] = lambda do |hash|
         # in this case the string will be the absolute zookeeper path (i.e.
@@ -186,26 +177,6 @@ protected
     path[chroot_path.length..-1]
   end
 
-  def barf_unless_running!
-    @start_stop_mutex.synchronize do
-      raise ShuttingDownException unless (@_running and not @_closed)
-      yield
-    end
-  end
-
-  def setup_dispatch_thread!
-    @dispatcher = Thread.new do
-      while running?
-        begin                     # calling user code, so protect ourselves
-          dispatch_next_callback
-        rescue Exception => e
-          $stderr.puts "Error in dispatch thread, #{e.class}: #{e.message}\n" << e.backtrace.map{|n| "\t#{n}"}.join("\n")
-        end
-      end
-    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])}" }