zkruby 3.4.3

data/spec/shared/chroot.rb

@@ -0,0 +1,61 @@
+shared_examples_for "chrooted connection" do
+    describe "chrooted connection" do
+
+        around(:each) do |example|
+            @zk = connect(:binding => binding)
+            @ch_zk = connect(:binding => binding, :chroot => "/zkruby")
+
+            example.run
+
+            safe_close(@zk)
+            safe_close(@ch_zk)
+        end
+
+        it "should perform all the ZooKeeper CRUD chrooted" do
+            path = @ch_zk.create("/spec-chroot","someData",ZK::ACL_OPEN_UNSAFE,:ephemeral)
+            path.should == "/spec-chroot"
+            real_path = "/zkruby#{path}"
+            stat,data = @ch_zk.get(path)
+            stat.should be_a ZooKeeper::Data::Stat
+            data.should == "someData"
+
+            stat,data = @zk.get(real_path)
+            data.should == "someData"
+
+            new_stat = @ch_zk.set(path,"different data",stat.version)
+            new_stat.should be_a ZooKeeper::Data::Stat
+
+            stat,data = @ch_zk.get(path)
+            data.should == "different data"
+
+            stat,data = @zk.get(real_path)
+            data.should == "different data"
+
+            @ch_zk.delete(path,stat.version)
+            @ch_zk.exists?(path).should be_false
+        end
+
+        it "should return a client path for sync" do
+            path = @ch_zk.sync("/aPath")
+            path.should == "/aPath"
+        end
+
+        context "util recipes" do
+
+            it "Client#mkpath should work with chroot" do
+                @zk.rmpath("/zkruby/spec-util") 
+                @ch_zk.mkpath("/spec-util/test/mkpath")
+                stat,data = @zk.get("/zkruby/spec-util/test")
+                data.should == ""
+            end
+
+            it "Client#rmpath should work with chroot" do
+                @zk.mkpath("/zkruby/spec-util/test")
+                @zk.mkpath("/zkruby/spec-util/test/two/three/four")
+                @ch_zk.rmpath("/spec-util")
+                @zk.exists?("/zkruby/spec-util").should be_false
+            end
+
+        end
+    end
+end

data/spec/shared/multi.rb

@@ -0,0 +1,38 @@
+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
+            delete_path = @zk.create("/zkruby/multi","hello multi",ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential)
+
+            new_path = nil
+            stat,data = @zk.get("/zkruby")
+            @zk.transaction() do |txn|
+                txn.create("/zkruby/multi","hello world", ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential) { |path| logger.debug{ "New path #{path}"} ; new_path = path }
+                txn.check("/zkruby",stat.version)
+                txn.set("/zkruby","new multi data",-1)
+                txn.delete(delete_path,-1)
+            end
+
+            new_path.should_not be_nil
+
+            stat, data = @zk.get(new_path)
+            data.should == "hello world"
+
+            stat, data = @zk.get("/zkruby")
+            data.should == "new multi data"
+
+            @zk.exists?(delete_path).should be_nil
+
+        end
+
+        it "should raise exceptions if the multi op fails" do
+            lambda { @zk.transaction() do |txn|
+                txn.create("/multi","hello world", ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential) { |path| puts path }
+                txn.create("/multi/something/","hello world", ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential) { |path| puts path }
+                txn.create("/multi","hello world 2", ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential) { |path| puts path }
+            end }.should raise_error(ZooKeeper::Error)
+
+        end
+    end
+end
+

data/spec/shared/util.rb

@@ -0,0 +1,56 @@
+shared_examples_for "util recipes" do
+   context "util recipes" do
+        context "Client#mkpath" do
+            #you'll note that these tests rely on each other!
+            before(:each) do
+                @zk.rmpath("/zkruby/spec-util")
+            end
+
+            it "should create empty nodes at all the intermediate paths" do
+                @zk.mkpath("/zkruby/spec-util/test/mkpath")
+                stat,data = @zk.get("/zkruby/spec-util/test")
+                data.should == ""
+                stat,data = @zk.get("/zkruby/spec-util/test/mkpath")
+                data.should == ""
+            end
+
+            it "should not raise errors when path already exists" do
+                @zk.mkpath("/zkruby")
+            end
+
+            it "should only create the final path if all parents exist" do
+                @zk.create("/zkruby/spec-util","node that exists",ZK::ACL_OPEN_UNSAFE)
+                @zk.mkpath("/zkruby/spec-util/mkpath")
+                stat, data = @zk.get("/zkruby/spec-util")
+                data.should == "node that exists"
+            end
+
+            it "should not raise error if something else creates an intermediate path"
+
+
+        end
+
+        context "Client#rmpath" do
+            before(:each) do
+                @zk.mkpath("/zkruby/spec_util/one")
+                @zk.mkpath("/zkruby/spec_util/two/twopointtwo")
+                @zk.mkpath("/zkruby/spec_util/two/three/four/five")
+            end
+              
+            it "should delete a tree of paths" do
+                @zk.rmpath("/zkruby/spec_util")
+                @zk.exists?("/zkruby/spec_util").should be_false
+            end
+
+            it "should not raise errors if the path is already deleted"
+            it "should delete leaf nodes just like delete does" do
+                @zk.rmpath("/zkruby/spec_util/one")
+                @zk.exists?("/zkruby/spec_util/one").should be_false
+            end
+           
+            
+            it "should not raise errors if some nodes are deleted by something else during processing"
+            it "should fight to the death if something else is creating subnodes"
+        end
+    end
+end

