myelin-zookeeper_client 0.0.2

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_ruby.c

@@ -0,0 +1,198 @@
+/* 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(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,
+			  &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;
+}
+
+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);
+
+  eNoNode = rb_define_class_under(ZooKeeper, "NoNodeError", rb_eRuntimeError);
+  eBadVersion = rb_define_class_under(ZooKeeper, "BadVersionError", rb_eRuntimeError);
+
+  rb_define_const(ZooKeeper, "EPHEMERAL", INT2FIX(EPHEMERAL));
+  rb_define_const(ZooKeeper, "SEQUENCE", INT2FIX(SEQUENCE));
+
+  rb_define_const(ZooKeeper, "SESSION_EVENT", INT2FIX(SESSION_EVENT));
+  rb_define_const(ZooKeeper, "CONNECTED_STATE", INT2FIX(CONNECTED_STATE));
+  rb_define_const(ZooKeeper, "AUTH_FAILED_STATE", INT2FIX(AUTH_FAILED_STATE));
+  rb_define_const(ZooKeeper, "EXPIRED_SESSION_STATE", INT2FIX(EXPIRED_SESSION_STATE));
+}

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::EPHEMERAL | ZooKeeper::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 == SESSION_EVENT
+
+    case state
+    when CONNECTED_STATE
+      puts "ruby watcher; got an event for #{path}"
+
+    when AUTH_FAILED_STATE
+      raise Exception, "auth failure"
+    when EXPIRED_SESSION_STATE
+      raise Exception, "session expired"
+    end
+  end
+end

data/test/test_basic.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'zookeeper_client'
+
+z = ZooKeeper.new("localhost:2181")
+
+puts "root: #{z.ls("/").inspect}"
+
+path = "/testing_node"
+
+puts "working with path #{path}"
+
+stat = z.stat(path)
+puts "exists? #{stat.inspect}"
+
+unless stat.nil?
+  z.ls(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..."
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+name: myelin-zookeeper_client
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Phillip Pearson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: zookeeper_client is a Ruby library to interface with the ZooKeeper replicated object store / lock server.
+email: pp@myelin.co.nz
+executables: []
+
+extensions: 
+- ext/zookeeper_c/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- lib/zookeeper_client.rb
+- ext/zookeeper_c/zookeeper_ruby.c
+has_rdoc: false
+homepage: http://github.com/myelin/zookeeper_client
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby wrapper for the ZooKeeper C client library
+test_files: 
+- test/test_basic.rb