zkruby 3.4.3 → 3.4.4.rc3

data/lib/zkruby/util.rb

@@ -31,111 +31,96 @@ module ZooKeeper
 
                 op = create(sub_path,"",acl) { if i == -1 then callback.call() else :true end }
 
-                op.errback do |err|
-                    if i == -1
-                        if ZK::Error::NODE_EXISTS === err
-                            callback.call()
-                        elsif ZK::Error::CONNECTION_LOST === err || ( ZK::Error::NO_NODE && connection_lost )
-                            # try again
-                            mkpath(path,acl)
-                            callback.call()
-                        else 
-                            raise err 
-                        end
-                    elsif ZK::Error::CONNECTION_LOST === err
-                        connection_lost = true
-                        :connection_lost
-                    else
-                        # we don't care about any other errors, but we will log them
-                        logger.warn { "Error creating #{sub_path}, #{err}" }
-                    end
+                if i == -1
+                    op.on_error(ZK::Error::NODE_EXISTS) { callback.call() }
+                    op.on_error(ZK::Error::CONNECTION_LOST, ZK::Error::NO_NODE) { |ex|
+                        connection_lost = true if ZK::Error::CONNECTION_LOST === ex
+                        raise ex unless connection_lost
+                        mkpath(path,acl) 
+                        callback.call()
+                    }
+                    last_op = op
+                else
+                    op.on_error(ZK::Error::CONNECTION_LOST) { connection_lost = true }
+                    op.on_error(ZK::Error::NODE_EXISTS) { }
+                    op.on_error() { |err| logger.debug { "mkpath error creating #{sub_path}, #{err}" } }
                 end
-                last_op = op if (i == -1)
-               end
-
-            return WrappedOp.new(last_op)
         end
 
-        # Recursive delete
-        #
-        # Although this method itself can be called synchronously all the zk activity
-        # is asynchronous, ie all subnodes are removed in parallel
-        #
-        # Will retry on connection loss, or if some other activity is adding nodes in parallel.
-        # If you get a session expiry in the middle of this you will end up with a
-        # partially completed recursive delete. In all other circumstances it will eventually
-        # complete.
-        #
-        # @overload rmpath(path,version)
-        #    @param [String] path this node and all its children will be recursively deleted
-        #    @param [FixNum] version the expected version to be deleted (-1 to match any version).
-        #         Only applies to the top level path
-        #    @return 
-        #    @raise [Error]
-        # @overload rmpath(path,version)
-        #    @return [AsyncOp]
-        #    @yield  [] callback invoked if delete is successful
-        def rmpath(path,version = -1, &callback)
-
-            return synchronous_call(:rmpath,path,version) unless block_given?
-
-            del_op = delete(path,version) { callback.call() }
-
-            del_op.errback do |err|
-                # we don't leave this method unless we get an exception
-                # or have completed and called the callback
-                case err
-                when ZK::Error::NO_NODE
-                when ZK::Error::CONNECTION_LOST
-                    rmpath(path,version)
-                when ZK::Error::NOT_EMPTY
-
-                    stat, child_list = children(path)
-
-                    unless child_list.empty?
-                        child_ops = {}
-                        child_list.each do |child| 
-                            child_path = "#{path}/#{child}"
-
-                            rm_op = rmpath(child_path,-1) { :success }
-
-                            rm_op.errback { |err| child_results[child_path] = err }
-
-                            child_ops[child_path] = rm_op
-                        end
-
-                        # Wait until all our children are done (or error'd)
-                        child_ops.each { |child_path,op| op.value }
-                        rmpath(path,version)
-                    end
-                else
-                    raise err
-                end
-                callback.call()
-            end
+        return WrappedOp.new(last_op)
+    end
 
