zookeeper-ng 1.5.2.1-java

data/lib/zookeeper/logger.rb

@@ -0,0 +1,39 @@
+module Zookeeper
+  module Logger
+    def self.wrapped_logger
+      if defined?(@@wrapped_logger)
+        @@wrapped_logger 
+      else
+        @@wrapped_logger = ::Logger.new(STDERR).tap { |l| l.level = ::Logger::FATAL }
+      end
+    end
+
+    def self.wrapped_logger=(log)
+      @@wrapped_logger = log
+    end
+
+    # @private
+    module ClassMethods
+      def logger
+        ::Zookeeper.logger || ForwardingLogger.for(::Zookeeper::Logger.wrapped_logger, _zk_logger_name)
+      end
+    end
+
+    def self.included(base)
+      # return false if base < self    # avoid infinite recursion
+      base.extend(ClassMethods)
+    end
+
+    private
+      def log_realtime(what)
+        logger.debug do
+          t = Benchmark.realtime { yield }
+          "#{what} took #{t} sec"
+        end
+      end
+
+      def logger
+        @logger ||= (::Zookeeper.logger || self.class.logger)
+      end
+  end # Logger
+end # Zookeeper

data/lib/zookeeper/monitor.rb

@@ -0,0 +1,19 @@
+module Zookeeper
+  # just like stdlib Monitor but provides the SAME API AS MUTEX, FFS!
+  class Monitor
+    include MonitorMixin
+
+    alias try_enter try_mon_enter
+    alias enter mon_enter
+    alias exit mon_exit
+
+    # here, HERE!
+    # *here* are the methods that are the same
+    # god *dammit*
+
+    alias lock mon_enter
+    alias unlock mon_exit
+    alias try_lock try_mon_enter
+  end
+end
+

data/lib/zookeeper/rake_tasks.rb

