zkruby 3.4.3

data/lib/zkruby/util.rb

@@ -0,0 +1,141 @@
+module ZooKeeper
+
+    class Client
+
+        # Recursive make path
+        #
+        # This will send parallel creates for ALL nodes up to the root
+        # and then ignore any NODE_EXISTS errors.
+        #
+        # You generally want to call this after receiving a NO_NODE error from a 
+        # simple {#create}
+        #
+        # @param [String] path
+        # @param [Data::ACL] acl the access control list to apply to any created nodes
+        # @return 
+        # @raise [Error]
+        def mkpath(path,acl=ZK::ACL_OPEN_UNSAFE,&callback)
+
+            return synchronous_call(:mkpath,path,acl) unless block_given?
+
+            connection_lost = false
+
+            path_comp = path.split("/")
+
+            # we only care about the result of the final create op
+            last_op = nil
+
+            (1-path_comp.length..-1).each do |i|
+
+                sub_path = path_comp[0..i].join("/")
+
+                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
+                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(del_op)
+        end
+    end #Client
+
+    class WrappedOp < AsyncOp
+        def initialize(delegate_op)
+            @delegate_op = delegate_op
+            @errback = nil
+        end
+
+        private
+        def wait_value()
+            begin  
+                @delegate_op.value()
+            rescue StandardError > err
+                @errback ? @errback.call(err) : raise
+            end
+        end
+
+        def set_error_handler(errback)
+            @errback = errback
+        end
+    end
+
+end #ZooKeeper

data/lib/zkruby/zkruby.rb

@@ -0,0 +1,27 @@
+# A pure ruby implementation of the zk client library
+#
+# It implements the client side of the ZooKeeper TCP protocol directly rather
+# 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
+ZK=ZooKeeper
+
+require 'slf4r'
+require 'zkruby/enum'
+require 'zkruby/bindata'
+require 'jute/zookeeper'
+require 'zkruby/multi'
+require 'zkruby/protocol'
+require 'zkruby/session'
+require 'zkruby/client'
+# Utilities
+require 'zkruby/util'

data/spec/bindata_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+class ZKBTest < BinData::Record
+    int8 :testint
+    zk_boolean :bool
+end
+
+describe ZK::ZKBoolean do
+
+    it "should behave like 'false' after reading 00" do
+        hex = "0000"
+        bin = [ hex ].pack("H*")
+
+        b = ZKBTest.read(bin)
+
+        b.bool.should == false
+        # NOTE!! this is unfortunate consequence of Ruby's view of FALSE
+        b.bool.should_not be_false
+        
+        b.to_binary_s.unpack("H*")[0].should == hex
+    end
+
+    it "should behave like 'true' after reading 01" do
+        hex = "0001"
+        bin = [ hex ].pack("H*")
+
+        b = ZKBTest.read(bin)
+
+        b.bool.should == true
+        # NOTE!! this is unfortunate consequence of Ruby's view of FALSE
+        b.bool.should be_true
+
+        b.to_binary_s.unpack("H*")[0].should == hex
+    end
+
+    it "should behave like a boolean after creating" do
+
+        b = ZKBTest.new()
+        b.bool= true
+        b.bool.should == true
+
+        b.bool= false
+        b.bool.should == false
+
+        b = ZKBTest.new( :bool => true  )
+        b.bool.should == true
+
+        b = ZKBTest.new( :bool => false )
+        b.bool.should == false
+    end
+end

data/spec/enum_spec.rb

@@ -0,0 +1,84 @@
+require 'zkruby/enum.rb'
+
+class TestEnum
+    include Enumeration
+
+    enum :one, 1
+    enum :two, -2
+end
+
+class TestError < StandardError
+    include Enumeration
+    enum :badone, 10
+    enum :oops,20
+end
+
+describe Enumeration do
+    it "should equate to itself" do
+        TestEnum::ONE.should == TestEnum::ONE
+    end
+
+    it "should have case equals comparisons to symbols and ints" do
+        t = TestEnum.fetch(1)
+        t.should === :one
+        t.should === 1
+    end
+
+    it "should be useable in a mock" do
+        m = mock("watchevent")
+        m.should_receive(:test).with(TestEnum::TWO)
+        m.test(TestEnum::TWO)
+    end
+
+    describe "errors" do
+        # Ruby 1.9 inadvertently dropped requirement that the argument
+        # to rescue must be a class or module, but despite its usefulness
+        # it is not supposed to be that way and JRuby doesn't work that way
+        it "should be an exception class" do
+            TestError.get(:badone).should equal (TestError::BADONE)
+            TestError.get(:badone).class.should == Class
+            TestError::BADONE.should < StandardError
+            TestError::BADONE.new().should be_kind_of(TestError)
+            TestError::OOPS.should === TestError.get(:oops).exception()
+            TestError::OOPS.to_sym.should == :oops
+        end
+
+        it "should be raisable with get and rescuable by a constant" do
+            begin
+                raise TestError.get(:badone), "mymessage"
+            rescue TestError::BADONE => ex
+                ex.message.should == "mymessage"
+            end
+        end
+
+        it "should be raisable with constant and rescuable with fetch" do
+            begin
+                raise TestError::OOPS, "a message"
+            rescue TestError::fetch(20) => ex
+                # do nothing
+                ex.message.should == "a message"
+            end
+        end
+
+        it "should catch the superclass" do
+            begin
+                raise TestError::BADONE, "a message"
+            rescue TestError
+            end
+        end
+
+        it "should be raisable with unknown symbol" do
+            begin
+                raise TestError.lookup(:unknown)
+            rescue TestError => err
+            end
+        end
+
+        it "should be raisable with unknown int" do
+            begin
+                raise TestError.lookup(-132)
+            rescue TestError => err
+            end
+        end
+    end
+end

