carlosnz-zookeeper 0.2

data/README

@@ -0,0 +1,70 @@
+zookeeper
+    by Shane Mingins
+    http://github.com/smingins/zookeeper/tree/master
+
+== DESCRIPTION:
+
+Ruby Interface to Yahoo's ZooKeeper http://zookeeper.wiki.sourceforge.net/
+
+
+== FEATURES/PROBLEMS:
+
+Work in progress -- most of the needed ZooKeeper methods have been supported.
+Queue was a hacked copy from the Java Tutorial on the site --- will refactor into a useable Recipe at some point.
+ACL issues exist in ZooKeeper that have been patched, but patch only seems to work on trunk (Revision 176).  See https://issues.apache.org/jira/browse/ZOOKEEPER-48
+
+== TODO
+
+Extend support for Ruby using ZooKeeper C API's
+
+== SYNOPSIS:
+
+Given a running ZooKeeper server listening for a client connection on port 2181:
+
+  zk = ZooKeeper.new(:host => "localhost:2181")
+  zk.create(:path => "/test", :data => "test_data")
+  
+See spec/zookeeper_spec for expected use and behaviour.
+
+== REQUIREMENTS:
+
+ZooKeeper installed and running.
+
+I built zookeeper from source with the ACL patch https://issues.apache.org/jira/secure/attachment/12384350/acl_3.patch applied
+
+For MRI version, ZooKeeper C client library (http://zookeeper.sourceforge.net/)
+
+== INSTALL:
+
+gem install smingins-zookeeper --source=http://gems.github.com/
+
+jruby -S  gem install smingins-zookeeper --source=http://gems.github.com/
+
+== TESTS:
+
+To run specs for MRI version execute extconf.rb to create makefile and then run make to create zookeeper_c.bundle, then run specs.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Shane Mingins)
+
+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/ext/zookeeper_c/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+extension_name = 'zookeeper_c'
+dir_config(extension_name)
+
+if have_library("zookeeper_mt", "zoo_set_debug_level") then
+  create_makefile(extension_name)
+else
+  puts "No ZooKeeper C client library available"
+end

data/ext/zookeeper_c/zookeeper.rb

@@ -0,0 +1,86 @@
+require 'zookeeper_c'
+
+class ZooKeeper < CZooKeeper
+  
+  def initialize(args)
+    args  = {:host => args} unless args.is_a?(Hash)
+    host    = args[:host]
+    # timeout = args[:timeout] || DEFAULTS[:timeout]
+    # watcher = args[:watcher] || DefaultWatcher.new
+    # super(host, timeout, watcher)
+    super(host)
+    @watchers = {} # path => [ block, block, ... ]
+  end
+  
+  def connected?
+    state == CONNECTED_STATE
+  end
+  
+  def closed?
+    true # we hope TODO fix this
+  end
+  
+  def close
+    # TODO
+  end
+  
+  def create(args)
+    path     = args[:path]
+    data     = args[:data]
+    flags    = 0
+    flags    |= EPHEMERAL if args[:ephemeral]
+    flags    |= SEQUENCE  if args[:sequence]
+    super(path, data, flags)
+  end
+
+  def exists(path, &blk)
+    (@watchers[path] ||= []) << blk if blk
+    Stat.new(super(path, !!blk))
+  rescue NoNodeError
+    return nil
+  end
+  
+  def get(args)
+    args  = {:path => args} unless args.is_a?(Hash)
+    path     = args[:path]
+    watch    = args[:watch] || false
+    callback = args[:callback]
+    context  = args[:context]
+    
+    value, stat = super(path)
+    [value, Stat.new(stat)]
+  rescue NoNodeError
+    raise KeeperException::NoNode
+  end
+  
+  def set(args)
+    path     = args[:path]
+    data     = args[:data]
+    version  = args[:version] || -1
+    callback = args[:callback]
+    context  = args[:context]
+  
+    super(path, data, version)
+  end
+
+  def delete(args)
+    args = {:path => args} unless args.is_a?(Hash)
+    path     = args[:path]
+    version  = args[:version] || -1
+    callback = args[:callback]
+    context  = args[:context]
+    
+    super(path, version)
+  end
+
+  def children(args)
+    args    = {:path => args} unless args.is_a?(Hash)
+    path     = args[:path]
+    watch    = args[:watch] || false
+    callback = args[:callback]
+    context  = args[:context]
+
+    ls(path)
+  end
+  
+end

