zookeeper-ng 1.5.2.1-java

data/ext/zkrb_wrapper.h

@@ -0,0 +1,350 @@
+#ifndef ZKRB_WRAPPER_H
+#define ZKRB_WRAPPER_H
+#if 0
+
+  AUTOGENERATED BY generate_gvl_code.rb 
+
+#endif
+
+#include "ruby.h"
+#include "zookeeper/zookeeper.h"
+#include "zkrb_wrapper_compat.h"
+#include "dbg.h"
+
+#define ZKRB_FAIL -1
+
+typedef struct {
+  zhandle_t *zh;
+  int rc;
+} zkrb_zoo_recv_timeout_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  int rc;
+} zkrb_zoo_state_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  const char *value;
+  int valuelen;
+  const struct ACL_vector *acl;
+  int flags;
+  string_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_acreate_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int version;
+  void_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_adelete_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  stat_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_aexists_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  stat_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_awexists_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  data_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_aget_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  data_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_awget_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  const char *buffer;
+  int buflen;
+  int version;
+  stat_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_aset_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  strings_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_aget_children_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  strings_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_awget_children_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  strings_stat_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_aget_children2_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  strings_stat_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_awget_children2_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  string_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_async_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  acl_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_aget_acl_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int version;
+  struct ACL_vector *acl;
+  void_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_aset_acl_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  int count;
+  const zoo_op_t *ops;
+  zoo_op_result_t *results;
+  void_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_amulti_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char* scheme;
+  const char* cert;
+  int certLen;
+  void_completion_t completion;
+  const void *data;
+  int rc;
+} zkrb_zoo_add_auth_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  const char *value;
+  int valuelen;
+  const struct ACL_vector *acl;
+  int flags;
+  char *path_buffer;
+  int path_buffer_len;
+  int rc;
+} zkrb_zoo_create_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int version;
+  int rc;
+} zkrb_zoo_delete_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_exists_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_wexists_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  char *buffer;
+  int* buffer_len;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_get_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  char *buffer;
+  int* buffer_len;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_wget_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  const char *buffer;
+  int buflen;
+  int version;
+  int rc;
+} zkrb_zoo_set_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  const char *buffer;
+  int buflen;
+  int version;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_set2_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  struct String_vector *strings;
+  int rc;
+} zkrb_zoo_get_children_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  struct String_vector *strings;
+  int rc;
+} zkrb_zoo_wget_children_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int watch;
+  struct String_vector *strings;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_get_children2_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  watcher_fn watcher;
+  void* watcherCtx;
+  struct String_vector *strings;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_wget_children2_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  struct ACL_vector *acl;
+  struct Stat *stat;
+  int rc;
+} zkrb_zoo_get_acl_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  const char *path;
+  int version;
+  const struct ACL_vector *acl;
+  int rc;
+} zkrb_zoo_set_acl_args_t;
+
+typedef struct {
+  zhandle_t *zh;
+  int count;
+  const zoo_op_t *ops;
+  zoo_op_result_t *results;
+  int rc;
+} zkrb_zoo_multi_args_t;
+
+int zkrb_call_zoo_recv_timeout(zhandle_t *zh);
+int zkrb_call_zoo_state(zhandle_t *zh);
+int zkrb_call_zoo_acreate(zhandle_t *zh, const char *path, const char *value, int valuelen, const struct ACL_vector *acl, int flags, string_completion_t completion, const void *data);
+int zkrb_call_zoo_adelete(zhandle_t *zh, const char *path, int version, void_completion_t completion, const void *data);
+int zkrb_call_zoo_aexists(zhandle_t *zh, const char *path, int watch, stat_completion_t completion, const void *data);
+int zkrb_call_zoo_awexists(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, stat_completion_t completion, const void *data);
+int zkrb_call_zoo_aget(zhandle_t *zh, const char *path, int watch, data_completion_t completion, const void *data);
+int zkrb_call_zoo_awget(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, data_completion_t completion, const void *data);
+int zkrb_call_zoo_aset(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version, stat_completion_t completion, const void *data);
+int zkrb_call_zoo_aget_children(zhandle_t *zh, const char *path, int watch, strings_completion_t completion, const void *data);
+int zkrb_call_zoo_awget_children(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, strings_completion_t completion, const void *data);
+int zkrb_call_zoo_aget_children2(zhandle_t *zh, const char *path, int watch, strings_stat_completion_t completion, const void *data);
+int zkrb_call_zoo_awget_children2(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, strings_stat_completion_t completion, const void *data);
+int zkrb_call_zoo_async(zhandle_t *zh, const char *path, string_completion_t completion, const void *data);
+int zkrb_call_zoo_aget_acl(zhandle_t *zh, const char *path, acl_completion_t completion, const void *data);
+int zkrb_call_zoo_aset_acl(zhandle_t *zh, const char *path, int version, struct ACL_vector *acl, void_completion_t completion, const void *data);
+int zkrb_call_zoo_amulti(zhandle_t *zh, int count, const zoo_op_t *ops, zoo_op_result_t *results, void_completion_t completion, const void *data);
+int zkrb_call_zoo_add_auth(zhandle_t *zh, const char* scheme, const char* cert, int certLen, void_completion_t completion, const void *data);
+int zkrb_call_zoo_create(zhandle_t *zh, const char *path, const char *value, int valuelen, const struct ACL_vector *acl, int flags, char *path_buffer, int path_buffer_len);
+int zkrb_call_zoo_delete(zhandle_t *zh, const char *path, int version);
+int zkrb_call_zoo_exists(zhandle_t *zh, const char *path, int watch, struct Stat *stat);
+int zkrb_call_zoo_wexists(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct Stat *stat);
+int zkrb_call_zoo_get(zhandle_t *zh, const char *path, int watch, char *buffer, int* buffer_len, struct Stat *stat);
+int zkrb_call_zoo_wget(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, char *buffer, int* buffer_len, struct Stat *stat);
+int zkrb_call_zoo_set(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version);
+int zkrb_call_zoo_set2(zhandle_t *zh, const char *path, const char *buffer, int buflen, int version, struct Stat *stat);
+int zkrb_call_zoo_get_children(zhandle_t *zh, const char *path, int watch, struct String_vector *strings);
+int zkrb_call_zoo_wget_children(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct String_vector *strings);
+int zkrb_call_zoo_get_children2(zhandle_t *zh, const char *path, int watch, struct String_vector *strings, struct Stat *stat);
+int zkrb_call_zoo_wget_children2(zhandle_t *zh, const char *path, watcher_fn watcher, void* watcherCtx, struct String_vector *strings, struct Stat *stat);
+int zkrb_call_zoo_get_acl(zhandle_t *zh, const char *path, struct ACL_vector *acl, struct Stat *stat);
+int zkrb_call_zoo_set_acl(zhandle_t *zh, const char *path, int version, const struct ACL_vector *acl);
+int zkrb_call_zoo_multi(zhandle_t *zh, int count, const zoo_op_t *ops, zoo_op_result_t *results);
+
+#endif /* ZKRB_WRAPPER_H */