data/spec/shared/watch.rb

@@ -0,0 +1,49 @@
+shared_examples_for "watches" do
+    describe "watches" do
+        around(:each) do |example|
+            @zk = connect(:binding => binding)
+            @zk2 = connect(:binding => binding)
+
+            example.run
+
+            safe_close(@zk)
+            safe_close(@zk2)
+        end
+
+        it "should handle data watches" do
+            path = @zk.create("/zkruby/rspec_watch","somedata",ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential)
+            watch_results = []
+            watch = lambda { |state,path,event| watch_results << [ state,path,event ] }
+
+            stat,data = @zk.get(path,watch)
+            # set the data on the 2nd session
+            @zk2.set(path,"newdata",stat.version)
+            sleep(5)
+            watch_results.size().should == 1
+            watch_results[0][1].should == path
+            watch_results[0][2].should === :node_data_changed
+        end
+
+        it "should handle exists watches"
+        it "should handle child watches" do
+            watch_results = []
+            watch = lambda { |state,path,event| watch_results << [ state,path,event ] }
+
+            stat,children = @zk.children("/zkruby",watch)
+            path = @zk2.create("/zkruby/rspec_watch","somedata",ZK::ACL_OPEN_UNSAFE,:ephemeral,:sequential)
+            sleep(5)
+            watch_results.size().should == 1
+            watch_results[0][1].should == "/zkruby"
+            watch_results[0][2].should === :node_children_changed
+
+        end
+
+        it "should reset watches over socket disconnects"
+        it "should not send :connection_lost to watches on disconnect if so configured"
+
+        describe :close do
+            it "should send :session_expired to the default watcher on close"
+            it "should send :Session_expired to all watchers on close"
+        end
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+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[ZooKeeper::RubyIO::Connection].level = :error
+#Logging.logger[ZooKeeper::RubyIO::Binding].level = :error
+#Logging.logger[ZooKeeper::Session].level = :debug
+#Logging.logger["ZooKeeper::EventMachine::ClientConn"].level = :debug
+#Logging.logger["ZooKeeper::Session::Ping"].level = :error
+
+Thread.current[:name] = "Rspec::Main"

data/src/jute/zookeeper.jute