-            return WrappedOp.new(del_op)
-        end
-    end #Client
+    # Recursive delete
+    #
+    # Although this method itself can be called synchronously all the zk activity
+    # is asynchronous, ie all subnodes are removed in parallel
+    #
+    # Will retry on connection loss, or if some other activity is adding nodes in parallel.
+    # If you get a session expiry in the middle of this you will end up with a
+    # partially completed recursive delete. In all other circumstances it will eventually
+    # complete.
+    #
+    # @overload rmpath(path,version)
+    #    @param [String] path this node and all its children will be recursively deleted
+    #    @param [FixNum] version the expected version to be deleted (-1 to match any version).
+    #         Only applies to the top level path
+    #    @return 
+    #    @raise [Error]
+    # @overload rmpath(path,version)
+    #    @return [AsyncOp]
+    #    @yield  [] callback invoked if delete is successful
+    def rmpath(path,version = -1, &callback)
 
-    class WrappedOp < AsyncOp
-        def initialize(delegate_op)
-            @delegate_op = delegate_op
-            @errback = nil
-        end
+        return synchronous_call(:rmpath,path,version) unless block_given?
+
+        del_op = delete(path,version) { callback.call() }
+
+        del_op.on_error(ZK::Error::NO_NODE) { callback.call() }
 
-        private
-        def wait_value()
-            begin  
-                @delegate_op.value()
-            rescue StandardError > err
-                @errback ? @errback.call(err) : raise
+        del_op.on_error(ZK::Error::CONNECTION_LOST) { del_op.try_again() }
+
+        del_op.on_error(ZK::Error::NOT_EMPTY) do 
+
+            stat, child_list = children(path)
+
+            unless child_list.empty?
+                
+                child_ops = {}
+                child_list.each do |child| 
+                    child_path = "#{path}/#{child}"
+
+                    rm_op = rmpath(child_path,-1) { :success }
+
+                    rm_op.on_error { |err| child_results[child_path] = err }
+
+                    child_ops[child_path] = rm_op
+                    ZK.pass
+                end
+
+                # Wait until all our children are done (or error'd)
+                child_ops.each { |child_path,op| op.value }
+                rmpath(path,version)
             end
         end
 
-        def set_error_handler(errback)
-            @errback = errback
+        return WrappedOp.new(del_op)
+    end
+end #Client
+
+class WrappedOp < AsyncOp
+    #TODO you can't retry a wrapped op
+    def initialize(delegate_op)
+        @delegate_op = delegate_op
+    end
+
+    private
+    def wait_value()
+        begin  
+            @delegate_op.value()
+        rescue StandardError => err
+            @errback ? @errback.call(err) : raise
         end
     end
+end
 
 end #ZooKeeper

data/lib/zkruby/version.rb

@@ -0,0 +1,5 @@
+
+module ZooKeeper
+    # Major/Minor numbers track zookeeper itself, final digit is our build number
+    VERSION = "3.4.4.rc3"
+end

data/lib/zkruby/zkruby.rb

@@ -4,12 +4,6 @@
 # than calling the zk client libraries
 #
 module ZooKeeper
-    # Major/Minor numbers track zookeeper itself, final digit is our build number
-    VERSION = "3.4.3"
-    @bindings = []
-    def self.add_binding(binding)
-        @bindings << binding unless @bindings.include?(binding)
-    end
 end
 
 # Shorthand

data/spec/eventmachine_spec.rb

@@ -2,49 +2,28 @@ require 'server_helper'
 require 'shared/binding'
 require 'zkruby/eventmachine'
 
-module EMHelper
-    alias :restart_cluster_orig :restart_cluster
-    def restart_cluster(delay=0)
-        if EM.reactor_running?
-                cv = Strand::ConditionVariable.new()
-                op = Proc.new do
-                    begin
-                        restart_cluster_orig(delay)
-                    rescue Exception => ex
-                        logger.error ("Exception restarting cluster #{ex}")
-                    end
-                    true
-                end
-                cb = Proc.new { |result| cv.signal() } 
-                defer = EM.defer(op,cb)
-                cv.wait()
-        else
-            restart_cluster_orig(delay)
-        end
-    end
-
-    def sleep(delay)
-        Strand.sleep(delay)
-    end
-end
-
 describe ZooKeeper::EventMachine::Binding do
 
     include Slf4r::Logger
-    include EMHelper
 
     around(:each) do |example|
         EventMachine.run {
             Strand.new() do
-               begin
+            begin
                 example.run
-               ensure
+            rescue Exception => ex
+                logger.error("Exception in example",ex)
+            ensure
                 EM::stop
-               end
+            end
             end
         }
     end
 