@@ -0,0 +1,165 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Zookeeper
+  # @private
+  module RakeTasks
+    def self.define_test_tasks_for(*rubies)
+      rubies.each do |r|
+
+        TestOneRuby.new(:name => r) do |tor|
+          yield tor if block_given?
+        end
+      end
+    end
+
+    class TestOneRuby < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
+
+      DEFAULT_RVM_RUBY_NAME = '1.9.3'
+
+      # defaults to 'zk', test tasks will be built under this
+      attr_accessor :namespace
+
+      # the name of the task
+      # (tasks will be 'zk:1.9.3:run_rspec')
+      #
+      # this is mainly here so that the rvm ruby name rbx-2.0.testing 
+      # will have its tasks defined as 'zk:rbx'
+      attr_accessor :name
+
+      # what is the rvm name we should use for testing? (i.e. could be an alias)
+      # defaults to {#name}
+      attr_accessor :rvm_ruby_name
+
+      # any extra environment variables?
+      attr_accessor :env
+
+      # gemset name to use, deafults to the name of the gemspec in the top of the
+      # project directory (minus the .gempsec)
+      attr_accessor :gemset_name
+
+      # @private
+      attr_reader :ruby_with_gemset,       
+        :create_gemset_name,
+        :clobber_task_name,
+        :clean_task_name,
+        :build_task_name,
+        :bundle_task_name,
+        :rspec_task_name,
+        :phony_gemfile_link_name,
+        :phony_gemfile_lock_name
+
+
+      def self.default_gemset_name
+        ary = Dir['*.gemspec']
+        raise 'No gemspec found' if ary.empty?
+        ary.first[/(.+)\.gemspec\Z/, 1]
+      end
+
+      def initialize(opts={})
+        @namespace      = 'zk'
+        @name           = nil
+        @env            = {}
+        @rvm_ruby_name  = nil
+        @gemset_name    = nil
+
+        opts.each { |k,v| __send__(:"#{k}=", v) }
+
+        yield self if block_given?
+
+        @gemset_name    ||= self.class.default_gemset_name
+        
+        # XXX: add an exception just for me in here (yes, i know this is naughty)
+        #      or else i'd have to do this in every zk variant i want to test
+        #      (like i have to now)
+
+        unless @rvm_ruby_name
+          @rvm_ruby_name = 'rbx-2.0.testing' if @name == 'rbx'
+        end
+
+        @rvm_ruby_name  ||= name
+
+        @ruby_with_gemset         = "#{@rvm_ruby_name}@#{@gemset_name}"
+        @create_gemset_name       = "#{namespace}:#{name}:create_gemset"
+        @clobber_task_name        = "#{namespace}:#{name}:clobber"
+        @clean_task_name          = "#{namespace}:#{name}:clean"
+        @build_task_name          = "#{namespace}:#{name}:build"
+        @bundle_task_name         = "#{namespace}:#{name}:bundle_install"
+        @rspec_task_name          = "#{namespace}:#{name}:run_rspec"
+        @phony_gemfile_link_name  = "Gemfile.#{name}"
+        @phony_gemfile_lock_name  = "#{phony_gemfile_link_name}.lock"
+
+        define_tasks
+      end
+
+      private
+        def need_ext_build?
+          name != 'jruby' && File.directory?('./ext')
+        end
+
+        def define_tasks
+          file phony_gemfile_link_name do
+            # apparently, rake doesn't deal with symlinks intelligently :P
+            ln_s('Gemfile', phony_gemfile_link_name) unless File.symlink?(phony_gemfile_link_name)
+          end
+
+          task :clean do
+            rm_rf [phony_gemfile_lock_name, phony_gemfile_lock_name]
+          end
+
+          task create_gemset_name do
+            sh "rvm #{rvm_ruby_name} do rvm gemset create #{gemset_name}"
+          end
+
+          task clobber_task_name do
+            if need_ext_build?
+              cd 'ext' do
+                sh "rake clobber"
+              end
+            end
+          end
+
+          task clean_task_name do
+            if need_ext_build?
+              cd 'ext' do
+                sh "rake clean"
+              end
+            end
+          end
+
+          task build_task_name => [create_gemset_name, clean_task_name] do
+            if need_ext_build?
+              cd 'ext' do
+                sh "rvm #{ruby_with_gemset} do rake build"
+              end
+            end
+          end
+
+          task bundle_task_name => [phony_gemfile_link_name, build_task_name] do
+            sh "rvm #{ruby_with_gemset} do bundle install --gemfile #{phony_gemfile_link_name}"
+          end
+
+          task rspec_task_name => bundle_task_name do
+            sh "rvm #{ruby_with_gemset} do env BUNDLE_GEMFILE=#{phony_gemfile_link_name} bundle exec rspec spec --fail-fast"
+          end
+
+          task "#{namespace}:#{name}" => rspec_task_name
+
+          task "#{namespace}:test_all_rubies" => rspec_task_name
+
+          unless Rake::Task.task_defined?("#{namespace}:test_all")
+            task "#{namespace}:test_all" do
+              require 'benchmark'
+              t = Benchmark.realtime do
+                Rake::Task["#{namespace}:test_all_rubies"].invoke
+              end
+
+              $stderr.puts "Test run took: #{t} s"
+            end
+          end
+        end
+    end
+  end
+end
+

data/lib/zookeeper/request_registry.rb

