zookeeper-ng 1.5.2.1-java

data/Rakefile

@@ -0,0 +1,121 @@
+release_ops_path = File.expand_path('../releaseops/lib', __FILE__)
+
+# if the special submodule is availabe, use it
+# we use a submodule because it doesn't depend on anything else (*cough* bundler)
+# and can be shared across projects
+#
+if File.exists?(release_ops_path)
+  require File.join(release_ops_path, 'releaseops')
+
+  # sets up the multi-ruby zk:test_all rake tasks
+  ReleaseOps::TestTasks.define_for(*%w[1.8.7 1.9.2 jruby rbx ree 1.9.3])
+
+  # sets up the task :default => 'spec:run' and defines a simple
+  # "run the specs with the current rvm profile" task
+  ReleaseOps::TestTasks.define_simple_default_for_travis
+
+  # Define a task to run code coverage tests
+  ReleaseOps::TestTasks.define_simplecov_tasks
+
+  # set up yard:server, yard:gems, and yard:clean tasks 
+  # for doing documentation stuff
+  ReleaseOps::YardTasks.define
+
+  task :clean => 'yard:clean'
+
+  namespace :zk do
+    namespace :gems do
+      desc "Build gems to prepare for a release. Requires TAG="
+      task :build do
+        require 'tmpdir'
+
+        raise "You must specify a TAG" unless ENV['TAG']
+
+        ReleaseOps.with_tmpdir(:prefix => 'zookeeper') do |tmpdir|
+          tag = ENV['TAG']
+
+          sh "git clone . #{tmpdir}"
+
+          orig_dir = Dir.getwd
+
+          Dir.chdir tmpdir do
+            sh "git co #{tag} && git reset --hard && git clean -fdx"
+
+            ENV['JAVA_GEM'] = nil
+            sh "gem build zookeeper.gemspec"
+            sh "env JAVA_GEM=1 gem build zookeeper.gemspec"
+
+            mv FileList['*.gem'], orig_dir
+          end
+        end
+      end
+
+      desc "Release gems that have been built"
+      task :push do
+        gems = FileList['*.gem']
+        raise "No gemfiles to push!" if gems.empty?
+
+        gems.each do |gem|
+          sh "gem push #{gem}"
+        end
+      end
+
+      task :clean do
+        rm_rf FileList['*.gem']
+      end
+
+      task :all => [:build, :push, :clean]
+    end
+  end
+end
+
+task :clobber do
+  rm_rf 'tmp'
+end
+
+# cargo culted from http://blog.flavorjon.es/2009/06/easily-valgrind-gdb-your-ruby-c.html
+VALGRIND_BASIC_OPTS = '--num-callers=50 --error-limit=no --partial-loads-ok=yes --undef-value-errors=no --trace-children=yes'
+
+task 'valgrind' do
+  Dir.chdir 'ext' do
+    sh "rake clean build"
+  end
+
+  sh "valgrind #{VALGRIND_BASIC_OPTS} bundle exec rspec spec"
+end
+
+namespace :build do
+  task :clean do
+    Dir.chdir 'ext' do
+      sh 'rake clean'
+    end
+
+    Rake::Task['build'].invoke
+  end
+
+  task :clobber do
+    Dir.chdir 'ext' do
+      sh 'rake clobber'
+    end
+
+    Rake::Task['build'].invoke
+  end
+end
+
+desc "Build C component"
+task :build do
+  Dir.chdir 'ext' do
+    sh "rake"
+  end
+end
+
+task 'spec:run' => 'build:clean' unless defined?(::JRUBY_VERSION)
+
+task 'ctags' do
+  sh 'bundle-ctags'
+end
+
+# because i'm a creature of habit
+task 'mb:test_all' => 'zk:test_all'
+
+

