zookeeper-ng 1.5

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'
+  DRIVER_VERSION = '3.4.5'
+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
+

data/spec/chrooted_connection_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'shared/connection_examples'
+
+describe 'Zookeeper chrooted' do
+  let(:path) { "/_zkchroottest_" }
+  let(:data) { "underpants" } 
+  let(:chroot_path) { '/slyphon-zookeeper-chroot' }
+
+  let(:connection_string) { "#{Zookeeper.default_cnx_str}#{chroot_path}" }
+
+  before do
+    @zk = Zookeeper.new(connection_string)
+  end
+
+  after do
+    @zk and @zk.close
+  end
+
+  def zk
+    @zk
+  end
+
+  describe 'non-existent' do
+    describe 'with existing parent' do
+      let(:chroot_path) { '/one-level' }
+
+      describe 'create' do
+        before do
+          with_open_zk { |z| rm_rf(z, chroot_path) }
+        end
+
+        after do
+          with_open_zk { |z| rm_rf(z, chroot_path) }
+        end
+
+        it %[should successfully create the path] do
+          rv = zk.create(:path => '/', :data => '')
+          rv[:rc].should be_zero
+          rv[:path].should == ''
+        end
+      end
+    end
+
+    describe 'with missing parent' do
+      let(:chroot_path) { '/deeply/nested/path' }
+
+      describe 'create' do
+        before do
+          with_open_zk do |z|
+            rm_rf(z, chroot_path)
+          end
+        end
+
+        it %[should return ZNONODE] do
+          rv = zk.create(:path => '/', :data => '')
+          rv[:rc].should_not be_zero
+          rv[:rc].should == Zookeeper::Exceptions::ZNONODE
+        end
+      end
+    end
+  end
+
+
+  describe do
+    before :all do
+      logger.warn "running before :all"
+
+      with_open_zk do |z|
+        z.create(:path => chroot_path, :data => '')
+      end
+    end
+
+    after :all do
+      with_open_zk do |z|
+        rm_rf(z, chroot_path)
+      end
+    end
+
+    it_should_behave_like "connection"
+  end
+end
+
+

data/spec/compatibilty_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe 'Compatibiliy layer' do
+  it %[should raise the correct error when a const is missing] do
+    lambda { Zookeeper::THISISANINVALIDCONST }.should raise_error(NameError)
+  end
+end
+

data/spec/default_watcher_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Zookeeper do
+  describe :initialize, 'with watcher block' do
+    before do
+      @events = []
+      @watch_block = lambda do |hash| 
+        logger.debug "watch_block: #{hash.inspect}"
+        @events << hash
+      end
+
+      @zk = Zookeeper.new(Zookeeper.default_cnx_str, 10, @watch_block)
+
+      wait_until(2) { @zk.connected? }
+      @zk.should be_connected
+      logger.debug "connected!"
+
+      wait_until(2) { !@events.empty? }
+      logger.debug "got events!"
+    end
+
+    after do
+      @zk.close if @zk.connected?
+    end
+
+    it %[should receive initial connection state events] do
+      @events.should_not be_empty
+      @events.length.should == 1
+      @events.first[:state].should == Zookeeper::ZOO_CONNECTED_STATE
+    end
+
+    it %[should receive disconnection events] do
+      pending "the C driver doesn't appear to deliver disconnection events (?)"
+      @events.clear
+      @zk.close
+      wait_until(2) { !@events.empty? }
+      @events.should_not be_empty
+    end
+  end
+end
+

data/spec/em_spec.rb

@@ -0,0 +1,51 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'zookeeper/em_client'
+
+gem 'evented-spec', '~> 0.9.0'
+require 'evented-spec'
+
+
+describe 'ZookeeperEM' do
+  describe 'Client' do
+    include EventedSpec::SpecHelper
+    default_timeout 3.0
+
+    def setup_zk
+      @zk = ZookeeperEM::Client.new(Zookeeper.default_cnx_str)
+      em do
+        @zk.on_attached do
+          yield
+        end
+      end
+    end
+
+    def teardown_and_done
+      @zk.close do 
+        logger.debug { "TEST: about to call done" }
+        EM.next_tick do
+          done
+        end
+      end
+    end
+
+    describe 'callbacks' do
+      it %[should be called on the reactor thread] do
+        cb = lambda do |h|
+          EM.reactor_thread?.should be_true
+          logger.debug { "called back on the reactor thread? #{EM.reactor_thread?}" }
+          teardown_and_done
+        end
+
+        setup_zk do
+          @zk.on_attached do |*|
+            logger.debug { "on_attached called" }
+            rv = @zk.get(:path => '/', :callback => cb) 
+            logger.debug { "rv from @zk.get: #{rv.inspect}" }
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/spec/ext/zookeeper_base_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+unless defined?(::JRUBY_VERSION)
+  describe Zookeeper::ZookeeperBase do
+    before do
+      @zk = described_class.new(Zookeeper.default_cnx_str)
+    end
+
+    after do
+      @zk.close unless @zk.closed?
+    end
+
+    it %[should have an original_pid assigned] do
+      @zk.original_pid.should == Process.pid
+    end
+  end
+end
+
+

data/spec/forked_connection_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+unless defined?(::JRUBY_VERSION)
+  describe %[forked connection] do
+    let(:path) { "/_zktest_" }
+    let(:pids_root) { "#{path}/pids" }
+    let(:data) { "underpants" } 
+    let(:connection_string) { Zookeeper.default_cnx_str }
+
+    def process_alive?(pid)
+      Process.kill(0, @pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    LBORDER = ('-' * 35) << '< '
+    RBORDER = ' >' << ('-' * 35) 
+
+    def mark(thing)
+      logger << "\n#{LBORDER}#{thing}#{RBORDER}\n\n"
+    end
+
+    before do
+      mark "BEFORE: START"
+      if defined?(::Rubinius)
+        pending("this test is currently broken in rbx")
+#       elsif ENV['TRAVIS']
+#         pending("this test is currently hanging in travis")
+      else
+        @zk = Zookeeper.new(connection_string)
+        rm_rf(@zk, path)
+      end
+      mark "BEFORE: END"
+    end
+
+    after do
+      mark "AFTER: START"
+
+      if @pid and process_alive?(@pid)
+        begin
+          Process.kill('KILL', @pid)
+          p Process.wait2(@pid)
+        rescue Errno::ESRCH
+        end
+      end
+
+      @zk.close if @zk and !@zk.closed?
+      with_open_zk(connection_string) { |z| rm_rf(z, path) }
+
+      mark "AFTER: END"
+    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
+
+    it %[should do the right thing and not fail] do
+      mark "TEST: START"
+
+      @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)
+
+      @zk.pause_before_fork_in_parent
+
+      mark "FORK"
+
+      @pid = fork do
+        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
+
+      @zk.resume_after_fork_in_parent
+
+      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
+
+      status.should_not be_signaled
+      status.should be_success
+
+      event_waiter_th.join(5).should == event_waiter_th
+      @event.should_not be_nil
+    end
+  end
+end