@@ -0,0 +1,153 @@
+module Zookeeper
+  class RequestRegistry
+    include Constants
+    include Logger
+
+    # @param [Hash] opts
+    # @option opts [String] :chroot_path (nil) if given, will be used to
+    #   correct a discrepancy between the C and Java clients when using a
+    #   chrooted connection. If given, the chroot path will be stripped from
+    #   the string returned by a `create`. It should be an absolute path.
+    #
+    def initialize(watcher, opts={})
+      @mutex = Monitor.new
+
+      @default_watcher  = watcher
+
+      @current_req_id   = 0
+      @watcher_reqs     = {}
+      @completion_reqs  = {}
+
+      @chroot_path = opts[:chroot_path]
+    end
+
+    def default_watcher
+      @mutex.synchronize { @default_watcher }
+    end
+
+    def default_watcher=(blk)
+      @mutex.synchronize { @default_watcher = blk }
+    end
+
+    def setup_call(meth_name, opts)
+      req_id = nil
+      @mutex.synchronize {
+        req_id = @current_req_id
+        @current_req_id += 1
+        setup_completion(req_id, meth_name, opts) if opts[:callback]
+        setup_watcher(req_id, opts)               if opts[:watcher]
+      }
+      req_id
+    end
+
+    def get_context_for(hash)
+      return nil unless hash
+
+      is_session_event  = (hash[:type] == ZOO_SESSION_EVENT)
+
+      req_id  = hash.fetch(:req_id)
+
+      if hash.has_key?(:rc)
+        get_completion(req_id, :keep => is_session_event)
+      else
+        get_watcher(req_id, :keep => is_session_event)
+      end
+    end
+
+    def clear_watchers!
+      @mutex.synchronize { @watcher_reqs.clear }
+    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
+
+    private
+      def get_completion(req_id, opts={})
+        @mutex.synchronize do
+          if opts[:keep] 
+            @completion_reqs[req_id]
+          else
+            @completion_reqs.delete(req_id)
+          end
+        end
+      end
+
+      # Return the watcher hash associated with the req_id. If the req_id
+      # is the ZKRB_GLOBAL_CB_REQ, then does not clear the req from the internal
+      # store, otherwise the req_id is removed.
+      #
+      def get_watcher(req_id, opts={})
+        @mutex.synchronize do
+          if Constants::ZKRB_GLOBAL_CB_REQ == req_id
+            { :watcher => @default_watcher, :watcher_context => nil }
+          elsif opts[:keep]
+            @watcher_reqs[req_id]
+          else
+            @watcher_reqs.delete(req_id)
+          end
+        end
+      end
+
+
+      def setup_watcher(req_id, call_opts)
+        @mutex.synchronize do
+          @watcher_reqs[req_id] = { 
+            :watcher => call_opts[:watcher],
+            :context => call_opts[:watcher_context] 
+          }
+        end
+      end
+
+      # as a hack, to provide consistency between the java implementation and the C
+      # implementation when dealing w/ chrooted connections, we override this in
+      # ext/zookeeper_base.rb to wrap the callback in a chroot-path-stripping block.
+      #
+      # we don't use meth_name here, but we need it in the C implementation
+      #
+      def setup_completion(req_id, meth_name, call_opts)
+        @mutex.synchronize do
+          @completion_reqs[req_id] = { 
+            :callback => maybe_wrap_callback(meth_name, call_opts[:callback]),
+            :context  => call_opts[:callback_context]
+          }
+        end
+      end
+
+      # 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
+      # strip the chroot path from the returned path (important in an async create
+      # sequential call). This is the only place where we can hook *just* the C
+      # version. The non-async manipulation is handled in ZookeeperBase#create.
+      # 
+      # TODO: need to move the continuation setup into here, so that it can get 
+      #       added to the callback hash
+      #
+      def maybe_wrap_callback(meth_name, cb)
+        return cb unless cb and chrooted? and (meth_name == :create)
+
+        lambda do |hash|
+          # in this case the string will be the absolute zookeeper path (i.e.
+          # with the chroot still prepended to the path). Here's where we strip it off
+          hash[:string] = strip_chroot_from(hash[:string])
+
+          # call the original callback
+          cb.call(hash)
+        end
+      end
+      
+      def chrooted?
+        @chroot_path && !@chroot_path.empty?
+      end
+
+      def default_watcher_proc
+        Proc.new { |args|
+          logger.debug { "Ruby ZK Global CB called type=#{event_by_value(args[:type])} state=#{state_by_value(args[:state])}" }
+          true
+        }
+      end
+  end
+end
+

data/lib/zookeeper/stat.rb

@@ -0,0 +1,21 @@
+module Zookeeper
+class Stat
+  attr_reader :version, :exists, :czxid, :mzxid, :ctime, :mtime, :cversion, :aversion, :ephemeralOwner, :dataLength, :numChildren, :pzxid
+
+  alias :ephemeral_owner :ephemeralOwner
+  alias :num_children :numChildren
+  alias :data_length :dataLength
+
+  def initialize(val)
+    @exists = !!val
+    @czxid, @mzxid, @ctime, @mtime, @version, @cversion, @aversion,
+        @ephemeralOwner, @dataLength, @numChildren, @pzxid = val if val.is_a?(Array)
+    val.each { |k,v| instance_variable_set "@#{k}", v } if val.is_a?(Hash)
+    raise ArgumentError unless (val.is_a?(Hash) or val.is_a?(Array) or val.nil?)
+  end
+
+  def exists?
+    @exists
+  end
+end
+end