data/cause-abort.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+
+require 'zookeeper'
+require File.expand_path('../spec/support/zookeeper_spec_helpers', __FILE__)
+
+class CauseAbort
+  include Zookeeper::Logger
+  include Zookeeper::SpecHelpers
+
+  attr_reader :path, :pids_root, :data
+
+  def initialize
+    @path = "/_zktest_"
+    @pids_root = "#{@path}/pids"
+    @data = 'underpants'
+  end
+
+  def before
+    @zk = Zookeeper.new('localhost:2181')
+    rm_rf(@zk, path)
+    logger.debug { "----------------< BEFORE: END >-------------------" }
+  end
+
+  def process_alive?(pid)
+    Process.kill(0, @pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  def wait_for_child_safely(pid, timeout=5)
+    time_to_stop = Time.now + timeout
+
+    until Time.now > time_to_stop
+      if a = Process.wait2(@pid, Process::WNOHANG)
+        return a.last
+      else
+        sleep(0.01)
+      end
+    end
+
+    nil
+  end
+
+  def try_pause_and_resume
+    @zk.pause
+    logger.debug { "paused" }
+    @zk.resume
+    logger.debug { "resumed" }
+    @zk.close
+    logger.debug { "closed" }
+  end
+
+  def run_test
+    logger.debug { "----------------< TEST: BEGIN >-------------------" }
+    @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)
+
+    logger.debug { "------------------->   FORK   <---------------------------" }
+
+    @pid = fork do
+      rand_sleep = rand()
+
+      $stderr.puts "sleeping for rand_sleep: #{rand_sleep}"
+      sleep(rand_sleep)
+
+      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[:path]}" }
+      @zk.close
+
+      logger.debug { "close finished" }
+      exit!(0)
+    end
+
+    event_waiter_th = Thread.new do
+      @latch.await(5) unless @event 
+      @event
+    end
+
+    logger.debug { "waiting on child #{@pid}" }
+
+    status = wait_for_child_safely(@pid)
+    raise "Child process did not exit, likely hung"  unless status
+
+    if event_waiter_th.join(5) == event_waiter_th
+      logger.warn { "event waiter has not received events" }
+    end
+
+    exit(@event.nil? ? 1 : 0)
+  end
+
+  def run
+    before
+    run_test
+#     try_pause_and_resume
+  end
+end
+
+CauseAbort.new.run

data/ext/.gitignore

@@ -0,0 +1,6 @@
+bin
+include
+lib
+*.bundle
+
+c

data/ext/Rakefile

@@ -0,0 +1,41 @@
+require 'rbconfig'
+
+ZKRB_WRAPPER = %w[zkrb_wrapper.c zkrb_wrapper.h]
+
+namespace :zkrb do
+  task :clean do
+    if File.exists?('Makefile')
+      sh 'make clean'
+      rm 'Makefile' # yep, regenerate this
+    else
+      $stderr.puts "nothing to clean, no Makefile"
+    end
+  end
+
+  task :clobber => :clean do
+    rm_rf %w[Makefile c lib bin include ._c] + ZKRB_WRAPPER
+  end
+end
+
+task :clean    => 'zkrb:clean'
+task :clobber  => 'zkrb:clobber'
+task :wrappers => ZKRB_WRAPPER
+task :default  => :build
+
+file 'zkrb_wrapper.c' => 'generate_gvl_code.rb' do
+  sh "ruby generate_gvl_code.rb code"
+end
+
+file 'zkrb_wrapper.h' => 'generate_gvl_code.rb' do
+  sh "ruby generate_gvl_code.rb headers"
+end
+
+file 'Makefile' do
+  sh "ruby extconf.rb"
+end
+
+task :build => [ 'Makefile', :wrappers ] do
+  sh 'make'
+end
+
+

data/ext/c_zookeeper.rb