+    it "should be running in event machine" do
+        Strand.event_machine?.should be_true
+    end
+
     it_should_behave_like "a zookeeper client binding"
 
 end

data/spec/server_helper.rb

@@ -4,15 +4,18 @@ module ZooKeeperServerHelper
 
     include Slf4r::Logger
 
+    JRUBY_COMPAT_SYSTEM = (RUBY_PLATFORM == "java" && Gem::Version.new(JRUBY_VERSION.dup) < Gem::Version.new("1.6.5"))
+
+    def jruby_safe_system(arg)
+        arg = "#{arg} &" if JRUBY_COMPAT_SYSTEM
+        system(arg)
+        Strand.sleep(3) if JRUBY_COMPAT_SYSTEM
+    end
+
     def restart_cluster(delay=0)
-        system("../../bin/zkServer.sh stop >> zk.out")
-        Kernel::sleep(delay) if delay > 0
-        if (::RUBY_PLATFORM == "java")
-            #in JRuby 1.6.3 system does not return 
-            system("../../bin/zkServer.sh start >> zk.out &")
-        else
-            system("../../bin/zkServer.sh start >> zk.out")
-        end
+        jruby_safe_system("../../bin/zkServer.sh stop >> zk.out")
+        Strand::sleep(delay) if delay > 0
+        jruby_safe_system("../../bin/zkServer.sh start >> zk.out")
     end
 
     def get_addresses()
@@ -34,7 +37,7 @@ end
 include ZooKeeperServerHelper
 
 restart_cluster()
-sleep(3)
+Strand.sleep(3)
 require 'net/telnet'
 t = Net::Telnet.new("Host" => "localhost", "Port" => 2181)
 properties = t.cmd("mntr")
@@ -42,4 +45,5 @@ properties = t.cmd("mntr")
 RSpec.configure do |c|
     #Exclude multi unless we are on a 3.4 server
     c.filter_run_excluding :multi => true unless properties
+    c.filter_run_excluding :perf => true
 end

data/spec/shared/basic.rb

@@ -52,6 +52,7 @@ shared_examples_for "basic integration" do
                 # only because JRuby 1.9 doesn't support the === syntax for exceptions
                 ZooKeeper::Error::NO_NODE.should === ex
                 ex.message.should =~ /\/anunknownpath/
+                ex.message.should =~ /no_node/
                 skip = if defined?(JRUBY_VERSION) then 2 else 1 end
                 ex.backtrace[skip..-1].should == get_caller
             end
@@ -67,11 +68,13 @@ shared_examples_for "basic integration" do
             rescue ZooKeeper::Error => ex
                 ZooKeeper::Error::NO_NODE.should === ex
                 ex.message.should =~ /\/an\/unknown\/path/
+                ex.message.should =~ /no_node/
                 ex.backtrace[1..-1].should == get_caller
             end
         end
 
         it "should call the error call back for asynchronous errors" do
+            get_caller = caller
             op = @zk.get("/an/unknown/path") do
                 :callback_invoked_unexpectedly
             end
@@ -79,6 +82,9 @@ shared_examples_for "basic integration" do
             op.on_error do |err|
                 case err
                 when ZK::Error::NO_NODE
+                    err.message.should =~ /\/an\/unknown\/path/
+                    err.message.should =~ /no_node/
+                    err.backtrace[1..-1].should == get_caller
                     :found_no_node_error
                 else
                     raise err
@@ -88,6 +94,33 @@ shared_examples_for "basic integration" do
             op.value.should == :found_no_node_error
         end
 
+        it "should rescue errors" do
+            op = @zk.get("/an/unknown/path") do
+                :callback_invoked_unexpectedly
+            end
+
+            op.async_rescue (ZK::Error::NO_NODE) { :found_no_node_error }
+
+            op.value.should == :found_no_node_error
+        end
+
+        it "should retry on error" do
+            @zk.create("/retrypath","",ZK::ACL_OPEN_UNSAFE,:ephemeral)
+
+            result = :not_ready_yet
+            op = @zk.set("/retrypath","new data",2) do
+                result 
+            end
+
+            op.async_rescue ZK::Error::BAD_VERSION do
+                @zk.set("/retrypath","version 2",-1)
+                result = :all_done_now
+                op.async_retry
+            end
+
+            op.value.should == :all_done_now
+        end
+
         it "should capture exceptions from asynchronous callback" do
             async_caller = nil
             op = @zk.exists?("/zkruby") do |stat|
