Add files using upload-large-folder tool

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-fatjar/README.md

@@ -0,0 +1,21 @@
+ZooKeeper Fatjar
+================
+
+This package contains build to create a fat zookeeper jar. Fatjar can be used to run:
+- zookeeper server
+- zookeeper client
+- distributed load generator for testing (generateLoad)
+- container that will instantiate classes as directed by an instance manager (ic)
+- system test (systest)
+- jmh micro benchmarks (jmh)
+
+
+Use following command to build fatjar
+```
+mvn clean install -P fatjar -DskipTests
+```
+
+To run the fatjar use:
+```
+java -jar zoookeeper-<version>-fatjar.jar
+```

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-loggraph/README.md

@@ -0,0 +1,80 @@
+# LogGraph README
+
+## 1 - About
+LogGraph is an application for viewing and filtering zookeeper logs. It can handle transaction logs and message logs. 
+
+## 2 - Compiling
+
+Run `mvn clean install dependency:copy-dependencies` in zookeeper-contrib/zookeeper-contrib-loggraph/.
+This will download all dependencies and compile all the loggraph code.
+
+Once compilation has finished, you can run it the the `loggraph.sh` script in zookeeper-contrib/zookeeper-contrib-loggraph/src/main/resources.
+This will start and embedded web server on your machine.
+Navigate to `http://localhost:8182/graph/main.html`
+
+## 3 - Usage
+LogGraph presents the user with 4 views, 
+ 
+  a) Simple log view
+     This view simply displays the log text. This isn't very useful without filters (see "Filtering the logs").
+
+  b) Server view
+     The server view shows the interactions between the different servers in an ensemble. The X axis represents time.
+      
+    * Exceptions show up as red dots. Hovering your mouse over them will give you more details of the exception
+	* The colour of the line represents the election state of the server. 
+	   - orange means LOOKING for leader
+	   - dark green means the server is the leader
+	   - light green means the server is following a leader
+	   - yellow means there isn't enough information to determine the state of the server. 
+	* The gray arrows denote election messages between servers. Pink dashed arrows are messages that were sent but never delivered.
+
+  c) Session view
+     The session view shows the lifetime of sessions on a server. Use the time filter to narrow down the view. Any more than about 2000 events will take a long time to view in your browser. 
+     The X axis represents time. Each line is a session. The black dots represent events on the session. You can click on the black dots for more details of the event.
+
+  d) Stats view
+     There is currently only one statistics view, Transactions/minute. Suggestions for other statistic views are very welcome.
+
+## 4 - Filtering the logs
+The logs can be filtered in 2 ways, by time and by content. 
+
+To filter by time simply move the slider to the desired start time. The time window specifies how many milliseconds after and including the start time will be displayed.
+
+Content filtering uses a adhoc filtering language, using prefix notation. The language looks somewhat similar to lisp. A statement in the language takes the form (op arg arg ....). A statement resolves to a boolean value. Statements can be nested. 
+
+### 4.1 - Filter arguments
+An argument can be a number, a string or a symbol. A number is any argument which starts with -, + or 0 to 9. If the number starts with 0x it is interpreted as hexadecimal. Otherwise it is interpreted as decimal. If the argument begins with a double-quote, (") it is interpreted as a string. Anything else is interpreted as a symbol.
+
+### 4.2 - Filter symbols
+The possible filter symbols are: 
+
+client-id : number, the session id of the client who initiated a transaction.
+
+cxid : number, the cxid of a transaction
+
+zxid : number, the zxid of a transaction
+
+operation : string, the operation being performed, for example "setData", "createSession", "closeSession", "error", "create"
+
+### 4.3 - Filter operations
+The possible filter operations are:
+
+or : logical or, takes 1 or more arguments which must be other statements.
+
+and : logical and, takes 1 or more arguments which must be other statements.
+
+not : logical not, takes 1 argument which must be another statement.
+
+xor : exclusive or, takes 1 or more arguments which must be other statements.
+
+ = : equals, takes 1 or more arguments, which must all be equal to each other to return true.
+
+> : greater than, takes 1 or more arguments, to return true the 1st argument must be greater than the 2nd argument which must be greater than the 3rd argument and so on... 
+
+< : less than, takes 1 or more arguments, to return true the 1st argument must be less than the 2nd argument which must be less than the 3rd argument and so on... 
+
+### 4.4 - Filter examples
+Give me all the setData operations with session id 0xdeadbeef or 0xcafeb33r but not with zxid 0x12341234 ->
+
+(and (= operation "setData") (or (= client-id 0xdeadbeef) (= client-id 0xcafeb33r)) (not (= zxid 0x12341234)))

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-monitoring/test.py

@@ -0,0 +1,282 @@
+#! /usr/bin/env python
+#  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.
+
+import unittest
+import socket
+import sys
+
+from StringIO import StringIO
+
+from check_zookeeper import ZooKeeperServer, NagiosHandler, CactiHandler, GangliaHandler
+
+ZK_MNTR_OUTPUT = """zk_version\t3.4.0--1, built on 06/19/2010 15:07 GMT
+zk_avg_latency\t1
+zk_max_latency\t132
+zk_min_latency\t0
+zk_packets_received\t640
+zk_packets_sent\t639
+zk_outstanding_requests\t0
+zk_server_state\tfollower
+zk_znode_count\t4
+zk_watch_count\t0
+zk_ephemerals_count\t0
+zk_approximate_data_size\t27
+zk_open_file_descriptor_count\t22
+zk_max_file_descriptor_count\t1024
+"""
+
+ZK_MNTR_OUTPUT_WITH_BROKEN_LINES = """zk_version\t3.4.0
+zk_avg_latency\t23
+broken-line
+
+"""
+
+ZK_STAT_OUTPUT = """Zookeeper version: 3.3.0-943314, built on 05/11/2010 22:20 GMT
+Clients:
+ /0:0:0:0:0:0:0:1:34564[0](queued=0,recved=1,sent=0)
+
+Latency min/avg/max: 0/40/121
+Received: 11
+Sent: 10
+Outstanding: 0
+Zxid: 0x700000003
+Mode: follower
+Node count: 4
+"""
+
+class SocketMock(object):
+    def __init__(self):
+        self.sent = []
+
+    def settimeout(self, timeout):
+        self.timeout = timeout
+
+    def connect(self, address):
+        self.address = address
+
+    def send(self, data):
+        self.sent.append(data)
+        return len(data)
+
+    def recv(self, size):
+        return ZK_MNTR_OUTPUT[:size]
+
+    def close(self): pass
+
+class ZK33xSocketMock(SocketMock):
+    def __init__(self):
+        SocketMock.__init__(self)
+        self.got_stat_cmd = False
+
+    def recv(self, size):
+        if 'stat' in self.sent:
+            return ZK_STAT_OUTPUT[:size]
+        else:
+            return ''
+
+class UnableToConnectSocketMock(SocketMock):
+    def connect(self, _):
+        raise socket.error('[Errno 111] Connection refused')
+
+def create_server_mock(socket_class):
+    class ZooKeeperServerMock(ZooKeeperServer):
+        def _create_socket(self):
+            return socket_class()
+    return ZooKeeperServerMock()
+
+class TestCheckZookeeper(unittest.TestCase):
+
+    def setUp(self):
+        self.zk = ZooKeeperServer()
+    
+    def test_parse_valid_line(self):
+        key, value = self.zk._parse_line('something\t5')
+
+        self.assertEqual(key, 'something')
+        self.assertEqual(value, 5)
+
+    def test_parse_line_raises_exception_on_invalid_output(self):
+        invalid_lines = ['something', '', 'a\tb\tc', '\t1']
+        for line in invalid_lines:
+            self.assertRaises(ValueError, self.zk._parse_line, line)
+
+    def test_parser_on_valid_output(self):
+        data = self.zk._parse(ZK_MNTR_OUTPUT)
+
+        self.assertEqual(len(data), 14)
+        self.assertEqual(data['zk_znode_count'], 4)
+        
+    def test_parse_should_ignore_invalid_lines(self):
+        data = self.zk._parse(ZK_MNTR_OUTPUT_WITH_BROKEN_LINES)
+
+        self.assertEqual(len(data), 2)
+
+    def test_parse_stat_valid_output(self):
+        data = self.zk._parse_stat(ZK_STAT_OUTPUT)
+
+        result = {
+            'zk_version' : '3.3.0-943314, built on 05/11/2010 22:20 GMT',
+            'zk_min_latency' : 0,
+            'zk_avg_latency' : 40,
+            'zk_max_latency' : 121,
+            'zk_packets_received': 11,
+            'zk_packets_sent': 10,
+            'zk_server_state': 'follower',
+            'zk_znode_count': 4
+        }
+        for k, v in result.iteritems():
+            self.assertEqual(v, data[k])
+
+    def test_recv_valid_output(self):
+        zk = create_server_mock(SocketMock)
+
+        data = zk.get_stats()
+        self.assertEqual(len(data), 14)
+        self.assertEqual(data['zk_znode_count'], 4)
+
+    def test_socket_unable_to_connect(self):
+        zk = create_server_mock(UnableToConnectSocketMock)
+
+        self.assertRaises(socket.error, zk.get_stats)
+
+    def test_use_stat_cmd_if_mntr_is_not_available(self):
+        zk = create_server_mock(ZK33xSocketMock)
+
+        data = zk.get_stats()
+        self.assertEqual(data['zk_version'], '3.3.0-943314, built on 05/11/2010 22:20 GMT')
+
+class HandlerTestCase(unittest.TestCase):
+    
+    def setUp(self):
+        try:
+            sys._stdout
+        except:
+            sys._stdout = sys.stdout
+        
+        sys.stdout = StringIO()
+
+    def tearDown(self):
+        sys.stdout = sys._stdout
+
+    def output(self):
+        sys.stdout.seek(0)
+        return sys.stdout.read()
+
+
+class TestNagiosHandler(HandlerTestCase):
+
+    def _analyze(self, w, c, k, stats):
+        class Opts(object):
+            warning = w
+            critical = c
+            key = k
+
+        return NagiosHandler().analyze(Opts(), {'localhost:2181':stats})
+
+    def test_ok_status(self):
+        r = self._analyze(10, 20, 'a', {'a': 5})
+
+        self.assertEqual(r, 0)
+        self.assertEqual(self.output(), 'Ok "a"!|localhost:2181=5;10;20\n')
+
+        r = self._analyze(20, 10, 'a', {'a': 30})
+        self.assertEqual(r, 0)
+
+    def test_warning_status(self):
+        r = self._analyze(10, 20, 'a', {'a': 15})
+        self.assertEqual(r, 1)
+        self.assertEqual(self.output(), 
+            'Warning "a" localhost:2181!|localhost:2181=15;10;20\n')
+
+        r = self._analyze(20, 10, 'a', {'a': 15})
+        self.assertEqual(r, 1)
+
+    def test_critical_status(self):
+        r = self._analyze(10, 20, 'a', {'a': 30})
+        self.assertEqual(r, 2)
+        self.assertEqual(self.output(),
+            'Critical "a" localhost:2181!|localhost:2181=30;10;20\n')
+
+        r = self._analyze(20, 10, 'a', {'a': 5})
+        self.assertEqual(r, 2)
+
+    def test_check_a_specific_key_on_all_hosts(self):
+        class Opts(object):
+            warning = 10
+            critical = 20
+            key = 'latency'
+
+        r = NagiosHandler().analyze(Opts(), {
+            's1:2181': {'latency': 5},
+            's2:2181': {'latency': 15},
+            's3:2181': {'latency': 35},
+        })
+        self.assertEqual(r, 2)
+        self.assertEqual(self.output(), 
+            'Critical "latency" s3:2181!|s1:2181=5;10;20 '\
+            's3:2181=35;10;20 s2:2181=15;10;20\n')
+
+class TestCactiHandler(HandlerTestCase):
+    class Opts(object):
+        key = 'a'
+        leader = False
+
+        def __init__(self, leader=False):
+            self.leader = leader
+
+    def test_output_values_for_all_hosts(self):
+        r = CactiHandler().analyze(TestCactiHandler.Opts(), {
+            's1:2181':{'a':1},
+            's2:2181':{'a':2, 'b':3}
+        })
+        self.assertEqual(r, None)
+        self.assertEqual(self.output(), 's1_2181:1 s2_2181:2')
+    
+    def test_output_single_value_for_leader(self):
+        r = CactiHandler().analyze(TestCactiHandler.Opts(leader=True), {
+            's1:2181': {'a':1, 'zk_server_state': 'leader'},
+            's2:2181': {'a':2}
+        })
+        self.assertEqual(r, 0)
+        self.assertEqual(self.output(), '1\n')
+
+
+class TestGangliaHandler(unittest.TestCase):
+
+    class TestableGangliaHandler(GangliaHandler):
+        def __init__(self):
+            GangliaHandler.__init__(self)
+            self.cli_calls = []
+    
+        def call(self, cli):
+            self.cli_calls.append(' '.join(cli))
+            
+    def test_send_single_metric(self):
+        class Opts(object):
+            @property
+            def gmetric(self): return '/usr/bin/gmetric'
+        opts = Opts()
+        
+        h = TestGangliaHandler.TestableGangliaHandler()
+        h.analyze(opts, {'localhost:2181':{'latency':10}})
+
+        cmd = "%s -n latency -v 10 -t uint32" % opts.gmetric
+        assert cmd in h.cli_calls
+
+if __name__ == '__main__':
+    unittest.main()
+

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-rest/NOTICE.txt

@@ -0,0 +1,7 @@
+This contrib module includes software developed under the
+COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
+
+This contrib depends on binary only jar libraries developed at:
+
+https://jersey.dev.java.net/
+https://grizzly.dev.java.net/

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkfuse/README.txt

@@ -0,0 +1,63 @@
+Original authors of zkfuse are Swee Lim & Bartlomiej M Niechwiej of Yahoo.
+'
+ZooKeeper FUSE (File System in Userspace)
+=========================================
+
+Pre-requisites
+--------------
+1. Linux system with 2.6.X kernel.
+2. Fuse (Filesystem in Userspace) must be installed on the build node. 
+3. Development build libraries:
+  a. fuse
+  b. log4cxx
+  c. pthread
+  d. boost
+
+Build instructions
+------------------
+1. cd into this directory
+2. autoreconf -if
+3. ./configure
+4. make
+5. zkfuse binary is under the src directory
+
+Testing Zkfuse
+--------------
+1. Depending on permission on /dev/fuse, you may need to sudo -u root.
+   * If /dev/fuse has permissions 0600, then you have to run Zkfuse as root.
+   * If /dev/fuse has permissions 0666, then you can run Zkfuse as any user.
+2. Create or find a mount point that you have "rwx" permission. 
+   * e.g. mkdir -p /tmp/zkfuse
+3. Run Zkfuse as follows:
+   zkfuse -z <hostspec> -m /tmp/zkfuse -d
+   -z specifies ZooKeeper address(es) <host>:<port>
+   -m specifies the mount point
+   -d specifies the debug mode.
+   For additional command line options, try "zkfuse -h".
+
+FAQ
+---
+Q. How to fix "warning: macro `AM_PATH_CPPUNIT' not found in library"?
+A. * install cppunit (src or pkg) on build machine
+
+Q. Why can't Zkfuse cannot write to current directory?
+A. * If Zkfuse is running as root on a NFS mounted file system, it will not
+     have root permissions because root user is mapped to another user by
+     NFS admin.
+   * If you run Zkfuse as root, it is a good idea to run Zkfuse from a
+     directory that you have write access to. This will allow core files
+     to be saved.
+
+Q. Why Zkfuse cannot mount?
+A. * Check that the mount point exists and you have "rwx" permissions.
+   * Check that previous mounts have been umounted. If Zkfuse does not 
+     exit cleanly, its mount point may have to be umounted manually. 
+     If you cannot umount manually, make sure that there no files is open 
+     within the mount point.
+
+Q. Why does Zkfuse complain about logging at startup?
+A. * Zkfuse uses log4cxx for logging. It is looking for log4cxx.properties
+     file to obtain its logging configuration.
+   * There is an example log4cxx.properties file in the Zkfuse source 
+     directory.
+

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkfuse/build.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0"?>
+
+<!--
+   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.
+-->
+
+<project name="zkfuse" default="compile">
+  <import file="../build-contrib.xml"/>
+
+  <target name="init" depends="check-contrib" unless="skip.contrib">
+    <echo message="contrib: ${name}"/>
+    <mkdir dir="${build.dir}"/>
+    <antcall target="init-contrib"/>
+  </target>
+
+  <target name="compile" depends="init" unless="skip.contrib">
+    <echo message="contrib: ${name}"/>
+
+    <mkdir dir="${build.dir}"/>
+    <copy todir="${build.dir}">
+      <fileset dir="${basedir}">
+        <exclude name="**/VERSION"/>
+      </fileset>
+    </copy>
+    <exec executable="echo" output="${build.dir}/VERSION">
+      <arg line="${version}" />
+    </exec>
+  </target>
+
+	<target name="jar" depends="compile" >
+		<echo message="No jar target defined for this package"/>
+	</target>
+
+ 	<target name="test">
+        <echo message="No test target defined for this package" />
+    </target>
+
+
+  <target name="package" depends="compile" unless="skip.contrib">
+    <echo message="contrib: ${name}"/>
+
+    <mkdir dir="${dist.dir}/zookeeper-contrib/zookeeper-contrib-${name}"/>
+    <copy todir="${dist.dir}/zookeeper-contrib/zookeeper-contrib-${name}">
+      <fileset dir="${build.dir}"/>
+    </copy>
+  </target>
+
+</project>

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkperl/Changes

@@ -0,0 +1,65 @@
+Net::ZooKeeper - Perl extension for Apache ZooKeeper
+
+Revision history
+================
+
+0.01  Dec 5, 2008
+        - initial version
+
+0.02  Dec 16, 2008
+        - support connection to ZooKeeper and get() method
+
+0.03  Jan 9, 2009
+        - implemented watch mechanism for get()
+
+0.04  Jan 15, 2009
+        - all basic ZooKeeper methods supported
+
+0.05  Jan 21, 2009
+        - converted from T_PTROBJ to T_ZK_HASH with PERL_MAGIC_ext,
+          allows DESTROY() to be called repeatedly
+
+0.06  Jan 27, 2009
+        - converted from attribute accessor methods to inner and outer hashes
+          with PERL_MAGIC_tied
+
+0.07  Jan 29, 2009
+        - all tied hash methods completed
+
+0.08  Jan 30, 2009
+        - simple thread safety enforced with CLONE_SKIP
+
+0.09  Feb 12, 2009
+        - ACL constants
+
+0.10  Feb 18, 2009
+        - ACL support
+
+0.11  Feb 21, 2009
+        - ZooKeeper version check
+
+0.20  Feb 25, 2009
+        - refactored watches as subclass
+
+0.30  Feb 27, 2009
+        - refactored stats as subclass
+
+0.31  Mar 6, 2009
+        - test suite completed
+
+0.32  Mar 25, 2009
+        - initial documentation completed, first public release
+
+0.33  Apr 20, 2009
+        - copyright donated to ASF
+
+0.34  Jul 14, 2009
+        - support ZooKeeper 3.2.0 release
+
+0.35  Jul 15, 2009
+        - support multiple include and library locations
+
+0.36  Mar 27, 2011
+        - Fix zookeeper version check, but only warn since we haven't been enforcing it in a while
+        - Look for zookeeper includes in some sane places by default
+

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkperl/MANIFEST

@@ -0,0 +1,23 @@
+Changes
+LICENSE
+Makefile.PL
+MANIFEST
+NOTICE
+README
+typemap
+ZooKeeper.pm
+ZooKeeper.xs
+build/check_zk_version.c
+build/check_zk_version.h
+t/10_invalid.t
+t/15_thread.t
+t/20_tie.t
+t/22_stat_tie.t
+t/24_watch_tie.t
+t/30_connect.t
+t/35_log.t
+t/40_basic.t
+t/45_class.t
+t/50_access.t
+t/60_watch.t
+t/util.pl

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkperl/Makefile.PL

@@ -0,0 +1,87 @@
+# Net::ZooKeeper - Perl extension for Apache ZooKeeper
+#
+# 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.
+
+use 5.008_008;
+
+use Config;
+use ExtUtils::MakeMaker;
+use Getopt::Long;
+
+my $ZOO_MAJOR_VERSION = 3;
+my $ZOO_REQUIRED_VERSION = qr{^$ZOO_MAJOR_VERSION\.\d+.\d+$}ismx;
+
+my @zk_inc_paths;
+my @zk_lib_paths;
+
+my $with_sasl2 = 0;
+my @sasl2_inc_paths;
+my @sasl2_lib_paths;
+
+GetOptions(
+    'zookeeper-include=s' => \@zk_inc_paths,
+    'zookeeper-lib=s' => \@zk_lib_paths,
+    'with-sasl2!' => \$with_sasl2,
+    'sasl2-include=s' => \@sasl2_inc_paths,
+    'sasl2-lib=s' => \@sasl2_lib_paths
+);
+
+my $zk_inc = (join(' ', map("-I$_", @zk_inc_paths)) . ' -I.');
+my $zk_libs = (join(' ', map("-L$_", @zk_lib_paths)) . ' -lzookeeper_mt');
+
+my $cc = $Config{'cc'};
+my $check_file = 'build/check_zk_version';
+
+my $check_out = qx($cc $zk_inc -o $check_file $check_file.c $zk_libs 2>&1);
+
+if ($?) {
+    if ($check_out =~ /zookeeper_version\.h/) {
+        die("Could not determine ZooKeeper version:\n\n$check_out");
+    }
+    else {
+        ## keep in sync with build/check_zk_version.h
+        die("Net::ZooKeeper requires at least ZooKeeper version 3.1.1\n");
+    }
+}
+
+chomp(my $zk_ver = qx($check_file));
+
+if ($? >> 8 != 0) {
+  die "Couldn't check zookeeper version: $zk_ver: $r";
+}
+elsif ($zk_ver !~ $ZOO_REQUIRED_VERSION) {
+  warn "Net::ZooKeeper requires ZooKeeper 3.x, found $zk_ver!";
+}
+
+my @inc = ($zk_inc);
+my @libs = ($zk_libs);
+my %mmopt = ();
+
+if ($with_sasl2) {
+    push(@inc, join(' ', map("-I$_", @sasl2_inc_paths)));
+    push(@libs, join(' ', map("-L$_", @sasl2_lib_paths)) . ' -lsasl2');
+    $mmopt{DEFINE} = '-DHAVE_CYRUS_SASL_H';
+}
+
+WriteMakefile(
+    'INC'          => join(' ', @inc),
+    'LIBS'         => \@libs,
+    'NAME'         => 'Net::ZooKeeper',
+    'VERSION_FROM' => 'ZooKeeper.pm',
+    'clean'        => { 'FILES' => 'build/check_zk_version.o' },
+    %mmopt,
+);

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkperl/NOTICE

@@ -0,0 +1,6 @@
+Net::ZooKeeper - Perl extension for Apache ZooKeeper
+Copyright 2009 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
+

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkperl/ZooKeeper.pm

@@ -0,0 +1,1285 @@
+# Net::ZooKeeper - Perl extension for Apache ZooKeeper
+#
+# 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.
+
+use 5.008_008;
+
+use strict;
+use warnings;
+
+package Net::ZooKeeper;
+
+require Exporter;
+require XSLoader;
+
+our $VERSION = '0.36';
+
+our @ISA = qw(Exporter);
+
+our %EXPORT_TAGS = (
+    'errors' => [qw(
+        ZOK
+        ZSYSTEMERROR
+        ZRUNTIMEINCONSISTENCY
+        ZDATAINCONSISTENCY
+        ZCONNECTIONLOSS
+        ZMARSHALLINGERROR
+        ZUNIMPLEMENTED
+        ZOPERATIONTIMEOUT
+        ZBADARGUMENTS
+        ZINVALIDSTATE
+        ZAPIERROR
+        ZNONODE
+        ZNOAUTH
+        ZBADVERSION
+        ZNOCHILDRENFOREPHEMERALS
+        ZNODEEXISTS
+        ZNOTEMPTY
+        ZSESSIONEXPIRED
+        ZINVALIDCALLBACK
+        ZINVALIDACL
+        ZAUTHFAILED
+        ZCLOSING
+        ZNOTHING
+    )],
+    'node_flags' => [qw(
+        ZOO_EPHEMERAL
+        ZOO_SEQUENCE
+    )],
+    'acl_perms' => [qw(
+        ZOO_PERM_READ
+        ZOO_PERM_WRITE
+        ZOO_PERM_CREATE
+        ZOO_PERM_DELETE
+        ZOO_PERM_ADMIN
+        ZOO_PERM_ALL
+    )],
+    'acls' => [qw(
+        ZOO_OPEN_ACL_UNSAFE
+        ZOO_READ_ACL_UNSAFE
+        ZOO_CREATOR_ALL_ACL
+    )],
+    'events' => [qw(
+        ZOO_CREATED_EVENT
+        ZOO_DELETED_EVENT
+        ZOO_CHANGED_EVENT
+        ZOO_CHILD_EVENT
+        ZOO_SESSION_EVENT
+        ZOO_NOTWATCHING_EVENT
+    )],
+    'states' => [qw(
+        ZOO_EXPIRED_SESSION_STATE
+        ZOO_AUTH_FAILED_STATE
+        ZOO_CONNECTING_STATE
+        ZOO_ASSOCIATING_STATE
+        ZOO_CONNECTED_STATE
+    )],
+    'log_levels' => [qw(
+        ZOO_LOG_LEVEL_OFF
+        ZOO_LOG_LEVEL_ERROR
+        ZOO_LOG_LEVEL_WARN
+        ZOO_LOG_LEVEL_INFO
+        ZOO_LOG_LEVEL_DEBUG
+    )]
+);
+
+{
+    my %tags;
+
+    push @{$EXPORT_TAGS{'all'}},
+        grep {!$tags{$_}++} @{$EXPORT_TAGS{$_}} foreach (keys(%EXPORT_TAGS));
+}
+
+our @EXPORT_OK = ( @{$EXPORT_TAGS{'all'}} );
+
+XSLoader::load('Net::ZooKeeper', $VERSION);
+
+1;
+
+__END__
+
+=head1 NAME
+
+Net::ZooKeeper - Perl extension for Apache ZooKeeper
+
+=head1 SYNOPSIS
+
+  use Net::ZooKeeper qw(:node_flags :acls);
+
+  my $zkh = Net::ZooKeeper->new('localhost:7000');
+
+  $zkh->create('/foo', 'bar',
+               'flags' => ZOO_EPHEMERAL,
+               'acl' => ZOO_OPEN_ACL_UNSAFE) or
+    die("unable to create node /foo: " . $zkh->get_error() . "\n");
+
+  print "node /foo has value: " . $zkh->get('/foo') . "\n";
+
+  $zkh->set('/foo', 'baz');
+
+  print "node / has child nodes:\n";
+  foreach my $path ($zkh->get_children('/')) {
+    print "  /$path\n";
+  }
+
+  my $stat = $zkh->stat();
+  if ($zkh->exists('/foo', 'stat' => $stat)) {
+    print "node /foo has stat info:\n";
+    while (my($key,$value) = each(%{$stat})) {
+      print "  $key: $value\n";
+    }
+  }
+
+  foreach my $acl_entry ($zkh->get_acl('/foo')) {
+    print "node /foo has ACL entry:\n";
+    print "  perms:  $acl_entry->{perms}\n";
+    print "  scheme: $acl_entry->{scheme}\n";
+    print "  id:     $acl_entry->{id}\n";
+  }
+
+  my $watch = $zkh->watch('timeout' => 10000);
+  $zkh->exists('/foo', 'watch' => $watch);
+
+  if ($watch->wait()) {
+    print "watch triggered on node /foo:\n";
+    print "  event: $watch->{event}\n";
+    print "  state: $watch->{state}\n";
+  }
+  else {
+    print "watch timed out after 10 seconds\n";
+  }
+
+  $zkh->delete('/foo');
+
+=head1 DESCRIPTION
+
+Net::ZooKeeper provides a Perl interface to the synchronous C API
+of Apache ZooKeeper.  ZooKeeper is coordination service for
+distributed applications.
+
+Each connection to ZooKeeper is represented as a handle object
+of the class Net::ZooKeeper, similar to the manner in which database
+connections are represented in the DBI module.
+
+To disconnect from ZooKeeper, simply destroy the Net::ZooKeeper
+handle object by undefining it or by explicitly calling the
+C<DESTROY()> method.
+
+The methods which may be invoked on Net::ZooKeeper handles
+correspond to the functions of the synchronous ZooKeeper C API;
+e.g., the Net::ZooKeeper method C<create()> calls the ZooKeeper
+C function C<zoo_create()>, C<delete()> calls C<zoo_delete()>,
+and so forth.
+
+The synchronous API functions wait for a response from the ZooKeeper
+cluster before returning a result to the caller.  Using these
+functions permits Net::ZooKeeper to provide an interface similar
+to that of a DBI driver module.
+
+=head2 Internal POSIX Threads
+
+The use of the synchronous ZooKeeper C API still requires that
+the ZooKeeper C client code create several POSIX threads which run
+concurrently with the main thread containing the Perl interpreter.
+
+The synchronous API functions are wrappers of the asynchronous
+functions in the ZooKeeper C API.  When a request is made by the
+caller's thread (i.e., the one with the running Perl interpreter),
+it is enqueued for delivery at a later time by the ZooKeeper C client
+code's IO thread.  The caller's thread then waits for notification
+before returning from the synchronous API function.
+
+The IO thread dequeues the request and sends it to the ZooKeeper
+cluster, while also ensuring that a regular "heartbeat" is maintained
+with the cluster so that the current session does not time out.
+When the IO thread receives a response from
+the ZooKeeper cluster, it enqueues the response for delivery to the
+client by the second thread of the ZooKeeper client code, the
+completion thread.
+
+If the caller is using the asynchronous API, the completion thread
+invokes the appropriate callback function provided by the caller
+for the given request.  In the case of Net::ZooKeeper, it is not
+viable for the completion thread to invoke a Perl callback function
+at arbitrary times; this could interfere with the state of the
+Perl interpreter.
+
+For this reason Net::ZooKeeper uses the synchronous API only.  After
+enqueuing requests the synchronous API functions wait for notification
+of the corresponding response.  The completion thread delivers these
+notifications, at which point the synchronous functions return to
+their caller.
+
+Note that the IO and completion threads are POSIX threads, not
+Perl ithreads.  Net::ZooKeeper defined a C<CLONE_SKIP()> function so
+that if Perl ithreads are spawned while a Net::ZooKeeper connection
+is active, the Net::ZooKeeper handle objects inherited by the
+spawned ithread contain undefined values so that they can not be used.
+Thus each ithread will need to create its own private connections to a
+ZooKeeper cluster.
+
+Note also that before invoking C<fork()> to spawn a new process,
+all Net::ZooKeeper handles should be destroyed so that all
+connections to ZooKeeper are closed and all internal POSIX threads
+have exited.  If a child process needs to communicate with
+ZooKeeper it should open its own private connections after it is
+created by C<fork()>.
+
+=head2 Signals
+
+The ZooKeeper C API uses TCP connections to communicate with
+the ZooKeeper cluster.  These connections may generate SIGPIPE
+signals when they encounter errors, such as when a connection
+is terminated by a ZooKeeper server.  Therefore most applications
+will want to trap or ignore SIGPIPE signals, e.g.:
+
+  local $SIG{'PIPE'} = 'IGNORE';
+
+Ignoring SIGPIPE signals (or providing a signal handler that returns
+control to the interrupted program after receiving the signal)
+will allow the ZooKeeper C client code to detect the connection error
+and report it upon return from the next Net::ZooKeeper method.
+
+=head2 Error Handling
+
+Net::ZooKeeper methods return different values in the case of an
+error depending on their purpose and context.  For example,
+C<exists()> returns true if the node exists and false otherwise,
+which may indicate either that the node does not exist or that
+an error occurred.
+
+After any method returns a false, empty, or undefined value which
+might indicate an error has occurred, the C<get_error()> method
+may be called to examine the specific error code, if any.
+
+If C<get_error()> returns C<ZOK>, no error has occurred.  If the
+error code is less than C<ZAPIERROR>, it indicates a normal error
+condition reported by the ZooKeeper server, such as C<ZNONODE>
+(node does not exist) or C<ZNODEEXISTS> (node already exists).
+
+If the error code is greater than C<ZAPIERROR>, then a connection
+error or server error has occurred and the client should probably
+close the connection by undefining the Net::ZooKeeper handle object
+and, if necessary, attempt to create a new connection to the
+ZooKeeper cluster.
+
+=head2 Access Control
+
+If the ZooKeeper cluster is not configured with C<skipACL=yes> then
+it will respect the access controls set for each node in the
+ZooKeeper hierarchy.  These access controls are defined using ACLs
+(Access Control Lists); see the ZooKeeper documentation for compete
+details.
+
+In Net::ZooKeeper, ACLs are represented as arrays of hashes, where
+each hash is an ACL entry that must contain three attributes,
+C<perms>, C<scheme>, and C<id>.  The C<perms> attribute's value
+should be composed by combining ACL permission flags using the
+bitwise OR operator.  See C<:acl_perms> for a list of the
+available ACL permission flags.
+
+The ACL for a node may be read using the C<get_acl()> method.  A
+node's ACL may be set when the node is created by passing an ACL
+array as the value of the C<'acl'> option to the C<create()> method,
+and may be updated by passing an ACL array to the C<set_acl()> method.
+
+When a client connects to a ZooKeeper cluster it is automatically
+assigned authentication credentials based on its IP address.
+Additional authentication credentials may be added using
+the C<add_auth()> method.  Once a credential has been added for
+the current session, there is no way to disable it.
+
+As an example, digest authentication may be enabled for a session
+by calling C<add_auth()> as follows:
+
+  $zkh->add_auth('digest', "$username:$password");
+
+Note that the username and password are transmitted in cleartext
+to the ZooKeeper cluster.
+
+Such authentication credentials would enable access to a node
+whose ACL contained an entry with a C<scheme> attribute of
+C<'digest'> and an C<id> attribute containing a Base64-encoded
+SHA1 digest of the string C<"$username:$password">.  The
+Perl modules Digest and MIME::Base64 may be used to create
+such ACL ID values as follows:
+
+  use Digest qw();
+  use MIME::Base64 qw();
+
+  my $ctx = Digest->new('SHA-1')->add("$username:$password");
+  my $digest = MIME::Base64::encode($ctx->digest());
+
+Note that using the C<b64digest()> method of the Digest module
+will not result in digest strings with the "=" suffix characters
+required by ZooKeeper.
+
+=head2 Logging
+
+As of ZooKeeper version 3.1.1, logging in the C client code is
+implemented with a single, shared file handle to which all
+of the internal POSIX threads write log messages; by default,
+this file handle is attached to STDERR.
+
+Moreover, this file handle is shared by all active ZooKeeper
+connections (each of which has its own private IO and completion
+threads; see L</Internal POSIX Threads> above).
+
+Net::ZooKeeper therefore does not provide per-connection handle
+attributes related to logging.  The global function
+C<Net::ZooKeeper::set_log_level()> may be used to set the current
+log level.  See C<:log_levels> for a list of the available log
+levels.  The default log level is C<ZOO_LOG_LEVEL_OFF>.
+
+To capture ZooKeeper log messages to a file instead of STDERR,
+redirect STDERR to a new file handle in the normal Perl manner:
+
+  open(OLDERR, '>&', fileno(STDERR)) or
+    die("unable to dup STDERR: $!");
+  open(STDERR, '>', $log_file) or
+    die("unable to redirect STDERR: $!");  
+
+=head2 Connection Order
+
+ZooKeeper clusters are typically made up of an odd number of
+ZooKeeper servers.  When connecting to such a cluster, the
+C<new()> method should be passed a comma-separated list of
+the hostnames and ports for each of the servers in the cluster,
+e.g., C<'host1:7000,host2:7000,host2:7100'>.
+
+The default behaviour of the ZooKeeper client code is to
+reorder this list randomly before making any connections.
+A connection is then made to the first server in the reordered
+list.  If that connection fails, the IO thread will
+automatically attempt to reconnect to the cluster, this time
+to the next server in the list; when the last server in the list
+is reached, the IO thread will continue again with the first
+server.
+
+For certain purposes it may be necessary for ZooKeeper clients
+to know the exact order in which the IO thread will attempt to
+connect to the servers of a cluster.  To do so, call
+C<Net::ZooKeeper::set_deterministic_conn_order(1)>.  Note,
+however, that this will affect all Net::ZooKeeper object
+handles created by the current process.
+
+=head1 ATTRIBUTES
+
+=head2 Net::ZooKeeper
+
+The Net::ZooKeeper class provides the main interface to the
+ZooKeeper client API.  The following attributes are available
+for each Net::ZooKeeper handle object and are specific to
+that handle and the method calls invoked on it.  As with DBI
+handle objects, attributes may be read and written through
+a hash interface, e.g.:
+
+  print sprintf("Session timeout is %.2f seconds.\n",
+    $zkh->{session_timeout} / 1000);
+
+  $zkh->{watch_timeout} = 10000;
+
+=over 4
+
+=item hosts
+
+The comma-separated list of ZooKeeper server hostnames and ports
+as passed to the C<new()> method.  Note that by default the
+ZooKeeper C client code will reorder this list before attempting
+to connect for the first time; see L</Connection Order> for details.
+
+This attribute is B<read-only> and may not be modified.
+
+=item session_timeout
+
+The session timeout value, in milliseconds, as set by the
+ZooKeeper server after connection.  This value may not be
+exactly the same as what was requested in the C<'session_timeout'>
+option of the C<new()> method; the server will adjust the
+requested timeout value so that it is within a certain range
+of the server's C<tickTime> setting.  See the ZooKeeper
+documentation for details.
+
+Because the actual connection to the ZooKeeper server is
+not made during the C<new()> method call but shortly
+thereafter by the IO thread, note that this value may not
+be initialized to its final value until at least one
+other method which requires communication with the server
+(such as C<exists()>) has succeeded.
+
+This attribute is B<read-only> and may not be modified.
+
+=item session_id
+
+The client's session ID value as set by the ZooKeeper server
+after connection.  This is a binary data string which may
+be passed to subsequent C<new()> calls as the value of
+the C<'session_id'> option, if the user wishes to attempt to
+continue a session after a failure.  Note that the server
+may not honour such an attempt.
+
+Because the actual connection to the ZooKeeper server is
+not made during the C<new()> method call but shortly
+thereafter by the IO thread, note that this value may not
+be initialized to its final value until at least one
+other method which requires communication with the server
+(such as C<exists()>) has succeeded.
+
+This attribute is B<read-only> and may not be modified.
+
+=item data_read_len
+
+The maximum length of node data that will be returned to
+the caller by the C<get()> method.  If a node's data exceeds
+this length, the returned value will be shorter than the
+actual node data as stored in the ZooKeeper cluster.
+
+The default maximum length of the node data returned by
+C<get()> is 1023 bytes.  This may be changed by setting
+the C<data_read_len> attribute to a different value.
+
+Passing a value for the C<'data_read_len'> option when calling
+the C<get()> method will temporarily override the per-handle
+maximum.
+
+=item path_read_len
+
+The maximum length of a newly created node's path that will
+be returned to the caller by the C<create()> method.  If the path
+of the newly created node exceeds this length, the returned
+value will be shorter than the actual path of the node as stored
+in the ZooKeeper cluster.
+
+The default maximum length of the node path returned by
+C<create()> is 1023 bytes.  This may be changed by setting
+the C<path_read_len> attribute to a different value.
+
+Passing a value for the C<'path_read_len'> option when calling
+the C<create()> method will temporarily override the current
+value of this attribute.
+
+=item watch_timeout
+
+The C<timeout> attribute value, in milliseconds, inherited by
+all watch objects (of class Net::ZooKeeper::Watch) created by
+calls to the C<watch()> method.  When a watch object's
+C<wait()> method is invoked without a C<'timeout'> option,
+it waits for an event notification from the ZooKeeper cluster
+for no longer than the timeout period specified by the value of
+the watch object's C<timeout> attribute.
+
+The default C<timeout> attribute value for all watch objects
+created by the C<watch()> method is 1 minute (60000
+milliseconds).  This may be changed for a particular handle
+object by setting this attribute to a different value; afterwards,
+the new value will be inherited by any watch objects created
+by the handle object's C<watch()> method.  Previously
+created watch objects will not be affected.
+
+Passing a value for the C<'timeout'> option when calling
+the C<watch()> method will temporarily override the current
+value of this attribute and cause the newly created watch object
+to inherit a different value.
+
+See also the C<watch()> method, and the C<timeout> attribute
+and C<wait()> method of the Net::ZooKeeper::Watch class.
+
+=item pending_watches
+
+The number of internal ZooKeeper watches created for this handle
+object that are still awaiting an event notification from the
+ZooKeeper cluster.
+
+Note that this number may be different than the number of
+extant watch objects created by the handle object's C<watch()>
+method, not only because some event notifications may have
+occurred, but also if any watch objects have been reassigned
+by reusing them in more than one call to any of the C<exists()>,
+C<get_children()>, or C<get()> methods.
+
+This attribute is B<read-only> and may not be modified.
+
+=back
+
+=head2 Net::ZooKeeper::Stat
+
+The Net::ZooKeeper::Stat class provides a hash interface to
+the individual pieces of information which together compose the
+state of a given ZooKeeper node.  Net::ZooKeeper::Stat objects
+are created by calling the C<stat()> method on a Net::ZooKeeper
+handle object, and may then be passed to any methods which accept
+a C<'stat'> option value, such as C<exists()>.
+
+Net::ZooKeeper::Stat objects may be reused multiple times.
+If the Net::ZooKeeper method to which the stat object is
+passed succeeds, then the stat object is updated with the newly
+retrieved node state information, and any state information
+previously stored in the stat object is overwritten.
+
+All of the attributes of stat objects are B<read-only>.
+
+=over 4
+
+=item ctime
+
+The creation time of the node in milliseconds since the epoch.
+
+=item mtime
+
+The time of the last modification of the node's data in
+milliseconds since the epoch.
+
+=item data_len
+
+The length of the node's data in bytes.
+
+=item num_children
+
+The number of child nodes beneath of the current node.
+
+=item ephemeral_owner
+
+If the node was created with the C<ZOO_EPHEMERAL> flag,
+this attribute holds the session ID of the ZooKeeper client
+which created the node.  If the node was not created with
+the C<ZOO_EPHEMERAL> flag, this attribute is set to zero.
+
+=item version
+
+The number of revisions of the node's data.  The ZooKeeper
+cluster will increment this version number whenever the
+node's data is changed.  When the node is first created this
+version number is initialized to zero.
+
+=item acl_version
+
+The number of revisions of the node's ACL.  The ZooKeeper
+cluster will increment this version number whenever the
+node's ACL is changed.  When the node is first created this
+version number is initialized to zero.
+
+=item children_version
+
+The number of revisions of the node's list of child nodes.
+The ZooKeeper cluster will increment this version number
+whenever the list of child nodes is changed.  When the node
+is first created this version number is initialized to zero.
+
+=item czxid
+
+The ZooKeeper transaction ID (ZXID) of the transaction which
+created the node.
+
+=item mzxid
+
+The ZooKeeper transaction ID (ZXID) of the transaction which
+last modified the node's data.  This is initially set to
+the same transaction ID as the C<czxid> attribute by the
+C<create()> method.
+
+=item children_zxid
+
+The ZooKeeper transaction ID (ZXID) of the transaction which
+last modified the node's list of child nodes.  This is
+initially set to the same transaction ID as the C<czxid>
+attribute by the C<create()> method.
+
+=back
+
+=head2 Net::ZooKeeper::Watch
+
+The Net::ZooKeeper::Watch class provides a hash interface
+to the data returned by event notifications from the ZooKeeper
+cluster.  Net::ZooKeeper::Watch objects are created by calling
+the C<watch()> method on a Net::ZooKeeper handle object, and
+may then be passed to any methods which accept a C<'watch'>
+option value, such as C<exists()>.
+
+Net::ZooKeeper::Watch objects may be reused multiple times.
+Regardless of whether the Net::ZooKeeper method to which the
+watch object is passed succeeds, the watch object will be
+updated to receive an event notification exclusively for the
+node referenced in that method call.  In the case of an error,
+however, the watch object may never receive any event
+notification.
+
+=over 4
+
+=item timeout
+
+The default timeout value, in milliseconds, for all
+invocations of the C<wait()> method made on the watch object.
+When the C<wait()> method is invoked without a
+C<'timeout'> option value, it waits for an
+event notification from the ZooKeeper cluster for no longer
+than the timeout period specified by this attribute.
+This default timeout period may be altered by setting this
+attribute to a different value.
+
+Passing a value for the C<'timeout'> option when calling
+the C<wait()> method will temporarily override the current
+value of this attribute and cause the C<wait()> method to
+use a different timeout period.
+
+When a Net::ZooKeeper handle object's C<watch()> method is
+invoked without a C<'timeout'> option, it returns a newly
+created watch object whose C<timeout> attribute value
+is initialized to the current value of the handle object's
+C<watch_timeout> attribute.  When the C<watch()> method is invoked
+with a C<'timeout'> option, the new watch object's C<timeout>
+attribute value is initialized to the value specified by
+the C<'timeout'> option.
+
+See also the C<wait()> method, and the C<watch_timeout> attribute
+and C<watch()> method of the Net::ZooKeeper class.
+
+=item event
+
+The type of event which triggered the notification, such
+as C<ZOO_CHANGED_EVENT> if the node's data was changed.
+See C<:events> for a list of the possible event types.
+If zero, no event notification has occurred yet.
+
+Note that the events which will trigger a notification
+will depend on the Net::ZooKeeper method to which
+the watch object was passed.  Watches set through the
+C<exists()> and C<get()> methods will report events relating
+to the node's data, while watches set through the
+C<get_children()> method will report events relating to the
+creation or deletion of child nodes of the watched node.
+
+This attribute is B<read-only> and may not be modified.
+
+=item state
+
+The state of the Net::ZooKeeper connection at the time of
+the event notification.  See C<:states> for a list of
+the possible connection states.  If zero, no event
+notification has occurred yet.
+
+This attribute is B<read-only> and may not be modified.
+
+=back
+
+=head1 METHODS
+
+=head2 Net::ZooKeeper
+
+The following methods are defined for the Net::ZooKeeper class.
+
+=over 4
+
+=item new()
+
+  $zkh = Net::ZooKeeper->new('host1:7000,host2:7000');
+  $zkh = Net::ZooKeeper->new('host1:7000,host2:7000',
+                             'session_timeout' => $session_timeout,
+                             'session_id' => $session_id,
+                             'sasl_options' => $sasl_options);
+
+Creates a new Net::ZooKeeper handle object and attempts to
+connect to the one of the servers of the given ZooKeeper
+cluster.  As described in the L</Internal POSIX Threads> and
+L</Connection Order> sections, the ZooKeeper client code will
+create an IO thread which maintains the connection with a
+regular "heartbeat" request.  In the event of a connection error
+the IO thread will also attempt to reconnect to another one of
+the servers using the same session ID.  In general, these actions
+should be invisible to the user, although Net::ZooKeeper methods
+may return transient errors while the IO thread
+reconnects with another server.
+
+To disconnect, undefine the Net::ZooKeeper handle object
+or call the C<DESTROY()> method.  (After calling C<DESTROY()>
+the handle object can not be reused.)
+
+The ZooKeeper client code will send a "heartbeat" message
+if a third of the session timeout period has elapsed without
+any communication with the ZooKeeper server.  A specific
+session timeout period may be requested when creating a
+Net::ZooKeeper handle object by supplying a value, in
+milliseconds, for the C<'session_timeout'> option.  The
+ZooKeeper server adjust the requested timeout value so that
+it is within a certain range of the server's C<tickTime> setting;
+the actual session timeout value will be available as the
+value of the handle's C<session_timeout> attribute after at
+least one method call has succeeded.  See the C<session_timeout>
+attribute for more information.
+
+If no C<'session_timeout'> option is provided, the default
+value of 10 seconds (10000 milliseconds) will be used in the
+initial connection request; again, the actual timeout period to
+which the server agrees will be available subsequently as the
+value of the C<session_timeout> attribute.
+
+If a C<'sasl_options'> option is provided, it is used to automatically
+SASL-authenticate with the server during connections (including
+reconnects).  Here is a brief description of the recognized keys;
+please refer to the C client documentation for details:
+
+=over 5
+
+=item service => VALUE
+
+=item host => VALUE
+
+=item mechlist => VALUE
+
+These map to the corresponding fields of C<zoo_sasl_params_t> from the
+library.
+
+=item user => VALUE
+
+=item realm => VALUE
+
+=item password_file => VALUE
+
+These map to the corresponding parameters of
+C<zoo_sasl_make_basic_callbacks> from the library.
+
+=back
+
+Upon successful connection (i.e., after the success of a method
+which requires communication with the server), the C<session_id>
+attribute will hold a short binary string which represents the
+client's session ID as set by the server.  All ephemeral nodes
+created by the session are identified by this ID in the
+C<ephemeral_owner> attribute of any Net::ZooKeeper::Stat objects
+used to query their state.
+
+The ZooKeeper client code will use this session ID internally
+whenever it tries to reconnect to another server in the ZooKeeper
+cluster after detecting a failed connection.  If it successfully
+reconnects with the same session ID, the session will continue
+and ephemeral nodes belonging to it will not be deleted.
+
+However, if the server determines that the session has timed
+out (for example because no "heartbeat" requests have been
+received within the agreed-upon session timeout period), the
+session will be terminated by the cluster and all ephemeral nodes
+owned by the current session automatically deleted.
+
+On occasion the ZooKeeper client code may not be able to quickly
+reconnect to a live server and the caller may want to destroy
+the existing Net::ZooKeeper handle object and attempt a
+fresh connection using the same session ID as before with a
+new Net::ZooKeeper object.  To do so, save the C<session_id>
+attribute value before undefining the old handle object
+and then pass that binary string as the value of the
+C<'session_id'> option to the C<new()> method when creating the
+next handle object.  After the successful completion of a
+method which requires communication with the server, if the
+new handle object's C<session_id> attribute value matches the
+old session ID then the session has been successfully maintained;
+otherwise, the old session was expired by the cluster.
+
+=item get_error()
+
+  $code = $zkh->get_error();
+
+Returns the ZooKeeper error code, if any, from the most
+recent Net::ZooKeeper method invocation.  The returned value
+will be zero (equivalent to C<ZOK>) if no error occurred,
+otherwise non-zero.  Non-zero values may be compared to
+the error code names exported by the C<:errors> tagset.
+
+See L</Error Handling> for more details.
+
+=item add_auth()
+
+  $zkh->add_auth('digest', "$username:$password");
+
+The C<add_auth()> method may be used to add authentication
+credentials to a session.  Once a credential has been added for
+the current session, there is no way to disable it.
+
+When using the digest authentication scheme, note that the
+username and password are transmitted in cleartext
+to the ZooKeeper cluster.
+
+See L</Access Control> for additional details.
+
+=item create()
+
+  $path = $zkh->create($req_path, $data);
+  $path = $zkh->create($req_path, $data,
+                       'flags' => (ZOO_EPHEMERAL | ZOO_SEQUENCE),
+                       'acl' => ZOO_OPEN_ACL_UNSAFE,
+                       'path_read_len' => 100);
+
+Requests that a node be created in the ZooKeeper cluster's
+hierarchy with the given path and data.  Upon success,
+the returns the node's path, otherwise undef.
+
+The path returned by a successful C<create()> method call
+may not be the new node's full path as it appears in the
+ZooKeeper hierarchy, depending on the length of the actual
+path and the value of the handle object's C<path_read_len>
+attribute.  If the length of the actual path exceeds the
+current value of the C<path_read_len> attribute, the path
+returned by the C<create()> method will be truncated; note
+that the node's path in the ZooKeeper hierarchy is not
+affected by this truncation.
+
+Specifying a value for the C<'path_read_len'> option will
+temporarily override the value of the C<path_read_len>
+attribute for the duration of the C<create()> method.
+
+The flag values available for use with the C<'flags'> option
+are C<ZOO_EPHEMERAL> and C<ZOO_SEQUENCE>; both are
+included in the C<:flags> tagset.  The flags should be
+combined with the bitwise OR operator if more than one
+is required.
+
+The C<ZOO_EPHEMERAL> flag causes the node to be marked as
+ephemeral, meaning it will be automatically deleted if it
+still exists when the client's session ends.  The
+C<ZOO_SEQUENCE> flag causes a unique integer to be appended
+to the node's final path component.  See the ZooKeeper
+documentation for additional advice on how to use these flags.
+
+When creating a node it may be important to define an ACL
+for it; to do this, pass a reference to an ACL array (as
+described in L</Access Control>) using the C<'acl'> option.
+See also the C<:acl_perms> and C<:acls> tagsets for lists
+of the available ACL permission flags and pre-defined ACLs.
+
+=item delete()
+
+  $ret = $zkh->delete($path);
+  $ret = $zkh->delete($path, 'version' => $version);
+
+Requests that a node be deleted from the ZooKeeper hierarchy.
+Returns true upon success, false otherwise.  
+
+If a value for the C<'version'> option is supplied, the node
+will only be deleted if its version number matches the given
+value.  See the C<version> attribute of the Net::ZooKeeper::Stat
+class for details on node version numbering.
+
+=item exists()
+
+  $ret = $zkh->exists($path);
+  $ret = $zkh->exists($path, 'stat' => $stat, 'watch' => $watch);
+
+Tests whether a given node exists.  Returns true if the node
+exists, otherwise false.  When the C<exists()> method is successful
+but the node does not exist, it returns false, and C<get_error()>
+will return C<ZNONODE> until another method is called on the
+handle object.
+
+The C<'stat'> option may be used to request that a
+Net::ZooKeeper::Stat object be updated with the node's
+current state information.  The stat object will only be
+updated if the node exists and the C<exists()> method
+succeeds.  The stat object must first have been created
+using the C<stat()> method.
+
+The C<'watch'> option may be used to request that a
+Net::ZooKeeper::Watch object be assigned to receive
+notification of an event which alters the node's data.
+The watch object must first have been created using the
+C<watch()> method.  If the watch object was previously
+assigned to receive notifications for another node, it
+will be reassigned even if the C<exists()> method fails.
+
+=item get_children()
+
+  @child_names  = $zkh->get_children($path);
+  $num_children = $zkh->get_children($path, 'watch' => $watch);
+
+Queries the names or number of the child nodes stored beneath
+a given node in the ZooKeeper hierarchy.  In a list context,
+returns a list of the child nodes' names upon success, otherwise
+an empty list.  When the C<get_children()> method is successful
+but there are no child nodes, it returns an empty list, and
+C<get_error()> will return C<ZOK> until another method is called
+on the handle object.
+
+In a scalar context, C<get_children()> returns the number
+of child nodes upon success, otherwise undef.
+
+The names of the child nodes are simply the final component
+of the nodes' paths, i.e., the portion of their path which
+follows the path of the given parent node, excluding the
+"/" delimiter.
+
+The C<'watch'> option may be used to request that a
+Net::ZooKeeper::Watch object be assigned to receive
+notification of an event which alters the node's list of
+child nodes.  The watch object must first have been created
+using the C<watch()> method.  If the watch object was
+previously assigned to receive notifications for another node,
+it will be reassigned even if the C<get_children()> method fails.
+
+=item get()
+
+  $data = $zkh->get($path);
+  $data = $zkh->get($path, 'data_read_len' => 100,
+                    'stat' => $stat, 'watch' => $watch);
+
+Queries the data stored in a given node.  Returns the
+data as a string upon success, otherwise undef.  Note
+that the data may contain nulls if the node's data is
+not a text string.
+
+If the length of the node's data exceeds the current value
+of the handle object's C<data_read_len> attribute, the
+string returned by the C<get()> method will be truncated;
+note that the node's data in the ZooKeeper cluster is not
+affected by this truncation.
+
+Specifying a value for the C<'data_read_len'> option will
+temporarily override the value of the C<data_read_len>
+attribute for the duration of the C<get()> method.
+
+The C<'stat'> option may be used to request that a
+Net::ZooKeeper::Stat object be updated with the node's
+current state information.  The stat object will only be
+updated if the C<get()> method succeeds.  The stat object
+must first have been created using the C<stat()> method.
+
+The C<'watch'> option may be used to request that a
+Net::ZooKeeper::Watch object be assigned to receive
+notification of an event which alters the node's data.
+The watch object must first have been created using the
+C<watch()> method.  If the watch object was previously
+assigned to receive notifications for another node, it
+will be reassigned even if the C<get()> method fails.
+
+=item set()
+
+  $ret = $zkh->set($path, $data);
+  $ret = $zkh->set($path, $data, 'version' => $version,
+                   'stat' => $stat);
+
+Requests that a node's data be updated in the ZooKeeper
+hierarchy.  Returns true upon success, false otherwise.  
+
+If a value for the C<'version'> option is supplied, the node's
+data will only be updated if its version number matches the
+given value.  See the C<version> attribute of the
+Net::ZooKeeper::Stat class for details on node version numbering.
+
+The C<'stat'> option may be used to request that a
+Net::ZooKeeper::Stat object be updated with the node's
+current state information.  The stat object will only be
+updated if the C<set()> method succeeds.  The stat object
+must first have been created using the C<stat()> method.
+
+=item get_acl()
+
+  @acl = $zkh->get_acl($path);
+  $num_acl_entries = $zkh->get_acl($path, 'stat' => $stat);
+
+Queries the ACL associated with a node in the ZooKeeper
+hierarchy, if any.  In a list context, returns an array with
+the node's ACL entries upon success, otherwise
+an empty list.  When the C<get_acl()> method is successful
+but there are no ACL entries, it returns an empty list, and
+C<get_error()> will return C<ZOK> until another method is called
+on the handle object.
+
+The elements of the returned array are hashes, each of which
+represents one ACL entry.  Each hash contains C<perms>,
+C<scheme>, and C<id> elements.  See the L</Access Control>
+section for additional details, and the
+C<:acl_perms> and C<:acls> tagsets for lists of the
+available ACL permission flags and pre-defined ACLs.
+
+In a scalar context, C<get_acl()> returns the number
+of ACL entries upon success, otherwise undef.
+
+The C<'stat'> option may be used to request that a
+Net::ZooKeeper::Stat object be updated with the node's
+current state information.  The stat object will only be
+updated if the C<get_acl()> method succeeds.  The stat object
+must first have been created using the C<stat()> method.
+
+=item set_acl()
+
+  $acl = [{
+    'perms' => (ZOO_PERM_READ | ZOO_PERM_WRITE),
+    'scheme' => 'digest',
+    'id' => "$username:$digest"
+  }];
+  $ret = $zkh->set_acl($path, $acl);
+  $ret = $zkh->set_acl($path, ZOO_OPEN_ACL_UNSAFE,
+                       'version' => $version);
+
+Requests that a node's ACL be updated in the ZooKeeper
+hierarchy.  Returns true upon success, false otherwise.
+
+The ACL should be passed as a reference to an array of
+hashes, where each hash represents one ACL entry.  Each
+hash should contain  C<perms>, C<scheme>, and C<id> elements
+as described in the L</Access Control> section.
+See also the C<:acl_perms> and C<:acls> tagsets for lists
+of the available ACL permission flags and pre-defined ACLs.
+
+If a value for the C<'version'> option is supplied, the node's
+ACL will only be updated if its version number matches the
+given value.  See the C<version> attribute of the
+Net::ZooKeeper::Stat class for details on node version numbering.
+
+=item stat()
+
+  $stat = $zkh->stat();
+
+Creates a new Net::ZooKeeper::Stat object which may be used
+with the C<'stat'> option of the C<exists()>, C<get()>,
+C<set()>, and C<get_acl()> methods.  When the stat object
+is passed to any of these methods, upon success its attribute
+values are updated to reflect the current state of the
+node specified in the method call.  The stat object is not
+updated if the method call does not succeed.
+
+=item watch()
+
+  $watch = $zkh->watch();
+  $watch = $zkh->watch('timeout' => $timeout);
+
+Creates a new Net::ZooKeeper::Watch object which may be
+used to wait for event notifications from the ZooKeeper
+cluster.  Each time the watch object is passed to any
+of the C<exists()>, C<get_children()>, or C<get()> methods,
+its attribute values are immediately reset to zero, and will
+later be updated upon receipt of an appropriate event
+notification for the node specified in the method call.
+
+The specific types of events which cause notifications to be
+sent by the ZooKeeper cluster depend on the method call used.
+After use with the C<exists()> and C<get()> methods, the
+watch object will be set to receive an event notification
+caused by a modification of the node's data or the node itself
+(e.g., deletion of the node).  After use with the
+C<get_children()> method, the watch object will be set to
+receive an event notification caused by a modification
+of the node's list of child nodes.
+
+Watch objects receive at most one event notification after
+their assignment to a node by one of the C<exists()>,
+C<get_children()>, or C<get()> methods.  Note that in the
+case of an error, the watch object may never receive any
+event notification.  However, when the parent Net::ZooKeeper
+handle object experiences a connection error, the ZooKeeper
+client code will notify all pending watches with an event of
+type C<ZOO_SESSION_EVENT>.  See C<wait()> for more information
+regarding the watch object's attribute values after a
+connection error.
+
+A watch object may be reused with another C<exists()>,
+C<get_children()>, or C<get()> method call at any time,
+in which case the watch object's attribute values
+are reset to zero and the watch object will no longer be updated
+by any event notification relevant to the previous method call.
+
+When the C<watch()> method is invoked without a C<'timeout'>
+option, it returns a newly created watch object whose C<timeout>
+attribute value is initialized to the current value of the
+Net::ZooKeeper handle object's C<watch_timeout> attribute.
+Otherwise, when the C<watch()> method is invoked with a
+C<'timeout'> option, the new watch object's C<timeout> attribute
+value is initialized to the value specified by the
+C<'timeout'> option.
+
+See also the C<watch_timeout> attribute, and the C<timeout>
+attribute and C<wait()> method of the Net::ZooKeeper::Watch
+class.
+
+=back
+
+=head2 Net::ZooKeeper::Stat
+
+No methods are defined for the Net::ZooKeeper::Stat class.
+
+=head2 Net::ZooKeeper::Watch
+
+Only one method is defined for the Net::ZooKeeper::Watch class.
+
+=over 4
+
+=item wait()
+
+  $ret = $watch->wait();
+  $ret = $watch->wait('timeout' => $timeout);
+
+Waits for an event notification from the ZooKeeper cluster
+for the node most recently associated with the watch object.
+Nodes are associated with a watch object by passing the
+watch object as the value of a C<'watch'> option to a
+Net::ZooKeeper method; methods which accept a C<'watch'> option
+are C<exists()>, C<get_children()>, and C<get()>.
+
+When the C<wait()> method is invoked with a C<'timeout'>
+option, it waits for no more than the number of milliseconds
+specified by the C<'timeout'> option.
+Otherwise, when the C<wait()> method is invoked without a
+C<'timeout'> option, it waits for no more than the timeout
+period specified by the value of the watch object's C<timeout>
+attribute.
+
+The C<wait()> method returns true if an event notification
+was received, otherwise false.  When C<wait()> returns true,
+the C<event> and C<state> attributes of the watch object
+will be updated with the event's type and the current
+connection state.
+
+When the parent Net::ZooKeeper handle object experiences a
+connection error, the ZooKeeper client code will notify all
+pending watches with an event of type C<ZOO_SESSION_EVENT>.
+In this case, the C<state> attribute will report the current
+state of the connection to the ZooKeeper cluster.
+
+See also the C<timeout> attribute, and the C<watch()> method
+and C<watch_timeout> attribute of the Net::ZooKeeper class.
+
+=back
+
+=head1 FUNCTIONS
+
+The following functions have global scope and affect all
+Net::ZooKeeper handle objects.
+
+=over 4
+
+=item set_log_level()
+
+  Net::ZooKeeper::set_log_level($level);
+
+The C<Net::ZooKeeper::set_log_level()> function may be called to
+alter the number and type of messages written to the current log
+file handle (if any).  The default value is C<ZOO_LOG_LEVEL_OFF>
+which disables all logging.
+
+See the L</Logging> section for more details and C<:log_levels>
+for a list of the available log levels.
+
+=item set_deterministic_conn_order()
+
+  Net::ZooKeeper::set_deterministic_conn_order(1);
+
+The C<Net::ZooKeeper::set_deterministic_conn_order()> function
+may be called to indicate whether or not the list of ZooKeeper
+servers passed to the C<new()> method should be randomly permuted.
+If set to a true value, the list of servers will not be altered.
+The default false value indicates the list of servers will
+be randomly reordered prior to connection.
+
+See the L</Connection Order> section for more details.
+
+=back
+
+=head1 EXPORTS
+
+Nothing is exported by default.  Various tagsets exist which
+group the tags available for export into different categories:
+
+=over 4
+
+=item :errors
+
+ZooKeeper error codes.  These may be compared to the values
+returned by the C<get_error()> method.
+
+=item :node_flags
+
+The ZooKeeper node flags C<ZOO_EPHEMERAL> and C<ZOO_SEQUENCE>,
+which may be passed in the C<'flags'> option to the C<create()>
+method.  When more than node flag is required they
+should be combined using the bitwise OR operator.
+
+=item :acl_perms
+
+The ZooKeeper ACL permission flags which may be used in
+the value of the C<perms> attribute of an ACL entry hash.
+When more than one ACL permission flag is required they
+should be combined using the bitwise OR operator.
+
+The available ACL permission flags are C<ZOO_PERM_READ>,
+C<ZOO_PERM_WRITE>, C<ZOO_PERM_CREATE>, C<ZOO_PERM_DELETE>,
+and C<ZOO_PERM_ADMIN>.  For convenience, C<ZOO_PERM_ALL> is
+defined as the bitwise OR of all of these flags.
+
+=item :acls
+
+Common ZooKeeper ACLs which may be useful.  C<ZOO_OPEN_ACL_UNSAFE>
+specifies a node which is entirely open to all users with no
+restrictions at all.  C<ZOO_READ_ACL_UNSAFE> specifies
+a node which is readable by all users; permissions for other actions
+are not defined in this ACL.  C<ZOO_CREATOR_ALL_ACL> specifies a node
+for which all actions require the same authentication credentials as
+held by the session which created the node; this implies that a
+session should authenticate with an appropriate scheme before
+creating a node with this ACL.
+
+=item :events
+
+The ZooKeeper event types which are returned in value of
+the C<event> attribute a Net::ZooKeeper::Watch object after
+an event occurs on a watched node.
+
+=item :states
+
+The ZooKeeper connection states which are returned in value of
+the C<state> attribute of a Net::ZooKeeper::Watch object after
+an event occurs on a watched node.
+
+=item :log_levels
+
+The ZooKeeper log levels which may be passed to the
+C<Net::ZooKeeper::set_log_level()> function.  The available
+log levels are, from least to most verbose, C<ZOO_LOG_LEVEL_OFF>
+(the default), C<ZOO_LOG_LEVEL_ERROR>, C<ZOO_LOG_LEVEL_WARN>,
+C<ZOO_LOG_LEVEL_INFO>, and C<ZOO_LOG_LEVEL_DEBUG>.
+
+=item :all
+
+Everything from all of the above tagsets.
+
+=back
+
+=head1 SEE ALSO
+
+The Apache ZooKeeper project's home page at
+L<http://zookeeper.apache.org/> provides a wealth of detail
+on how to develop applications using ZooKeeper.
+
+=head1 AUTHOR
+
+Chris Darroch, E<lt>chrisd@apache.orgE<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+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.
+
+=cut
+

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkperl/ZooKeeper.xs

@@ -0,0 +1,2722 @@
+/* Net::ZooKeeper - Perl extension for Apache ZooKeeper
+ *
+ * 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.
+ */
+
+#define PERL_NO_GET_CONTEXT
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#include <pthread.h>                    /* pthread_mutex_lock(), etc. */
+#include <string.h>                     /* memset(), etc. */
+#include <limits.h>                     /* CHAR_BIT */
+#include <sys/time.h>                   /* gettimeofday() */
+
+#define THREADED
+#include <zookeeper/zookeeper.h>
+#undef THREADED
+
+#include "build/check_zk_version.h"
+
+
+#define PACKAGE_NAME "Net::ZooKeeper"
+#define PACKAGE_SIGNATURE 19631123
+
+#define STAT_PACKAGE_NAME "Net::ZooKeeper::Stat"
+#define STAT_PACKAGE_SIGNATURE 19960512
+
+#define WATCH_PACKAGE_NAME "Net::ZooKeeper::Watch"
+#define WATCH_PACKAGE_SIGNATURE 20050326
+
+#define MAX_KEY_NAME_LEN 16             /* "children_version" */
+
+#define NUM_ACL_ENTRY_KEYS 3
+#define NUM_KEYS 7
+#define NUM_STAT_KEYS 11
+#define NUM_WATCH_KEYS 3
+
+#define DEFAULT_RECV_TIMEOUT_MSEC 10000
+
+#define DEFAULT_DATA_BUF_LEN 1023
+#define DEFAULT_PATH_BUF_LEN 1023
+#define DEFAULT_WATCH_TIMEOUT 60000
+
+#define ZOO_LOG_LEVEL_OFF 0
+
+#ifndef strcaseEQ
+#define strcaseEQ(a,b) (!strcasecmp((a),(b)))
+#endif
+
+
+typedef struct Stat zk_stat_t;
+
+typedef HV* Net__ZooKeeper__Stat;
+
+typedef struct zk_watch_t zk_watch_t;
+
+struct zk_watch_t {
+    pthread_mutex_t mutex;
+    pthread_cond_t cond;
+    int done;
+    int ret;
+    int event_type;
+    int event_state;
+    unsigned int timeout;
+    zk_watch_t *prev;
+    zk_watch_t *next;
+    int ref_count;
+};
+
+typedef HV* Net__ZooKeeper__Watch;
+
+typedef struct {
+    zhandle_t *handle;
+    zk_watch_t *first_watch;
+    int data_buf_len;
+    int path_buf_len;
+    unsigned int watch_timeout;
+    const char *hosts;
+    int hosts_len;
+    int last_ret;
+    int last_errno;
+} zk_t;
+
+typedef HV* Net__ZooKeeper;
+
+typedef struct {
+    I32 signature;
+    union {
+        zk_t *zk;
+        zk_stat_t *stat;
+        zk_watch_t *watch;
+    } handle;
+} zk_handle_t;
+
+typedef struct {
+    const char name[MAX_KEY_NAME_LEN + 1];
+    U32 name_len;
+    size_t offset;
+    size_t size;
+    U32 hash;
+} zk_key_t;
+
+
+static zk_key_t zk_acl_entry_keys[NUM_ACL_ENTRY_KEYS] = {
+    {"perms", 0, 0, 0, 0},
+    {"scheme", 0, 0, 0, 0},
+    {"id", 0, 0, 0, 0}
+};
+
+static zk_key_t zk_keys[NUM_KEYS] = {
+    {"data_read_len", 0, 0, 0, 0},
+    {"path_read_len", 0, 0, 0, 0},
+    {"watch_timeout", 0, 0, 0, 0},
+    {"hosts", 0, 0, 0, 0},
+    {"session_timeout", 0, 0, 0, 0},
+    {"session_id", 0, 0, 0, 0},
+    {"pending_watches", 0, 0, 0, 0}
+};
+
+static zk_key_t zk_stat_keys[NUM_STAT_KEYS] = {
+    {"czxid", 0, offsetof(struct Stat, czxid),
+     sizeof(((struct Stat*) 0)->czxid), 0},
+    {"mzxid", 0, offsetof(struct Stat, mzxid),
+     sizeof(((struct Stat*) 0)->mzxid), 0},
+    {"ctime", 0, offsetof(struct Stat, ctime),
+     sizeof(((struct Stat*) 0)->ctime), 0},
+    {"mtime", 0, offsetof(struct Stat, mtime),
+     sizeof(((struct Stat*) 0)->mtime), 0},
+    {"version", 0, offsetof(struct Stat, version),
+     sizeof(((struct Stat*) 0)->version), 0},
+    {"children_version", 0, offsetof(struct Stat, cversion),
+     sizeof(((struct Stat*) 0)->cversion), 0},
+    {"acl_version", 0, offsetof(struct Stat, aversion),
+     sizeof(((struct Stat*) 0)->aversion), 0},
+    {"ephemeral_owner", 0, offsetof(struct Stat, ephemeralOwner),
+     sizeof(((struct Stat*) 0)->ephemeralOwner), 0},
+    {"data_len", 0, offsetof(struct Stat, dataLength),
+     sizeof(((struct Stat*) 0)->dataLength), 0},
+    {"num_children", 0, offsetof(struct Stat, numChildren),
+     sizeof(((struct Stat*) 0)->numChildren), 0},
+    {"children_zxid", 0, offsetof(struct Stat, pzxid),
+     sizeof(((struct Stat*) 0)->pzxid), 0}
+};
+
+static zk_key_t zk_watch_keys[NUM_WATCH_KEYS] = {
+    {"timeout", 0, 0, 0, 0},
+    {"event", 0, 0, 0, 0},
+    {"state", 0, 0, 0, 0}
+};
+
+
+static void _zk_watcher(zhandle_t *handle, int type, int state,
+                        const char *path, void *context)
+{
+    zk_watch_t *watch_ctx = context;
+
+    pthread_mutex_lock(&watch_ctx->mutex);
+
+    watch_ctx->event_type = type;
+    watch_ctx->event_state = state;
+
+    watch_ctx->done = 1;
+
+    pthread_cond_signal(&watch_ctx->cond);
+    pthread_mutex_unlock(&watch_ctx->mutex);
+
+    return;
+}
+
+static void _zk_auth_completion(int ret, const void *data)
+{
+    zk_watch_t *watch_ctx = (zk_watch_t*) data;
+
+    pthread_mutex_lock(&watch_ctx->mutex);
+
+    watch_ctx->ret = ret;
+
+    watch_ctx->done = 1;
+
+    pthread_cond_signal(&watch_ctx->cond);
+    pthread_mutex_unlock(&watch_ctx->mutex);
+
+    return;
+}
+
+static zk_watch_t *_zk_create_watch(pTHX)
+{
+    zk_watch_t *watch;
+
+    Newxz(watch, 1, zk_watch_t);
+
+    if (pthread_mutex_init(&watch->mutex, NULL)) {
+        int save_errno = errno;
+
+        Safefree(watch);
+
+        errno = save_errno;
+        return NULL;
+    }
+
+    if (pthread_cond_init(&watch->cond, NULL)) {
+        int save_errno = errno;
+
+        pthread_mutex_destroy(&watch->mutex);
+        Safefree(watch);
+
+        errno = save_errno;
+        return NULL;
+    }
+
+    return watch;
+}
+
+static void _zk_destroy_watch(pTHX_ zk_watch_t *watch)
+{
+    pthread_cond_destroy(&watch->cond);
+    pthread_mutex_destroy(&watch->mutex);
+
+    Safefree(watch);
+
+    return;
+}
+
+static zk_watch_t *_zk_acquire_watch(pTHX)
+{
+    zk_watch_t *watch = _zk_create_watch(aTHX);
+
+    if (watch) {
+        watch->ref_count = 1;
+    }
+
+    return watch;
+}
+
+static void _zk_release_watch(pTHX_ zk_watch_t *watch, int list)
+{
+    if (list) {
+        if (watch->prev) {
+            watch->prev->next = watch->next;
+        }
+        if (watch->next) {
+            watch->next->prev = watch->prev;
+        }
+        watch->prev = NULL;
+        watch->next = NULL;
+    }
+
+    if (--watch->ref_count == 0) {
+        _zk_destroy_watch(aTHX_ watch);
+    }
+
+    return;
+}
+
+static unsigned int _zk_release_watches(pTHX_ zk_watch_t *first_watch,
+                                        int final)
+{
+    zk_watch_t *watch = first_watch->next;
+    unsigned int pending_watches = 0;
+
+    while (watch) {
+        zk_watch_t *next_watch = watch->next;
+        int done = final;
+
+        if (!final) {
+            pthread_mutex_lock(&watch->mutex);
+            done = watch->done;
+            pthread_mutex_unlock(&watch->mutex);
+        }
+
+        if (done) {
+            _zk_release_watch(aTHX_ watch, 1);
+        }
+        else {
+            ++pending_watches;
+        }
+
+        watch = next_watch;
+    }
+
+    return pending_watches;
+}
+
+static void _zk_replace_watch(pTHX_ zk_handle_t *handle,
+                              zk_watch_t *first_watch,
+                              zk_watch_t *old_watch, zk_watch_t *new_watch)
+{
+    zk_watch_t *next_watch;
+
+    new_watch->timeout = old_watch->timeout;
+
+    _zk_release_watch(aTHX_ old_watch, 0);
+
+    /* cleanup any completed watches not tied to a handle */
+    _zk_release_watches(aTHX_ first_watch, 0);
+
+    next_watch = first_watch->next;
+
+    new_watch->prev = first_watch;
+    new_watch->next = next_watch;
+
+    if (next_watch) {
+        next_watch->prev = new_watch;
+    }
+
+    first_watch->next = new_watch;
+
+    ++new_watch->ref_count;
+
+    handle->handle.watch = new_watch;
+
+    return;
+}
+
+static void _zk_free_acl(pTHX_ struct ACL_vector *acl)
+{
+    if (acl->data) {
+        Safefree(acl->data);
+    }
+
+    return;
+}
+
+static const char *_zk_fill_acl(pTHX_ AV *acl_arr, struct ACL_vector *acl)
+{
+    I32 num_acl_entries = av_len(acl_arr) + 1;
+    int i;
+
+    Zero(acl, 1, struct ACL_vector);
+
+    if (num_acl_entries <= 0) {
+        return NULL;
+    }
+    else if (num_acl_entries > PERL_INT_MAX) {
+        num_acl_entries = PERL_INT_MAX;
+    }
+
+    Newx(acl->data, num_acl_entries, struct ACL);
+
+    for (i = 0; i < num_acl_entries; ++i) {
+        SV **acl_entry_ptr;
+        HV *acl_entry_hash;
+        zk_key_t *key;
+        SV **val_ptr;
+        struct ACL acl_entry;
+
+        acl_entry_ptr = av_fetch(acl_arr, i, 0);
+
+        if (!acl_entry_ptr) {
+            continue;
+        }
+
+        if (!SvROK(*acl_entry_ptr) ||
+            SvTYPE(SvRV(*acl_entry_ptr)) != SVt_PVHV) {
+            _zk_free_acl(aTHX_ acl);
+
+            return "invalid ACL entry hash reference";
+        }
+
+        acl_entry_hash = (HV*) SvRV(*acl_entry_ptr);
+
+        key = &zk_acl_entry_keys[0];
+        val_ptr = hv_fetch(acl_entry_hash, key->name, key->name_len, 0);
+
+        if (!val_ptr) {
+            _zk_free_acl(aTHX_ acl);
+
+            return "no ACL entry perms element";
+        }
+
+        acl_entry.perms = SvIV(*val_ptr);
+
+        if (!acl_entry.perms || (acl_entry.perms & ~ZOO_PERM_ALL)) {
+            _zk_free_acl(aTHX_ acl);
+
+            return "invalid ACL entry perms";
+        }
+
+        key = &zk_acl_entry_keys[1];
+        val_ptr = hv_fetch(acl_entry_hash, key->name, key->name_len, 0);
+
+        if (!val_ptr) {
+            _zk_free_acl(aTHX_ acl);
+
+            return "no ACL entry scheme element";
+        }
+
+        acl_entry.id.scheme = SvPV_nolen(*val_ptr);
+
+        key = &zk_acl_entry_keys[2];
+        val_ptr = hv_fetch(acl_entry_hash, key->name, key->name_len, 0);
+
+        if (!val_ptr) {
+            _zk_free_acl(aTHX_ acl);
+
+            return "no ACL entry id element";
+        }
+
+        acl_entry.id.id = SvPV_nolen(*val_ptr);
+
+        ++acl->count;
+        acl->data[i] = acl_entry;
+    }
+
+    return NULL;
+}
+
+static void _zk_fill_acl_entry_hash(pTHX_ struct ACL *acl_entry,
+                                    HV *acl_entry_hash)
+{
+    zk_key_t *key;
+    SV *val;
+
+    key = &zk_acl_entry_keys[0];
+    val = newSViv(acl_entry->perms);
+
+    if (!hv_store(acl_entry_hash, key->name, key->name_len, val, key->hash)) {
+        SvREFCNT_dec(val);
+    }
+
+    key = &zk_acl_entry_keys[1];
+    val = newSVpv(acl_entry->id.scheme, 0);
+
+    if (!hv_store(acl_entry_hash, key->name, key->name_len, val, key->hash)) {
+        SvREFCNT_dec(val);
+    }
+
+    key = &zk_acl_entry_keys[2];
+    val = newSVpv(acl_entry->id.id, 0);
+
+    if (!hv_store(acl_entry_hash, key->name, key->name_len, val, key->hash)) {
+        SvREFCNT_dec(val);
+    }
+
+    return;
+}
+
+static zk_handle_t *_zk_check_handle_inner(pTHX_ HV *attr_hash,
+                                           I32 package_signature)
+{
+    zk_handle_t *handle = NULL;
+
+    if (SvRMAGICAL(attr_hash)) {
+        MAGIC *magic = mg_find((SV*) attr_hash, PERL_MAGIC_ext);
+
+        if (magic) {
+            handle = (zk_handle_t*) magic->mg_ptr;
+
+            if (handle->signature != package_signature) {
+                handle = NULL;
+            }
+        }
+    }
+
+    return handle;
+}
+
+static zk_handle_t *_zk_check_handle_outer(pTHX_ HV *hash, HV **attr_hash_ptr,
+                                           const char *package_name,
+                                           I32 package_signature)
+{
+    zk_handle_t *handle = NULL;
+
+    if (attr_hash_ptr) {
+        *attr_hash_ptr = NULL;
+    }
+
+    if (SvRMAGICAL((SV*) hash)) {
+        MAGIC *magic = mg_find((SV*) hash, PERL_MAGIC_tied);
+
+        if (magic) {
+            SV *attr = magic->mg_obj;
+
+            if (SvROK(attr) && SvTYPE(SvRV(attr)) == SVt_PVHV &&
+                sv_derived_from(attr, package_name)) {
+                HV *attr_hash = (HV*) SvRV(attr);
+
+                handle = _zk_check_handle_inner(aTHX_ attr_hash,
+                                                package_signature);
+
+                if (handle && attr_hash_ptr) {
+                    *attr_hash_ptr = attr_hash;
+                }
+            }
+        }
+    }
+
+    return handle;
+}
+
+static zk_t *_zk_get_handle_inner(pTHX_ Net__ZooKeeper attr_hash)
+{
+    zk_handle_t *handle;
+
+    handle = _zk_check_handle_inner(aTHX_ attr_hash, PACKAGE_SIGNATURE);
+
+    return handle ? handle->handle.zk : NULL;
+}
+
+static zk_t *_zk_get_handle_outer(pTHX_ Net__ZooKeeper zkh)
+{
+    zk_handle_t *handle;
+
+    handle = _zk_check_handle_outer(aTHX_ zkh, NULL, PACKAGE_NAME,
+                                    PACKAGE_SIGNATURE);
+
+    return handle ? handle->handle.zk : NULL;
+}
+
+static zk_stat_t *_zks_get_handle_inner(pTHX_ Net__ZooKeeper__Stat attr_hash)
+{
+    zk_handle_t *handle;
+
+    handle = _zk_check_handle_inner(aTHX_ attr_hash, STAT_PACKAGE_SIGNATURE);
+
+    return handle ? handle->handle.stat : NULL;
+}
+
+static zk_stat_t *_zks_get_handle_outer(pTHX_ Net__ZooKeeper__Stat zksh)
+{
+    zk_handle_t *handle;
+
+    handle = _zk_check_handle_outer(aTHX_ zksh, NULL, STAT_PACKAGE_NAME,
+                                    STAT_PACKAGE_SIGNATURE);
+
+    return handle ? handle->handle.stat : NULL;
+}
+
+static zk_watch_t *_zkw_get_handle_inner(pTHX_ Net__ZooKeeper__Watch attr_hash)
+{
+    zk_handle_t *handle;
+
+    handle = _zk_check_handle_inner(aTHX_ attr_hash, WATCH_PACKAGE_SIGNATURE);
+
+    return handle ? handle->handle.watch : NULL;
+}
+
+static zk_watch_t *_zkw_get_handle_outer(pTHX_ Net__ZooKeeper__Watch zkwh,
+                                         zk_handle_t **handle_ptr)
+{
+    zk_handle_t *handle;
+
+    handle = _zk_check_handle_outer(aTHX_ zkwh, NULL, WATCH_PACKAGE_NAME,
+                                    WATCH_PACKAGE_SIGNATURE);
+
+    if (handle_ptr) {
+        *handle_ptr = handle;
+    }
+
+    return handle ? handle->handle.watch : NULL;
+}
+
+
+MODULE = Net::ZooKeeper  PACKAGE = Net::ZooKeeper  PREFIX = zk_
+
+REQUIRE: 1.9508
+
+PROTOTYPES: ENABLE
+
+BOOT:
+{
+    int i;
+
+    for (i = 0; i < NUM_ACL_ENTRY_KEYS; ++i) {
+        zk_key_t *key = &zk_acl_entry_keys[i];
+
+        key->name_len = strlen(key->name);
+        PERL_HASH(key->hash, key->name, key->name_len);
+    }
+
+    for (i = 0; i < NUM_KEYS; ++i) {
+        zk_keys[i].name_len = strlen(zk_keys[i].name);
+    }
+
+    for (i = 0; i < NUM_STAT_KEYS; ++i) {
+        zk_stat_keys[i].name_len = strlen(zk_stat_keys[i].name);
+    }
+
+    for (i = 0; i < NUM_WATCH_KEYS; ++i) {
+        zk_watch_keys[i].name_len = strlen(zk_watch_keys[i].name);
+    }
+
+    zoo_set_log_stream(NULL);
+    zoo_set_debug_level(0);
+}
+
+
+I32
+zk_constant(alias=Nullch)
+        char *alias
+    ALIAS:
+        ZOK = ZOK
+        ZSYSTEMERROR = ZSYSTEMERROR
+        ZRUNTIMEINCONSISTENCY = ZRUNTIMEINCONSISTENCY
+        ZDATAINCONSISTENCY = ZDATAINCONSISTENCY
+        ZCONNECTIONLOSS = ZCONNECTIONLOSS
+        ZMARSHALLINGERROR = ZMARSHALLINGERROR
+        ZUNIMPLEMENTED = ZUNIMPLEMENTED
+        ZOPERATIONTIMEOUT = ZOPERATIONTIMEOUT
+        ZBADARGUMENTS = ZBADARGUMENTS
+        ZINVALIDSTATE = ZINVALIDSTATE
+        ZAPIERROR = ZAPIERROR
+        ZNONODE = ZNONODE
+        ZNOAUTH = ZNOAUTH
+        ZBADVERSION = ZBADVERSION
+        ZNOCHILDRENFOREPHEMERALS = ZNOCHILDRENFOREPHEMERALS
+        ZNODEEXISTS = ZNODEEXISTS
+        ZNOTEMPTY = ZNOTEMPTY
+        ZSESSIONEXPIRED = ZSESSIONEXPIRED
+        ZINVALIDCALLBACK = ZINVALIDCALLBACK
+        ZINVALIDACL = ZINVALIDACL
+        ZAUTHFAILED = ZAUTHFAILED
+        ZCLOSING = ZCLOSING
+        ZNOTHING = ZNOTHING
+
+        ZOO_EPHEMERAL = ZOO_EPHEMERAL
+        ZOO_SEQUENCE = ZOO_SEQUENCE
+
+        ZOO_PERM_READ = ZOO_PERM_READ
+        ZOO_PERM_WRITE = ZOO_PERM_WRITE
+        ZOO_PERM_CREATE = ZOO_PERM_CREATE
+        ZOO_PERM_DELETE = ZOO_PERM_DELETE
+        ZOO_PERM_ADMIN = ZOO_PERM_ADMIN
+        ZOO_PERM_ALL = ZOO_PERM_ALL
+
+        ZOO_CREATED_EVENT = ZOO_CREATED_EVENT
+        ZOO_DELETED_EVENT = ZOO_DELETED_EVENT
+        ZOO_CHANGED_EVENT = ZOO_CHANGED_EVENT
+        ZOO_CHILD_EVENT = ZOO_CHILD_EVENT
+        ZOO_SESSION_EVENT = ZOO_SESSION_EVENT
+        ZOO_NOTWATCHING_EVENT = ZOO_NOTWATCHING_EVENT
+
+        ZOO_EXPIRED_SESSION_STATE = ZOO_EXPIRED_SESSION_STATE
+        ZOO_AUTH_FAILED_STATE = ZOO_AUTH_FAILED_STATE
+        ZOO_CONNECTING_STATE = ZOO_CONNECTING_STATE
+        ZOO_ASSOCIATING_STATE = ZOO_ASSOCIATING_STATE
+        ZOO_CONNECTED_STATE = ZOO_CONNECTED_STATE
+
+        ZOO_LOG_LEVEL_OFF = ZOO_LOG_LEVEL_OFF
+        ZOO_LOG_LEVEL_ERROR = ZOO_LOG_LEVEL_ERROR
+        ZOO_LOG_LEVEL_WARN = ZOO_LOG_LEVEL_WARN
+        ZOO_LOG_LEVEL_INFO = ZOO_LOG_LEVEL_INFO
+        ZOO_LOG_LEVEL_DEBUG = ZOO_LOG_LEVEL_DEBUG
+    CODE:
+         if (!ix) {
+             if (!alias) {
+                 alias = GvNAME(CvGV(cv));
+             }
+
+             if (strEQ(alias, "ZOK")) {
+                 RETVAL = ZOK;
+             }
+             else if (strEQ(alias, "ZOO_LOG_LEVEL_OFF")) {
+                 RETVAL = ZOO_LOG_LEVEL_OFF;
+             }
+             else {
+                 Perl_croak(aTHX_ "unknown " PACKAGE_NAME " constant: %s",
+                            alias);
+             }
+         }
+         else {
+             RETVAL = ix;
+         }
+    OUTPUT:
+        RETVAL
+
+
+AV *
+zk_acl_constant(alias=Nullch)
+        char *alias
+    ALIAS:
+        ZOO_OPEN_ACL_UNSAFE = 1
+        ZOO_READ_ACL_UNSAFE = 2
+        ZOO_CREATOR_ALL_ACL = 3
+    PREINIT:
+        struct ACL_vector acl;
+        AV *acl_arr;
+        int i;
+    PPCODE:
+        if (!ix && !alias) {
+            alias = GvNAME(CvGV(cv));
+        }
+
+        if (ix == 1 || (alias != NULL && strEQ(alias, "ZOO_OPEN_ACL_UNSAFE"))) {
+            acl = ZOO_OPEN_ACL_UNSAFE;
+        }
+        else if (ix == 2 || (alias != NULL && strEQ(alias, "ZOO_READ_ACL_UNSAFE"))) {
+            acl = ZOO_READ_ACL_UNSAFE;
+        }
+        else if (ix == 3 || (alias != NULL && strEQ(alias, "ZOO_CREATOR_ALL_ACL"))) {
+            acl = ZOO_CREATOR_ALL_ACL;
+        }
+        else {
+             Perl_croak(aTHX_ "unknown " PACKAGE_NAME " constant: %s", alias);
+        }
+
+        acl_arr = newAV();
+
+        av_extend(acl_arr, acl.count);
+
+        for (i = 0; i < acl.count; ++i) {
+            HV *acl_entry_hash = newHV();
+            SV *val;
+
+            _zk_fill_acl_entry_hash(aTHX_ &acl.data[i], acl_entry_hash);
+
+            val = newRV_noinc((SV*) acl_entry_hash);
+
+            if (!av_store(acl_arr, i, val)) {
+                SvREFCNT_dec(val);
+            }
+        }
+
+        ST(0) = sv_2mortal(newRV_noinc((SV*) acl_arr));
+
+        XSRETURN(1);
+
+
+void
+zk_set_log_level(level)
+        int level
+    PPCODE:
+        if (level < ZOO_LOG_LEVEL_OFF || level > ZOO_LOG_LEVEL_DEBUG) {
+            Perl_croak(aTHX_ "invalid log level: %d", level);
+        }
+
+        zoo_set_debug_level(level);
+
+        XSRETURN_EMPTY;
+
+
+void
+zk_set_deterministic_conn_order(flag)
+        bool flag
+    PPCODE:
+        zoo_deterministic_conn_order(!!flag);
+
+        XSRETURN_EMPTY;
+
+
+void
+zk_new(package, hosts, ...)
+        char *package
+        char *hosts
+    PREINIT:
+        int recv_timeout = DEFAULT_RECV_TIMEOUT_MSEC;
+#ifdef HAVE_CYRUS_SASL_H
+        zoo_sasl_params_t sasl_params = { 0 };
+        const char *sasl_user = NULL;
+        const char *sasl_realm = NULL;
+        const char *sasl_password_file = NULL;
+        int use_sasl = 0;
+#endif /* HAVE_CYRUS_SASL_H */
+        const clientid_t *client_id = NULL;
+        zk_t *zk;
+        zk_handle_t *handle;
+        HV *stash, *zk_hash, *attr_hash;
+        SV *attr;
+        int i;
+    PPCODE:
+        if (items > 2 && items % 2) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        for (i = 2; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "session_timeout")) {
+                recv_timeout = SvIV(ST(i + 1));
+
+                /* NOTE: would be nice if requirement in zookeeper_interest()
+                 * that recv_timeout*2 be non-negative was documented
+                 */
+                if (recv_timeout < 0 || recv_timeout > (PERL_INT_MAX >> 1)) {
+                    Perl_croak(aTHX_ "invalid session timeout: %d",
+                               recv_timeout);
+                }
+            }
+            else if (strcaseEQ(key, "session_id")) {
+                STRLEN client_id_len;
+
+                client_id = (const clientid_t*) SvPV(ST(i + 1), client_id_len);
+
+                if (client_id_len != sizeof(clientid_t)) {
+                    Perl_croak(aTHX_ "invalid session ID");
+                }
+            }
+#ifdef HAVE_CYRUS_SASL_H
+            else if (strcaseEQ(key, "sasl_options")) {
+                SV *hash_sv = ST(i + 1);
+                HV *hash;
+                char *key;
+                I32 key_length;
+                SV *value;
+
+                if (!SvROK(hash_sv) || SvTYPE(SvRV(hash_sv)) != SVt_PVHV) {
+                    Perl_croak(aTHX_ "sasl_options requires a hash reference");
+                }
+
+                hash = (HV *)SvRV(hash_sv);
+                hv_iterinit(hash);
+                while ((value = hv_iternextsv(hash, &key, &key_length))) {
+                    if (strcaseEQ(key, "service")) {
+                        sasl_params.service = SvPV_nolen(value);
+                    }
+                    else if (strcaseEQ(key, "host")) {
+                        sasl_params.host = SvPV_nolen(value);
+                    }
+                    else if (strcaseEQ(key, "mechlist")) {
+                        sasl_params.mechlist = SvPV_nolen(value);
+                    }
+                    else if (strcaseEQ(key, "user")) {
+                        sasl_user = SvPV_nolen(value);
+                    }
+                    else if (strcaseEQ(key, "realm")) {
+                        sasl_realm = SvPV_nolen(value);
+                    }
+                    else if (strcaseEQ(key, "password_file")) {
+                        sasl_password_file = SvPV_nolen(value);
+                    }
+                }
+                use_sasl = 1;
+            }
+#endif /* HAVE_CYRUS_SASL_H */
+        }
+
+        Newxz(zk, 1, zk_t);
+#ifdef HAVE_CYRUS_SASL_H
+        if (use_sasl) {
+            /* KLUDGE: Leaks a reference count.  Authen::SASL::XS does
+               the same, though.  TODO(ddiederen): Fix. */
+            sasl_client_init(NULL);
+            sasl_params.callbacks = zoo_sasl_make_basic_callbacks(sasl_user,
+                sasl_realm, sasl_password_file);
+        }
+
+        zk->handle = zookeeper_init_sasl(hosts, NULL, recv_timeout,
+            client_id, NULL, 0, NULL, use_sasl ? &sasl_params : NULL);
+#else
+        zk->handle = zookeeper_init(hosts, NULL, recv_timeout,
+            client_id, NULL, 0);
+#endif /* HAVE_CYRUS_SASL_H */
+
+        if (!zk->handle) {
+            Safefree(zk);
+
+            XSRETURN_UNDEF;
+        }
+
+        Newxz(zk->first_watch, 1, zk_watch_t);
+
+        zk->data_buf_len = DEFAULT_DATA_BUF_LEN;
+        zk->path_buf_len = DEFAULT_PATH_BUF_LEN;
+        zk->watch_timeout = DEFAULT_WATCH_TIMEOUT;
+
+        zk->hosts_len = strlen(hosts);
+        zk->hosts = savepvn(hosts, zk->hosts_len);
+
+        Newx(handle, 1, zk_handle_t);
+
+        handle->signature = PACKAGE_SIGNATURE;
+        handle->handle.zk = zk;
+
+        /* We use several tricks from DBI here.  The attr_hash is our
+         * empty inner hash; we attach extra magic to it in the form of
+         * our zk_handle_t structure.  Then we tie attr_hash to zk_hash,
+         * our outer hash.  This is what is passed around (by reference) by
+         * callers.
+         *
+         * Most methods use _zk_get_handle_outer() which finds our inner
+         * handle, then returns the zk_t structure from its extra magic
+         * pointer.
+         *
+         * However, the tied hash methods, FETCH(), STORE(), and so forth,
+         * receive an already-dereferenced inner handle hash.  This is
+         * because we bless both inner and outer handles into this class,
+         * so when a caller's code references a hash element in our
+         * outer handle, Perl detects its tied magic, looks up the
+         * tied object (our inner handle) and invokes the tied hash methods
+         * in its class on it.  Since we blessed it into the same class
+         * as the outer handle, these methods simply reside in our package.
+         */
+
+        stash = gv_stashpv(package, GV_ADDWARN);
+
+        attr_hash = newHV();
+
+        sv_magic((SV*) attr_hash, Nullsv, PERL_MAGIC_ext,
+                 (const char*) handle, 0);
+
+        attr = sv_bless(newRV_noinc((SV*) attr_hash), stash);
+
+        zk_hash = newHV();
+
+        sv_magic((SV*) zk_hash, attr, PERL_MAGIC_tied, Nullch, 0);
+        SvREFCNT_dec(attr);
+
+        ST(0) = sv_bless(sv_2mortal(newRV_noinc((SV*) zk_hash)), stash);
+
+        XSRETURN(1);
+
+
+void
+zk_DESTROY(zkh)
+        Net::ZooKeeper zkh
+    PREINIT:
+        zk_handle_t *handle;
+        HV *attr_hash;
+        int ret = ZBADARGUMENTS;
+    PPCODE:
+        handle = _zk_check_handle_outer(aTHX_ zkh, &attr_hash,
+                                        PACKAGE_NAME, PACKAGE_SIGNATURE);
+
+        if (!handle) {
+            handle = _zk_check_handle_inner(aTHX_ zkh, PACKAGE_SIGNATURE);
+
+            if (handle) {
+                attr_hash = zkh;
+                zkh = NULL;
+            }
+        }
+
+        if (handle) {
+            zk_t *zk = handle->handle.zk;
+
+            ret = zookeeper_close(zk->handle);
+
+            /* detach all now-inactive watches still tied to handles */
+            _zk_release_watches(aTHX_ zk->first_watch, 1);
+
+            Safefree(zk->first_watch);
+            Safefree(zk->hosts);
+            Safefree(zk);
+            Safefree(handle);
+
+            sv_unmagic((SV*) attr_hash, PERL_MAGIC_ext);
+        }
+
+        if (zkh && attr_hash) {
+            sv_unmagic((SV*) zkh, PERL_MAGIC_tied);
+        }
+
+        if (GIMME_V == G_VOID) {
+            XSRETURN_EMPTY;
+        }
+        else if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zk_CLONE(package)
+        char *package
+    PPCODE:
+        XSRETURN_EMPTY;
+
+
+void
+zk_CLONE_SKIP(package)
+        char *package
+    PPCODE:
+        XSRETURN_YES;
+
+
+void
+zk_TIEHASH(package, ...)
+        char *package
+    PPCODE:
+        Perl_croak(aTHX_ "tying hashes of class "
+                         PACKAGE_NAME " not supported");
+
+
+void
+zk_UNTIE(attr_hash, ref_count)
+        Net::ZooKeeper attr_hash
+        IV ref_count
+    PPCODE:
+        Perl_croak(aTHX_ "untying hashes of class "
+                         PACKAGE_NAME " not supported");
+
+
+void
+zk_FIRSTKEY(attr_hash)
+        Net::ZooKeeper attr_hash
+    PREINIT:
+        zk_t *zk;
+    PPCODE:
+        zk = _zk_get_handle_inner(aTHX_ attr_hash);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        ST(0) = sv_2mortal(newSVpvn(zk_keys[0].name, zk_keys[0].name_len));
+
+        XSRETURN(1);
+
+
+void
+zk_NEXTKEY(attr_hash, attr_key)
+        Net::ZooKeeper attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_t *zk;
+        char *key;
+        int i;
+    PPCODE:
+        zk = _zk_get_handle_inner(aTHX_ attr_hash);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_KEYS; ++i) {
+            if (strcaseEQ(key, zk_keys[i].name)) {
+                ++i;
+
+                break;
+            }
+        }
+
+        if (i < NUM_KEYS) {
+            ST(0) = sv_2mortal(newSVpvn(zk_keys[i].name, zk_keys[i].name_len));
+
+            XSRETURN(1);
+        }
+        else {
+            XSRETURN_EMPTY;
+        }
+
+
+void
+zk_SCALAR(attr_hash)
+        Net::ZooKeeper attr_hash
+    PPCODE:
+        XSRETURN_YES;
+
+
+void
+zk_FETCH(attr_hash, attr_key)
+        Net::ZooKeeper attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_t *zk;
+        char *key;
+        SV *val = NULL;
+    PPCODE:
+        zk = _zk_get_handle_inner(aTHX_ attr_hash);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        if (strcaseEQ(key, "data_read_len")) {
+            val = newSViv(zk->data_buf_len);
+        }
+        else if (strcaseEQ(key, "path_read_len")) {
+            val = newSViv(zk->path_buf_len);
+        }
+        else if (strcaseEQ(key, "watch_timeout")) {
+            val = newSVuv(zk->watch_timeout);
+        }
+        else if (strcaseEQ(key, "hosts")) {
+            val = newSVpvn(zk->hosts, zk->hosts_len);
+        }
+        else if (strcaseEQ(key, "session_timeout")) {
+            val = newSViv(zoo_recv_timeout(zk->handle));
+        }
+        else if (strcaseEQ(key, "session_id")) {
+            const clientid_t *client_id;
+            clientid_t null_client_id;
+
+            client_id = zoo_client_id(zk->handle);
+
+            memset(&null_client_id, 0, sizeof(clientid_t));
+
+            if (!memcmp(client_id, &null_client_id, sizeof(clientid_t))) {
+                val = newSVpv("", 0);
+            }
+            else {
+                val = newSVpvn((const char*) client_id, sizeof(clientid_t));
+            }
+        }
+        else if (strcaseEQ(key, "pending_watches")) {
+            /* cleanup any completed watches not tied to a handle */
+            val = newSVuv(_zk_release_watches(aTHX_ zk->first_watch, 0));
+        }
+
+        if (val) {
+            ST(0) = sv_2mortal(val);
+
+            XSRETURN(1);
+        }
+
+        Perl_warn(aTHX_ "invalid element: %s", key);
+
+        XSRETURN_UNDEF;
+
+
+void
+zk_STORE(attr_hash, attr_key, attr_val)
+        Net::ZooKeeper attr_hash
+        SV *attr_key
+        SV *attr_val
+    PREINIT:
+        zk_t *zk;
+        char *key;
+    PPCODE:
+        zk = _zk_get_handle_inner(aTHX_ attr_hash);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        if (strcaseEQ(key, "data_read_len")) {
+            int val = SvIV(attr_val);
+
+            if (val < 0) {
+                Perl_croak(aTHX_ "invalid data read length: %d", val);
+            }
+
+            zk->data_buf_len = val;
+        }
+        else if (strcaseEQ(key, "path_read_len")) {
+            int val = SvIV(attr_val);
+
+            if (val < 0) {
+                Perl_croak(aTHX_ "invalid path read length: %d", val);
+            }
+
+            zk->path_buf_len = val;
+        }
+        else if (strcaseEQ(key, "watch_timeout")) {
+            zk->watch_timeout = SvUV(attr_val);
+        }
+        else {
+            int i;
+
+            for (i = 0; i < NUM_KEYS; ++i) {
+                if (strcaseEQ(key, zk_keys[i].name)) {
+                    Perl_warn(aTHX_ "read-only element: %s", key);
+
+                    XSRETURN_EMPTY;
+                }
+            }
+
+            Perl_warn(aTHX_ "invalid element: %s", key);
+        }
+
+        XSRETURN_EMPTY;
+
+
+void
+zk_EXISTS(attr_hash, attr_key)
+        Net::ZooKeeper attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_t *zk;
+        char *key;
+        int i;
+    PPCODE:
+        zk = _zk_get_handle_inner(aTHX_ attr_hash);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_KEYS; ++i) {
+            if (strcaseEQ(key, zk_keys[i].name)) {
+                XSRETURN_YES;
+            }
+        }
+
+        XSRETURN_NO;
+
+
+void
+zk_DELETE(attr_hash, attr_key)
+        Net::ZooKeeper attr_hash
+        SV *attr_key
+    PPCODE:
+        Perl_warn(aTHX_ "deleting elements from hashes of class "
+                        PACKAGE_NAME " not supported");
+
+        XSRETURN_EMPTY;
+
+
+void
+zk_CLEAR(attr_hash)
+        Net::ZooKeeper attr_hash
+    PPCODE:
+        Perl_warn(aTHX_ "clearing hashes of class "
+                        PACKAGE_NAME " not supported");
+
+        XSRETURN_EMPTY;
+
+
+SV *
+zk_get_error(zkh)
+        Net::ZooKeeper zkh
+    PREINIT:
+        zk_t *zk;
+    CODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        RETVAL = newSViv(zk->last_ret);
+        errno = zk->last_errno;
+    OUTPUT:
+        RETVAL
+
+
+void
+zk_add_auth(zkh, scheme, cert)
+        Net::ZooKeeper zkh
+        char *scheme
+        char *cert; cert = (char *) SvPV($arg, cert_len);
+    PREINIT:
+        zk_t *zk;
+        STRLEN cert_len;
+        zk_watch_t *watch;
+        int ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (cert_len > PERL_INT_MAX) {
+            Perl_croak(aTHX_ "invalid certificate length: %zu", cert_len);
+        }
+
+        watch = _zk_create_watch(aTHX);
+
+        if (!watch) {
+            /* errno will be set */
+            zk->last_ret = ZSYSTEMERROR;
+            zk->last_errno = errno;
+
+            XSRETURN_NO;
+        }
+
+        errno = 0;
+        ret = zoo_add_auth(zk->handle, scheme, cert, cert_len,
+                           _zk_auth_completion, watch);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (ret == ZOK) {
+            pthread_mutex_lock(&watch->mutex);
+
+            while (!watch->done) {
+                pthread_cond_wait(&watch->cond, &watch->mutex);
+            }
+
+            pthread_mutex_unlock(&watch->mutex);
+
+            if (watch->done) {
+                ret = watch->ret;
+            }
+            else {
+                ret = ZINVALIDSTATE;
+            }
+
+            /* errno may be set while we waited */
+            zk->last_ret = ret;
+            zk->last_errno = errno;
+        }
+
+        _zk_destroy_watch(aTHX_ watch);
+
+        if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zk_create(zkh, path, buf, ...)
+        Net::ZooKeeper zkh
+        char *path
+        char *buf; buf = (char *) SvPV($arg, buf_len);
+    PREINIT:
+        zk_t *zk;
+        STRLEN buf_len;
+        int flags = 0;
+        char *path_buf;
+        int path_buf_len;
+        AV *acl_arr = NULL;
+        struct ACL_vector acl;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 3 && !(items % 2)) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        if (buf_len > PERL_INT_MAX) {
+            Perl_croak(aTHX_ "invalid data length: %zu", buf_len);
+        }
+
+        path_buf_len = zk->path_buf_len;
+
+        for (i = 3; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "path_read_len")) {
+                path_buf_len = SvIV(ST(i + 1));
+
+                if (path_buf_len < 2) {
+                    Perl_croak(aTHX_ "invalid path read length: %d",
+                               path_buf_len);
+                }
+            }
+            else if (strcaseEQ(key, "flags")) {
+                flags = SvIV(ST(i + 1));
+
+                if (flags & ~(ZOO_SEQUENCE | ZOO_EPHEMERAL)) {
+                    Perl_croak(aTHX_ "invalid create flags: %d", flags);
+                }
+            }
+            else if (strcaseEQ(key, "acl")) {
+                const char *err;
+
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVAV) {
+                    Perl_croak(aTHX_ "invalid ACL array reference");
+                }
+
+                acl_arr = (AV*) SvRV(ST(i + 1));
+
+                err = _zk_fill_acl(aTHX_ acl_arr, &acl);
+
+                if (err) {
+                    Perl_croak(aTHX_ "%s", err);
+                }
+            }
+        }
+
+        /* NOTE: would be nice to be able to rely on null-terminated string */
+        ++path_buf_len;
+        Newxz(path_buf, path_buf_len, char);
+
+        errno = 0;
+        ret = zoo_create(zk->handle, path, buf, buf_len,
+                         (acl_arr ? &acl : NULL), flags,
+                         path_buf, path_buf_len);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (acl_arr) {
+            _zk_free_acl(aTHX_ &acl);
+        }
+
+        if (ret == ZOK) {
+            ST(0) = sv_newmortal();
+#ifdef SV_HAS_TRAILING_NUL
+            sv_usepvn_flags(ST(0), path_buf, strlen(path_buf),
+                            SV_HAS_TRAILING_NUL);
+#else
+            sv_usepvn(ST(0), path_buf, strlen(path_buf));
+#endif
+            SvCUR_set(ST(0), strlen(path_buf));
+
+            XSRETURN(1);
+        }
+
+        Safefree(path_buf);
+
+        XSRETURN_UNDEF;
+
+
+void
+zk_delete(zkh, path, ...)
+        Net::ZooKeeper zkh
+        char *path
+    PREINIT:
+        zk_t *zk;
+        int version = -1;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 2 && items % 2) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        for (i = 2; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "version")) {
+                version = SvIV(ST(i + 1));
+
+                if (version < 0) {
+                    Perl_croak(aTHX_ "invalid version requirement: %d",
+                               version);
+                }
+            }
+        }
+
+        errno = 0;
+        ret = zoo_delete(zk->handle, path, version);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zk_exists(zkh, path, ...)
+        Net::ZooKeeper zkh
+        char *path
+    PREINIT:
+        zk_t *zk;
+        zk_stat_t *stat = NULL;
+        zk_watch_t *old_watch = NULL;
+        zk_handle_t *watch_handle = NULL;
+        watcher_fn watcher = NULL;
+        zk_watch_t *new_watch = NULL;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 2 && items % 2) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        for (i = 2; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "stat")) {
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVHV ||
+                    !sv_derived_from(ST(i + 1), STAT_PACKAGE_NAME)) {
+                    Perl_croak(aTHX_ "stat is not a hash reference of "
+                                     "type " STAT_PACKAGE_NAME);
+                }
+
+                stat = _zks_get_handle_outer(aTHX_ (HV*) SvRV(ST(i + 1)));
+
+                if (!stat) {
+                    Perl_croak(aTHX_ "invalid stat handle");
+                }
+            }
+            else if (strcaseEQ(key, "watch")) {
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVHV ||
+                    !sv_derived_from(ST(i + 1), WATCH_PACKAGE_NAME)) {
+                    Perl_croak(aTHX_ "watch is not a hash reference of "
+                                     "type " WATCH_PACKAGE_NAME);
+                }
+
+                old_watch = _zkw_get_handle_outer(aTHX_ (HV*) SvRV(ST(i + 1)),
+                                                  &watch_handle);
+
+                if (!old_watch) {
+                    Perl_croak(aTHX_ "invalid watch handle");
+                }
+            }
+        }
+
+        if (watch_handle) {
+            new_watch = _zk_acquire_watch(aTHX);
+
+            if (!new_watch) {
+                /* errno will be set */
+                zk->last_ret = ZSYSTEMERROR;
+                zk->last_errno = errno;
+
+                XSRETURN_NO;
+            }
+
+            watcher = _zk_watcher;
+        }
+
+        errno = 0;
+        ret = zoo_wexists(zk->handle, path, watcher, new_watch, stat);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (watch_handle) {
+            _zk_replace_watch(aTHX_ watch_handle, zk->first_watch,
+                              old_watch, new_watch);
+        }
+
+        if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zk_get_children(zkh, path, ...)
+        Net::ZooKeeper zkh
+        char *path
+    PREINIT:
+        zk_t *zk;
+        zk_watch_t *old_watch = NULL;
+        zk_handle_t *watch_handle = NULL;
+        watcher_fn watcher = NULL;
+        zk_watch_t *new_watch = NULL;
+        struct String_vector strings;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 2 && items % 2) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        for (i = 2; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "watch")) {
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVHV ||
+                    !sv_derived_from(ST(i + 1), WATCH_PACKAGE_NAME)) {
+                    Perl_croak(aTHX_ "watch is not a hash reference of "
+                                     "type " WATCH_PACKAGE_NAME);
+                }
+
+                old_watch = _zkw_get_handle_outer(aTHX_ (HV*) SvRV(ST(i + 1)),
+                                                  &watch_handle);
+
+                if (!old_watch) {
+                    Perl_croak(aTHX_ "invalid watch handle");
+                }
+            }
+        }
+
+        if (watch_handle) {
+            new_watch = _zk_acquire_watch(aTHX);
+
+            if (!new_watch) {
+                /* errno will be set */
+                zk->last_ret = ZSYSTEMERROR;
+                zk->last_errno = errno;
+
+                if (GIMME_V == G_ARRAY) {
+                    XSRETURN_EMPTY;
+                }
+                else {
+                    XSRETURN_UNDEF;
+                }
+            }
+
+            watcher = _zk_watcher;
+        }
+
+        Zero(&strings, 1, struct String_vector);
+
+        errno = 0;
+        ret = zoo_wget_children(zk->handle, path, watcher, new_watch,
+                                &strings);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (watch_handle) {
+            _zk_replace_watch(aTHX_ watch_handle, zk->first_watch,
+                              old_watch, new_watch);
+        }
+
+        if (ret == ZOK) {
+            int num_children;
+
+            num_children =
+                (strings.count > PERL_INT_MAX) ? PERL_INT_MAX : strings.count;
+
+            if (GIMME_V == G_ARRAY && num_children > 0) {
+                EXTEND(SP, num_children);
+
+                for (i = 0; i < num_children; ++i) {
+                    ST(i) = sv_2mortal(newSVpv(strings.data[i], 0));
+                }
+            }
+
+            /* NOTE: would be nice if this were documented as required */
+            deallocate_String_vector(&strings);
+
+            if (GIMME_V == G_ARRAY) {
+                if (num_children == 0) {
+                    XSRETURN_EMPTY;
+                }
+
+                XSRETURN(num_children);
+            }
+            else {
+                ST(0) = sv_2mortal(newSViv(num_children));
+
+                XSRETURN(1);
+            }
+        }
+        else {
+            if (GIMME_V == G_ARRAY) {
+                XSRETURN_EMPTY;
+            }
+            else {
+                XSRETURN_UNDEF;
+            }
+        }
+
+
+void
+zk_get(zkh, path, ...)
+        Net::ZooKeeper zkh
+        char *path
+    PREINIT:
+        zk_t *zk;
+        int buf_len;
+        zk_stat_t *stat = NULL;
+        zk_watch_t *old_watch = NULL;
+        zk_handle_t *watch_handle = NULL;
+        char *buf;
+        watcher_fn watcher = NULL;
+        zk_watch_t *new_watch = NULL;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 2 && items % 2) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        buf_len = zk->data_buf_len;
+
+        for (i = 2; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "data_read_len")) {
+                buf_len = SvIV(ST(i + 1));
+
+                if (buf_len < 0) {
+                    Perl_croak(aTHX_ "invalid data read length: %d",
+                               buf_len);
+                }
+            }
+            else if (strcaseEQ(key, "stat")) {
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVHV ||
+                    !sv_derived_from(ST(i + 1), STAT_PACKAGE_NAME)) {
+                    Perl_croak(aTHX_ "stat is not a hash reference of "
+                                     "type " STAT_PACKAGE_NAME);
+                }
+
+                stat = _zks_get_handle_outer(aTHX_ (HV*) SvRV(ST(i + 1)));
+
+                if (!stat) {
+                    Perl_croak(aTHX_ "invalid stat handle");
+                }
+            }
+            else if (strcaseEQ(key, "watch")) {
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVHV ||
+                    !sv_derived_from(ST(i + 1), WATCH_PACKAGE_NAME)) {
+                    Perl_croak(aTHX_ "watch is not a hash reference of "
+                                     "type " WATCH_PACKAGE_NAME);
+                }
+
+                old_watch = _zkw_get_handle_outer(aTHX_ (HV*) SvRV(ST(i + 1)),
+                                                  &watch_handle);
+
+                if (!old_watch) {
+                    Perl_croak(aTHX_ "invalid watch handle");
+                }
+            }
+        }
+
+        if (watch_handle) {
+            new_watch = _zk_acquire_watch(aTHX);
+
+            if (!new_watch) {
+                /* errno will be set */
+                zk->last_ret = ZSYSTEMERROR;
+                zk->last_errno = errno;
+
+                XSRETURN_UNDEF;
+            }
+
+            watcher = _zk_watcher;
+        }
+
+        Newx(buf, buf_len + 1, char);
+
+        errno = 0;
+        ret = zoo_wget(zk->handle, path, watcher, new_watch,
+                       buf, &buf_len, stat);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (watch_handle) {
+            _zk_replace_watch(aTHX_ watch_handle, zk->first_watch,
+                              old_watch, new_watch);
+        }
+
+        if (ret == ZOK && buf_len != -1) {
+            ST(0) = sv_newmortal();
+#ifdef SV_HAS_TRAILING_NUL
+            buf[buf_len] = '\0';
+            sv_usepvn_flags(ST(0), buf, buf_len, SV_HAS_TRAILING_NUL);
+#else
+            sv_usepvn(ST(0), buf, buf_len);
+#endif
+
+            XSRETURN(1);
+        }
+        else {
+            Safefree(buf);
+
+            XSRETURN_UNDEF;
+        }
+
+
+void
+zk_set(zkh, path, buf, ...)
+        Net::ZooKeeper zkh
+        char *path
+        char *buf; buf = (char *) SvPV($arg, buf_len);
+    PREINIT:
+        zk_t *zk;
+        int version = -1;
+        zk_stat_t *stat = NULL;
+        STRLEN buf_len;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 3 && !(items % 2)) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        if (buf_len > PERL_INT_MAX) {
+            Perl_croak(aTHX_ "invalid data length: %zu", buf_len);
+        }
+
+        for (i = 3; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "version")) {
+                version = SvIV(ST(i + 1));
+
+                if (version < 0) {
+                    Perl_croak(aTHX_ "invalid version requirement: %d",
+                               version);
+                }
+            }
+            else if (strcaseEQ(key, "stat")) {
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVHV ||
+                    !sv_derived_from(ST(i + 1), STAT_PACKAGE_NAME)) {
+                    Perl_croak(aTHX_ "stat is not a hash reference of "
+                                     "type " STAT_PACKAGE_NAME);
+                }
+
+                stat = _zks_get_handle_outer(aTHX_ (HV*) SvRV(ST(i + 1)));
+
+                if (!stat) {
+                    Perl_croak(aTHX_ "invalid stat handle");
+                }
+            }
+        }
+
+        errno = 0;
+        ret = zoo_set2(zk->handle, path, buf, buf_len, version, stat);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zk_get_acl(zkh, path, ...)
+        Net::ZooKeeper zkh
+        char *path
+    PREINIT:
+        zk_t *zk;
+        zk_stat_t *stat = NULL;
+        struct ACL_vector acl;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 2 && items % 2) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        for (i = 2; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "stat")) {
+                if (!SvROK(ST(i + 1)) || SvTYPE(SvRV(ST(i + 1))) != SVt_PVHV ||
+                    !sv_derived_from(ST(i + 1), STAT_PACKAGE_NAME)) {
+                    Perl_croak(aTHX_ "stat is not a hash reference of "
+                                     "type " STAT_PACKAGE_NAME);
+                }
+
+                stat = _zks_get_handle_outer(aTHX_ (HV*) SvRV(ST(i + 1)));
+
+                if (!stat) {
+                    Perl_croak(aTHX_ "invalid stat handle");
+                }
+            }
+        }
+
+        errno = 0;
+        ret = zoo_get_acl(zk->handle, path, &acl, stat);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        if (ret == ZOK) {
+            int num_acl_entries;
+
+            num_acl_entries =
+                (acl.count > PERL_INT_MAX) ? PERL_INT_MAX : acl.count;
+
+            if (GIMME_V == G_ARRAY && num_acl_entries > 0) {
+                EXTEND(SP, num_acl_entries);
+
+                for (i = 0; i < num_acl_entries; ++i) {
+                    HV *acl_entry_hash = newHV();
+
+                    _zk_fill_acl_entry_hash(aTHX_ &acl.data[i],
+                                            acl_entry_hash);
+
+                    ST(i) = sv_2mortal(newRV_noinc((SV*) acl_entry_hash));
+                }
+            }
+
+            /* NOTE: would be nice if this were documented as required */
+            deallocate_ACL_vector(&acl);
+
+            if (GIMME_V == G_ARRAY) {
+                if (num_acl_entries == 0) {
+                    XSRETURN_EMPTY;
+                }
+
+                XSRETURN(num_acl_entries);
+            }
+            else {
+                ST(0) = sv_2mortal(newSViv(num_acl_entries));
+
+                XSRETURN(1);
+            }
+        }
+        else {
+            if (GIMME_V == G_ARRAY) {
+                XSRETURN_EMPTY;
+            }
+            else {
+                XSRETURN_UNDEF;
+            }
+        }
+
+
+void
+zk_set_acl(zkh, path, acl_arr, ...)
+        Net::ZooKeeper zkh
+        char *path
+        AV *acl_arr
+    PREINIT:
+        zk_t *zk;
+        const char *err;
+        int version = -1;
+        struct ACL_vector acl;
+        int i, ret;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 3 && !(items % 2)) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        err = _zk_fill_acl(aTHX_ acl_arr, &acl);
+
+        if (err) {
+            Perl_croak(aTHX_ "%s", err);
+        }
+
+        for (i = 3; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "version")) {
+                version = SvIV(ST(i + 1));
+
+                if (version < 0) {
+                    Perl_croak(aTHX_ "invalid version requirement: %d",
+                               version);
+                }
+            }
+        }
+
+        errno = 0;
+        ret = zoo_set_acl(zk->handle, path, version, &acl);
+
+        zk->last_ret = ret;
+        zk->last_errno = errno;
+
+        _zk_free_acl(aTHX_ &acl);
+
+        if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zk_stat(zkh)
+        Net::ZooKeeper zkh
+    PREINIT:
+        zk_t *zk;
+        zk_handle_t *handle;
+        HV *stash, *stat_hash, *attr_hash;
+        SV *attr;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        Newx(handle, 1, zk_handle_t);
+
+        handle->signature = STAT_PACKAGE_SIGNATURE;
+
+        Newxz(handle->handle.stat, 1, zk_stat_t);
+
+        /* As in zk_new(), we use two levels of magic here. */
+
+        stash = gv_stashpv(STAT_PACKAGE_NAME, GV_ADDWARN);
+
+        attr_hash = newHV();
+
+        sv_magic((SV*) attr_hash, Nullsv, PERL_MAGIC_ext,
+                 (const char*) handle, 0);
+
+        attr = sv_bless(newRV_noinc((SV*) attr_hash), stash);
+
+        stat_hash = newHV();
+
+        sv_magic((SV*) stat_hash, attr, PERL_MAGIC_tied, Nullch, 0);
+        SvREFCNT_dec(attr);
+
+        ST(0) = sv_bless(sv_2mortal(newRV_noinc((SV*) stat_hash)), stash);
+
+        XSRETURN(1);
+
+
+void
+zk_watch(zkh, ...)
+        Net::ZooKeeper zkh
+    PREINIT:
+        zk_t *zk;
+        unsigned int timeout;
+        zk_watch_t *watch;
+        zk_handle_t *handle;
+        HV *stash, *watch_hash, *attr_hash;
+        SV *attr;
+        int i;
+    PPCODE:
+        zk = _zk_get_handle_outer(aTHX_ zkh);
+
+        if (!zk) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        zk->last_ret = ZOK;
+        zk->last_errno = 0;
+
+        if (items > 1 && !(items % 2)) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        timeout = zk->watch_timeout;
+
+        for (i = 1; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "timeout")) {
+                timeout = SvUV(ST(i + 1));
+            }
+        }
+
+        watch = _zk_acquire_watch(aTHX);
+
+        if (!watch) {
+            /* errno will be set */
+            zk->last_ret = ZSYSTEMERROR;
+            zk->last_errno = errno;
+
+            XSRETURN_UNDEF;
+        }
+
+        Newx(handle, 1, zk_handle_t);
+
+        handle->signature = WATCH_PACKAGE_SIGNATURE;
+        handle->handle.watch = watch;
+
+        /* As in zk_new(), we use two levels of magic here. */
+
+        stash = gv_stashpv(WATCH_PACKAGE_NAME, GV_ADDWARN);
+
+        attr_hash = newHV();
+
+        watch->timeout = timeout;
+
+        sv_magic((SV*) attr_hash, Nullsv, PERL_MAGIC_ext,
+                 (const char*) handle, 0);
+
+        attr = sv_bless(newRV_noinc((SV*) attr_hash), stash);
+
+        watch_hash = newHV();
+
+        sv_magic((SV*) watch_hash, attr, PERL_MAGIC_tied, Nullch, 0);
+        SvREFCNT_dec(attr);
+
+        ST(0) = sv_bless(sv_2mortal(newRV_noinc((SV*) watch_hash)), stash);
+
+        XSRETURN(1);
+
+
+MODULE = Net::ZooKeeper  PACKAGE = Net::ZooKeeper::Stat  PREFIX = zks_
+
+void
+zks_DESTROY(zksh)
+        Net::ZooKeeper::Stat zksh
+    PREINIT:
+        zk_handle_t *handle;
+        HV *attr_hash;
+        int ret = ZBADARGUMENTS;
+    PPCODE:
+        handle = _zk_check_handle_outer(aTHX_ zksh, &attr_hash,
+                                        STAT_PACKAGE_NAME,
+                                        STAT_PACKAGE_SIGNATURE);
+
+        if (!handle) {
+            handle = _zk_check_handle_inner(aTHX_ zksh,
+                                            STAT_PACKAGE_SIGNATURE);
+
+            if (handle) {
+                attr_hash = zksh;
+                zksh = NULL;
+            }
+        }
+
+        if (handle) {
+            ret = ZOK;
+
+            Safefree(handle->handle.stat);
+            Safefree(handle);
+
+            sv_unmagic((SV*) attr_hash, PERL_MAGIC_ext);
+        }
+
+        if (zksh && attr_hash) {
+            sv_unmagic((SV*) zksh, PERL_MAGIC_tied);
+        }
+
+        if (GIMME_V == G_VOID) {
+            XSRETURN_EMPTY;
+        }
+        else if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zks_CLONE(package)
+        char *package
+    PPCODE:
+        XSRETURN_EMPTY;
+
+
+void
+zks_CLONE_SKIP(package)
+        char *package
+    PPCODE:
+        XSRETURN_YES;
+
+
+void
+zks_TIEHASH(package, ...)
+        char *package
+    PPCODE:
+        Perl_croak(aTHX_ "tying hashes of class "
+                         STAT_PACKAGE_NAME " not supported");
+
+
+void
+zks_UNTIE(attr_hash, ref_count)
+        Net::ZooKeeper::Stat attr_hash
+        IV ref_count
+    PPCODE:
+        Perl_croak(aTHX_ "untying hashes of class "
+                         STAT_PACKAGE_NAME " not supported");
+
+
+void
+zks_FIRSTKEY(attr_hash)
+        Net::ZooKeeper::Stat attr_hash
+    PREINIT:
+        zk_stat_t *stat;
+    PPCODE:
+        stat = _zks_get_handle_inner(aTHX_ attr_hash);
+
+        if (!stat) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        ST(0) = sv_2mortal(newSVpvn(zk_stat_keys[0].name,
+                                    zk_stat_keys[0].name_len));
+
+        XSRETURN(1);
+
+
+void
+zks_NEXTKEY(attr_hash, attr_key)
+        Net::ZooKeeper::Stat attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_stat_t *stat;
+        char *key;
+        int i;
+    PPCODE:
+        stat = _zks_get_handle_inner(aTHX_ attr_hash);
+
+        if (!stat) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_STAT_KEYS; ++i) {
+            if (strcaseEQ(key, zk_stat_keys[i].name)) {
+                ++i;
+
+                break;
+            }
+        }
+
+        if (i < NUM_STAT_KEYS) {
+            ST(0) = sv_2mortal(newSVpvn(zk_stat_keys[i].name,
+                                        zk_stat_keys[i].name_len));
+
+            XSRETURN(1);
+        }
+        else {
+            XSRETURN_EMPTY;
+        }
+
+
+void
+zks_SCALAR(attr_hash)
+        Net::ZooKeeper::Stat attr_hash
+    PPCODE:
+        XSRETURN_YES;
+
+
+void
+zks_FETCH(attr_hash, attr_key)
+        Net::ZooKeeper::Stat attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_stat_t *stat;
+        char *key;
+        SV *val = NULL;
+        int i;
+    PPCODE:
+        stat = _zks_get_handle_inner(aTHX_ attr_hash);
+
+        if (!stat) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_STAT_KEYS; ++i) {
+            if (strcaseEQ(key, zk_stat_keys[i].name)) {
+                if (zk_stat_keys[i].size * CHAR_BIT == 32) {
+                    val = newSViv(*((int32_t*) (((char*) stat) +
+                                                zk_stat_keys[i].offset)));
+                }
+                else {
+                    /* NOTE: %lld is inconsistent, so cast to a double */
+                    val = newSVpvf("%.0f", (double)
+                                   *((int64_t*) (((char*) stat) +
+                                                 zk_stat_keys[i].offset)));
+                }
+
+                break;
+            }
+        }
+
+        if (val) {
+            ST(0) = sv_2mortal(val);
+
+            XSRETURN(1);
+        }
+
+        Perl_warn(aTHX_ "invalid element: %s", key);
+
+        XSRETURN_UNDEF;
+
+
+void
+zks_STORE(attr_hash, attr_key, attr_val)
+        Net::ZooKeeper::Stat attr_hash
+        SV *attr_key
+        SV *attr_val
+    PREINIT:
+        zk_stat_t *stat;
+        char *key;
+        int i;
+    PPCODE:
+        stat = _zks_get_handle_inner(aTHX_ attr_hash);
+
+        if (!stat) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_STAT_KEYS; ++i) {
+            if (strcaseEQ(key, zk_stat_keys[i].name)) {
+                Perl_warn(aTHX_ "read-only element: %s", key);
+
+                XSRETURN_EMPTY;
+            }
+        }
+
+        Perl_warn(aTHX_ "invalid element: %s", key);
+
+        XSRETURN_EMPTY;
+
+
+void
+zks_EXISTS(attr_hash, attr_key)
+        Net::ZooKeeper::Stat attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_stat_t *stat;
+        char *key;
+        int i;
+    PPCODE:
+        stat = _zks_get_handle_inner(aTHX_ attr_hash);
+
+        if (!stat) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_STAT_KEYS; ++i) {
+            if (strcaseEQ(key, zk_stat_keys[i].name)) {
+                XSRETURN_YES;
+            }
+        }
+
+        XSRETURN_NO;
+
+
+void
+zks_DELETE(attr_hash, attr_key)
+        Net::ZooKeeper::Stat attr_hash
+        SV *attr_key
+    PPCODE:
+        Perl_warn(aTHX_ "deleting elements from hashes of class "
+                        STAT_PACKAGE_NAME " not supported");
+
+        XSRETURN_EMPTY;
+
+
+void
+zks_CLEAR(attr_hash)
+        Net::ZooKeeper::Stat attr_hash
+    PPCODE:
+        Perl_warn(aTHX_ "clearing hashes of class "
+                        STAT_PACKAGE_NAME " not supported");
+
+        XSRETURN_EMPTY;
+
+
+MODULE = Net::ZooKeeper  PACKAGE = Net::ZooKeeper::Watch  PREFIX = zkw_
+
+void
+zkw_DESTROY(zkwh)
+        Net::ZooKeeper::Watch zkwh
+    PREINIT:
+        zk_handle_t *handle;
+        HV *attr_hash;
+        int ret = ZBADARGUMENTS;
+    PPCODE:
+        handle = _zk_check_handle_outer(aTHX_ zkwh, &attr_hash,
+                                        WATCH_PACKAGE_NAME,
+                                        WATCH_PACKAGE_SIGNATURE);
+
+        if (!handle) {
+            handle = _zk_check_handle_inner(aTHX_ zkwh,
+                                            WATCH_PACKAGE_SIGNATURE);
+
+            if (handle) {
+                attr_hash = zkwh;
+                zkwh = NULL;
+            }
+        }
+
+        if (handle) {
+            ret = ZOK;
+
+            _zk_release_watch(aTHX_ handle->handle.watch, 0);
+            Safefree(handle);
+
+            sv_unmagic((SV*) attr_hash, PERL_MAGIC_ext);
+        }
+
+        if (zkwh && attr_hash) {
+            sv_unmagic((SV*) zkwh, PERL_MAGIC_tied);
+        }
+
+        if (GIMME_V == G_VOID) {
+            XSRETURN_EMPTY;
+        }
+        else if (ret == ZOK) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+
+
+void
+zkw_CLONE(package)
+        char *package
+    PPCODE:
+        XSRETURN_EMPTY;
+
+
+void
+zkw_CLONE_SKIP(package)
+        char *package
+    PPCODE:
+        XSRETURN_YES;
+
+
+void
+zkw_TIEHASH(package, ...)
+        char *package
+    PPCODE:
+        Perl_croak(aTHX_ "tying hashes of class "
+                         WATCH_PACKAGE_NAME " not supported");
+
+
+void
+zkw_UNTIE(attr_hash, ref_count)
+        Net::ZooKeeper::Watch attr_hash
+        IV ref_count
+    PPCODE:
+        Perl_croak(aTHX_ "untying hashes of class "
+                         WATCH_PACKAGE_NAME " not supported");
+
+
+void
+zkw_FIRSTKEY(attr_hash)
+        Net::ZooKeeper::Watch attr_hash
+    PREINIT:
+        zk_watch_t *watch;
+    PPCODE:
+        watch = _zkw_get_handle_inner(aTHX_ attr_hash);
+
+        if (!watch) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        ST(0) = sv_2mortal(newSVpvn(zk_watch_keys[0].name,
+                                    zk_watch_keys[0].name_len));
+
+        XSRETURN(1);
+
+
+void
+zkw_NEXTKEY(attr_hash, attr_key)
+        Net::ZooKeeper::Watch attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_watch_t *watch;
+        char *key;
+        int i;
+    PPCODE:
+        watch = _zkw_get_handle_inner(aTHX_ attr_hash);
+
+        if (!watch) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_WATCH_KEYS; ++i) {
+            if (strcaseEQ(key, zk_watch_keys[i].name)) {
+                ++i;
+
+                break;
+            }
+        }
+
+        if (i < NUM_WATCH_KEYS) {
+            ST(0) = sv_2mortal(newSVpvn(zk_watch_keys[i].name,
+                                        zk_watch_keys[i].name_len));
+
+            XSRETURN(1);
+        }
+        else {
+            XSRETURN_EMPTY;
+        }
+
+
+void
+zkw_SCALAR(attr_hash)
+        Net::ZooKeeper::Watch attr_hash
+    PPCODE:
+        XSRETURN_YES;
+
+
+void
+zkw_FETCH(attr_hash, attr_key)
+        Net::ZooKeeper::Watch attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_watch_t *watch;
+        char *key;
+        SV *val = NULL;
+    PPCODE:
+        watch = _zkw_get_handle_inner(aTHX_ attr_hash);
+
+        if (!watch) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        if (strcaseEQ(key, "timeout")) {
+            val = newSVuv(watch->timeout);
+        }
+        else if (strcaseEQ(key, "event")) {
+            val = newSViv(watch->event_type);
+        }
+        else if (strcaseEQ(key, "state")) {
+            val = newSViv(watch->event_state);
+        }
+
+        if (val) {
+            ST(0) = sv_2mortal(val);
+
+            XSRETURN(1);
+        }
+
+        Perl_warn(aTHX_ "invalid element: %s", key);
+
+        XSRETURN_UNDEF;
+
+
+void
+zkw_STORE(attr_hash, attr_key, attr_val)
+        Net::ZooKeeper::Watch attr_hash
+        SV *attr_key
+        SV *attr_val
+    PREINIT:
+        zk_watch_t *watch;
+        char *key;
+    PPCODE:
+        watch = _zkw_get_handle_inner(aTHX_ attr_hash);
+
+        if (!watch) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        if (strcaseEQ(key, "timeout")) {
+            watch->timeout = SvUV(attr_val);
+        }
+        else {
+            int i;
+
+            for (i = 0; i < NUM_WATCH_KEYS; ++i) {
+                if (strcaseEQ(key, zk_watch_keys[i].name)) {
+                    Perl_warn(aTHX_ "read-only element: %s", key);
+
+                    XSRETURN_EMPTY;
+                }
+            }
+
+            Perl_warn(aTHX_ "invalid element: %s", key);
+        }
+
+        XSRETURN_EMPTY;
+
+
+void
+zkw_EXISTS(attr_hash, attr_key)
+        Net::ZooKeeper::Watch attr_hash
+        SV *attr_key
+    PREINIT:
+        zk_watch_t *watch;
+        char *key;
+        int i;
+    PPCODE:
+        watch = _zkw_get_handle_inner(aTHX_ attr_hash);
+
+        if (!watch) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        key = SvPV_nolen(attr_key);
+
+        for (i = 0; i < NUM_WATCH_KEYS; ++i) {
+            if (strcaseEQ(key, zk_watch_keys[i].name)) {
+                XSRETURN_YES;
+            }
+        }
+
+        XSRETURN_NO;
+
+
+void
+zkw_DELETE(attr_hash, attr_key)
+        Net::ZooKeeper::Watch attr_hash
+        SV *attr_key
+    PPCODE:
+        Perl_warn(aTHX_ "deleting elements from hashes of class "
+                        WATCH_PACKAGE_NAME " not supported");
+
+        XSRETURN_EMPTY;
+
+
+void
+zkw_CLEAR(attr_hash)
+        Net::ZooKeeper::Watch attr_hash
+    PPCODE:
+        Perl_warn(aTHX_ "clearing hashes of class "
+                        WATCH_PACKAGE_NAME " not supported");
+
+        XSRETURN_EMPTY;
+
+
+void
+zkw_wait(zkwh, ...)
+        Net::ZooKeeper::Watch zkwh
+    PREINIT:
+        zk_watch_t *watch;
+        unsigned int timeout;
+        struct timeval end_timeval;
+        int i, done;
+        struct timespec wait_timespec;
+    PPCODE:
+        watch = _zkw_get_handle_outer(aTHX_ zkwh, NULL);
+
+        if (!watch) {
+            Perl_croak(aTHX_ "invalid handle");
+        }
+
+        if (items > 1 && !(items % 2)) {
+            Perl_croak(aTHX_ "invalid number of arguments");
+        }
+
+        timeout = watch->timeout;
+
+        for (i = 1; i < items; i += 2) {
+            char *key = SvPV_nolen(ST(i));
+
+            if (strcaseEQ(key, "timeout")) {
+                timeout = SvUV(ST(i + 1));
+            }
+        }
+
+        gettimeofday(&end_timeval, NULL);
+
+        end_timeval.tv_sec += timeout / 1000;
+        end_timeval.tv_usec += (timeout % 1000) * 1000;
+
+        wait_timespec.tv_sec = end_timeval.tv_sec;
+        wait_timespec.tv_nsec = end_timeval.tv_usec * 1000;
+
+        pthread_mutex_lock(&watch->mutex);
+
+        while (!watch->done) {
+            struct timeval curr_timeval;
+
+            gettimeofday(&curr_timeval, NULL);
+
+            if (end_timeval.tv_sec < curr_timeval.tv_sec ||
+                (end_timeval.tv_sec == curr_timeval.tv_sec &&
+                 end_timeval.tv_usec <= curr_timeval.tv_usec)) {
+                break;
+            }
+
+            pthread_cond_timedwait(&watch->cond, &watch->mutex,
+                                   &wait_timespec);
+        }
+
+        done = watch->done;
+
+        pthread_mutex_unlock(&watch->mutex);
+
+        if (done) {
+            XSRETURN_YES;
+        }
+        else {
+            XSRETURN_NO;
+        }
+

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zkperl/typemap