data/ext/zookeeper_c/zookeeper_ruby.c

@@ -0,0 +1,206 @@
+/* Ruby wrapper for the ZooKeeper C API
+ * Phillip Pearson <pp@myelin.co.nz>
+ */
+
+#define THREADED
+
+#include "ruby.h"
+
+#include "c-client-src/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) {
+  VALUE self, watcher_id;
+
+  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));
+}
+
+static void check_errors(int rc) {
+  switch (rc) {
+  case ZOK: /* all good! */ break;
+  case ZBADARGUMENTS: rb_raise(rb_eRuntimeError, "invalid input parameters");
+  case ZMARSHALLINGERROR: rb_raise(rb_eRuntimeError, "failed to marshall a request; possibly out of memory");
+  case ZOPERATIONTIMEOUT: rb_raise(rb_eRuntimeError, "failed to flush the buffers within the specified timeout");
+  case ZCONNECTIONLOSS: rb_raise(rb_eRuntimeError, "a network error occured while attempting to send request to server");
+  case ZSYSTEMERROR: rb_raise(rb_eRuntimeError, "a system (OS) error occured; it's worth checking errno to get details");
+  case ZNONODE: rb_raise(eNoNode, "the node does not exist");
+  case ZNOAUTH: rb_raise(rb_eRuntimeError, "the client does not have permission");
+  case ZBADVERSION: rb_raise(eBadVersion, "expected version does not match actual version");
+  case ZINVALIDSTATE: rb_raise(rb_eRuntimeError, "zhandle state is either SESSION_EXPIRED_STATE or AUTH_FAILED_STATE");
+  case ZNODEEXISTS: rb_raise(rb_eRuntimeError, "the node already exists");
+  case ZNOCHILDRENFOREPHEMERALS: rb_raise(rb_eRuntimeError, "cannot create children of ephemeral nodes");
+  case ZINVALIDACL: rb_raise(rb_eRuntimeError, "invalid ACL specified");
+  default: rb_raise(rb_eRuntimeError, "unknown error returned from zookeeper: %d", rc);
+  }
+}
+
+static void free_zk_rb_data(struct zk_rb_data* ptr) {
+  /*fprintf(stderr, "free zk_rb_data at %p\n", 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;
+}
+
+static VALUE method_ls(VALUE self, VALUE path) {
+  struct zk_rb_data* zk;
+  struct String_vector strings;
+  int i;
+  VALUE output;
+
+  Check_Type(path, T_STRING);
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, 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 zk_rb_data* zk;
+  struct Stat stat;
+
+  Check_Type(path, T_STRING);
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, 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) {
+  struct zk_rb_data* zk;
+  char realpath[10240];
+
+  Check_Type(path, T_STRING);
+  Check_Type(value, T_STRING);
+  Check_Type(flags, T_FIXNUM);
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk);
+
+  check_errors(zoo_create(zk->zh, RSTRING(path)->ptr, RSTRING(value)->ptr, RSTRING(value)->len,
+			  &ZOO_OPEN_ACL_UNSAFE, FIX2INT(flags), realpath, 10240));
+
+  return rb_str_new2(realpath);
+}
+
+static VALUE method_delete(VALUE self, VALUE path, VALUE version) {
+  struct zk_rb_data* zk;
+
+  Check_Type(path, T_STRING);
+  Check_Type(version, T_FIXNUM);
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk);
+
+  check_errors(zoo_delete(zk->zh, RSTRING(path)->ptr, FIX2INT(version)));
+
+  return Qnil;
+}
+
+static VALUE method_get(VALUE self, VALUE path) {
+  struct zk_rb_data* zk;
+  char data[1024];
+  int data_len = 1024;
+  struct Stat stat;
+
+  Check_Type(path, T_STRING);
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk);
+  
+  check_errors(zoo_get(zk->zh, RSTRING(path)->ptr, 0, data, &data_len, &stat));
+  /*printf("got some data; version=%d\n", stat.version);*/
+
+  return rb_ary_new3(2,
+		     rb_str_new(data, data_len),
+		     array_from_stat(&stat));
+}
+
+
+static VALUE method_set(VALUE self, VALUE path, VALUE data, VALUE version) {
+  struct zk_rb_data* zk;
+
+  Check_Type(path, T_STRING);
+  Check_Type(data, T_STRING);
+  Check_Type(version, T_FIXNUM);
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk);
+  
+  check_errors(zoo_set(zk->zh, RSTRING(path)->ptr, RSTRING(data)->ptr, RSTRING(data)->len, FIX2INT(version)));
+
+  return Qnil;
+}
+
+static VALUE method_state(VALUE self) {
+  struct zk_rb_data* zk;
+  Data_Get_Struct(rb_iv_get(self, "@data"), struct zk_rb_data, zk);
+  return INT2NUM(zoo_state(zk->zh));
+}
+
+void Init_zookeeper_c() {
+  ZooKeeper = rb_define_class("CZooKeeper", rb_cObject);
+  rb_define_method(ZooKeeper, "initialize", method_initialize, 1);
+  rb_define_method(ZooKeeper, "ls", method_ls, 1);
+  rb_define_method(ZooKeeper, "exists", method_exists, 2);
+  rb_define_method(ZooKeeper, "create", method_create, 3);
+  rb_define_method(ZooKeeper, "delete", method_delete, 2);
+  rb_define_method(ZooKeeper, "get", method_get, 1);
+  rb_define_method(ZooKeeper, "set", method_set, 3);
+  rb_define_method(ZooKeeper, "state", method_state, 0);
+
+  eNoNode = rb_define_class_under(ZooKeeper, "NoNodeError", rb_eRuntimeError);
+  eBadVersion = rb_define_class_under(ZooKeeper, "BadVersionError", rb_eRuntimeError);
+
+  rb_define_const(ZooKeeper, "EPHEMERAL", INT2FIX(ZOO_EPHEMERAL));
+  rb_define_const(ZooKeeper, "SEQUENCE", INT2FIX(ZOO_SEQUENCE));
+
+  rb_define_const(ZooKeeper, "SESSION_EVENT", INT2FIX(ZOO_SESSION_EVENT));
+  rb_define_const(ZooKeeper, "CONNECTED_STATE", INT2FIX(ZOO_CONNECTED_STATE));
+  rb_define_const(ZooKeeper, "AUTH_FAILED_STATE", INT2FIX(ZOO_AUTH_FAILED_STATE));
+  rb_define_const(ZooKeeper, "EXPIRED_SESSION_STATE", INT2FIX(ZOO_EXPIRED_SESSION_STATE));
+}