@@ -114,7 +147,7 @@ shared_examples_for "basic integration" do
     context "auto reconnect" do
 
         it "should stay connected" do
-            sleep(@zk.timeout * 2.0)
+            Strand.sleep(@zk.timeout * 2.0)
             @zk.exists?("/zkruby").should be_true
         end
 
@@ -125,7 +158,7 @@ shared_examples_for "basic integration" do
             watcher.should_receive(:process_watch).with(ZK::KeeperState::CONNECTED,nil,ZK::WatchEvent::NONE)
             watcher.should_not_receive(:process_watch).with(ZK::KeeperState::EXPIRED,nil,ZK::WatchEvent::NONE)
             @zk.watcher = watcher
-            restart_cluster(2)
+            restart_cluster(1.5)
             @zk.exists?("/zkruby").should be_true
         end
 
@@ -148,6 +181,7 @@ shared_examples_for "basic integration" do
         end
 
         it "should handle a synchronous call inside an asynchronous callback" do
+            ZK.current.should equal(@zk)
             op = @zk.create("/zkruby/sync_async","somedata",ZK::ACL_OPEN_UNSAFE) do
                 ZK.current.should equal(@zk)
                 stat, data = @zk.get("/zkruby/sync_async")

data/spec/shared/binding.rb

@@ -5,6 +5,7 @@ require 'shared/chroot'
 require 'shared/watch'
 require 'shared/multi'
 require 'shared/auth'
+require 'shared/performance'
 
 shared_examples_for "a zookeeper client binding" do
 
@@ -23,6 +24,7 @@ shared_examples_for "a zookeeper client binding" do
         include_examples("basic integration")
         include_examples("util recipes")
         include_examples("multi")
+        include_examples("performance")
 
     end
 

data/spec/shared/chroot.rb

@@ -57,5 +57,35 @@ shared_examples_for "chrooted connection" do
             end
 
         end
+
+        context "multi", :multi => true do
+
+            it "should do chrooted operations in a transaction" do
+                new_path = nil
+
+                # we're gonna delete this one
+                delete_path = @zk.create("/zkruby/multi","hello multi",ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential)
+                
+                # we use the version in the check command below
+                stat, data = @zk.get("/zkruby")
+                @ch_zk.transaction() do |txn|
+                    txn.create("/multi","chroot world", ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential) { |path| logger.debug{ "New path #{path}"} ; new_path = path }
+                    txn.check("/",stat.version)
+                    txn.set("/","chroot multi data",-1)
+                    txn.delete(delete_path[7..-1],-1)
+                end
+                new_path.should_not be_nil
+
+                stat, data = @zk.get("/zkruby#{new_path}")
+                data.should == "chroot world"
+
+                stat, data = @zk.get("/zkruby")
+                data.should == "chroot multi data"
+
+                @zk.exists?(delete_path).should be_nil
+
+            end
+
+        end
     end
 end

data/spec/shared/multi.rb

@@ -1,7 +1,7 @@
 shared_examples_for "multi"  do
 
     context "only in 3.4 and up", :multi => true do
-        it "should do a create in a multi-op" do
+        it "should do all the multi ops" do
             delete_path = @zk.create("/zkruby/multi","hello multi",ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential)
 
             new_path = nil

data/spec/shared/performance.rb