@@ -0,0 +1,38 @@
+# Net::ZooKeeper - Perl extension for Apache ZooKeeper
+#
+# 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.
+
+TYPEMAP
+Net::ZooKeeper	T_ZK_HANDLE
+Net::ZooKeeper::Stat	T_ZK_HANDLE
+Net::ZooKeeper::Watch	T_ZK_HANDLE
+
+INPUT
+T_ZK_HANDLE
+	if (SvROK($arg) && SvTYPE(SvRV($arg)) == SVt_PVHV &&
+	    sv_derived_from($arg, \"${ntype}\")) {
+	    $var = (HV*) SvRV($arg);
+	}
+	else {
+	    Perl_croak(aTHX_
+                       \"$var is not a hash reference of type ${ntype}\");
+	}
+
+OUTPUT
+T_ZK_HANDLE
+	NOT_IMPLEMENTED
+

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zooinspector/NOTICE.txt

@@ -0,0 +1,9 @@
+src/java/com/nitido/utils/toaster/Toaster.java:
+This java file is copyright by Daniele Piras ("danielepiras80", no email known) released under the Apache Software License 2.0
+It has been downloaded in december 2009 from the CVS web interface of the sourceforge project http://sourceforge.net/projects/jtoaster/ . The web interface to CVS is not available anymore on sourceforge.
+
+The icons in src/main/resources/icons are taken from the Tango project
+downloaded from http://tango.freedesktop.org/releases on 2011-09-06.
+The Tango project is public domain.
+
+Distribution packagers should not include the icons in the package but rather depend on tango-icon-theme (Debian package name). ZooInspector will then try to get the icons from /usr/share/icons/Tango rather then from its jar file.

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zooinspector/README.txt

@@ -0,0 +1,102 @@
+==========================================
+ZooInspector - Browser and Editor for ZooKeeper Instances
+Author: Colin Goodheart-Smithe
+Date: February 2010
+==========================================
+
+ZooInspector is a Java Swing based application for browsing and editing ZooKeeper instances.
+
+Contents
+--------
+	- Features
+	- Pre-requisites
+	- Build Instructions
+	- Using ZooInspector
+	- Creating and Using Plugins
+	
+Features
+--------
+	Below is a list of features in the current release of ZooInspector.
+	- Load connection settings from a zookeeper properties file
+	- Pluggable DataEncryptionManagers to specify how data should be encrypted and decrypted in the Zookeeper instance
+	- Browsable tree view of the ZooKeeper instance
+	- View the data in a node
+	- View the ACLs currently applied to a node
+	- View the metadata for a node (Version, Number of Children, Last modified Time, etc.)
+	- Pluggable NodeViewers interface
+	- Ability to save/load and set default Node Viewers
+
+Maven Build Instructions
+-------------------------
+  0. Pre-requisites
+     - Run "mvn install" in the root directory of the Zookeeper project
+  1. Open a command line
+  2. cd into this directory
+  3. mvn install
+  4. To run ZooInspector run zooInspector.cmd (on Windows) or zooInspector.sh (on Linux) (these scripts will
+     find the built JAR automatically in the "target" directory as long as you don't move it)
+
+Ant Build Instructions
+-----------------------
+  0. Pre-requisites
+	   - The main zookeeper build script must have been run before building this module
+	1. Open a command line.
+	2. cd into this directory
+	3. Run command: ant
+	4. ZooInspector will be built to ../../../build/contrib/ZooInspector
+	5. Copy zookeeper-3.x.x.jar into the lib sub-directory (if you are using zookeeper-3.3.0.jar it will have been
+       copied to this directory during the build
+	6. By default the zookeeper.cmd and zookeeper.sh files expect zookeeper-3.3.0.jar.  If you are using another version
+	   you will need to change these files to point to the zookeeper-3.x.x.jar you copied to the lib directory
+	7. To run ZooInspector run zooInspector.cmd (on Windows) or zooInspector.sh (on Linux).  If you are using
+	   zookeeper-3.3.0.jar and do not require any classpath changes you can run the zookeeper-dev-ZooInspector.jar
+	   directly
+
+Using ZooInspector
+------------------
+	To start ZooInspector run zooInspector.cmd (on Windows) or zooInspector.sh (on Linux).  If you are using
+	zookeeper-3.3.0.jar and do not require any classpath changes you can run the zookeeper-dev-ZooInspector.jar
+	directly.
+
+	Click the play button on the toolbar to bring up the connection dialog.  From here you can enter connection
+	information for your zookeeper instance.  You can also load the connection properties from a file.  This file can
+	have the format as a normal zookeeper properties file (i.e. hosts and timeout key-value pairs) and van optional have
+	an encryptionManager key-value pair to specify the DataEncryptionManager to use for this connection
+	(DataEncryptionManagers are explained in further detail in the 'Creating and Using Plugins' section below).  You can
+	also set the entered information as the defaults so that when you first start ZooInspector these settings are
+	automatically loaded into this dialog.  Pressing the OK button with connect to your ZooKeeper instance and show the
+	current node tree on the left of the main panel.
+
+	Clicking a node in the node tree will load the data for that node into the node viewers.  Three node viewers are
+	currently distributed with ZooInspector:
+		1. Node Data - This enables you to see the data current stored on that node.  This data can be modified and
+		   saved.  The data is decrypted and encrypted using the DataEncryptionManager specified on the connection
+		   dialog.
+		2. Node Metadata - This enables you to see the metadata associated with this node.  This is essentially the data
+		   obtained from the Stat object for this node.
+		3. Node ACLs - This allows you to see the ACLs currently applied to this node.  Currently there is no ability
+		   to change the ACLs on a node, but it is a feature I would like to add.
+	Other custom Node Viewers can be added, this is explained in the 'Creating and Using Plugins' section below.
+
+
+Creating and Using Plugins
+--------------------------
+	There are two types of plugin which can be used with ZooInspector:
+		1. DataEncryptionManager - This specifies how data should be encrypted and decrypted when working with a
+		   zookeeper instance.
+		2. ZooInspectorNodeViewer - This is a GUI panel which provides a view of visualisation on a node.
+	More information on these interfaces can be found in the javadocs for this module.
+
+	To use a plugin in ZooInspector, build the plugin to a jar and copy the jar to the lib sub-directory.  Edit the
+	zooInspector.cmd and/or zooInspector.sh files to include your new jar on the classpath and run ZooInspector.
+
+	For DataEncryptionManagers, click the play button to open the connection dialog and enter the full class name of
+	your DataEncryptionManager in the 'Data Encryption Manager' field.  You can make this Data Encryption Manager the
+	default by clicking 'Set As Default'.  Click the 'OK' button to instantiate and use your plugin.
+
+	For ZooInspectorNodeViewers, Click the 'Change Node Viewers' button on the toolbar (looks like a tree with a pencil)
+	and enter the full classname for your Node Viewer in the field left of the 'Add' button, then click the 'Add'
+	button.  The Node Viewer will be instantiated and should appear in the list.  You can change the order of the Node
+	viewers by clicking the up and down buttons and delete a Node Viewer by clicking the delete button.  You can save
+	to configuration to a file or set it as the default if necessary. Then click the 'OK' button and your Node Viewer 
+	should appear in the tabs on the right of the main panel.

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zooinspector/TODO

@@ -0,0 +1,19 @@
+- replace JToaster with standard notifications, see:
+  http://www.galago-project.org/specs/notification/
+  http://stackoverflow.com/questions/857154/freedesktop-org-notifications-in-java
+  DBus and Java:
+  http://bolta-gecko.blogspot.com/2009/06/using-d-bus-in-java.html
+  http://dbus.freedesktop.org/doc/dbus-java/ (packaged in Debian)
+
+- properly respect
+  http://standards.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html
+  http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+  http://standards.freedesktop.org/icon-theme-spec/icon-theme-spec-latest.html
+
+- Rename classes to avoid redundant "ZooInspector" prefix.
+
+- Ant build file has hard coded log4j dependency. (ZK will move to maven anyways...)
+
+- make directory for config files configurable via commandline parameter
+
+- Clean up the code! :-)

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zooinspector/zooInspector-dev.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+# 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.
+         
+java -cp ../../build/contrib/ZooInspector/*:../../../build/*:../../../build/lib/*:lib org.apache.zookeeper.inspector.ZooInspector

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zooinspector/zooInspector.cmd

@@ -0,0 +1,26 @@
+@echo off
+@rem Licensed to the Apache Software Foundation (ASF) under one or more
+@rem contributor license agreements.  See the NOTICE file distributed with
+@rem this work for additional information regarding copyright ownership.
+@rem The ASF licenses this file to You under the Apache License, Version 2.0
+@rem (the "License"); you may not use this file except in compliance with
+@rem the License.  You may obtain a copy of the License at
+@rem
+@rem     http://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+
+@rem Get the path to the directory containing this script
+SET SCRIPT_DIR=%~dp0
+
+@rem Get the path to the uber jar for this tool
+@rem (Requires "mvn install" or "mvn package" be run first)
+set JAVA_LIB=
+for /F %%f in ('dir /b "%SCRIPT_DIR%\target\zookeeper-contrib-zooinspector-*-jar-with-dependencies.jar" 2^>nul') do (
+   set JAVA_LIB=%SCRIPT_DIR%target\%%f
+)
+java -jar %JAVA_LIB%

local-test-zookeeper-full-01/afc-zookeeper/zookeeper-contrib/zookeeper-contrib-zooinspector/zooInspector.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# 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.
+
+# Get the path to the directory containing this script
+SCRIPT_DIR=$(dirname "$0")
+
+# Get the path to the uber jar for this tool
+# (Requires "mvn install" or "mvn package" be run first)
+JAVA_LIB=`ls ${SCRIPT_DIR}/target/zookeeper-contrib-zooinspector-*-jar-with-dependencies.jar`
+
+java -jar "${JAVA_LIB}"