data/lib/zookeeper/version.rb

@@ -0,0 +1,4 @@
+module Zookeeper
+  VERSION = '1.5.2.1'
+  DRIVER_VERSION = '3.4.5'
+end

data/lib/zookeeper.rb

@@ -0,0 +1,115 @@
+# Ruby wrapper for the Zookeeper C API
+
+require 'thread'
+require 'monitor'
+require 'forwardable'
+require 'logger'
+require 'benchmark'
+
+module Zookeeper
+  ZOOKEEPER_ROOT = File.expand_path('../..', __FILE__)
+
+  # require a path relative to the lib directory
+  # this is to avoid monkeying explicitly with $LOAD_PATH
+  #
+  # @private
+  def self.require_lib(*relpaths)
+    relpaths.each do |relpath|
+      require File.join(ZOOKEEPER_ROOT, 'lib', relpath)
+    end
+  end
+
+  # require a path that's relative to ZOOKEEPER_ROOT
+  # @private
+  def self.require_root(*relpaths)
+    relpaths.each do |relpath|
+      require File.join(ZOOKEEPER_ROOT, relpath)
+    end
+  end
+end
+
+Zookeeper.require_lib(
+  'zookeeper/core_ext',
+  'zookeeper/monitor',
+  'zookeeper/logger',
+  'zookeeper/logger/forwarding_logger',
+  'zookeeper/forked',
+  'zookeeper/latch',
+  'zookeeper/acls',
+  'zookeeper/constants',
+  'zookeeper/exceptions',
+  'zookeeper/continuation',
+  'zookeeper/common',
+  'zookeeper/request_registry',
+  'zookeeper/callbacks',
+  'zookeeper/stat',
+  'zookeeper/client_methods'
+)
+
+# ok, now we construct the client
+Zookeeper.require_lib 'zookeeper/client'
+
+module Zookeeper
+  include Constants
+  #::Logger.new($stderr).tap { |l| l.level = ENV['ZOOKEEPER_DEBUG'] ? ::Logger::DEBUG : ::Logger::ERROR } 
+  #
+  
+  @@logger = nil unless defined?(@@logger)
+  
+  def self.logger
+    @@logger
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  # @private
+  def self.deprecation_warnings?
+    @deprecation_warnings = true if @deprecation_warnings.nil?
+  end
+
+  # set this to false to mute Zookeeper related deprecation warnings...
+  # __AT YOUR PERIL__
+  def self.deprecation_warnings=(v)
+    @deprecation_warnings = v
+  end
+
+  # @private
+  def self.deprecation_warning(warning)
+    Kernel.warn(warning) if deprecation_warnings?
+  end
+
+  # for expert use only. set the underlying debug level for the C layer, has no
+  # effect in java
+  #
+  # @private
+  def self.set_debug_level(val)
+    if defined?(CZookeeper)
+      CZookeeper.set_debug_level(val.to_i)
+    end
+  end
+
+  # @private
+  def self.get_debug_level
+    if defined?(CZookeeper)
+      CZookeeper.get_debug_level
+    end
+  end
+
+  class << self
+    # @private
+    alias :debug_level= :set_debug_level
+    
+    # @private
+    alias :debug_level :get_debug_level
+  end
+end
+
+# just for first test, get rid of this soon
+Zookeeper.require_lib 'zookeeper/compatibility'
+
+if ENV['ZKRB_DEBUG']
+  Zookeeper.debug_level = Zookeeper::Constants::ZOO_LOG_LEVEL_DEBUG
+end
+

data/notes.txt