data/lib/zookeeper.rb

@@ -0,0 +1,22 @@
+if defined?(JRUBY_VERSION)
+  require 'zookeeper_j/zookeeper'
+else
+  require 'zookeeper_c/zookeeper'
+end
+
+class ZooKeeper
+  DEFAULTS = {
+    :timeout => 10000
+  }
+  
+end
+
+require 'zookeeper/id'
+require 'zookeeper/permission'
+require 'zookeeper/acl'
+require 'zookeeper/stat'
+require 'zookeeper/keeper_exception'
+require 'zookeeper/watcher_event'
+require 'zookeeper/sync_primitive'
+require 'zookeeper/queue'
+require 'zookeeper/logging'

data/lib/zookeeper/acl.rb

@@ -0,0 +1,19 @@
+class ZooKeeper
+  class ACL
+    attr_reader :permissions, :id
+    
+    def initialize(permissions, id)
+      @permissions, @id = permissions, id
+    end
+    
+    def ==(obj)
+      self.permissions == obj.permissions &&
+      self.id == obj.id
+    end
+
+   OPEN_ACL_UNSAFE = [ACL.new(Permission::ALL,  Id::ANYONE_ID_UNSAFE)]    
+   READ_ACL_UNSAFE = [ACL.new(Permission::READ, Id::ANYONE_ID_UNSAFE)]    
+   CREATOR_ALL_ACL = [ACL.new(Permission::ALL | Permission::ADMIN, Id::AUTH_IDS)]    
+
+  end
+end

data/lib/zookeeper/id.rb

@@ -0,0 +1,18 @@
+class ZooKeeper
+  class Id
+    attr_reader :scheme, :identification 
+
+    def initialize(scheme, id)
+      @scheme, @identification = scheme, id
+    end
+
+    def ==(obj)
+      self.scheme == obj.scheme &&
+      self.identification == obj.identification
+    end
+    
+
+    ANYONE_ID_UNSAFE = Id.new("world", "anyone")
+    AUTH_IDS         = Id.new("auth", "")
+  end
+end

data/lib/zookeeper/keeper_exception.rb

