zookeeper 0.9.3-java

data/ext/.gitignore

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

data/ext/Rakefile

@@ -0,0 +1,51 @@
+
+task :clean do
+  if File.exists?('Makefile')
+    sh 'make clean'
+  else
+    $stderr.puts "nothing to clean, no Makefile"
+  end
+end
+
+GENERATE_GVL_CODE_RB = 'generate_gvl_code.rb'
+
+file 'c' do
+  if tarball = Dir['zkc-*.tar.gz'].first
+    sh "tar -zxf #{tarball}"
+  else
+    raise "couldn't find the tarball! wtf?!"
+  end
+end
+
+file GENERATE_GVL_CODE_RB => 'c'
+
+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
+
+ZKRB_WRAPPER = %w[zkrb_wrapper.c zkrb_wrapper.h]
+
+
+task :wrappers => ZKRB_WRAPPER
+
+
+task :clobber => :clean do
+  rm_rf %w[Makefile c lib bin include]
+end
+
+task :build_zkc do
+  sh 'ruby extconf.rb'
+end
+
+file 'Makefile' => :build_zkc
+
+task :build => [ZKRB_WRAPPER, 'Makefile'].flatten do
+  sh 'make'
+end
+
+task :default => :build
+

data/ext/c_zookeeper.rb

@@ -0,0 +1,212 @@
+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(&method(:_event_thread_body))
+    end
+
+    def _event_thread_body
+      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
+    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

@@ -0,0 +1,53 @@
+#ifndef __dbg_h__
+#define __dbg_h__
+
+// ALL GLORY TO THE Zed A. Shaw
+// http://c.learncodethehardway.org/book/learn-c-the-hard-waych21.html#x26-10500021
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#ifdef NDEBUG
+#define debug(M, ...)
+#else
+#define debug(M, ...) fprintf(stderr, "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#endif
+
+#define clean_errno() (errno == 0 ? "None" : strerror(errno))
+
+#define log_err(M, ...) fprintf(stderr, "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, clean_errno(), ##__VA_ARGS__) 
+
+#define log_warn(M, ...) fprintf(stderr, "[WARN] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, clean_errno(), ##__VA_ARGS__) 
+
+#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.")
+
+// 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 %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

@@ -0,0 +1,5 @@
+zookeeper_lib.c:	zookeeper_lib.h
+zkrb_wrapper_compat.c:  zkrb_wrapper_compat.h
+zkrb_wrapper.c:		zkrb_wrapper_compat.c zkrb_wrapper.h
+zookeeper_c.c:	zookeeper_lib.c zookeeper_lib.h zkrb_wrapper.c zkrb_wrapper.h dbg.h
+

data/ext/extconf.rb