@@ -0,0 +1,288 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module org.apache.zookeeper.data {
+    class Id {
+        ustring scheme;
+        ustring id;
+    }
+    class ACL {
+        int perms;
+        Id id;
+    }
+    // information shared with the client
+    class Stat {
+        long czxid;      // created zxid
+        long mzxid;      // last modified zxid
+        long ctime;      // created
+        long mtime;      // last modified
+        int version;     // version
+        int cversion;    // child version
+        int aversion;    // acl version
+        long ephemeralOwner; // owner id if ephemeral, 0 otw
+        int dataLength;  //length of the data in the node
+        int numChildren; //number of children of this node
+        long pzxid;      // last modified children
+    }
+    // information explicitly stored by the server persistently
+    class StatPersisted {
+        long czxid;      // created zxid
+        long mzxid;      // last modified zxid
+        long ctime;      // created
+        long mtime;      // last modified
+        int version;     // version
+        int cversion;    // child version
+        int aversion;    // acl version
+        long ephemeralOwner; // owner id if ephemeral, 0 otw
+        long pzxid;      // last modified children
+    }
+
+   // information explicitly stored by the version 1 database of servers 
+   class StatPersistedV1 {
+       long czxid; //created zxid
+       long mzxid; //last modified zxid
+       long ctime; //created
+       long mtime; //last modified
+       int version; //version
+       int cversion; //child version
+       int aversion; //acl version
+       long ephemeralOwner; //owner id if ephemeral. 0 otw
+    }
+}
+
+module org.apache.zookeeper.proto {
+    class ConnectRequest {
+        int protocolVersion;
+        long lastZxidSeen;
+        int timeOut;
+        long sessionId;
+        buffer passwd;
+    }
+    class ConnectResponse {
+        int protocolVersion;
+        int timeOut;
+        long sessionId;
+        buffer passwd;
+    }
+    class SetWatches {
+        long relativeZxid;
+        vector<ustring>dataWatches;
+        vector<ustring>existWatches;
+        vector<ustring>childWatches;
+    }        
+    class RequestHeader {
+        int xid;
+        int type;
+    }
+    class MultiHeader {
+        int type;
+        boolean done;
+        int err;
+    }
+    class AuthPacket {
+        int type;
+        ustring scheme;
+        buffer auth;
+    }
+    class ReplyHeader {
+        int xid;
+        long zxid;
+        int err;
+    }
+    class GetDataRequest {
+        ustring path;
+        boolean watch;
+    }
+    class SetDataRequest {
+        ustring path;
+        buffer data;
+        int version;
+    }
+    class SetDataResponse {
+        org.apache.zookeeper.data.Stat stat;
+    }
+    class GetSASLRequest {
+        buffer token;
+    }
+    class SetSASLRequest {
+        buffer token;
+    }
+    class SetSASLResponse {
+        buffer token;
+    }
+    class CreateRequest {
+        ustring path;
+        buffer data;
+        vector<org.apache.zookeeper.data.ACL> acl;
+        int flags;
+    }
+    class DeleteRequest {
+        ustring path;
+        int version;
+    }
+    class GetChildrenRequest {
+        ustring path;
+        boolean watch;
+    }
+    class GetChildren2Request {
+        ustring path;
+        boolean watch;
+    }
+    class CheckVersionRequest {
+        ustring path;
+        int version;
+    }
+    class GetMaxChildrenRequest {
+        ustring path;
+    }
+    class GetMaxChildrenResponse {
+        int max;
+    }
+    class SetMaxChildrenRequest {
+        ustring path;
+        int max;
+    }
+    class SyncRequest {
+        ustring path;
+    }
+    class SyncResponse {
+        ustring path;
+    }
+    class GetACLRequest {
+        ustring path;
+    }
+    class SetACLRequest {
+        ustring path;
+        vector<org.apache.zookeeper.data.ACL> acl;
+        int version;
+    }
+    class SetACLResponse {
+        org.apache.zookeeper.data.Stat stat;
+    }
+    class WatcherEvent {
+        int type;  // event type
+        int state; // state of the Keeper client runtime
+        ustring path;
+    }
+    class ErrorResponse {
+        int err;
+    }
+    class CreateResponse {
+        ustring path;
+    }
+    class ExistsRequest {
+        ustring path;
+        boolean watch;
+    }
+    class ExistsResponse {
+        org.apache.zookeeper.data.Stat stat;
+    }
+    class GetDataResponse {
+        buffer data;
+        org.apache.zookeeper.data.Stat stat;
+    }
+    class GetChildrenResponse {
+        vector<ustring> children;
+    }
+    class GetChildren2Response {
+        vector<ustring> children;
+        org.apache.zookeeper.data.Stat stat;
+    }
+    class GetACLResponse {
+        vector<org.apache.zookeeper.data.ACL> acl;
+        org.apache.zookeeper.data.Stat stat;
+    }
+}
+
+module org.apache.zookeeper.server.quorum {
+    class LearnerInfo {
+        long serverid;
+        int protocolVersion;
+    }
+    class QuorumPacket {
+        int type; // Request, Ack, Commit, Ping
+        long zxid;
+        buffer data; // Only significant when type is request
+        vector<org.apache.zookeeper.data.Id> authinfo;
+    }
+}
+
+module org.apache.zookeeper.server.persistence {
+    class FileHeader {
+        int magic;
+        int version;
+        long dbid;
+    }
+}
+
+module org.apache.zookeeper.txn {
+    class TxnHeader {
+        long clientId;
+        int cxid;
+        long zxid;
+        long time;
+        int type;
+    }
+    class CreateTxnV0 {
+        ustring path;
+        buffer data;
+        vector<org.apache.zookeeper.data.ACL> acl;
+        boolean ephemeral;
+    }
+    class CreateTxn {
+        ustring path;
+        buffer data;
+        vector<org.apache.zookeeper.data.ACL> acl;
+        boolean ephemeral;
+        int parentCVersion;
+    }
+    class DeleteTxn {
+        ustring path;
+    }
+    class SetDataTxn {
+        ustring path;
+        buffer data;
+        int version;
+    }
+    class CheckVersionTxn {
+        ustring path;
+        int version;
+    }
+    class SetACLTxn {
+        ustring path;
+        vector<org.apache.zookeeper.data.ACL> acl;
+        int version;
+    }
+    class SetMaxChildrenTxn {
+        ustring path;
+        int max;
+    }
+    class CreateSessionTxn {
+        int timeOut;
+    }
+    class ErrorTxn {
+        int err;
+    }
+    class Txn {
+        int type;
+        buffer data;
+    }
+    class MultiTxn {
+        vector<org.apache.zookeeper.txn.Txn> txns;
+    }
+}