@@ -0,0 +1,71 @@
+class KeeperException < Exception
+
+  OK                      = 0
+  # System and server-side errors
+  SYSTEMERROR             = -1
+  RUNTIMEINCONSISTENCY    = SYSTEMERROR - 1
+  DATAINCONSISTENCY       = SYSTEMERROR - 2
+  CONNECTIONLOSS          = SYSTEMERROR - 3
+  MARSHALLINGERROR        = SYSTEMERROR - 4
+  UNIMPLEMENTED           = SYSTEMERROR - 5
+  OPERATIONTIMEOUT        = SYSTEMERROR - 6
+  BADARGUMENTS            = SYSTEMERROR - 7
+  # API errors  
+  APIERROR                = -100; 
+  NONODE                  = APIERROR - 1 # Node does not exist
+  NOAUTH                  = APIERROR - 2 # Current operation not permitted
+  BADVERSION              = APIERROR - 3 # Version conflict
+  NOCHILDRENFOREPHEMERALS = APIERROR - 8
+  NODEEXISTS              = APIERROR - 10
+  NOTEMPTY                = APIERROR - 11
+  SESSIONEXPIRED          = APIERROR - 12
+  INVALIDCALLBACK         = APIERROR - 13
+  INVALIDACL              = APIERROR - 14
+  AUTHFAILED              = APIERROR - 15 # client authentication failed
+  
+  class SystemError             < KeeperException; end
+  class RunTimeInconsistency    < KeeperException; end
+  class DataInconsistency       < KeeperException; end
+  class ConnectionLoss          < KeeperException; end
+  class MarshallingError        < KeeperException; end
+  class Unimplemented           < KeeperException; end
+  class OperationTimeOut        < KeeperException; end
+  class BadArguments            < KeeperException; end
+  class ApiError                < KeeperException; end
+  class NoNode                  < KeeperException; end
+  class NoAuth                  < KeeperException; end
+  class BadVersion              < KeeperException; end
+  class NoChildrenForEphemerals < KeeperException; end
+  class NodeExists              < KeeperException; end
+  class NotEmpty                < KeeperException; end
+  class SessionExpired          < KeeperException; end
+  class InvalidCallback         < KeeperException; end
+  class InvalidACL              < KeeperException; end
+  class AuthFailed              < KeeperException; end
+  
+  def self.by_code(code)
+    case code
+    when OK: Ok
+    when SYSTEMERROR: SystemError
+    when RUNTIMEINCONSISTENCY: RunTimeInconsistency
+    when DATAINCONSISTENCY: DataInconsistency
+    when CONNECTIONLOSS: ConnectionLoss
+    when MARSHALLINGERROR: MarshallingError
+    when UNIMPLEMENTED: Unimplemented
+    when OPERATIONTIMEOUT: OperationTimeOut
+    when BADARGUMENTS: BadArguments
+    when APIERROR: ApiError
+    when NONODE: NoNode
+    when NOAUTH: NoAuth
+    when BADVERSION: BadVersion
+    when NOCHILDRENFOREPHEMERALS: NoChildrenForEphemerals 
+    when NODEEXISTS: NodeExists              
+    when NOTEMPTY: NotEmpty                
+    when SESSIONEXPIRED: SessionExpired          
+    when INVALIDCALLBACK: InvalidCallback         
+    when INVALIDACL: InvalidACL
+    when AUTHFAILED: AuthFailed
+    else Exception.new("no exception defined for code #{code}")
+    end
+  end
+end

data/lib/zookeeper/logging.rb

@@ -0,0 +1,5 @@
+require 'logger'
+
+class ZooKeeper
+  $LOG = Logger.new($stderr)  
+end

data/lib/zookeeper/permission.rb

@@ -0,0 +1,12 @@
+class ZooKeeper
+  
+  module Permission
+    READ   = 1 << 0
+    WRITE  = 1 << 1
+    CREATE = 1 << 2
+    DELETE = 1 << 3
+    ADMIN  = 1 << 4
+    ALL    = READ | WRITE | CREATE | DELETE
+  end
+  
+end

data/lib/zookeeper/queue.rb