data/ext/zkrb_wrapper_compat.c

@@ -0,0 +1,15 @@
+#include "ruby.h"
+#include "zkrb_wrapper_compat.h"
+
+
+VALUE zkrb_thread_blocking_region(zkrb_blocking_function_t *func, void *data1) {
+
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+  return rb_thread_blocking_region((rb_blocking_function_t *)func, data1, RUBY_UBF_IO, 0);
+#else
+  return func(data1);
+#endif
+
+}
+
+// vim:sts=2:sw=2:et

data/ext/zkrb_wrapper_compat.h

@@ -0,0 +1,11 @@
+#ifndef ZKRB_WRAPPER_COMPAT_H
+#define ZKRB_WRAPPER_COMPAT_H
+
+typedef VALUE zkrb_blocking_function_t(void *);
+typedef void zkrb_unblock_function_t(void *);
+
+// delegates to rb_thread_blocking_region on 1.9.x, always uses UBF_IO
+VALUE zkrb_thread_blocking_region(zkrb_blocking_function_t *func, void *data1);
+
+
+#endif /* ZKRB_WRAPPER_COMPAT_H */

data/ext/zookeeper_base.rb

@@ -0,0 +1,256 @@
+require 'forwardable'
+
+Zookeeper.require_root 'ext/c_zookeeper'
+
+# The low-level wrapper-specific methods for the C lib
+# subclassed by the top-level Zookeeper class
+module Zookeeper
+class ZookeeperBase
+  extend Forwardable
+  include Forked
+  include Common       # XXX: clean this up, no need to include *everything*
+  include Callbacks
+  include Constants
+  include Exceptions
+  include ACLs
+  include Logger
+
+  attr_accessor :original_pid
+
+  # @private
+  class ClientShutdownException < StandardError; end
+
+  # debug levels
+  ZOO_LOG_LEVEL_ERROR  = 1
+  ZOO_LOG_LEVEL_WARN   = 2
+  ZOO_LOG_LEVEL_INFO   = 3
+  ZOO_LOG_LEVEL_DEBUG  = 4
+
+  def_delegators :czk, :get_children, :exists, :delete, :get, :set,
+    :set_acl, :get_acl, :client_id, :sync, :add_auth, :wait_until_connected,
+    :connected_host
+
+  def self.threadsafe_inquisitor(*syms)
+    syms.each do |sym|
+      class_eval(<<-EOM, __FILE__, __LINE__+1)
+        def #{sym}
+          c = @mutex.synchronize { @czk }
+          false|(c && c.#{sym})
+        end
+      EOM
+    end
+  end
+
+  threadsafe_inquisitor :connected?, :connecting?, :associating?, :running?,
+    :shutting_down?
+
+  attr_reader :event_queue
+  
+  # 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__} fork detected!" } if forked?
+
+    @mutex = Monitor.new
+    @dispatch_shutdown_cond = @mutex.new_cond
+    @event_queue = QueueWithPipe.new
+
+    @dispatcher = nil if @dispatcher and not @dispatcher.alive?
+
+    update_pid!  # from Forked
+  end
+  private :reopen_after_fork!
+
+  def reopen(timeout = 10, watcher=nil, opts = {})
+    raise "You cannot set the watcher to a different value this way anymore!" if watcher
+
+    reopen_after_fork! if forked?
+
+    @mutex.synchronize do
+      @czk.close if @czk
+      @czk = CZookeeper.new(@host, @event_queue, opts)
+
+      # flushes all outstanding watcher reqs.
+      @req_registry.clear_watchers!
+      
+      @czk.wait_until_connected(timeout)
+    end
+
+    setup_dispatch_thread!
+    state
+  end
+
+  def initialize(host, timeout = 10, watcher=nil, opts = {})
+    # approximate the java behavior of raising java.lang.IllegalArgumentException if the host
+    # argument ends with '/'
+    raise ArgumentError, "Host argument #{host.inspect} may not end with /" if host.end_with?('/')
+
+    @host = host.dup
+
+    watcher ||= get_default_global_watcher
+
+    @req_registry = RequestRegistry.new(watcher, :chroot_path => chroot_path)
+
+    @dispatcher = @czk = nil
+
+    update_pid!
+    reopen_after_fork!
+    
+    yield self if block_given?
+
+    reopen(timeout, nil, opts)
+  end
+
+  # 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 !@czk or @czk.closed?
+      if forked?
+        raise InheritedConnectionError, <<-EOS.gsub(/(?:^|\n)\s*/, ' ').strip
+          You tried to use a connection inherited from another process 
+          (original pid: #{original_pid}, your pid: #{Process.pid})
+          You need to call reopen() after forking
+        EOS
+      end
+    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!
+    inst, @czk = @czk, nil
+    inst && inst.close
+  end
+
+  # close the connection normally, stops the dispatch thread and closes the
+  # underlying connection cleanly
+  def close
+    sd_thread = nil
+
+    @mutex.synchronize do
+      return unless @czk
+      inst, @czk = @czk, nil
+    
+      sd_thread = Thread.new(inst) do |_inst|
+        stop_dispatch_thread!
+        _inst.close
+      end
+    end
+
+    # if we're on the event dispatch thread for some stupid reason, then don't join
+    unless event_dispatch_thread?
+      # hard-coded 30 second delay, don't hang forever
+      if sd_thread.join(30) != sd_thread 
+        logger.error { "timed out waiting for shutdown thread to exit" }
+      end
+    end
+
+    nil
+  end
+
+  # the C lib doesn't strip the chroot path off of returned path values, which
+  # 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 = czk.create(*args)
+    [rc, @req_registry.strip_chroot_from(new_path)]
+  end
+
+  def set_debug_level(int)
+    warn "DEPRECATION WARNING: #{self.class.name}#set_debug_level, it has moved to the class level and will be removed in a future release"
+    self.class.set_debug_level(int)
+  end
+
+  # set the watcher object/proc that will receive all global events (such as session/state events)
+  def set_default_global_watcher
+    raise "NO! YOU CANNOT HAZ set_default_global_watcher"
+  end
+
+  def state
+    return ZOO_CLOSED_STATE if closed?
+    czk.state
+  end
+
+  def session_id
+    @mutex.synchronize do
+      cid = client_id and cid.session_id
+    end
+  end
+
+  def session_passwd
+    @mutex.synchronize do
+      cid = client_id and cid.passwd
+    end
+  end
+
+  # we are closed if there is no @czk instance or @czk.closed?
+  def closed?
+    czk.closed?
+  rescue Exceptions::NotConnected
+    true
+  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
+  def czk
+    rval = @mutex.synchronize { @czk }
+    raise Exceptions::NotConnected, "underlying connection was nil" unless rval
+    rval
+  end
+
+  # if we're chrooted, this method will strip the chroot prefix from +path+
+  def strip_chroot_from(path)
+    return path unless (chrooted? and path and path.start_with?(chroot_path))
+    path[chroot_path.length..-1]
+  end
+
+  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])}" }
+      true
+    }
+  end
+
+  def chrooted?
+    !chroot_path.empty?
+  end
+
+  def chroot_path
+    if @chroot_path.nil?
+      @chroot_path = 
+        if idx = @host.index('/')
+          @host.slice(idx, @host.length)
+        else
+          ''
+        end
+    end
+
+    @chroot_path
+  end
+end
+end