zookeeper 0.1

data.tar.gz.sig

@@ -0,0 +1 @@
+��0i�4E�X���	
������I�>���Ya�0����� >��s���xSʷ����(9��?�#�2i2�#j����P��?E9Q!��T��Q)}v�HL��k�i�al)��(�U鱗kZ�r�?��->��������V��?s���s�CQ�^aL�N����R�đn��7�V�a��0/�_Tc���1s��ͦJ��Р;�LC�ͅA-��{��I��",��@���Gs&h���6���D]إi�g�����6���

data/CHANGELOG

@@ -0,0 +1,2 @@
+
+v0.1. First release.

data/Manifest

@@ -0,0 +1,8 @@
+CHANGELOG
+README
+Rakefile
+ext/zookeeper_c/extconf.rb
+ext/zookeeper_c/zookeeper_ruby.c
+lib/zookeeper_client.rb
+test/test_basic.rb
+Manifest

data/README

@@ -0,0 +1,98 @@
+zookeeper_client
+    by Phillip Pearson
+    http://github.com/myelin/zookeeper_client
+
+== DESCRIPTION:
+
+zookeeper_client is a Ruby library to interface with the ZooKeeper
+replicated object store / lock server.
+
+Project maturity: early alpha.  Working, although very chatty and
+there may be bugs to do with threading.  Expect to get your hands
+dirty.
+
+== REQUIREMENTS:
+
+* ZooKeeper C client library (http://zookeeper.sourceforge.net/)
+
+  See installation instructions in c/README, in the ZooKeeper source
+  distribution.  zookeeper_client expects the headers to live in
+  /usr/include/c-client-src/, which doesn't feel right but is where
+  they go on my system when I run 'make install'.
+
+== INSTALL:
+
+  $ gem sources -a http://gems.github.com/
+  $ gem install myelin-zookeeper_client
+
+== USAGE:
+
+= Connect to a server
+
+  require 'rubygems'
+  require 'myelin-zookeeper_client'
+  z = ZooKeeper.new("localhost:2181")
+
+= Create, set and read nodes
+
+  z.create("/bacon", "text to be stored in the new node", 0)
+  # => "/bacon"
+
+  data, stat = z.get("/bacon")
+  # => ["text to be stored in the new node", #<ZkStat:0xb771be54 @ephemeralOwner=0, @ctime=1216196667669, @aversion=0, @mzxid=1008, @cversion=0, @version=0, @czxid=1008, @mtime=1216196667669>]
+
+  z.set("/bacon", "an entirely different line of text", stat.version)
+  # => nil
+
+  z.set("/bacon", "this won't work", stat.version)
+  # CZooKeeper::BadVersionError: expected version does not match actual version
+
+  data, stat = z.get("/bacon")
+  # => ["an entirely different line of text", #<ZkStat:0xb77125d4 @ephemeralOwner=0, @ctime=1216196667669, @aversion=0, @mzxid=1009, @cversion=0, @version=1, @czxid=1008, @mtime=1216196704709>]
+
+  z.delete("/bacon", stat.version)
+  # => nil
+
+= Create ephemeral and sequence nodes
+
+  z.create("/parent", "parent node", 0)
+  # => "/parent"
+
+  z.create("/parent/test-", "an ordered node that will disappear when the connection goes down", ZooKeeper::EPHEMERAL | ZooKeeper::SEQUENCE)
+  # => "/parent/test-0"
+
+  z.create("/parent/test-", "an ordered node that will disappear when the connection goes down", ZooKeeper::EPHEMERAL | ZooKeeper::SEQUENCE)
+  # => "/parent/test-1"
+
+= Acquire locks
+
+  z.try_acquire "/parent/lock-", "content for the lock file" do |have_lock|
+    puts have_lock ? "we have the lock" : "we don't have the lock"
+  end
+  # we have the lock
+  # => nil
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (C) 2008 Phillip Pearson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'echoe'
+
+Echoe.new("zookeeper") do |p|
+  p.author = "Phillip Pearson, Eric Maland, Evan Weaver"
+  p.project = "fauna"
+  p.summary = "A Ruby wrapper for the ZooKeeper C client library."
+  p.url = "http://blog.evanweaver.com/files/doc/fauna/zookeeper/"
+  p.docs_host = "blog.evanweaver.com:~/www/bax/public/files/doc/"
+end

data/ext/zookeeper_c/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+dir_config("zookeeper")
+
+have_header "sys/errno.h" 
+have_header "stdio.h"
+find_header("zookeeper/zookeeper.h") or
+  raise "zookeeper.h not found."
+find_library("zookeeper_mt", "zoo_set_debug_level") or 
+  raise "libzookeeper_mt not found."
+  
+dir_config('zookeeper_c')
+create_makefile( 'zookeeper_c')
+

data/ext/zookeeper_c/zookeeper_ruby.c

@@ -0,0 +1,518 @@
+/* Ruby wrapper for the ZooKeeper C API
+ * Phillip Pearson <pp@myelin.co.nz>
+ * Eric Maland <eric@twitter.com>
+ */
+
+#define THREADED
+
+#include "ruby.h"
+
+#include "zookeeper/zookeeper.h"
+#include <errno.h>
+#include <stdio.h>
+
+static VALUE ZooKeeper = Qnil;
+static VALUE eNoNode = Qnil;
+static VALUE eBadVersion = Qnil;
+
+struct zk_rb_data {
+  zhandle_t *zh;
+  clientid_t myid;
+};
+
+static void watcher(zhandle_t *zh, int type, int state, const char *path, void *ctx) {
+  VALUE self, watcher_id;
+  (void)ctx;
+  return; // watchers don't work in ruby yet
+
+  self = (VALUE)zoo_get_context(zh);;
+  watcher_id = rb_intern("watcher");
+
+  fprintf(stderr,"C watcher %d state = %d for %s.\n", type, state, (path ? path: "null"));
+  rb_funcall(self, watcher_id, 3, INT2FIX(type), INT2FIX(state), rb_str_new2(path));
+}
+
+#warning [emaland] incomplete - but easier to read!
+static void check_errors(int rc) {
+  switch (rc) {
+  case ZOK: 
+    /* all good! */ 
+    break;
+  case ZNONODE: 
+    rb_raise(eNoNode, "the node does not exist");
+    break;
+  case ZBADVERSION: 
+    rb_raise(eBadVersion, "expected version does not match actual version");
+    break;
+  default: 
+    rb_raise(rb_eRuntimeError, "unknown error returned from zookeeper: %d (%s)", rc, zerror(rc));
+  }
+}
+
+static void free_zk_rb_data(struct zk_rb_data* ptr) {
+  zookeeper_close(ptr->zh);
+}
+
+static VALUE array_from_stat(const struct Stat* stat) {
+  return rb_ary_new3(8,
+		     LL2NUM(stat->czxid),
+		     LL2NUM(stat->mzxid),
+		     LL2NUM(stat->ctime),
+		     LL2NUM(stat->mtime),
+		     INT2NUM(stat->version),
+		     INT2NUM(stat->cversion),
+		     INT2NUM(stat->aversion),
+		     LL2NUM(stat->ephemeralOwner));
+}
+
+static VALUE method_initialize(VALUE self, VALUE hostPort) {
+  VALUE data;
+  struct zk_rb_data* zk = NULL;
+
+  Check_Type(hostPort, T_STRING);
+
+  data = Data_Make_Struct(ZooKeeper, struct zk_rb_data, 0, free_zk_rb_data, zk);
+
+  zoo_set_debug_level(ZOO_LOG_LEVEL_INFO);
+  zoo_deterministic_conn_order(0);
+
+  zk->zh = zookeeper_init(RSTRING(hostPort)->ptr, watcher, 10000, &zk->myid, (void*)self, 0);
+  if (!zk->zh) {
+    rb_raise(rb_eRuntimeError, "error connecting to zookeeper: %d", errno);
+  }
+
+  rb_iv_set(self, "@data", data);
+
+  return Qnil;
+}
+
+#define FETCH_DATA_PTR(x, y) \
+  struct zk_rb_data * y; \
+  Data_Get_Struct(rb_iv_get(x, "@data"), struct zk_rb_data, y)
+
+static VALUE method_get_children(VALUE self, VALUE path) {
+  struct String_vector strings;
+  int i;
+  VALUE output;
+
+  Check_Type(path, T_STRING);
+  FETCH_DATA_PTR(self, zk);
+
+  check_errors(zoo_get_children(zk->zh, RSTRING(path)->ptr, 0, &strings));
+
+  output = rb_ary_new();
+  for (i = 0; i < strings.count; ++i) {
+    rb_ary_push(output, rb_str_new2(strings.data[i]));
+  }
+  return output;
+}
+
+static VALUE method_exists(VALUE self, VALUE path, VALUE watch) {
+  struct Stat stat;
+
+  Check_Type(path, T_STRING);
+  FETCH_DATA_PTR(self, zk);
+
+  check_errors(zoo_exists(zk->zh, RSTRING(path)->ptr, (watch != Qfalse && watch != Qnil), &stat));
+
+  return array_from_stat(&stat);
+}
+
+static VALUE method_create(VALUE self, VALUE path, VALUE value, VALUE flags) {
+  char realpath[10240];
+
+  Check_Type(path, T_STRING);
+  Check_Type(value, T_STRING);
+  Check_Type(flags, T_FIXNUM);
+
+  FETCH_DATA_PTR(self, zk);
+
+  check_errors(zoo_create(zk->zh, RSTRING(path)->ptr, 
+                          RSTRING(value)->ptr, RSTRING(value)->len,
+			  &ZOO_OPEN_ACL_UNSAFE, FIX2INT(flags), 
+                          realpath, sizeof(realpath)));
+
+  return rb_str_new2(realpath);
+}
+
+static VALUE method_delete(VALUE self, VALUE path, VALUE version) {
+  Check_Type(path, T_STRING);
+  Check_Type(version, T_FIXNUM);
+
+  FETCH_DATA_PTR(self, zk);
+
+  check_errors(zoo_delete(zk->zh, RSTRING(path)->ptr, FIX2INT(version)));
+
+  return Qtrue;
+}
+
+static VALUE method_get(VALUE self, VALUE path) {
+  char data[1024];
+  int data_len = sizeof(data);
+
+  struct Stat stat;
+  memset(data, 0, sizeof(data));
+
+  Check_Type(path, T_STRING);
+  FETCH_DATA_PTR(self, zk);
+  
+  check_errors(zoo_get(zk->zh, RSTRING(path)->ptr, 0, data, &data_len, &stat));
+
+  return rb_ary_new3(2,
+		     rb_str_new(data, data_len),
+		     array_from_stat(&stat));
+}
+
+static VALUE method_set(int argc, VALUE* argv, VALUE self)
+{
+  VALUE v_path, v_data, v_version;
+  int real_version = -1;
+
+  FETCH_DATA_PTR(self, zk);
+
+  rb_scan_args(argc, argv, "21", &v_path, &v_data, &v_version);
+  
+  Check_Type(v_path, T_STRING);
+  Check_Type(v_data, T_STRING);
+  Check_Type(v_version, T_FIXNUM);
+
+  if(!NIL_P(v_version))
+    real_version = FIX2INT(v_version);
+
+  check_errors(zoo_set(zk->zh, 
+                       RSTRING(v_path)->ptr, 
+                       RSTRING(v_data)->ptr, RSTRING(v_data)->len, 
+                       FIX2INT(v_version)));
+
+  return Qtrue;
+}
+
+static void void_completion_callback(int rc, const void *data) {
+
+}
+
+static void string_completion_callback(int rc, const char *value, const void *data) {
+  
+}
+
+#warning [emaland] to be implemented
+static VALUE method_set2(int argc, VALUE *argv, VALUE self) {
+  //  ZOOAPI int zoo_set2(zhandle_t *zh, const char *path, const char *buffer,
+  //                    int buflen, int version, struct Stat *stat);
+  return Qnil;
+
+}
+
+static VALUE method_set_acl(int argc, VALUE* argv, VALUE self) {
+/* STUB */
+/*   VALUE v_path, v_data, v_version; */
+/*   struct zk_rb_data* zk; */
+/*   int real_version = -1; */
+
+/*   rb_scan_args(argc, argv, "21", &v_path, &v_data, &v_version); */
+  
+/*   Check_Type(v_path, T_STRING); */
+/*   Check_Type(v_data, T_STRING); */
+/*   Check_Type(v_version, T_FIXNUM); */
+
+/*   if(!NIL_P(v_version)) */
+/*     real_version = FIX2INT(v_version); */
+
+/*   Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk); */
+  
+/*   check_errors(zoo_set(zk->zh, RSTRING(v_path)->ptr,  */
+/*                        RSTRING(v_data)->ptr, RSTRING(v_data)->len,  */
+/*                        FIX2INT(v_version))); */
+
+  return Qnil;
+}
+
+/*
+        PARAMETERS:
+         zh: the zookeeper handle obtained by a call to zookeeper.init
+         scheme: the id of authentication scheme. Natively supported:
+        'digest' password-based authentication
+         cert: application credentials. The actual value depends on the scheme.
+         completion: the routine to invoke when the request completes. One of 
+        the following result codes may be passed into the completion callback:
+        OK operation completed successfully
+        AUTHFAILED authentication failed 
+        
+        RETURNS:
+        OK on success or one of the following errcodes on failure:
+        BADARGUMENTS - invalid input parameters
+        INVALIDSTATE - zhandle state is either SESSION_EXPIRED_STATE or AUTH_FAI
+LED_STATE
+        MARSHALLINGERROR - failed to marshall a request; possibly, out of memory
+        SYSTEMERROR - a system error occured
+*/
+#warning [emaland] make these magically synchronous for now?
+static VALUE method_add_auth(VALUE self, VALUE scheme, 
+                             VALUE cert, VALUE completion, 
+                             VALUE completion_data) {
+  struct zk_rb_data* zk;
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk);
+
+  Check_Type(scheme, T_STRING);
+  Check_Type(cert, T_STRING);
+  //  Check_Type(completion, T_OBJECT); // ???
+  
+  check_errors(zoo_add_auth(zk->zh, RSTRING(scheme)->ptr,
+                            RSTRING(cert)->ptr, RSTRING(cert)->len,
+                            void_completion_callback, DATA_PTR(completion_data)));
+  return Qtrue;
+}
+
+static VALUE method_async(VALUE self, VALUE path, 
+                          VALUE completion, VALUE completion_data) {
+  struct zk_rb_data* zk;
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk);
+
+  Check_Type(path, T_STRING);
+  //  Check_Type(completion, T_OBJECT); // ???
+  
+  check_errors(zoo_async(zk->zh, RSTRING(path)->ptr,
+                         string_completion_callback, DATA_PTR(completion_data)));
+
+  return Qtrue;
+}
+
+static VALUE method_client_id(VALUE self) {
+  FETCH_DATA_PTR(self, zk);
+  const clientid_t *id = zoo_client_id(zk->zh);
+  return UINT2NUM(id->client_id);
+}
+
+static VALUE method_close(VALUE self) {
+  FETCH_DATA_PTR(self, zk);
+  check_errors(zookeeper_close(zk->zh));
+  return Qtrue;
+}
+
+static VALUE method_deterministic_conn_order(VALUE self, VALUE yn) {
+  zoo_deterministic_conn_order(yn == Qtrue);
+  return Qnil;
+}
+
+static VALUE id_to_ruby(struct Id *id) {
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, rb_str_new2("scheme"), rb_str_new2(id->scheme));
+  rb_hash_aset(hash, rb_str_new2("id"), rb_str_new2(id->id));
+  return hash;
+}
+
+static VALUE acl_to_ruby(struct ACL *acl) {
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, rb_str_new2("perms"), INT2NUM(acl->perms));
+  rb_hash_aset(hash, rb_str_new2("id"), id_to_ruby(&(acl->id)));
+  return hash;
+}
+
+static VALUE acl_vector_to_ruby(struct ACL_vector *acl_vector) {
+  int i = 0;
+  VALUE ary = rb_ary_new();
+  for(i = 0; i < acl_vector->count; i++) {
+    rb_ary_push(ary, acl_to_ruby(acl_vector->data+i));
+  }
+  return ary;
+}
+
+/*
+  struct Stat {
+    int64_t czxid;
+    int64_t mzxid;
+    int64_t ctime;
+    int64_t mtime;
+    int32_t version;
+    int32_t cversion;
+    int32_t aversion;
+    int64_t ephemeralOwner;
+    int32_t dataLength;
+    int32_t numChildren;
+    int64_t pzxid;
+  }
+}
+*/
+static VALUE stat_to_ruby(struct Stat *stat) {
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, rb_str_new2("czxid"), UINT2NUM(stat->czxid));
+  rb_hash_aset(hash, rb_str_new2("mzxid"), UINT2NUM(stat->mzxid));
+  rb_hash_aset(hash, rb_str_new2("ctime"), UINT2NUM(stat->ctime));
+  rb_hash_aset(hash, rb_str_new2("mtime"), UINT2NUM(stat->mtime));
+  rb_hash_aset(hash, rb_str_new2("version"), INT2NUM(stat->version));
+  rb_hash_aset(hash, rb_str_new2("cversion"), INT2NUM(stat->cversion));
+  rb_hash_aset(hash, rb_str_new2("aversion"), INT2NUM(stat->aversion));
+  rb_hash_aset(hash, rb_str_new2("ephemeralOwner"), UINT2NUM(stat->ephemeralOwner));
+  rb_hash_aset(hash, rb_str_new2("dataLength"), INT2NUM(stat->dataLength));
+  rb_hash_aset(hash, rb_str_new2("numChildren"), INT2NUM(stat->numChildren));
+  rb_hash_aset(hash, rb_str_new2("pzxid"), UINT2NUM(stat->pzxid));
+  return hash;
+}
+
+static VALUE method_get_acl(VALUE self, VALUE path) {
+  FETCH_DATA_PTR(self, zk);
+  Check_Type(path, T_STRING);
+
+  //  ZOOAPI int zoo_get_acl(zhandle_t *zh, const char *path, struct ACL_vector *acl,
+  //                     struct Stat *stat);
+  struct ACL_vector acl;
+  struct Stat stat;
+  check_errors(zoo_get_acl(zk->zh, RSTRING(path)->ptr, &acl, &stat));
+
+  VALUE result = rb_ary_new();
+  rb_ary_push(result, acl_vector_to_ruby(&acl));
+  rb_ary_push(result, stat_to_ruby(&stat));
+  return result;
+}
+
+static VALUE method_is_unrecoverable(VALUE self) {
+  FETCH_DATA_PTR(self, zk);
+  if(is_unrecoverable(zk->zh) == ZINVALIDSTATE)
+    return Qtrue;
+
+  return Qfalse;
+}
+
+static VALUE method_recv_timeout(VALUE self) {
+  FETCH_DATA_PTR(self, zk);
+  return INT2NUM(zoo_recv_timeout(zk->zh));
+}
+
+#warning [emaland] make this a class method or global
+static VALUE method_set_debug_level(VALUE self, VALUE level) {
+  FETCH_DATA_PTR(self, zk);
+  Check_Type(level, T_FIXNUM);
+  zoo_set_debug_level(FIX2INT(level));
+  return Qnil;
+}
+
+#warning [emaland] make this a class method or global
+static VALUE method_zerror(VALUE self, VALUE errc) {
+  return rb_str_new2(zerror(FIX2INT(errc)));
+}
+
+static VALUE method_state(VALUE self) {
+  FETCH_DATA_PTR(self, zk);
+  return INT2NUM(zoo_state(zk->zh));
+}
+
+#warning [emaland] make this a class method or global
+static VALUE method_set_log_stream(VALUE self, VALUE stream) {
+  // convert stream to FILE*
+  FILE *fp_stream = (FILE*)stream;
+  zoo_set_log_stream(fp_stream);
+  return Qnil;
+}
+
+static VALUE method_set_watcher(VALUE self, VALUE new_watcher) {
+  FETCH_DATA_PTR(self, zk);
+#warning [emaland] needs to be tested/implemented
+  return Qnil;
+  //  watcher_fn old_watcher = zoo_set_watcher(zk->zh, new_watcher);
+  //  return old_watcher;
+}
+
+void Init_zookeeper_c() {
+  ZooKeeper = rb_define_class("CZooKeeper", rb_cObject);
+
+#define DEFINE_METHOD(method, args) { \
+    rb_define_method(ZooKeeper, #method, method_ ## method, args); }
+
+  DEFINE_METHOD(initialize, 1);
+  DEFINE_METHOD(get_children, 1);
+  DEFINE_METHOD(exists, 2);
+  DEFINE_METHOD(create, 3);
+  DEFINE_METHOD(delete, 2);
+  DEFINE_METHOD(get, 1);
+  DEFINE_METHOD(set, -1);
+
+  /* TODO */
+  DEFINE_METHOD(add_auth, 3);
+  DEFINE_METHOD(set_acl, -1);
+  DEFINE_METHOD(async, 1);
+  DEFINE_METHOD(client_id, 0);
+  DEFINE_METHOD(close, 0);
+  DEFINE_METHOD(deterministic_conn_order, 1);
+  DEFINE_METHOD(get_acl, 2);
+  DEFINE_METHOD(is_unrecoverable, 0);
+  DEFINE_METHOD(recv_timeout, 1);
+  DEFINE_METHOD(set2, -1);
+  DEFINE_METHOD(set_debug_level, 1);
+  DEFINE_METHOD(set_log_stream, 1);
+  DEFINE_METHOD(set_watcher, 2);
+  DEFINE_METHOD(state, 0);
+  DEFINE_METHOD(zerror, 1);
+
+  eNoNode = rb_define_class_under(ZooKeeper, "NoNodeError", rb_eRuntimeError);
+  eBadVersion = rb_define_class_under(ZooKeeper, "BadVersionError", rb_eRuntimeError);
+
+#define EXPORT_CONST(x) { rb_define_const(ZooKeeper, #x, INT2FIX(x)); }
+
+  /* create flags */
+  EXPORT_CONST(ZOO_EPHEMERAL);
+  EXPORT_CONST(ZOO_SEQUENCE);
+
+  /* 
+     session state
+  */
+  EXPORT_CONST(ZOO_EXPIRED_SESSION_STATE);
+  EXPORT_CONST(ZOO_AUTH_FAILED_STATE);
+  EXPORT_CONST(ZOO_CONNECTING_STATE);
+  EXPORT_CONST(ZOO_ASSOCIATING_STATE);
+  EXPORT_CONST(ZOO_CONNECTED_STATE);
+
+  /* notifications */
+  EXPORT_CONST(ZOOKEEPER_WRITE);
+  EXPORT_CONST(ZOOKEEPER_READ);
+
+  /* errors */
+  EXPORT_CONST(ZOK);
+  EXPORT_CONST(ZSYSTEMERROR);
+  EXPORT_CONST(ZRUNTIMEINCONSISTENCY);
+  EXPORT_CONST(ZDATAINCONSISTENCY);
+  EXPORT_CONST(ZCONNECTIONLOSS);
+  EXPORT_CONST(ZMARSHALLINGERROR);
+  EXPORT_CONST(ZUNIMPLEMENTED);
+  EXPORT_CONST(ZOPERATIONTIMEOUT);
+  EXPORT_CONST(ZBADARGUMENTS);
+  EXPORT_CONST(ZINVALIDSTATE);
+
+  /** API errors. */
+  EXPORT_CONST(ZAPIERROR);
+  EXPORT_CONST(ZNONODE);
+  EXPORT_CONST(ZNOAUTH);
+  EXPORT_CONST(ZBADVERSION);
+  EXPORT_CONST(ZNOCHILDRENFOREPHEMERALS);
+  EXPORT_CONST(ZNODEEXISTS);
+  EXPORT_CONST(ZNOTEMPTY);
+  EXPORT_CONST(ZSESSIONEXPIRED);
+  EXPORT_CONST(ZINVALIDCALLBACK);
+  EXPORT_CONST(ZINVALIDACL);
+  EXPORT_CONST(ZAUTHFAILED);
+  EXPORT_CONST(ZCLOSING);
+  EXPORT_CONST(ZNOTHING);
+  EXPORT_CONST(ZSESSIONMOVED);
+
+  /* debug levels */
+  EXPORT_CONST(ZOO_LOG_LEVEL_ERROR);
+  EXPORT_CONST(ZOO_LOG_LEVEL_WARN);
+  EXPORT_CONST(ZOO_LOG_LEVEL_INFO);
+  EXPORT_CONST(ZOO_LOG_LEVEL_DEBUG);
+
+  /* ACL constants */
+  EXPORT_CONST(ZOO_PERM_READ);
+  EXPORT_CONST(ZOO_PERM_WRITE);
+  EXPORT_CONST(ZOO_PERM_CREATE);
+  EXPORT_CONST(ZOO_PERM_DELETE);
+  EXPORT_CONST(ZOO_PERM_ADMIN);
+  EXPORT_CONST(ZOO_PERM_ALL);
+
+  /* Watch types */
+  EXPORT_CONST(ZOO_CREATED_EVENT);
+  EXPORT_CONST(ZOO_DELETED_EVENT);
+  EXPORT_CONST(ZOO_CHANGED_EVENT);
+  EXPORT_CONST(ZOO_CHILD_EVENT);
+  EXPORT_CONST(ZOO_SESSION_EVENT);
+  EXPORT_CONST(ZOO_NOTWATCHING_EVENT);
+  
+}

data/lib/zookeeper_client.rb

@@ -0,0 +1,78 @@
+# Ruby wrapper for the ZooKeeper C API
+# Phillip Pearson <pp@myelin.co.nz>
+
+require 'zookeeper_c'
+
+class ZkStat
+  attr_reader :version
+  def initialize(ary)
+    @czxid, @mzxid, @ctime, @mtime, @version, @cversion, @aversion, @ephemeralOwner = ary
+  end
+end
+
+class ZooKeeper < CZooKeeper
+  def initialize(host)
+    super(host)
+    @watchers = {} # path => [ block, block, ... ]
+  end
+
+  def exists(path, &blk)
+    (@watchers[path] ||= []) << blk if blk
+    ZkStat.new(super(path, !!blk))
+  end
+
+  def stat(path, &blk)
+    exists(path, &blk)
+  rescue ZooKeeper::NoNodeError
+    nil
+  end
+
+  def get(path)
+    value, stat = super
+    [value, ZkStat.new(stat)]
+  end
+
+  def try_acquire(path, value)
+    # create the parent node if it doesn't exist already
+    create(path, "lock node", 0) unless stat(path)
+
+    # attempt to obtain the lock
+    realpath = create("#{path}/lock-", value, ZooKeeper::ZOO_EPHEMERAL | ZooKeeper::ZOO_SEQUENCE)
+    #puts "created lock node #{realpath}"
+
+    # see if we got it
+    serial = /lock-(\d+)$/.match(realpath).captures[0].to_i
+    have_lock = true
+    ls(path).each do |child|
+      if m = /lock-(\d+)$/.match(child)
+        if m.captures[0].to_i < serial
+          have_lock = false
+          break
+        end
+      end
+    end
+
+    # call block
+    yield(have_lock)
+
+    # release the lock
+    #puts "deleting #{realpath}"
+    delete(realpath, stat(realpath).version)
+  end
+
+  def watcher(type, state, path)
+    raise Exception("watchers don't work in ruby yet") # ... until I figure out how to synchronize access to the Ruby interpreter
+
+    return unless type == ZOO_SESSION_EVENT
+
+    case state
+    when ZOO_CONNECTED_STATE
+      puts "ruby watcher; got an event for #{path}"
+
+    when ZOO_AUTH_FAILED_STATE
+      raise Exception, "auth failure"
+    when ZOO_EXPIRED_SESSION_STATE
+      raise Exception, "session expired"
+    end
+  end
+end

data/test/test_basic.rb

@@ -0,0 +1,63 @@
+$LOAD_PATH << '/home/eric/zk-clients/lib'
+require 'rubygems'
+require 'zookeeper_client'
+
+z = ZooKeeper.new("localhost:2181")
+
+puts "root: #{z.get_children("/").inspect}"
+
+path = "/testing_node"
+
+puts "working with path #{path}"
+
+stat = z.stat(path)
+puts "exists? #{stat.inspect}"
+
+unless stat.nil?
+  z.get_children(path).each do |o|
+    puts "  child object: #{o}"
+  end
+  puts "delete: #{z.delete(path, stat.version).inspect}"
+end
+
+puts "create: #{z.create(path, "initial value", 0).inspect}"
+
+value, stat = z.get(path)
+puts "current value #{value}, stat #{stat.inspect}"
+
+puts "set: #{z.set(path, "this is a test", stat.version).inspect}"
+
+value, stat = z.get(path)
+puts "new value: #{value.inspect} #{stat.inspect}"
+
+puts "delete: #{z.delete(path, stat.version).inspect}"
+
+begin
+  puts "exists? #{z.exists(path)}"
+  raise Exception, "it shouldn't exist"
+rescue ZooKeeper::NoNodeError
+  puts "doesn't exist - good, because we just deleted it!"
+end
+
+puts "trying a watcher"
+puts z
+if s = z.stat("/test"); z.delete("/test", s.version); end
+z.create("/test", "foo", 0)
+z.exists("/test") do
+  puts "callback!!!"
+end
+puts "now changing it"
+z.set("/test", "bar", 0)
+sleep 1
+puts "did the watcher say something?"
+
+puts "let's try using a lock"
+z.try_acquire("/test_lock", "this is the content of the lock file") do |have_lock|
+  puts have_lock ? "we have the lock!" : "failed to obtain lock :("
+  if have_lock
+    puts "sleeping"
+    sleep 5
+  end
+end
+puts "done with locking..."
+

data/zookeeper.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{zookeeper}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Phillip Pearson, Eric Maland, Evan Weaver"]
+  s.cert_chain = ["/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-public_cert.pem"]
+  s.date = %q{2010-02-09}
+  s.description = %q{A Ruby wrapper for the ZooKeeper C client library.}
+  s.email = %q{}
+  s.extensions = ["ext/zookeeper_c/extconf.rb"]
+  s.extra_rdoc_files = ["CHANGELOG", "README", "ext/zookeeper_c/extconf.rb", "ext/zookeeper_c/zookeeper_ruby.c", "lib/zookeeper_client.rb"]
+  s.files = ["CHANGELOG", "README", "Rakefile", "ext/zookeeper_c/extconf.rb", "ext/zookeeper_c/zookeeper_ruby.c", "lib/zookeeper_client.rb", "test/test_basic.rb", "Manifest", "zookeeper.gemspec"]
+  s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/zookeeper/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Zookeeper", "--main", "README"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{fauna}
+  s.rubygems_version = %q{1.3.5}
+  s.signing_key = %q{/Users/eweaver/p/configuration/gem_certificates/evan_weaver-original-private_key.pem}
+  s.summary = %q{A Ruby wrapper for the ZooKeeper C client library.}
+  s.test_files = ["test/test_basic.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: zookeeper
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Phillip Pearson, Eric Maland, Evan Weaver
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDLjCCAhagAwIBAgIBADANBgkqhkiG9w0BAQUFADA9MQ0wCwYDVQQDDARldmFu
+  MRgwFgYKCZImiZPyLGQBGRYIY2xvdWRidXIxEjAQBgoJkiaJk/IsZAEZFgJzdDAe
+  Fw0wNzA5MTYxMDMzMDBaFw0wODA5MTUxMDMzMDBaMD0xDTALBgNVBAMMBGV2YW4x
+  GDAWBgoJkiaJk/IsZAEZFghjbG91ZGJ1cjESMBAGCgmSJomT8ixkARkWAnN0MIIB
+  IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA5C0Io89nyApnr+PvbNFge9Vs
+  yRWAlGBUEMahpXp28VrrfXZT0rAW7JBo4PlCE3jl4nE4dzE6gAdItSycjTosrw7A
+  Ir5+xoyl4Vb35adv56TIQQXvNz+BzlqnkAY5JN0CSBRTQb6mxS3hFyD/h4qgDosj
+  R2RFVzHqSxCS8xq4Ny8uzOwOi+Xyu4w67fI5JvnPvMxqrlR1eaIQHmxnf76RzC46
+  QO5QhufjAYGGXd960XzbQsQyTDUYJzrvT7AdOfiyZzKQykKt8dEpDn+QPjFTnGnT
+  QmgJBX5WJN0lHF2l1sbv3gh4Kn1tZu+kTUqeXY6ShAoDTyvZRiFqQdwh8w2lTQID
+  AQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU+WqJz3xQ
+  XSea1hRvvHWcIMgeeC4wDQYJKoZIhvcNAQEFBQADggEBAGLZ75jfOEW8Nsl26CTt
+  JFrWxQTcQT/UljeefVE3xYr7lc9oQjbqO3FOyued3qW7TaNEtZfSHoYeUSMYbpw1
+  XAwocIPuSRFDGM4B+hgQGVDx8PMGiJKom4qLXjO40UZsR7QyN/u869Vj45LURm6h
+  MBcPeqCASI+WNprj9+uZa2kmHiitrFqqfMBNlm5IFbn9XeYSta9AHVvs5QQqV2m5
+  hIPfLqCyxsn/YgOGvo6iwyQTWyTswamaAC3HRWZxIS1sfn/Ssqa7E7oQMkv5FAXr
+  x5rKePfXINf8XTJczkl9OBEYdE9aNdJsJpXD0asLgGVwBICS5Bjohp6mizJcDC1+
+  yZ0=
+  -----END CERTIFICATE-----
+
+date: 2010-02-09 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: A Ruby wrapper for the ZooKeeper C client library.
+email: ""
+executables: []
+
+extensions: 
+- ext/zookeeper_c/extconf.rb
+extra_rdoc_files: 
+- CHANGELOG
+- README
+- ext/zookeeper_c/extconf.rb
+- ext/zookeeper_c/zookeeper_ruby.c
+- lib/zookeeper_client.rb
+files: 
+- CHANGELOG
+- README
+- Rakefile
+- ext/zookeeper_c/extconf.rb
+- ext/zookeeper_c/zookeeper_ruby.c
+- lib/zookeeper_client.rb
+- test/test_basic.rb
+- Manifest
+- zookeeper.gemspec
+has_rdoc: true
+homepage: http://blog.evanweaver.com/files/doc/fauna/zookeeper/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Zookeeper
+- --main
+- README
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: fauna
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Ruby wrapper for the ZooKeeper C client library.
+test_files: 
+- test/test_basic.rb