slyphon-zookeeper 0.1.0

data/lib/zookeeper/exceptions.rb

@@ -0,0 +1,92 @@
+module ZookeeperExceptions
+  # exceptions/errors
+  ZOK                    =  0
+  ZSYSTEMERROR           = -1
+  ZRUNTIMEINCONSISTENCY  = -2
+  ZDATAINCONSISTENCY     = -3
+  ZCONNECTIONLOSS        = -4
+  ZMARSHALLINGERROR      = -5
+  ZUNIMPLEMENTED         = -6
+  ZOPERATIONTIMEOUT      = -7
+  ZBADARGUMENTS          = -8
+  ZINVALIDSTATE          = -9
+  
+  # api errors
+  ZAPIERROR                 = -100
+  ZNONODE                   = -101
+  ZNOAUTH                   = -102
+  ZBADVERSION               = -103
+  ZNOCHILDRENFOREPHEMERALS  = -108
+  ZNODEEXISTS               = -110
+  ZNOTEMPTY                 = -111
+  ZSESSIONEXPIRED           = -112
+  ZINVALIDCALLBACK          = -113
+  ZINVALIDACL               = -114
+  ZAUTHFAILED               = -115
+  ZCLOSING                  = -116
+  ZNOTHING                  = -117
+  ZSESSIONMOVED             = -118
+
+  class ZookeeperException < Exception
+    class EverythingOk            < ZookeeperException; end
+    class SystemError             < ZookeeperException; end
+    class RunTimeInconsistency    < ZookeeperException; end
+    class DataInconsistency       < ZookeeperException; end
+    class ConnectionLoss          < ZookeeperException; end
+    class MarshallingError        < ZookeeperException; end
+    class Unimplemented           < ZookeeperException; end
+    class OperationTimeOut        < ZookeeperException; end
+    class BadArguments            < ZookeeperException; end
+    class InvalidState            < ZookeeperException; end
+    class ApiError                < ZookeeperException; end
+    class NoNode                  < ZookeeperException; end
+    class NoAuth                  < ZookeeperException; end
+    class BadVersion              < ZookeeperException; end
+    class NoChildrenForEphemerals < ZookeeperException; end
+    class NodeExists              < ZookeeperException; end
+    class NotEmpty                < ZookeeperException; end
+    class SessionExpired          < ZookeeperException; end
+    class InvalidCallback         < ZookeeperException; end
+    class InvalidACL              < ZookeeperException; end
+    class AuthFailed              < ZookeeperException; end
+    class Closing                 < ZookeeperException; end
+    class Nothing                 < ZookeeperException; end
+    class SessionMoved            < ZookeeperException; end
+    class ConnectionClosed        < ZookeeperException; end  # this is a Ruby client exception
+    
+    def self.by_code(code)
+      case code
+        when ZOK then EverythingOk
+        when ZSYSTEMERROR then SystemError
+        when ZRUNTIMEINCONSISTENCY then RunTimeInconsistency
+        when ZDATAINCONSISTENCY then DataInconsistency
+        when ZCONNECTIONLOSS then ConnectionLoss
+        when ZMARSHALLINGERROR then MarshallingError
+        when ZUNIMPLEMENTED then Unimplemented
+        when ZOPERATIONTIMEOUT then OperationTimeOut
+        when ZBADARGUMENTS then BadArguments
+        when ZINVALIDSTATE then InvalidState
+        when ZAPIERROR then ApiError
+        when ZNONODE then NoNode
+        when ZNOAUTH then NoAuth
+        when ZBADVERSION then BadVersion
+        when ZNOCHILDRENFOREPHEMERALS then NoChildrenForEphemerals 
+        when ZNODEEXISTS then NodeExists              
+        when ZNOTEMPTY then NotEmpty                
+        when ZSESSIONEXPIRED then SessionExpired          
+        when ZINVALIDCALLBACK then InvalidCallback         
+        when ZINVALIDACL then InvalidACL
+        when ZAUTHFAILED then AuthFailed
+        when ZCLOSING then Closing
+        when ZNOTHING then Nothing
+        when ZSESSIONMOVED then SessionMoved
+      else Exception.new("no exception defined for code #{code}")
+      end
+    end
+    
+    def self.raise_on_error(code)
+      exc = self.by_code(code)
+      raise exc unless exc == EverythingOk
+    end
+  end
+end