@@ -0,0 +1,50 @@
+shared_examples_for "performance" do
+
+    describe "performance", :perf => true do
+
+        it "should create and retrieve lots of nodes in a reasonable amount of time" do
+
+            path = "/zkruby/rspec-perf"
+
+            @zk.mkpath(path)
+
+            op = nil
+            start = Time.now
+            count = 0
+            pass_every = 5
+            first_error = true
+            6000.times do
+                count += 1
+                this_index = count
+                op = @zk.create("#{path}/","hello", ZK::ACL_OPEN_UNSAFE,:sequential,:ephemeral) { } 
+                op.on_error { |ex| puts "Error @ #{this_index}" if first_error; first_error = false }
+                if count % pass_every == 0
+                    #puts "Passing @ #{count}"
+                    ZK.pass
+                end
+            end
+
+            op.value
+            finish = Time.now
+            diff = finish - start
+            puts "Created #{count} in #{diff}" 
+            stat,children = @zk.children(path)
+
+            count = 0
+            children.each do |child|
+                op = @zk.get("#{path}/#{child}") { }
+                count += 1
+                if count % pass_every == 0
+                    #puts "Passing @ #{count}"
+                    ZK.pass
+                end
+            end
+
+            op.value
+            finish_get = Time.now
+            diff = finish_get - finish
+            puts "Retrieved #{count} in #{diff}"
+        end
+
+    end
+end

data/spec/shared/watch.rb

@@ -18,7 +18,7 @@ shared_examples_for "watches" do
             stat,data = @zk.get(path,watch)
             # set the data on the 2nd session
             @zk2.set(path,"newdata",stat.version)
-            sleep(5)
+            Strand.sleep(2)
             watch_results.size().should == 1
             watch_results[0][1].should == path
             watch_results[0][2].should === :node_data_changed
@@ -31,7 +31,7 @@ shared_examples_for "watches" do
 
             stat,children = @zk.children("/zkruby",watch)
             path = @zk2.create("/zkruby/rspec_watch","somedata",ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential)
-            sleep(5)
+            Strand.sleep(2)
             watch_results.size().should == 1
             watch_results[0][1].should == "/zkruby"
             watch_results[0][2].should === :node_children_changed

data/spec/spec_helper.rb

@@ -1,10 +1,10 @@
 require 'slf4r/logging_logger'
 require 'zkruby/zkruby'
 
-Logging.logger.root.level = :error
-Logging.logger.root.appenders = Logging.appenders.stdout(:layout => Logging.layouts.pattern(:pattern => '%c [%T] %-5l: %m\n'))
+Logging.logger.root.level = :warn
+Logging.logger.root.appenders = Logging.appenders.stdout(:layout => Logging.layouts.pattern(:pattern => '%r %c [%T] %-5l: %m\n'))
 #Logging.logger[ZooKeeper::RubyIO::Connection].level = :error
-#Logging.logger[ZooKeeper::RubyIO::Binding].level = :error
+#Logging.logger["ZooKeeper::RubyIO::Binding"].level = :debug
 #Logging.logger[ZooKeeper::Session].level = :debug
 #Logging.logger["ZooKeeper::EventMachine::ClientConn"].level = :debug
 #Logging.logger["ZooKeeper::Session::Ping"].level = :error

data/zkruby.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "zkruby/version"
+
+Gem::Specification.new do |s|
+  s.name        = "zkruby"
+  s.version     = ZooKeeper::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Grant Gardner"]
+  s.email       = ["grant@lastweekend.com.au"]
+  s.homepage    = "http://rubygems.org/gems/zkruby"
+  s.summary     = %q{Pure Ruby language binding for ZooKeeper}
+  s.description = %q{Supports full ZooKeeper API, synchronous or asynchronous style, watches etc.. with implementations over EventMachine or plain old Ruby IO/Threads}
+
+  s.files         = `git ls-files`.split("\n")
+  s.files << 'lib/jute/zookeeper.rb'
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.has_rdoc = 'yard'
+  # Yard options in .yardopts
+
+  s.add_dependency 'slf4r' , '~> 0.4.2'
+  s.add_dependency 'strand', '~> 0.2.0.rc0'
+  s.add_dependency 'bindata', '~> 1.4.1'
+
+  s.add_development_dependency 'eventmachine', '>= 0.12.10'
+  s.add_development_dependency 'logging', '>= 1.4.1'
+
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rspec")
+  s.add_development_dependency("yard")
+ 
+  # s.add_development_dependency("jute") 
+  s.add_development_dependency "citrus" , '~> 2.4.0'
+ 
+end