@@ -0,0 +1,14 @@
+Notes on this fork of http://github.com/twitter/zookeeper
+
+The main purpose of this fork is to provide JRuby compatibility with the MRI driver of the original. We have been using an early fork with an incomplete binding to the C client, and had recently bumped up against a fairly serious bug with handling events. The twitter/zookeeper driver solved this problem but was lacking JRuby support (which is a core piece of our environment).
+
+I've packaged the Java client (and its dependency on log4j) as gems that are installed separately from this codebase to cut down on the size of the zookeeper gem. If this poses a problem (for instance, if the original goal was to have an all-in-one install with no external dependencies), it would be trivial to package those jars along with this code.
+
+In the course of writing the wrapper for JRuby, I've written nearly-complete specs for all of the public API methods: get, set, get_children, stat, create, delete, get_acl, and set_acl. The reason I say they're "nearly" complete is that I have no use for set_acl, and quite honestly, couldn't figure out how to make it work. 
+
+I'm planning on writing a companion gem, 'ZK', that would take some of the higher-level constructs that we'd written around the lower-level driver to implement features like locking and queues, and also to provide a more ruby-like interface.
+
+I'd like to reorganize this codebase in a number of ways, most of all to move all of the various classes and modules under a common "Zookeeper" namespace, however I thought that would be a radical enough change where I'd want to discuss/coordinate with you on how exactly to do it.
+
+
+

data/scripts/upgrade-1.0-sed-alike.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+if ARGV.empty?
+  $stderr.puts <<-EOS
+Usage: #{File.basename(__FILE__)} file1 file2 file3
+
+Fix references to Zookeeper classes and modules.
+
+This script acts like sed and edits files in place (not saving backups,
+as you *are* using source control and aren't a complete tool). 
+
+if you have any doubts, *read the script*:
+----------------------------------------------------------------------
+
+#{File.read(__FILE__)}
+
+  EOS
+
+  exit 1
+end
+
+
+require 'tempfile'
+require 'fileutils'
+
+ARGV.each do |path|
+  Tempfile.open(File.basename(path)) do |tmp|
+    File.open(path) do |input|
+      while line = input.gets
+        tmp.puts line.gsub(/\bZookeeperStat::Stat\b/, 'Zookeeper::Stat').
+          gsub(/\bZookeeper::(\w+)Callback\b/, 'Zookeeper::Callbacks::\1Callback').
+          gsub(/\bZookeeperACLs::(ZOO_\w+)\b/, 'Zookeeper::Constants::\1').
+          gsub(/\bZookeeperExceptions::ZookeeperException::(\w+)\b/, 'Zookeeper::Exceptions::\1').
+          gsub(/\bZookeeper(Constants|Exceptions|Common|ACLs|Callbacks)\b/, 'Zookeeper::\1').
+          gsub(/\bZookeeperException::(\w+)\b/, 'Exceptions::\1')
+
+      end
+    end
+
+    tmp.fsync
+    tmp.close
+
+    FileUtils.mv(tmp.path, path)
+  end
+end
+

data/spec/c_zookeeper_spec.rb

@@ -0,0 +1,51 @@
+# tests the CZookeeper, obviously only available when running under MRI
+
+unless defined?(::JRUBY_VERSION)
+  require 'spec_helper'
+
+  describe Zookeeper::CZookeeper do
+    def pop_all_events
+      [].tap do |rv|
+        begin
+          rv << @event_queue.pop(non_blocking=true)
+        rescue ThreadError
+        end
+      end
+    end
+
+    def wait_until_connected(timeout=10)
+      wait_until(timeout) { @czk.state == Zookeeper::Constants::ZOO_CONNECTED_STATE }
+    end
+
+    describe do
+      before do
+        @event_queue = Zookeeper::Common::QueueWithPipe.new
+        @czk = Zookeeper::CZookeeper.new(Zookeeper.default_cnx_str, @event_queue)
+      end
+
+      after do
+        @czk.close rescue Exception
+        @event_queue.close rescue Exception
+      end
+
+      it %[should be in connected state within a reasonable amount of time] do
+        wait_until_connected.should be_true
+      end
+
+      describe :after_connected do
+        before do
+          wait_until_connected.should be_true
+        end
+
+        it %[should have a connection event after being connected] do
+          event = wait_until(10) { @event_queue.pop }
+          event.should be
+          event[:req_id].should == Zookeeper::Constants::ZKRB_GLOBAL_CB_REQ
+          event[:type].should   == Zookeeper::Constants::ZOO_SESSION_EVENT
+          event[:state].should  == Zookeeper::Constants::ZOO_CONNECTED_STATE
+        end
+      end
+    end
+  end
+end
+