data/spec/eventmachine_spec.rb

@@ -0,0 +1,50 @@
+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
+                example.run
+               ensure
+                EM::stop
+               end
+            end
+        }
+    end
+
+    it_should_behave_like "a zookeeper client binding"
+
+end

data/spec/multi_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+def tohex(s)
+    s.unpack("H*")[0]  
+end
+
+describe ZooKeeper::Proto::MultiRequest do
+
+    it "an empty multi should match the java output" do
+
+        java_hex = "ffffffff01ffffffff"
+        java_bin = [ java_hex ].pack("H*")
+        
+        read_request = ZooKeeper::Proto::MultiRequest.read(java_bin)
+        
+        read_hex = tohex(read_request.to_binary_s)
+        
+        m = ZooKeeper::Proto::MultiRequest.new()
+
+        m.requests << { :header => { :_type => -1, :done => true, :err => -1 } }
+
+        m_hex = tohex(m.to_binary_s)
+        m_hex.should == java_hex 
+        m.should == read_request
+    end
+
+    it "should match the java output with records" do
+
+        java_hex = "0000000d00ffffffff00000005636865636b000000010000000100ffffffff000000066372656174650000000b6372656174652064617461000000010000001f000000046175746800000000000000000000000200ffffffff0000000664656c657465000000110000000500ffffffff000000077365744461746100000008736574206461746100000013ffffffff01ffffffff"
+
+        java_bin = [ java_hex ].pack("H*")
+
+        read_request = ZooKeeper::Proto::MultiRequest.read(java_bin)
+
+        read_hex = tohex(read_request.to_binary_s)
+
+        read_hex.should == java_hex
+
+        m = ZooKeeper::Proto::MultiRequest.new()
+
+        check = ZK::Proto::CheckVersionRequest.new( :path => "check", :version => 1 )
+        m.requests << { :header => { :_type => 13, :done => false, :err => -1 }, :request => check }
+
+        create = ZK::Proto::CreateRequest.new( :path => "create", :data => "create data", :acl => ZK::CREATOR_ALL_ACL, :flags => 0)
+        m.requests << { :header => { :_type => 1, :done => false, :err => -1 }, :request => create }
+
+        delete = ZK::Proto::DeleteRequest.new( :path => "delete", :version => 17)
+        m.requests << { :header => { :_type => 2, :done => false, :err => -1 }, :request => delete }
+
+
+        set = ZK::Proto::SetDataRequest.new( :path => "setData", :data => "set data", :version => 19)
+        m.requests << { :header => { :_type => 5, :done => false, :err => -1 }, :request => set }
+
+        m.requests << { :header => { :_type => -1, :done => true, :err => -1 } }
+
+        m_hex = tohex(m.to_binary_s)
+        m_hex.should == java_hex 
+        m.should == read_request
+    end
+
+    it "should decode a response" do
+
+        response_hex = "000000010000000000000000062f6d756c7469ffffffff01ffffffff"
+        
+        response_bin = [ response_hex ].pack("H*")
+
+        m = ZooKeeper::Proto::MultiResponse.read(response_bin)
+        m.responses.size.should == 2
+        m.responses[0].done?.should be_false
+        m.responses[0].header.err.should == 0
+        m.responses[0].header._type.should == 1
+        m.responses[0].response.path.should == "/multi"
+        m.responses[1].done?.should be_true
+
+    end
+
+    it "should decode an error response" do
+        response_hex = "ffffffff000000000000000000ffffffff00ffffff9bffffff9bffffffff01ffffffff"
+
+        response_bin = [ response_hex ].pack("H*")
+        
+        m = ZooKeeper::Proto::MultiResponse.read(response_bin)
+        m.responses.size.should == 3
+        m.responses[0].header._type.should == -1
+        m.responses[0].header.err.should == 0
+        m.responses[0].done?.should be_false
+        m.responses[0].response.err.should == 0
+        m.responses[1].header._type.should == -1
+        m.responses[1].header.err.should == -101
+        m.responses[1].response.err.should == -101
+        m.responses[2].done?.should be_true
+    end    
+end