data/lib/zookeeper/stat.rb

@@ -0,0 +1,17 @@
+module ZookeeperStat
+  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
+  end
+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/slyphon-zookeeper.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "slyphon-zookeeper"
+  s.version     = '0.1.0'
+
+  s.authors     = ["Phillip Pearson", "Eric Maland", "Evan Weaver", "Brian Wickman", "Jonathan D. Simms"]
+  s.email       = ["slyphon@gmail.com"]
+  s.summary     = %q{twitter's zookeeper client}
+  s.description = s.summary
+
+  s.add_development_dependency "rspec", ">= 2.0.0"
+  s.add_development_dependency 'flexmock', '~> 0.8.11'
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  if ENV['JAVA_GEM']
+    s.platform = 'java'
+    s.add_runtime_dependency('slyphon-log4j',         '= 1.2.15')
+    s.add_runtime_dependency('slyphon-zookeeper_jar', '= 3.3.1')
+    s.require_paths += %w[java]
+  else
+    s.require_paths += %w[ext]
+    s.extensions = 'ext/extconf.rb'
+  end
+
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+end

data/spec/default_watcher_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../spec_helper', __FILE__) 
+
+describe Zookeeper do
+  describe :initialize, 'with watcher block' do
+    before do
+      @events = []
+      @watch_block = lambda do |hash| 
+        $stderr.puts "watch_block: #{hash.inspect}"
+        @events << hash
+      end
+
+      @zk = Zookeeper.new('localhost:2181', 10, @watch_block)
+
+      wait_until(2) { @zk.connected? }
+      @zk.should be_connected
+      $stderr.puts "connected!"
+
+      wait_until(2) { !@events.empty? }
+      $stderr.puts "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/log4j.properties

@@ -0,0 +1,17 @@
+log4j.rootLogger        = DEBUG,S
+
+log4j.appender.S        = org.apache.log4j.FileAppender
+log4j.appender.S.File   = /tmp/zk-test.log
+
+log4j.appender.S.layout = org.apache.log4j.PatternLayout
+log4j.appender.S.layout.ConversionPattern  = %5p [%t] (%c:%F:%L) - %m%n
+
+log4j.appender.C        = org.apache.log4j.FileAppender
+log4j.appender.C.File   = /tmp/zk-test-client.log
+
+log4j.appender.C.layout = org.apache.log4j.PatternLayout
+log4j.appender.C.layout.ConversionPattern  = %5p [%t] (%c:%F:%L) - %m%n
+
+log4j.org.apache.zookeeper.ZooKeeper = DEBUG,C
+log4j.org.apache.zookeeper.server    = DEBUG,S
+

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+$LOAD_PATH.unshift(File.expand_path('../../ext', __FILE__))
+$LOAD_PATH.uniq!
+
+require 'rubygems'
+
+gem 'flexmock', '~> 0.8.11'
+
+require 'flexmock'
+require 'zookeeper'
+
+Zookeeper.logger = Logger.new(File.expand_path('../../test.log', __FILE__)).tap do |log|
+  log.level = Logger::DEBUG
+end
+
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+end
+
+
+# method to wait until block passed returns true or timeout (default is 10 seconds) is reached 
+def wait_until(timeout=10, &block)
+  time_to_stop = Time.now + timeout
+  until yield do 
+    break if Time.now > time_to_stop
+    sleep 0.3
+  end
+end
+
+

data/spec/zookeeper_spec.rb

@@ -0,0 +1,924 @@
+require File.expand_path('../spec_helper', __FILE__) 
+
+shared_examples_for "all success return values" do
+  it %[should have a return code of Zookeeper::ZOK] do
+    @rv[:rc].should == Zookeeper::ZOK
+  end
+
+  it %[should have a req_id integer] do
+    @rv[:req_id].should be_kind_of(Integer)
+  end
+end
+
+describe Zookeeper do
+  before do
+    @path = "/_zktest_"
+    @data = "underpants"
+
+    @zk = Zookeeper.new('localhost:2181')
+
+    # uncomment for driver debugging output
+    #@zk.set_debug_level(Zookeeper::ZOO_LOG_LEVEL_DEBUG) unless defined?(::JRUBY_VERSION)
+
+    @zk.create(:path => @path, :data => @data)
+  end
+
+  after do
+    @zk.delete(:path => @path)
+    @zk.close
+
+    wait_until do 
+      begin
+        !@zk.connected?
+      rescue RuntimeError
+        true
+      end
+    end
+  end
+
+  # unfortunately, we can't test w/o exercising other parts of the driver, so
+  # if "set" is broken, this test will fail as well (but whaddyagonnado?)
+  describe :get do
+    describe :sync do
+      it_should_behave_like "all success return values"
+
+      before do
+        @rv = @zk.get(:path => @path)
+      end
+
+      it %[should return the data] do
+        @rv[:data].should == @data
+      end
+
+      it %[should return a stat] do
+        @rv[:stat].should_not be_nil
+        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
+      end
+    end
+
+    describe :sync_watch do
+      it_should_behave_like "all success return values"
+
+      before do
+        @event = nil
+        @watcher = Zookeeper::WatcherCallback.new
+
+        @rv = @zk.get(:path => @path, :watcher => @watcher, :watcher_context => @path) 
+      end
+
+      it %[should return the data] do
+        @rv[:data].should == @data
+      end
+
+      it %[should set a watcher on the node] do
+        # test the watcher by changing node data
+        @zk.set(:path => @path, :data => 'blah')[:rc].should be_zero
+
+        wait_until(1.0) { @watcher.completed? }
+
+        @watcher.path.should == @path
+        @watcher.context.should == @path
+        @watcher.should be_completed
+        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
+      end
+    end
+
+    describe :async do
+      it_should_behave_like "all success return values"
+
+      before do
+        @cb = Zookeeper::DataCallback.new
+
+        @rv = @zk.get(:path => @path, :callback => @cb, :callback_context => @path)
+        wait_until(1.0) { @cb.completed? }
+        @cb.should be_completed
+      end
+
+      it %[should have a return code of ZOK] do
+        @cb.return_code.should == Zookeeper::ZOK
+      end
+
+      it %[should have the stat object in the callback] do
+        @cb.stat.should_not be_nil
+        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
+      end
+
+      it %[should have the data] do
+        @cb.data.should == @data
+      end
+    end
+
+    describe :async_watch do
+      it_should_behave_like "all success return values"
+
+      before do
+        @cb = Zookeeper::DataCallback.new
+        @watcher = Zookeeper::WatcherCallback.new
+
+        @rv = @zk.get(:path => @path, :callback => @cb, :callback_context => @path, :watcher => @watcher, :watcher_context => @path)
+        wait_until(1.0) { @cb.completed? }
+        @cb.should be_completed
+      end
+
+      it %[should have the stat object in the callback] do
+        @cb.stat.should_not be_nil
+        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
+      end
+
+      it %[should have the data] do
+        @cb.data.should == @data
+      end
+
+      it %[should have a return code of ZOK] do
+        @cb.return_code.should == Zookeeper::ZOK
+      end
+
+      it %[should set a watcher on the node] do
+        @zk.set(:path => @path, :data => 'blah')[:rc].should be_zero
+
+        wait_until(2) { @watcher.completed? }
+
+        @watcher.should be_completed
+
+        @watcher.path.should == @path
+        @watcher.context.should == @path
+      end
+    end
+
+    describe 'bad arguments' do
+      it %[should barf with a BadArguments error] do
+        lambda { @zk.get(:bad_arg => 'what!?') }.should raise_error(ZookeeperExceptions::ZookeeperException::BadArguments)
+      end
+    end
+  end   # get
+
+  describe :set do
+    before do
+      @new_data = "Four score and \007 years ago"
+      @stat = @zk.stat(:path => @path)[:stat]
+    end
+
+    describe :sync do
+      describe 'without version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.set(:path => @path, :data => @new_data)
+        end
+
+        it %[should return the new stat] do
+          @rv[:stat].should_not be_nil
+          @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
+          @rv[:stat].version.should > @stat.version
+        end
+      end
+
+      describe 'with current version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.set(:path => @path, :data => @new_data, :version => @stat.version)
+        end
+
+        it %[should return the new stat] do
+          @rv[:stat].should_not be_nil
+          @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
+          @rv[:stat].version.should > @stat.version
+        end
+      end
+
+      describe 'with outdated version' do
+        before do
+          # need to do a couple of sets to ramp up the version
+          3.times { |n| @stat = @zk.set(:path => @path, :data => "#{@new_data}#{n}")[:stat] }
+
+          @rv = @zk.set(:path => @path, :data => @new_data, :version => 0)
+        end
+
+        it %[should have a return code of ZBADVERSION] do
+          @rv[:rc].should == Zookeeper::ZBADVERSION
+        end
+
+        it %[should return a stat with !exists] do
+          @rv[:stat].exists.should be_false
+        end
+      end
+    end   # sync
+
+    describe :async do
+      before do
+        @cb = Zookeeper::StatCallback.new
+      end
+
+      describe 'without version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.set(:path => @path, :data => @new_data, :callback => @cb, :callback_context => @path)
+
+          wait_until(2) { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have the stat in the callback] do
+          @cb.stat.should_not be_nil
+          @cb.stat.version.should > @stat.version
+        end
+
+        it %[should have a return code of ZOK] do
+          @cb.return_code.should == Zookeeper::ZOK
+        end
+      end
+
+      describe 'with current version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.set(:path => @path, :data => @new_data, :callback => @cb, :callback_context => @path, :version => @stat.version)
+
+          wait_until(2) { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have the stat in the callback] do
+          @cb.stat.should_not be_nil
+          @cb.stat.version.should > @stat.version
+        end
+
+        it %[should have a return code of ZOK] do
+          @cb.return_code.should == Zookeeper::ZOK
+        end
+      end
+
+      describe 'with outdated version' do
+        before do
+          # need to do a couple of sets to ramp up the version
+          3.times { |n| @stat = @zk.set(:path => @path, :data => "#{@new_data}#{n}")[:stat] }
+
+          @rv = @zk.set(:path => @path, :data => @new_data, :callback => @cb, :callback_context => @path, :version => 0)
+
+          wait_until(2) { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have a return code of ZBADVERSION] do
+          @cb.return_code.should == Zookeeper::ZBADVERSION
+        end
+
+        it %[should return a stat with !exists] do
+          @cb.stat.exists.should be_false
+        end
+      end
+    end
+  end
+
+  describe :get_children do
+    before do
+      @children = %w[child0 child1 child2]
+
+      @children.each do |name|
+        @zk.create(:path => "#{@path}/#{name}", :data => name)
+      end
+    end
+
+    after do
+      @children.each do |name|
+        @zk.delete(:path => "#{@path}/#{name}")
+      end
+    end
+
+    describe :sync do
+      it_should_behave_like "all success return values"
+
+      before do
+        @rv = @zk.get_children(:path => @path)
+      end
+
+      it %[should have an array of names of the children] do
+        @rv[:children].should be_kind_of(Array)
+        @rv[:children].length.should == 3
+        @rv[:children].sort.should == @children.sort 
+      end
+
+      # "Three shall be the number of the counting, and the number of the counting shall be 3"
+
+      it %[should have a stat object whose num_children is 3] do
+        @rv[:stat].should_not be_nil
+        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
+        @rv[:stat].num_children.should == 3
+      end
+    end
+
+    describe :sync_watch do
+      it_should_behave_like "all success return values"
+
+      before do
+        @addtl_child = 'child3'
+
+        @watcher = Zookeeper::WatcherCallback.new
+
+        @rv = @zk.get_children(:path => @path, :watcher => @watcher, :watcher_context => @path)
+      end
+
+      after do
+        @zk.delete(:path => "#{@path}/#{@addtl_child}")
+      end
+
+      it %[should have an array of names of the children] do
+        @rv[:children].should be_kind_of(Array)
+        @rv[:children].length.should == 3
+        @rv[:children].sort.should == @children.sort 
+      end
+
+      it %[should have a stat object whose num_children is 3] do
+        @rv[:stat].should_not be_nil
+        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
+        @rv[:stat].num_children.should == 3
+      end
+
+      it %[should set a watcher for children on the node] do
+        @watcher.should_not be_completed
+
+        @zk.create(:path => "#{@path}/#{@addtl_child}", :data => '')[:rc].should == Zookeeper::ZOK
+
+        wait_until { @watcher.completed? }
+        @watcher.should be_completed
+
+        @watcher.path.should == @path
+        @watcher.context.should == @path
+        @watcher.type.should == Zookeeper::ZOO_CHILD_EVENT
+      end
+    end
+
+    describe :async do
+      it_should_behave_like "all success return values"
+
+      before do
+        @cb = ZookeeperCallbacks::StringsCallback.new
+        @rv = @zk.get_children(:path => @path, :callback => @cb, :callback_context => @path)
+
+        wait_until { @cb.completed? }
+        @cb.should be_completed
+      end
+
+      it %[should succeed] do
+        @cb.return_code.should == Zookeeper::ZOK
+      end
+
+      it %[should return an array of children] do
+        @cb.children.should be_kind_of(Array)
+        @cb.children.length.should == 3
+        @cb.children.sort.should == @children.sort 
+      end
+
+      it %[should have a stat object whose num_children is 3] do
+        @cb.stat.should_not be_nil
+        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
+        @cb.stat.num_children.should == 3
+      end
+    end
+
+    describe :async_watch do
+      it_should_behave_like "all success return values"
+
+      before do
+        @addtl_child = 'child3'
+
+        @watcher = Zookeeper::WatcherCallback.new
+        @cb = ZookeeperCallbacks::StringsCallback.new
+
+        @rv = @zk.get_children(:path => @path, :watcher => @watcher, :watcher_context => @path, :callback => @cb, :callback_context => @path)
+        wait_until { @cb.completed? }
+        @cb.should be_completed
+      end
+
+      after do
+        @zk.delete(:path => "#{@path}/#{@addtl_child}")
+      end
+
+      it %[should succeed] do
+        @cb.return_code.should == Zookeeper::ZOK
+      end
+
+      it %[should return an array of children] do
+        @cb.children.should be_kind_of(Array)
+        @cb.children.length.should == 3
+        @cb.children.sort.should == @children.sort 
+      end
+
+      it %[should have a stat object whose num_children is 3] do
+        @cb.stat.should_not be_nil
+        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
+        @cb.stat.num_children.should == 3
+      end
+
+      it %[should set a watcher for children on the node] do
+        @watcher.should_not be_completed
+
+        @zk.create(:path => "#{@path}/#{@addtl_child}", :data => '')[:rc].should == Zookeeper::ZOK
+
+        wait_until { @watcher.completed? }
+        @watcher.should be_completed
+
+        @watcher.path.should == @path
+        @watcher.context.should == @path
+        @watcher.type.should == Zookeeper::ZOO_CHILD_EVENT
+      end
+    end
+  end
+
+  # NOTE: the jruby version of stat on non-existent node will have a
+  # return_code of 0, but the C version will have a return_code of -101
+  describe :stat do
+    describe :sync do
+      it_should_behave_like "all success return values"
+
+      before do
+        @rv = @zk.stat(:path => @path)
+      end
+
+      it %[should have a stat object] do
+        @rv[:stat].should be_kind_of(Zookeeper::Stat)
+      end
+    end
+
+    describe :sync_watch do
+      it_should_behave_like "all success return values"
+
+      before do
+        @watcher = Zookeeper::WatcherCallback.new
+
+        @rv = @zk.stat(:path => @path, :watcher => @watcher, :watcher_context => @path)
+      end
+
+      it %[should have a stat object] do
+        @rv[:stat].should be_kind_of(Zookeeper::Stat)
+      end
+
+      it %[should set a watcher for data changes on the node] do
+        @watcher.should_not be_completed
+
+        @zk.set(:path => @path, :data => 'skunk')[:rc].should == Zookeeper::ZOK
+
+        wait_until { @watcher.completed? }
+        @watcher.should be_completed
+
+        @watcher.path.should == @path
+        @watcher.context.should == @path
+        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
+      end
+    end
+
+    describe :async do
+      it_should_behave_like "all success return values"
+
+      before do
+        @cb = ZookeeperCallbacks::StatCallback.new
+        @rv = @zk.stat(:path => @path, :callback => @cb, :callback_context => @path)
+
+        wait_until { @cb.completed? }
+        @cb.should be_completed
+      end
+
+      it %[should succeed] do
+        @cb.return_code.should == Zookeeper::ZOK
+      end
+
+      it %[should have a stat object] do
+        @cb.stat.should be_kind_of(Zookeeper::Stat)
+      end
+    end
+
+    describe :async_watch do
+      it_should_behave_like "all success return values"
+
+      before do
+        @addtl_child = 'child3'
+
+        @watcher = Zookeeper::WatcherCallback.new
+
+        @cb = ZookeeperCallbacks::StatCallback.new
+        @rv = @zk.stat(:path => @path, :callback => @cb, :callback_context => @path, :watcher => @watcher, :watcher_context => @path)
+
+        wait_until { @cb.completed? }
+        @cb.should be_completed
+      end
+
+      after do
+        @zk.delete(:path => "#{@path}/#{@addtl_child}")
+      end
+
+      it %[should succeed] do
+        @cb.return_code.should == Zookeeper::ZOK
+      end
+
+      it %[should have a stat object] do
+        @cb.stat.should be_kind_of(Zookeeper::Stat)
+      end
+
+      it %[should set a watcher for data changes on the node] do
+        @watcher.should_not be_completed
+
+        @zk.set(:path => @path, :data => 'skunk')[:rc].should == Zookeeper::ZOK
+
+        wait_until { @watcher.completed? }
+        @watcher.should be_completed
+
+        @watcher.path.should == @path
+        @watcher.context.should == @path
+        @watcher.type.should == Zookeeper::ZOO_CHANGED_EVENT
+      end
+    end
+  end   # stat
+
+  describe :create do
+    before do
+      # remove the path set up by the global 'before' block
+      @zk.delete(:path => @path)
+    end
+
+    describe :sync do
+      describe :default_flags do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.create(:path => @path)
+        end
+
+        it %[should return the path that was set] do
+          @rv[:path].should == @path
+        end
+
+        it %[should have created a permanent node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should == 0
+        end
+      end
+
+      describe :ephemeral do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.create(:path => @path, :ephemeral => true)
+        end
+
+        it %[should return the path that was set] do
+          @rv[:path].should == @path
+        end
+
+        it %[should have created a ephemeral node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should_not be_zero
+        end
+      end
+
+      describe :sequence do
+        it_should_behave_like "all success return values"
+
+        before do
+          @orig_path  = @path
+          @rv         = @zk.create(:path => @path, :sequence => true)
+          @path       = @rv[:path]    # make sure this gets cleaned up
+        end
+
+        it %[should return the path that was set] do
+          @rv[:path].should_not == @orig_path
+        end
+
+        it %[should have created a permanent node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should be_zero
+        end
+      end
+
+      describe :ephemeral_sequence do
+        it_should_behave_like "all success return values"
+
+        before do
+          @orig_path  = @path
+          @rv         = @zk.create(:path => @path, :sequence => true, :ephemeral => true)
+          @path       = @rv[:path]    # make sure this gets cleaned up
+        end
+
+        it %[should return the path that was set] do
+          @rv[:path].should_not == @orig_path
+        end
+
+        it %[should have created an ephemeral node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should_not be_zero
+        end
+      end
+
+      describe :acl do
+        it %[should work] do
+          pending "need to write acl tests"
+        end
+      end
+    end
+
+    describe :async do
+      before do
+        @cb = ZookeeperCallbacks::StringCallback.new
+      end
+
+      describe :default_flags do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.create(:path => @path, :callback => @cb, :callback_context => @path)
+          wait_until(2) { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have a path] do
+          @cb.path.should_not be_nil
+        end
+
+        it %[should return the path that was set] do
+          @cb.path.should == @path
+        end
+
+        it %[should have created a permanent node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should == 0
+        end
+      end
+
+      describe :ephemeral do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.create(:path => @path, :ephemeral => true, :callback => @cb, :callback_context => @path)
+          wait_until(2) { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have a path] do
+          @cb.path.should_not be_nil
+        end
+
+        it %[should return the path that was set] do
+          @cb.path.should == @path
+        end
+
+        it %[should have created a ephemeral node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should_not be_zero
+        end
+      end
+
+      describe :sequence do
+        it_should_behave_like "all success return values"
+
+        before do
+          @orig_path  = @path
+          @rv         = @zk.create(:path => @path, :sequence => true, :callback => @cb, :callback_context => @path)
+
+          wait_until(2) { @cb.completed? }
+          @cb.should be_completed
+
+          @path = @cb.path
+        end
+
+        it %[should have a path] do
+          @cb.path.should_not be_nil
+        end
+
+        it %[should return the path that was set] do
+          @cb.path.should_not == @orig_path
+        end
+
+        it %[should have created a permanent node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should be_zero
+        end
+      end
+
+      describe :ephemeral_sequence do
+        it_should_behave_like "all success return values"
+
+        before do
+          @orig_path  = @path
+          @rv         = @zk.create(:path => @path, :sequence => true, :ephemeral => true, :callback => @cb, :callback_context => @path)
+          @path       = @rv[:path]    # make sure this gets cleaned up
+
+          wait_until(2) { @cb.completed? }
+          @cb.should be_completed
+          @path = @cb.path
+        end
+
+        it %[should have a path] do
+          @cb.path.should_not be_nil
+        end
+
+        it %[should return the path that was set] do
+          @path.should_not == @orig_path
+        end
+
+        it %[should have created an ephemeral node] do
+          st = @zk.stat(:path => @path)
+          st[:rc].should == Zookeeper::ZOK
+
+          st[:stat].ephemeral_owner.should_not be_zero
+        end
+      end
+
+      describe :acl do
+        it %[should work] do
+          pending "need to write acl tests"
+        end
+      end
+    end
+  end
+
+  describe :delete do
+    describe :sync do
+      describe 'without version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @zk.create(:path => @path)
+          @rv = @zk.delete(:path => @path)
+        end
+
+        it %[should have deleted the node] do
+          @zk.stat(:path => @path)[:stat].exists.should be_false
+        end
+      end
+
+      describe 'with current version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @zk.create(:path => @path)
+
+          @stat = @zk.stat(:path => @path)[:stat]
+          @stat.exists.should be_true
+
+          @rv = @zk.delete(:path => @path, :version => @stat.version)
+        end
+
+        it %[should have deleted the node] do
+          @zk.stat(:path => @path)[:stat].exists.should be_false
+        end
+      end
+
+      describe 'with old version' do
+        before do
+          3.times { |n| @stat = @zk.set(:path => @path, :data => n.to_s)[:stat] }
+
+          @rv = @zk.delete(:path => @path, :version => 0)
+        end
+
+        it %[should have a return code of ZBADVERSION] do
+          @rv[:rc].should == Zookeeper::ZBADVERSION
+        end
+      end
+    end # sync
+
+    describe :async do
+      before do
+        @cb = ZookeeperCallbacks::VoidCallback.new
+      end
+
+      describe 'without version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @rv = @zk.delete(:path => @path, :callback => @cb, :callback_context => @path)
+          wait_until { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have a success return_code] do
+          @cb.return_code.should == Zookeeper::ZOK
+        end
+
+        it %[should have deleted the node] do
+          @zk.stat(:path => @path)[:stat].exists.should be_false
+        end
+      end
+
+      describe 'with current version' do
+        it_should_behave_like "all success return values"
+
+        before do
+          @stat = @zk.stat(:path => @path)[:stat]
+          @rv   = @zk.delete(:path => @path, :version => @stat.version, :callback => @cb, :callback_context => @path)
+          wait_until { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have a success return_code] do
+          @cb.return_code.should == Zookeeper::ZOK
+        end
+
+        it %[should have deleted the node] do
+          @zk.stat(:path => @path)[:stat].exists.should be_false
+        end
+      end
+
+      describe 'with old version' do
+        before do
+          3.times { |n| @stat = @zk.set(:path => @path, :data => n.to_s)[:stat] }
+
+          @rv = @zk.delete(:path => @path, :version => 0, :callback => @cb, :callback_context => @path)
+          wait_until { @cb.completed? }
+          @cb.should be_completed
+        end
+
+        it %[should have a return code of ZBADVERSION] do
+          @cb.return_code.should == Zookeeper::ZBADVERSION
+        end
+      end
+    end
+  end # delete
+
+  describe :get_acl do
+    describe :sync do
+      it_should_behave_like "all success return values"
+
+      before do
+        @rv = @zk.get_acl(:path => @path)
+      end
+
+      it %[should return a stat for the path] do
+        @rv[:stat].should be_kind_of(ZookeeperStat::Stat)
+      end
+
+      it %[should return the acls] do
+        acls = @rv[:acl]
+        acls.should be_kind_of(Array)
+        h = acls.first
+
+        h.should be_kind_of(Hash)
+
+        h[:perms].should == Zookeeper::ZOO_PERM_ALL
+        h[:id][:scheme].should == 'world'
+        h[:id][:id].should == 'anyone'
+      end
+    end
+
+    describe :async do
+      it_should_behave_like "all success return values"
+
+      before do
+        @cb = Zookeeper::ACLCallback.new
+        @rv = @zk.get_acl(:path => @path, :callback => @cb, :callback_context => @path)
+
+        wait_until(2) { @cb.completed? }
+        @cb.should be_completed
+      end
+
+      it %[should return a stat for the path] do
+        @cb.stat.should be_kind_of(ZookeeperStat::Stat)
+      end
+
+      it %[should return the acls] do
+        acls = @cb.acl
+        acls.should be_kind_of(Array)
+
+        acl = acls.first
+        acl.should be_kind_of(ZookeeperACLs::ACL)
+
+        acl.perms.should == Zookeeper::ZOO_PERM_ALL
+
+        acl.id.scheme.should == 'world'
+        acl.id.id.should == 'anyone'
+      end
+    end
+  end
+
+  describe :set_acl do
+
+    before do
+      @perms = 5
+      @new_acl = [ZookeeperACLs::ACL.new(:perms => @perms, :id => ZookeeperACLs::ZOO_ANYONE_ID_UNSAFE)]
+      pending("No idea how to set ACLs")
+    end
+
+    describe :sync do
+      it_should_behave_like "all success return values"
+
+      before do
+        @rv = @zk.set_acl(:path => @path, :acl => @new_acl)
+      end
+      
+    end
+  end
+end