@@ -0,0 +1,85 @@
+
+require 'mkmf'
+require 'rbconfig'
+
+HERE = File.expand_path(File.dirname(__FILE__))
+BUNDLE = Dir.glob("zkc-*.tar.gz").first
+BUNDLE_PATH = "c"
+
+$EXTRA_CONF = ''
+
+# CLANG!!!! jeez, if apple would only *stop* "thinking different"
+if cc = RbConfig::CONFIG['CC'] && cc =~ /^gcc/
+  $CC = cc
+  $EXTRA_CONF = "#{$EXTRA_CONF} CC=#{$CC}"
+end
+
+$CFLAGS = "#{$CFLAGS}".gsub("$(cflags)", "").gsub("-arch ppc", "")
+$LDFLAGS = "#{$LDFLAGS}".gsub("$(ldflags)", "").gsub("-arch ppc", "")
+$CXXFLAGS = " -std=gnu++98 #{$CFLAGS}"
+$CPPFLAGS = $ARCH_FLAG = $DLDFLAGS = ""
+
+if RUBY_VERSION == '1.8.7'
+  $CFLAGS << ' -DZKRB_RUBY_187'
+end
+
+ZK_DEBUG = (ENV['DEBUG'] or ARGV.any? { |arg| arg == '--debug' })
+DEBUG_CFLAGS = " -O0 -ggdb3 -DHAVE_DEBUG"
+
+if ZK_DEBUG
+  $stderr.puts "*** Setting debug flags. ***"
+  $EXTRA_CONF = "#{$EXTRA_CONF} --enable-debug"
+  $CFLAGS.gsub!(/ -O[^0] /, ' ')
+  $CFLAGS << DEBUG_CFLAGS
+end
+
+$includes = " -I#{HERE}/include"
+$libraries = " -L#{HERE}/lib -L#{RbConfig::CONFIG['libdir']}"
+$CFLAGS = "#{$includes} #{$libraries} #{$CFLAGS}"
+$LDFLAGS = "#{$libraries} #{$LDFLAGS}"
+$LIBPATH = ["#{HERE}/lib"]
+$DEFLIBPATH = []
+
+def safe_sh(cmd)
+  puts cmd
+  system(cmd)
+  unless $?.exited? and $?.success?
+    raise "command failed! #{cmd}"
+  end
+end
+
+Dir.chdir(HERE) do
+  if File.exist?("lib")
+    puts "Zkc already built; run 'rake clobber' in ext/ first if you need to rebuild."
+  else
+    puts "Building zkc."
+
+    unless File.exists?('c')
+      puts(cmd = "tar xzf #{BUNDLE} 2>&1")
+      raise "'#{cmd}' failed" unless system(cmd)
+    end
+
+    Dir.chdir(BUNDLE_PATH) do        
+      configure = "./configure --prefix=#{HERE} --with-pic --without-cppunit --disable-dependency-tracking #{$EXTRA_CONF} 2>&1"
+      
+      configure = "env CFLAGS='#{DEBUG_CFLAGS}' #{configure}" if ZK_DEBUG
+
+      safe_sh(configure)
+      safe_sh("make  2>&1")
+      safe_sh("make install 2>&1")
+    end
+
+    system("rm -rf #{BUNDLE_PATH}") unless ENV['DEBUG'] or ENV['DEV']
+  end
+end
+
+# Absolutely prevent the linker from picking up any other zookeeper_mt
+Dir.chdir("#{HERE}/lib") do
+  system("cp -f libzookeeper_mt.a libzookeeper_mt_gem.a") 
+  system("cp -f libzookeeper_mt.la libzookeeper_mt_gem.la") 
+end
+$LIBS << " -lzookeeper_mt_gem"
+
+
+create_makefile 'zookeeper_c'
+

data/ext/generate_gvl_code.rb