@@ -0,0 +1,398 @@
+Zookeeper.require_lib(
+  'zookeeper/logger',
+  'zookeeper/common',
+  'zookeeper/constants',
+  'zookeeper/exceptions' # zookeeper_c depends on exceptions defined in here
+)
+
+Zookeeper.require_root 'ext/zookeeper_c'
+
+# require File.expand_path('../zookeeper_c', __FILE__)
+
+module Zookeeper
+# NOTE: this class extending (opening) the class defined in zkrb.c
+class CZookeeper
+  include Forked
+  include Constants
+  include Exceptions
+  include Logger
+
+  DEFAULT_RECEIVE_TIMEOUT_MSEC = 10000
+
+  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
+  end
+
+  def self.set_debug_level(value)
+    @debug_level = value
+    set_zkrb_debug_level(value)
+  end
+
+  # wrap these calls in our sync->async special sauce
+  %w[get set exists create delete get_acl set_acl get_children add_auth].each do |sym|
+    class_eval(<<-EOS, __FILE__, __LINE__+1)
+      def #{sym}(*args)
+        submit_and_block(:#{sym}, *args)
+      end
+    EOS
+  end
+
+  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.
+    #
+    # you should grab the @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
+
+    @_receive_timeout_msec = opts[:receive_timeout_msec] || DEFAULT_RECEIVE_TIMEOUT_MSEC
+
+    @mutex = Monitor.new
+
+    # used to signal that we're running
+    @running_cond = @mutex.new_cond
+
+    # used to signal we've received the connected event
+    @state_mutex = Monitor.new
+    @state_cond = @state_mutex.new_cond
+
+    # the current state of the connection
+    @state = ZOO_CLOSED_STATE
+
+    @pipe_read, @pipe_write = IO.pipe
+
+    @event_thread = nil
+
+    # hash of in-flight Continuation instances
+    @reg = Continuation::Registry.new
+
+    log_level = ENV['ZKC_DEBUG'] ? ZOO_LOG_LEVEL_DEBUG : ZOO_LOG_LEVEL_ERROR
+
+    logger.info { "initiating connection to #{@host}" }
+
+    zkrb_init(@host, opts)#, :zkc_log_level => log_level)
+
+    start_event_thread
+
+    logger.debug { "init returned!" }
+  end
+
+  def closed?
+    @mutex.synchronize { !!@_closed }
+  end
+
+  def running?
+    @mutex.synchronize { !!@_running }
+  end
+
+  def shutting_down?
+    @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?
+
+    fn_close = proc do
+      if !@_closed and @_data
+        logger.debug { "CALLING CLOSE HANDLE!!" }
+        close_handle
+      end
+    end
+
+    if forked?
+      fn_close.call
+    else
+      stop_event_thread
+      @mutex.synchronize(&fn_close)
+    end
+
+    [@pipe_read, @pipe_write].each { |io| io.close unless io.closed? }
+
+    nil
+  end
+
+  # call this to stop the event loop, you can resume with the
+  # resume method
+  #
+  # requests may still be added during this time, but they will not be
+  # processed until you call resume
+  def pause_before_fork_in_parent
+    logger.debug { "##{__method__}" }
+    @mutex.synchronize { stop_event_thread }
+  end
+
+  # call this if 'pause' was previously called to start the event loop again
+  def resume_after_fork_in_parent
+    logger.debug { "##{__method__}" }
+
+    @mutex.synchronize do
+      @_shutting_down = nil
+      start_event_thread
+    end
+  end
+
+  def state
+    return ZOO_CLOSED_STATE if closed?
+    @state_mutex.synchronize { @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)
+    time_to_stop = timeout ? Time.now + timeout : nil
+
+    return false unless wait_until_running(timeout)
+
+    @state_mutex.synchronize do
+      while true
+        if timeout
+          now = Time.now
+          break if (@state == ZOO_CONNECTED_STATE) || unhealthy? || (now > time_to_stop)
+          delay = time_to_stop.to_f - now.to_f
+          @state_cond.wait(delay)
+        else
+          break if (@state == ZOO_CONNECTED_STATE) || unhealthy?
+          @state_cond.wait
+        end
+      end
+    end
+
+    connected?
+  end
+
+  private
+    # This method is NOT SYNCHRONIZED!
+    #
+    # you must hold the @mutex lock while calling this method
+    def unhealthy?
+      @_closed || @_shutting_down || is_unrecoverable
+    end
+
+    # This method is NOT SYNCHRONIZED!
+    #
+    # you must hold the @mutex lock while calling this method
+    def healthy?
+      !unhealthy?
+    end
+
+    # submits a job for processing
+    # blocks the caller until result has returned
+    def submit_and_block(meth, *args)
+      @mutex.synchronize do
+        raise Exceptions::NotConnected if unhealthy?
+      end
+
+      cnt = Continuation.new(meth, *args)
+      @reg.synchronize do |r|
+        if meth == :state
+          r.state_check << cnt
+        else
+          r.pending << cnt
+        end
+      end
+      wake_event_loop!
+      cnt.value
+    end
+
+    # this method is part of the reopen/close code, and is responsible for
+    # shutting down the dispatch thread.
+    #
+    # this method must be EXTERNALLY SYNCHRONIZED!
+    #
+    # @event_thread will be nil when this method exits
+    #
+    def stop_event_thread
+      if @event_thread
+        logger.debug { "##{__method__}" }
+        shut_down!
+        wake_event_loop!
+        @event_thread.join
+        @event_thread = nil
+      end
+    end
+
+    # starts the event thread running if not already started
+    # returns false if already running
+    def start_event_thread
+      return false if @event_thread
+      @event_thread = Thread.new(&method(:event_thread_body))
+    end
+
+    # 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)
+      @mutex.synchronize do
+        return true if @_running
+        @running_cond.wait(timeout)
+        !!@_running
+      end
+    end
+
+    def event_thread_body
+      Thread.current.abort_on_exception = true
+      logger.debug { "##{__method__} starting event thread" }
+
+      event_thread_await_running
+
+      # this is the main loop
+      while healthy?
+        if @reg.anything_to_do? && connected?
+          submit_pending_calls
+        end
+
+        zkrb_iterate_event_loop
+        iterate_event_delivery
+      end
+
+      # ok, if we're exiting the event loop, and we still have a valid connection
+      # and there's still completions we're waiting to hear about, then we
+      # should pump the handle before leaving this loop
+      if @_shutting_down and not (@_closed or is_unrecoverable)
+        logger.debug { "we're in shutting down state, there are #{@reg.in_flight.length} in_flight completions" }
+
+        until @reg.in_flight.empty? or @_closed or is_unrecoverable
+          zkrb_iterate_event_loop
+          iterate_event_delivery
+          logger.debug { "there are #{@reg.in_flight} in_flight completions left" }
+        end
+
+        logger.debug { "finished completions" }
+      end
+
+      # anything left over after all that gets the finger
+      remaining = @reg.next_batch + @reg.in_flight.values
+
+      logger.debug { "there are #{remaining.length} completions to awaken" }
+
+      @reg.in_flight.clear
+
+      while cb = remaining.shift
+        cb.shutdown!
+      end
+    rescue ShuttingDownException
+      logger.error { "event thread saw @_shutting_down, bailing without entering loop" }
+    ensure
+      logger.debug { "##{__method__} exiting" }
+    end
+
+    def submit_pending_calls
+      calls = @reg.next_batch()
+
+      return if calls.empty?
+
+      while cntn = calls.shift
+        cntn.submit(self)                     # this delivers state check results (and does other stuff)
+        if req_id = cntn.req_id               # state checks will not have a req_id
+          @reg.in_flight[req_id] = cntn       # in_flight is only ever touched by us
+        end
+      end
+    end
+
+    def wake_event_loop!
+      @pipe_write && !@pipe_write.closed? && @pipe_write.write('1')
+    end
+
+    def iterate_event_delivery
+      while hash = zkrb_get_next_event_st()
+        logger.debug { "##{__method__} got #{hash.inspect} " }
+
+        if (hash[:req_id] == ZKRB_GLOBAL_CB_REQ) && (hash[:type] == -1)
+          ev_state = hash[:state]
+
+          @state_mutex.synchronize do
+            if @state != ev_state
+              @state = ev_state
+              @state_cond.broadcast
+            end
+          end
+        end
+
+        cntn = @reg.in_flight.delete(hash[:req_id])
+
+        if cntn and not cntn.user_callback?     # this is one of "our" continuations
+          cntn.call(hash)                       # so we handle delivering it
+          next                                  # and skip handing it to the dispatcher
+        end
+
+        # otherwise, the event was a session event (ZKRB_GLOBAL_CB_REQ)
+        # or a user-provided callback
+        @event_queue.push(hash)
+      end
+    end
+
+    def event_thread_await_running
+      logger.debug { "event_thread waiting until running: #{@_running}" }
+
+      @mutex.synchronize do
+        @running_cond.wait_until { @_running or @_shutting_down }
+        logger.debug { "event_thread running: #{@_running}" }
+
+        raise ShuttingDownException if @_shutting_down
+      end
+    end
+
+    # use this method to set the @_shutting_down flag to true
+    def shut_down!
+      logger.debug { "##{__method__}" }
+
+      @mutex.synchronize do
+        @_shutting_down = true
+        # ollie ollie oxen all home free!
+        @running_cond.broadcast
+      end
+
+      @state_mutex.synchronize do
+        @state_cond.broadcast
+      end
+    end
+
+    # called by underlying C code to signal we're running
+    def zkc_set_running_and_notify!
+      logger.debug { "##{__method__}" }
+
+      @mutex.synchronize do
+        @_running = true
+        @running_cond.broadcast
+      end
+    end
+end
+end

data/ext/common.h

@@ -0,0 +1,17 @@
+#ifndef ZKRB_COMMON_H
+#define ZKRB_COMMON_H
+
+#include "ruby.h"
+
+//#define THREADED
+#undef THREADED    // we are linking against the zookeeper_st lib, this is crucial
+
+#ifndef RB_GC_GUARD_PTR
+#define RB_GC_GUARD_PTR(V) (V);
+#endif
+#ifndef RB_GC_GUARD
+#define RB_GC_GUARD(V) (V);
+#endif
+
+
+#endif /* ZKRB_COMMON_H */