@@ -0,0 +1,57 @@
+class ZooKeeper
+
+  class Queue < SyncPrimitive
+
+    def initialize(address, name)
+      super(address)
+      until @@zk.connected? do; end
+      @root = name
+      if @@zk && @@zk.exists(@root).nil?
+        @@zk.create(:path => @root, :data => "") 
+      end
+    rescue Exception => e
+     	$LOG.error "Exception instantiating queue #{e.message}"
+    end
+
+    def produce(data)
+      @@zk.create(:path => "#{@root}/element", :data => data, :sequence => true) and return true
+    end
+
+    def consume
+      @@monitor.synchronize do
+        loop do
+          list = @@zk.children(:path => @root, :watch => true)
+
+          if list.empty?
+           	$LOG.info 'Queue empty, going to wait'
+            @@consume.wait
+          else
+            minimum_node = list.inject {|e1, e2| e2.delete("element").to_i < e1.delete("element").to_i ? e2 : e1 }
+            data, stat = @@zk.get("#{@root}/#{minimum_node}")
+            @@zk.delete(:path => "#{@root}/#{minimum_node}", :version => 0)
+            return data
+          end
+        end
+      end
+    end
+    
+    def empty?
+      @@zk.children(:path => @root).empty?
+    end
+    
+    def stop
+      @@zk.close
+      @@zk = nil
+    end
+    
+    def stopped?
+      @@zk.nil?
+    end
+    
+    def active?
+      @@zk.connected?
+    end
+
+  end
+
+end

data/lib/zookeeper/stat.rb

@@ -0,0 +1,11 @@
+class ZooKeeper
+  class Stat
+    attr_reader :created_zxid, :last_modified_zxid, :created_time, :last_modified_time, :version, :child_list_version,
+                :acl_list_version, :ephemeral_owner     
+
+    def initialize(attributes)
+      @created_zxid, @last_modified_zxid, @created_time, @last_modified_time, @version, 
+      @child_list_version, @acl_list_version, @ephemeral_owner = attributes
+    end
+  end
+end

data/lib/zookeeper/sync_primitive.rb

@@ -0,0 +1,32 @@
+require 'monitor'
+
+class ZooKeeper
+
+  class SyncPrimitive
+
+    @@zk =nil
+    @@monitor = nil
+    @@consume = nil
+
+    attr_accessor :root
+
+    def initialize(address)
+      unless @@zk 
+      	$LOG.info 'Connecting Zookeeper Client'
+        @@zk = ZooKeeper.new(:host => address, :timeout => 10000, :watcher => self)
+        @@monitor = Monitor.new
+        @@consume = @@monitor.new_cond
+      	$LOG.info 'Zookeeper Client Started'
+      end
+    rescue Exception => e
+    	$LOG.error "Exception connecting Zookeeper to #{address} #{e.message}"
+      @@zk = nil
+    end
+
+    def process(event)
+      @@monitor.synchronize { @@consume.signal }
+    end
+
+  end
+
+end

data/lib/zookeeper/watcher_event.rb

@@ -0,0 +1,24 @@
+class ZooKeeper
+  class WatcherEvent
+    attr_reader :type, :state, :path
+    
+    def initialize(type, state, path) 
+      @type, @state, @path = type, state, path
+    end
+    
+    # constants for connection states
+    KeeperStateChanged         =  0
+    KeeperStateUnknown         = -1
+    KeeperStateDisconnected    =  0
+    KeeperStateNoSyncConnected =  1
+    KeeperStateSyncConnected   =  3
+    KeeperStateExpired         = -112
+
+    # constants for event types
+    EventNone                  = -1
+    EventNodeCreated           = 1
+    EventNodeDeleted           = 2
+    EventNodeDataChanged       = 3
+    EventNodeChildrenChanged   = 4
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: carlosnz-zookeeper
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- Shane Mingins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-13 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A Ruby client interface to the Java ZooKeeper server.
+email: smingins@elctech.com
+executables: []
+
+extensions: 
+- ext/zookeeper_c/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- README
+- lib/zookeeper.rb
+- lib/zookeeper/acl.rb
+- lib/zookeeper/id.rb
+- lib/zookeeper/keeper_exception.rb
+- lib/zookeeper/logging.rb
+- lib/zookeeper/permission.rb
+- lib/zookeeper/stat.rb
+- lib/zookeeper/watcher_event.rb
+- lib/zookeeper/sync_primitive.rb
+- lib/zookeeper/queue.rb
+- ext/zookeeper_c/zookeeper_ruby.c
+- ext/zookeeper_c/zookeeper.rb
+has_rdoc: true
+homepage: 
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: A Ruby client interface to the Java ZooKeeper server.
+test_files: []
+