@@ -0,0 +1,316 @@
+#!/usr/bin/env ruby
+
+=begin
+the idea here is to take each zoo_* function declaration in the header file, and turn it into
+a calling arguments struct, a wrapper function and a macro for packing the values.
+
+so for:
+
+  ZOOAPI int 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);
+
+we want
+
+  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;
+  } zkrb_zoo_acreate_args_t;
+
+  static VALUE zkrb_gvl_zoo_acreate(void *data) {
+    zkrb_zoo_acreate_args_t *a = (zkrb_zoo_acreate_args_t *)data;
+  
+    a->rc = zoo_acreate(a->zh, a->path, a->value, a->valuelen, a->acl, a->flags, a->completion, a->data);
+  
+    return Qnil;
+  }
+
+  static 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) {
+
+    zkrb_zoo_acreate_args_t args = {
+      .rc = ZKRB_FAIL,
+      .zh = zh,
+      .path = path,
+      .value = value,
+      .valuelen = valuelen,
+      .acl = acl,
+      .flags = flags,
+      .completion = completion,
+      .data = data
+    };
+
+    zkrb_thread_blocking_region(zkrb_gvl_zoo_acreate, (void *)&args);
+
+    return args.rc;
+  }
+
+=end
+
+REGEXP = /^ZOOAPI int (zoo_[^(]+)\(([^)]+)\);$/m
+
+require 'forwardable'
+require 'stringio'
+
+ZKRB_WRAPPER_H_PATH = File.expand_path('../zkrb_wrapper.h', __FILE__)
+ZKRB_WRAPPER_C_PATH = File.expand_path('../zkrb_wrapper.c', __FILE__)
+
+# the struct that holds the call args for zoo_fn_name
+class CallStruct
+  attr_reader :zoo_fn_name, :typed_args, :name
+
+  def initialize(zoo_fn_name, typed_args)
+    @zoo_fn_name, @typed_args = zoo_fn_name, typed_args
+    @name = "zkrb_#{zoo_fn_name}_args_t"
+  end
+
+  def body
+    @body ||= (
+      lines = ["typedef struct {"]
+      lines += typed_args.map{|n| "  #{n};"}
+      lines << "  int rc;"
+      lines << "} #{name};"
+      lines.join("\n")
+    )
+  end
+end
+
+module MemberNames
+  def member_names
+    @member_names ||= typed_args.map { |n| n.split(/[ *]/).last }
+  end
+end
+
+# the zkrb_gvl_zoo_* function
+class WrapperFunction
+  extend Forwardable
+  include MemberNames
+
+  PREFIX = 'zkrb_gvl'
+
+  def_delegators :struct, :typed_args
+
+  attr_reader :struct, :name, :zoo_fn_name
+
+  def initialize(zoo_fn_name, struct)
+    @zoo_fn_name = zoo_fn_name
+    @struct = struct
+    @name = "#{PREFIX}_#{zoo_fn_name}"
+  end
+
+  def fn_signature
+    @fn_signature ||= "static VALUE #{name}(void *data)"
+  end
+
+  def body
+    @body ||= (
+      lines = ["#{fn_signature} {"]
+      lines << "  #{struct.name} *a = (#{struct.name} *)data;"
+
+      funcall = "  a->rc = #{zoo_fn_name}("
+      funcall << member_names.map { |m| "a->#{m}" }.join(', ')
+      funcall << ');'
+
+      lines << funcall
+
+      lines << "  return Qnil;"
+      lines << "}"
+      lines.join("\n")
+    )
+  end
+end
+
+# the zkrb_call_zoo_* function
+class CallingFunction
+  extend Forwardable
+  include MemberNames
+  
+  PREFIX = 'zkrb_call'
+
+  def_delegators :struct, :typed_args
+
+  attr_reader :struct, :wrapper_fn, :zoo_fn_name, :name
+
+  def initialize(zoo_fn_name, struct, wrapper_fn)
+    @zoo_fn_name, @struct, @wrapper_fn = zoo_fn_name, struct, wrapper_fn
+
+    @name = "#{PREFIX}_#{zoo_fn_name}"
+  end
+
+  def fn_signature
+    @fn_signature ||= "int #{name}(#{typed_args.join(', ')})"
+  end
+
+  def initializer_lines
+    @initializer_lines ||= member_names.map { |n| "    .#{n} = #{n}" }.join(",\n")
+  end
+
+  def top
+    <<-EOS
+// wrapper that calls #{zoo_fn_name} via #{wrapper_fn.name} inside rb_thread_blocking_region
+#{fn_signature} {
+  #{struct.name} args = {
+    .rc = ZKRB_FAIL,
+#{initializer_lines}
+  };
+    EOS
+  end
+
+  def rb_thread_blocking_region_call
+    "  zkrb_thread_blocking_region(#{wrapper_fn.name}, (void *)&args);"
+  end
+
+  def bottom
+    <<-EOS
+
+  return args.rc;
+}
+    EOS
+  end
+
+  def body
+    @body ||= [top, rb_thread_blocking_region_call, bottom].join("\n")
+  end
+end
+
+class GeneratedCode < Struct.new(:structs, :wrapper_fns, :calling_fns)
+  def initialize(*a)
+    super
+
+    self.structs     ||= []
+    self.wrapper_fns ||= []
+    self.calling_fns ||= []
+  end
+
+  def self.from_zookeeper_h(text)
+    new.tap do |code|
+      while true
+        break unless text =~ REGEXP
+        text = $~.post_match
+
+        zoo_fn_name, argstr = $1
+        argstr = $2
+
+        typed_args = argstr.split(',').map(&:strip)
+
+        # gah, fix up zoo_aset_acl which has a void_completion_t with no name assigned
+        if zoo_fn_name == 'zoo_aset_acl'
+          if idx = typed_args.index('void_completion_t')
+            typed_args[idx] = 'void_completion_t completion'
+          end
+        end
+
+        struct = CallStruct.new(zoo_fn_name, typed_args)
+        wrapper_fn = WrapperFunction.new(zoo_fn_name, struct)
+        calling_fn = CallingFunction.new(zoo_fn_name, struct, wrapper_fn)
+
+        code.structs << struct
+        code.wrapper_fns << wrapper_fn
+        code.calling_fns << calling_fn
+      end
+    end
+  end
+end
+
+def render_header_file(code)
+  StringIO.new('zkrb_wrapper.h', 'w').tap do |fp|
+    fp.puts <<-EOS
+#ifndef ZKRB_WRAPPER_H
+#define ZKRB_WRAPPER_H
+#if 0
+
+  AUTOGENERATED BY #{File.basename(__FILE__)} 
+
+#endif
+
+#include "ruby.h"
+#include "c-client-src/zookeeper.h"
+#include "zkrb_wrapper_compat.h"
+#include "dbg.h"
+
+#define ZKRB_FAIL -1
+
+    EOS
+
+    code.structs.each do |struct|
+      fp.puts(struct.body)
+      fp.puts
+    end
+
+    code.calling_fns.each do |cf|
+      fp.puts "#{cf.fn_signature};"
+    end
+
+    fp.puts <<-EOS
+
+#endif /* ZKRB_WRAPPER_H */
+    EOS
+
+  end.string
+end
+
+def render_c_file(code)
+  StringIO.new('zkrb_wrapper.c', 'w').tap do |fp|
+    fp.puts <<-EOS
+/*
+
+Autogenerated boilerplate wrappers around zoo_* function calls necessary for using
+rb_thread_blocking_region to release the GIL when calling native code.
+
+generated by ext/#{File.basename(__FILE__)}
+
+*/
+
+#include "ruby.h"
+#include "zkrb_wrapper.h"
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+    EOS
+
+    code.wrapper_fns.zip(code.calling_fns) do |wrap_fn, call_fn|
+      fp.puts "#{wrap_fn.body}\n\n"
+      fp.puts "#{call_fn.body}\n\n"
+    end
+
+  end.string
+end
+
+
+def help!
+  $stderr.puts "usage: #{File.basename(__FILE__)} {all|headers|code}"
+  exit 1
+end
+
+def main
+  help! if ARGV.empty?
+  
+  text = File.read('c/include/zookeeper.h')
+  code = GeneratedCode.from_zookeeper_h(text)
+
+  cmd = ARGV.first
+
+  help! unless %w[headers all code].include?(cmd)
+
+  if %w[headers all].include?(cmd)
+    $stderr.puts "writing #{ZKRB_WRAPPER_H_PATH}"
+    File.open(ZKRB_WRAPPER_H_PATH, 'w') { |fp| fp.write(render_header_file(code)) }
+  end
+
+  if %w[code all].include?(cmd)
+    $stderr.puts "writing #{ZKRB_WRAPPER_C_PATH}"
+    File.open(ZKRB_WRAPPER_C_PATH, 'w') { |fp| fp.write(render_c_file(code)) }
+  end
+
+end
+
+main
+