zookeeper 0.4.2 → 0.4.3

data/CHANGELOG

@@ -1,3 +1,6 @@
+v0.4.3 Fix a handful of memory-related bugs, fix SIGSEGV on master change,
+       reduce latency of event handling, fix compilation on OSX.
+
 v0.4.2 Add options to Zookeeper#initialize, silence most Zookeeper logs.
 
 v0.4.1 Upgrade to ZooKeeper 3.3.2

data/Rakefile

@@ -4,7 +4,7 @@ Echoe.new("zookeeper") do |p|
   p.author = "Phillip Pearson, Eric Maland, Evan Weaver, Brian Wickman"
   p.project = "fauna"
   p.summary = "An interface to the Zookeeper distributed configuration server."
-  p.url = "http://blog.evanweaver.com/files/doc/fauna/zookeeper/"
+  p.url = "https://github.com/twitter/zookeeper"
   p.docs_host = "blog.evanweaver.com:~/www/bax/public/files/doc/"
   p.clean_pattern += ["ext/lib", "ext/include", "ext/c", "ext/bin", "ext/conftest.dSYM"]
   p.rdoc_pattern = /README|TODO|LICENSE|CHANGELOG|BENCH|COMPAT|zookeeper_c.c|zookeeper.rb/

data/ext/extconf.rb

@@ -15,10 +15,11 @@ if ENV['DEBUG']
   puts "Setting debug flags."
   $CFLAGS << " -O0 -ggdb -DHAVE_DEBUG"
   $EXTRA_CONF = " --enable-debug"
+  $CFLAGS.gsub!(/ -O[^0] /, ' ')
 end
 
 $includes = " -I#{HERE}/include"
-$libraries = " -L#{HERE}/lib"
+$libraries = " -L#{HERE}/lib -L#{RbConfig::CONFIG['libdir']}"
 $CFLAGS = "#{$includes} #{$libraries} #{$CFLAGS}"
 $LDFLAGS = "#{$libraries} #{$LDFLAGS}"
 $LIBPATH = ["#{HERE}/lib"]
@@ -33,9 +34,9 @@ Dir.chdir(HERE) do
     raise "'#{cmd}' failed" unless system(cmd)
 
     Dir.chdir(BUNDLE_PATH) do        
-      puts(cmd = "env CFLAGS='-fPIC #{$CFLAGS}' LDFLAGS='-fPIC #{$LDFLAGS}' ./configure --prefix=#{HERE} --without-cppunit --disable-dependency-tracking #{$EXTRA_CONF} 2>&1")
+      puts(cmd = "env CC=gcc CXX=g++ CFLAGS='-fPIC #{$CFLAGS}' LDFLAGS='-fPIC #{$LDFLAGS}' ./configure --prefix=#{HERE} --without-cppunit --disable-dependency-tracking #{$EXTRA_CONF} 2>&1")
       raise "'#{cmd}' failed" unless system(cmd)
-      puts(cmd = "make CXXFLAGS='#{$CXXFLAGS}' || true 2>&1")
+      puts(cmd = "make CXXFLAGS='#{$CXXFLAGS}' CFLAGS='-fPIC #{$CFLAGS}' LDFLAGS='-fPIC #{$LDFLAGS}' || true 2>&1")
       raise "'#{cmd}' failed" unless system(cmd)
       puts(cmd = "make install || true 2>&1")
       raise "'#{cmd}' failed" unless system(cmd)

data/ext/zookeeper_c.c

@@ -16,6 +16,7 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <unistd.h>
 
 #include "zookeeper_lib.h"
 
@@ -37,21 +38,34 @@ typedef enum {
 #define IS_SYNC(zkrbcall) ((zkrbcall)==SYNC || (zkrbcall)==SYNC_WATCH)
 #define IS_ASYNC(zkrbcall) ((zkrbcall)==ASYNC || (zkrbcall)==ASYNC_WATCH)
 
-static void free_zkrb_instance_data(struct zkrb_instance_data* ptr) {
-#warning [wickman] TODO: fire off warning if queue is not empty
-  if (ptr->zh && zoo_state(ptr->zh) == ZOO_CONNECTED_STATE) {
-    zookeeper_close(ptr->zh);
+static int destroy_zkrb_instance(struct zkrb_instance_data* ptr) {
+  int rv = ZOK;
+
+  if (ptr->zh) {
+    const void *ctx = zoo_get_context(ptr->zh);
+    /* Note that after zookeeper_close() returns, ZK handle is invalid */
+    rv = zookeeper_close(ptr->zh);
+    free((void *) ctx);
   }
+
+#warning [wickman] TODO: fire off warning if queue is not empty
   if (ptr->queue) zkrb_queue_free(ptr->queue);
+
+  ptr->zh = NULL;
   ptr->queue = NULL;
+  return rv;
+}
+
+static void free_zkrb_instance_data(struct zkrb_instance_data* ptr) {
+  destroy_zkrb_instance(ptr);
 }
 
 static void print_zkrb_instance_data(struct zkrb_instance_data* ptr) {
-  fprintf(stderr, "zkrb_instance_data (%x) {\n", ptr);
-  fprintf(stderr, "   zh = %x\n",           ptr->zh);
+  fprintf(stderr, "zkrb_instance_data (%p) {\n", ptr);
+  fprintf(stderr, "   zh = %p\n",           ptr->zh);
   fprintf(stderr, "     { state = %d }\n",  zoo_state(ptr->zh));
   fprintf(stderr, "   id = %llx\n",         ptr->myid.client_id);
-  fprintf(stderr, "    q = %x\n",           ptr->queue);
+  fprintf(stderr, "    q = %p\n",           ptr->queue);
   fprintf(stderr, "}\n");
 }
 
@@ -78,7 +92,7 @@ static VALUE method_init(int argc, VALUE* argv, VALUE self) {
   }
 
   VALUE data;
-  struct zkrb_instance_data *zk_local_ctx = NULL;
+  struct zkrb_instance_data *zk_local_ctx;
   data = Data_Make_Struct(Zookeeper,
            struct zkrb_instance_data,
            0,
@@ -110,9 +124,11 @@ static VALUE method_init(int argc, VALUE* argv, VALUE self) {
   return Qnil;
 }
 
-#define FETCH_DATA_PTR(x, y) \
-  struct zkrb_instance_data * y; \
-  Data_Get_Struct(rb_iv_get(x, "@data"), struct zkrb_instance_data, y)
+#define FETCH_DATA_PTR(x, y)                                            \
+  struct zkrb_instance_data * y;                                        \
+  Data_Get_Struct(rb_iv_get(x, "@data"), struct zkrb_instance_data, y); \
+  if ((y)->zh == NULL)                                                  \
+    rb_raise(rb_eRuntimeError, "zookeeper handle is closed")
 
 #define STANDARD_PREAMBLE(self, zk, reqid, path, async, watch, cb_ctx, w_ctx, call_type) \
   if (TYPE(reqid) != T_FIXNUM && TYPE(reqid) != T_BIGNUM) {             \
@@ -122,6 +138,8 @@ static VALUE method_init(int argc, VALUE* argv, VALUE self) {
   Check_Type(path, T_STRING);                                           \
   struct zkrb_instance_data * zk;                                       \
   Data_Get_Struct(rb_iv_get(self, "@data"), struct zkrb_instance_data, zk); \
+  if (!zk->zh)                                                          \
+    rb_raise(rb_eRuntimeError, "zookeeper handle is closed");           \
   zkrb_calling_context* cb_ctx =                                        \
     (async != Qfalse && async != Qnil) ?                                \
        zkrb_calling_context_alloc(NUM2LL(reqid), zk->queue) :           \
@@ -206,7 +224,6 @@ static VALUE method_create(VALUE self, VALUE reqid, VALUE path, VALUE data, VALU
   VALUE watch = Qfalse;
   STANDARD_PREAMBLE(self, zk, reqid, path, async, watch, data_ctx, watch_ctx, call_type);
   
-  struct Stat stat;
   if (data != Qnil) Check_Type(data, T_STRING);
   Check_Type(flags, T_FIXNUM);
   const char *data_ptr = (data == Qnil) ? NULL : RSTRING_PTR(data);
@@ -220,11 +237,9 @@ static VALUE method_create(VALUE self, VALUE reqid, VALUE path, VALUE data, VALU
   switch (call_type) {
     case SYNC:
       rc = zoo_create(zk->zh, RSTRING_PTR(path), data_ptr, data_len, aclptr, FIX2INT(flags), realpath, sizeof(realpath));
-      if (aclptr != NULL) deallocate_ACL_vector(aclptr);
       break;
     case ASYNC:
       rc = zoo_acreate(zk->zh, RSTRING_PTR(path), data_ptr, data_len, aclptr, FIX2INT(flags), zkrb_string_callback, data_ctx);
-      if (aclptr != NULL) deallocate_ACL_vector(aclptr);
       break;
     default:
       /* TODO(wickman) raise proper argument error */
@@ -232,6 +247,11 @@ static VALUE method_create(VALUE self, VALUE reqid, VALUE path, VALUE data, VALU
       break;
   }
 
+  if (aclptr) {
+    deallocate_ACL_vector(aclptr);
+    free(aclptr);
+  }
+
   VALUE output = rb_ary_new();
   rb_ary_push(output, INT2FIX(rc));
   if (IS_SYNC(call_type) && rc == ZOK) {
@@ -295,7 +315,10 @@ static VALUE method_get(VALUE self, VALUE reqid, VALUE path, VALUE async, VALUE
   VALUE output = rb_ary_new();
   rb_ary_push(output, INT2FIX(rc));
   if (IS_SYNC(call_type) && rc == ZOK) {
-    rb_ary_push(output, rb_str_new(data, data_len));
+    if (data_len == -1)
+      rb_ary_push(output, Qnil);        /* No data associated with path */
+    else
+      rb_ary_push(output, rb_str_new(data, data_len));
     rb_ary_push(output, zkrb_stat_to_rarray(&stat));
   }
   free(data);
@@ -344,11 +367,9 @@ static VALUE method_set_acl(VALUE self, VALUE reqid, VALUE path, VALUE acls, VAL
   switch (call_type) {
     case SYNC:
       rc = zoo_set_acl(zk->zh, RSTRING_PTR(path), FIX2INT(version), aclptr);
-      deallocate_ACL_vector(aclptr);
       break;
     case ASYNC:
       rc = zoo_aset_acl(zk->zh, RSTRING_PTR(path), FIX2INT(version), aclptr, zkrb_void_callback, data_ctx);
-      deallocate_ACL_vector(aclptr);
       break;
     default:
       /* TODO(wickman) raise proper argument error */
@@ -356,6 +377,9 @@ static VALUE method_set_acl(VALUE self, VALUE reqid, VALUE path, VALUE acls, VAL
       break;
   }
 
+  deallocate_ACL_vector(aclptr);
+  free(aclptr);
+
   return INT2FIX(rc);
 }
 
@@ -380,32 +404,57 @@ static VALUE method_get_acl(VALUE self, VALUE reqid, VALUE path, VALUE async) {
       break;
   }
 
-  // do we need to deallocate the strings in the acl vector????
   VALUE output = rb_ary_new();
   rb_ary_push(output, INT2FIX(rc));
   if (IS_SYNC(call_type) && rc == ZOK) {
     rb_ary_push(output, zkrb_acl_vector_to_ruby(&acls));
     rb_ary_push(output, zkrb_stat_to_rarray(&stat));
+    deallocate_ACL_vector(&acls);
   }
   return output;
 }
 
 static VALUE method_get_next_event(VALUE self) {
+  char buf[64];
   FETCH_DATA_PTR(self, zk);
-  if (zk->queue == NULL) return Qnil;
-  
-  zkrb_event_t *event = zkrb_dequeue(zk->queue);
-  if (event == NULL) return Qnil;
 
-  VALUE hash = zkrb_event_to_ruby(event);
-  zkrb_event_free(event);
-  return hash;
+  for (;;) {
+    zkrb_event_t *event = zkrb_dequeue(zk->queue, 1);
+
+    /*
+     * If no events found, wait for an event by using rb_thread_select() on the
+     * queue's pipe. Note that the ZK handle might be closed while we're
+     * waiting; if this happens, the rb_thread_select() will fail, and we can't
+     * safely touch the "zk" instance handle.
+     */
+    if (event == NULL) {
+      int fd = zk->queue->pipe_read;
+      fd_set rset;
+
+      FD_ZERO(&rset);
+      FD_SET(fd, &rset);
+
+      if (rb_thread_select(fd + 1, &rset, NULL, NULL, NULL) == -1)
+        rb_raise(rb_eRuntimeError, "select failed: %d", errno);
+
+      if (read(fd, buf, sizeof(buf)) == -1)
+        rb_raise(rb_eRuntimeError, "read failed: %d", errno);
+
+      continue;
+    }
+
+    VALUE hash = zkrb_event_to_ruby(event);
+    zkrb_event_free(event);
+    return hash;
+  }
 }
 
 static VALUE method_has_events(VALUE self) {
+  VALUE rb_event;
   FETCH_DATA_PTR(self, zk);
-  if (zk->queue == NULL) return Qfalse;
-  return zkrb_peek(zk->queue) != NULL ? Qtrue : Qfalse;
+
+  rb_event = zkrb_peek(zk->queue) != NULL ? Qtrue : Qfalse;
+  return rb_event;
 }
 
 static VALUE method_client_id(VALUE self) {
@@ -416,7 +465,9 @@ static VALUE method_client_id(VALUE self) {
 
 static VALUE method_close(VALUE self) {
   FETCH_DATA_PTR(self, zk);
-  int rc = zookeeper_close(zk->zh);
+
+  /* Note that after zookeeper_close() returns, ZK handle is invalid */
+  int rc = destroy_zkrb_instance(zk);
   return INT2FIX(rc);
 }
 
@@ -487,7 +538,6 @@ static void zkrb_define_methods(void) {
 }
 void Init_zookeeper_c() {
   ZKRBDebugging = 0;
-
   /* initialize Zookeeper class */
   Zookeeper = rb_define_class("CZookeeper", rb_cObject);
   zkrb_define_methods();

data/ext/zookeeper_lib.c

@@ -14,58 +14,98 @@ wickman@twitter.com
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <pthread.h>
+#include <unistd.h>
 
 #define GET_SYM(str) ID2SYM(rb_intern(str))
 
 int ZKRBDebugging;
 
+pthread_mutex_t zkrb_q_mutex = PTHREAD_MUTEX_INITIALIZER;
+
 /* push/pop is a misnomer, this is a queue */
-#warning [wickman] TODO enqueue, peek, dequeue => pthread_mutex_lock
 void zkrb_enqueue(zkrb_queue_t *q, zkrb_event_t *elt) {
+  pthread_mutex_lock(&zkrb_q_mutex);
+  if (q == NULL || q->tail == NULL) {
+    pthread_mutex_unlock(&zkrb_q_mutex);
+    return;
+  }
   q->tail->event = elt;
   q->tail->next = (struct zkrb_event_ll_t *) malloc(sizeof(struct zkrb_event_ll_t));
   q->tail = q->tail->next;
   q->tail->event = NULL;
   q->tail->next = NULL;
+  ssize_t ret = write(q->pipe_write, "0", 1);   /* Wake up Ruby listener */
+  pthread_mutex_unlock(&zkrb_q_mutex);
+  if (ret == -1)
+    rb_raise(rb_eRuntimeError, "write to pipe failed: %d", errno);
 }
 
 zkrb_event_t * zkrb_peek(zkrb_queue_t *q) {
-  if (q->head != NULL && q->head->event != NULL)
-    return q->head->event;
-  return NULL;
+  pthread_mutex_lock(&zkrb_q_mutex);
+  zkrb_event_t *event = NULL;
+  if (q != NULL && q->head != NULL && q->head->event != NULL) {
+    event = q->head->event;
+  }
+  pthread_mutex_unlock(&zkrb_q_mutex);
+  return event;
 }
 
-zkrb_event_t* zkrb_dequeue(zkrb_queue_t *q) {
-  if (q->head == NULL || q->head->event == NULL) {
+zkrb_event_t* zkrb_dequeue(zkrb_queue_t *q, int need_lock) {
+  if (need_lock)
+    pthread_mutex_lock(&zkrb_q_mutex);
+  if (q == NULL || q->head == NULL || q->head->event == NULL) {
+    if (need_lock)
+      pthread_mutex_unlock(&zkrb_q_mutex);
     return NULL;
   } else {
     struct zkrb_event_ll_t *old_root = q->head;
     q->head = q->head->next;
     zkrb_event_t *rv = old_root->event;
     free(old_root);
+    if (need_lock)
+      pthread_mutex_unlock(&zkrb_q_mutex);
     return rv;
   }
 }
 
 zkrb_queue_t *zkrb_queue_alloc(void) {
+  int pfd[2];
+  if (pipe(pfd) == -1)
+    rb_raise(rb_eRuntimeError, "create of pipe failed: %d", errno);
+
+  pthread_mutex_lock(&zkrb_q_mutex);
   zkrb_queue_t *rq = malloc(sizeof(zkrb_queue_t));
   rq->head = malloc(sizeof(struct zkrb_event_ll_t));
   rq->head->event = NULL; rq->head->next = NULL;
   rq->tail = rq->head;
+  rq->pipe_read = pfd[0];
+  rq->pipe_write = pfd[1];
+  pthread_mutex_unlock(&zkrb_q_mutex);
+
   return rq;
 }
 
 void zkrb_queue_free(zkrb_queue_t *queue) {
-  if (queue == NULL) return;
-  zkrb_event_t *elt = NULL;
-  while ((elt = zkrb_dequeue(queue)) != NULL) {
+  pthread_mutex_lock(&zkrb_q_mutex);
+  if (queue == NULL) {
+    pthread_mutex_unlock(&zkrb_q_mutex);
+    return;
+  }
+
+  zkrb_event_t *elt;
+  while ((elt = zkrb_dequeue(queue, 0)) != NULL) {
     zkrb_event_free(elt);
   }
+  free(queue->head);
+  close(queue->pipe_read);
+  close(queue->pipe_write);
   free(queue);
+  pthread_mutex_unlock(&zkrb_q_mutex);
 }
 
 zkrb_event_t *zkrb_event_alloc(void) {
-  zkrb_event_t *rv  = (zkrb_event_t *) malloc(sizeof(zkrb_event_t));
+  zkrb_event_t *rv = (zkrb_event_t *) malloc(sizeof(zkrb_event_t));
   return rv;
 }
 
@@ -75,16 +115,19 @@ void zkrb_event_free(zkrb_event_t *event) {
       struct zkrb_data_completion *data_ctx = event->completion.data_completion;
       free(data_ctx->data);
       free(data_ctx->stat);
+      free(data_ctx);
       break;
     }
     case ZKRB_STAT: {
       struct zkrb_stat_completion *stat_ctx = event->completion.stat_completion;
       free(stat_ctx->stat);
+      free(stat_ctx);
       break;
     }
     case ZKRB_STRING: {
       struct zkrb_string_completion *string_ctx = event->completion.string_completion;
       free(string_ctx->value);
+      free(string_ctx);
       break;
     }
     case ZKRB_STRINGS: {
@@ -92,6 +135,7 @@ void zkrb_event_free(zkrb_event_t *event) {
       int k;
       for (k = 0; k < strings_ctx->values->count; ++k) free(strings_ctx->values->data[k]);
       free(strings_ctx->values);
+      free(strings_ctx);
       break;
     }
     case ZKRB_STRINGS_STAT: {
@@ -100,6 +144,7 @@ void zkrb_event_free(zkrb_event_t *event) {
       for (k = 0; k < strings_stat_ctx->values->count; ++k) free(strings_stat_ctx->values->data[k]);
       free(strings_stat_ctx->values);
       free(strings_stat_ctx->stat);
+      free(strings_stat_ctx);
       break;
     }
     case ZKRB_ACL: {
@@ -109,11 +154,13 @@ void zkrb_event_free(zkrb_event_t *event) {
         free(acl_ctx->acl);
       }
       free(acl_ctx->stat);
+      free(acl_ctx);
       break;
     }
     case ZKRB_WATCHER: {
       struct zkrb_watcher_completion *watcher_ctx = event->completion.watcher_completion;
       free(watcher_ctx->path);
+      free(watcher_ctx);
       break;
     }
     case ZKRB_VOID: {
@@ -214,30 +261,33 @@ zkrb_calling_context *zkrb_calling_context_alloc(int64_t req_id, zkrb_queue_t *q
 }
 
 void zkrb_print_calling_context(zkrb_calling_context *ctx) {
-  fprintf(stderr, "calling context (%#x){\n", ctx);
+  fprintf(stderr, "calling context (%p){\n", ctx);
   fprintf(stderr, "\treq_id = %lld\n", ctx->req_id);
-  fprintf(stderr, "\tqueue  = 0x%#x\n", ctx->queue);
+  fprintf(stderr, "\tqueue  = %p\n", ctx->queue);
   fprintf(stderr, "}\n");
 }
 
 /*
   process completions that get queued to the watcher queue, translate events
   to completions that the ruby side dispatches via callbacks.
+
+  The calling_ctx can be thought of as the outer shell that we discard in
+  this macro after pulling out the gooey delicious center.
 */
 
 #define ZKH_SETUP_EVENT(qptr, eptr) \
   zkrb_calling_context *ctx = (zkrb_calling_context *) calling_ctx; \
-  zkrb_event_t *eptr = zkrb_event_alloc();                      \
+  zkrb_event_t *eptr = zkrb_event_alloc();                          \
   eptr->req_id = ctx->req_id;                                       \
-  if (eptr->req_id != ZKRB_GLOBAL_REQ) free(ctx);                   \
-  zkrb_queue_t *qptr = ctx->queue;
+  zkrb_queue_t *qptr = ctx->queue;                                  \
+  if (eptr->req_id != ZKRB_GLOBAL_REQ) free(ctx)
 
 void zkrb_state_callback(
     zhandle_t *zh, int type, int state, const char *path, void *calling_ctx) {
   /* logging */
   if (ZKRBDebugging) {
     fprintf(stderr, "ZOOKEEPER_C_STATE WATCHER "
-                    "type = %d, state = %d, path = 0x%#x, value = %s\n",
+                    "type = %d, state = %d, path = %p, value = %s\n",
       type, state, (void *) path, path ? path : "NULL");
   }
 
@@ -245,13 +295,22 @@ void zkrb_state_callback(
   struct zkrb_watcher_completion *wc = malloc(sizeof(struct zkrb_watcher_completion));
   wc->type  = type;
   wc->state = state;
-  wc->path  = malloc(strlen(path) + 1);
-  strcpy(wc->path, path);
+  wc->path  = strdup(path);
+
+  // This is unfortunate copy-pasta from ZKH_SETUP_EVENT with one change: we
+  // check type instead of the req_id to see if we need to free the ctx.
+  zkrb_calling_context *ctx = (zkrb_calling_context *) calling_ctx;
+  zkrb_event_t *event = zkrb_event_alloc();
+  event->req_id = ctx->req_id;
+  zkrb_queue_t *queue = ctx->queue;
+  if (type != ZOO_SESSION_EVENT) {
+    free(ctx);
+    ctx = NULL;
+  }
 
-  ZKH_SETUP_EVENT(queue, event);
   event->type = ZKRB_WATCHER;
   event->completion.watcher_completion = wc;
-  
+
   zkrb_enqueue(queue, event);
 }
 
@@ -267,7 +326,8 @@ void zkrb_data_callback(
 
   /* copy data completion */
   struct zkrb_data_completion *dc = malloc(sizeof(struct zkrb_data_completion));
-  dc->data = dc->stat = NULL;
+  dc->data = NULL;
+  dc->stat = NULL;
   if (value != NULL) { dc->data  = malloc(value_len); memcpy(dc->data, value, value_len); }
   if (stat != NULL) { dc->stat  = malloc(sizeof(struct Stat)); memcpy(dc->stat, stat, sizeof(struct Stat)); }
 
@@ -307,7 +367,8 @@ void zkrb_string_callback(
 
   struct zkrb_string_completion *sc = malloc(sizeof(struct zkrb_string_completion));
   sc->value = NULL;
-  if (string != NULL) { sc->value = malloc(strlen(string) + 1); strcpy(sc->value, string); }
+  if (string)
+    sc->value = strdup(string);
 
   ZKH_SETUP_EVENT(queue, event);
   event->rc = rc;
@@ -321,7 +382,7 @@ void zkrb_strings_callback(
     int rc, const struct String_vector *strings, const void *calling_ctx) {
   if (ZKRBDebugging) {
     fprintf(stderr, "ZOOKEEPER_C_STRINGS WATCHER "
-                    "rc = %d (%s), calling_ctx = 0x%#x\n", rc, zerror(rc), calling_ctx);
+                    "rc = %d (%s), calling_ctx = %p\n", rc, zerror(rc), calling_ctx);
   }
 
   /* copy string vector */
@@ -340,7 +401,7 @@ void zkrb_strings_stat_callback(
     int rc, const struct String_vector *strings, const struct Stat *stat, const void *calling_ctx) {
   if (ZKRBDebugging) {
     fprintf(stderr, "ZOOKEEPER_C_STRINGS_STAT WATCHER "
-                    "rc = %d (%s), calling_ctx = 0x%#x\n", rc, zerror(rc), calling_ctx);
+                    "rc = %d (%s), calling_ctx = %p\n", rc, zerror(rc), calling_ctx);
   }
 
   struct zkrb_strings_stat_completion *sc = malloc(sizeof(struct zkrb_strings_stat_completion));
@@ -351,7 +412,7 @@ void zkrb_strings_stat_callback(
   ZKH_SETUP_EVENT(queue, event);
   event->rc = rc;
   event->type = ZKRB_STRINGS_STAT;
-  event->completion.strings_completion = sc;
+  event->completion.strings_stat_completion = sc;
   
   zkrb_enqueue(queue, event);
 }
@@ -379,7 +440,8 @@ void zkrb_acl_callback(
   }
 
   struct zkrb_acl_completion *ac = malloc(sizeof(struct zkrb_acl_completion));
-  ac->acl = ac->stat = NULL;
+  ac->acl = NULL;
+  ac->stat = NULL;
   if (acls != NULL) { ac->acl  = zkrb_clone_acl_vector(acls); }
   if (stat != NULL) { ac->stat = malloc(sizeof(struct Stat)); memcpy(ac->stat, stat, sizeof(struct Stat)); }
 
@@ -450,7 +512,7 @@ struct Id zkrb_ruby_to_id(VALUE rubyid) {
   }
 
   if (ident != Qnil) {
-    id.id     = malloc(RSTRING_LEN(ident) + 1);
+    id.id = malloc(RSTRING_LEN(ident) + 1);
     strncpy(id.id, RSTRING_PTR(ident), RSTRING_LEN(ident));
     id.id[RSTRING_LEN(ident)] = '\0';
   } else {
@@ -461,8 +523,8 @@ struct Id zkrb_ruby_to_id(VALUE rubyid) {
 }
 
 VALUE zkrb_acl_vector_to_ruby(struct ACL_vector *acl_vector) {
-  int i = 0;
-  VALUE ary = rb_ary_new();
+  int i;
+  VALUE ary = rb_ary_new2(acl_vector->count);
   for(i = 0; i < acl_vector->count; i++) {
     rb_ary_push(ary, zkrb_acl_to_ruby(acl_vector->data+i));
   }
@@ -470,8 +532,8 @@ VALUE zkrb_acl_vector_to_ruby(struct ACL_vector *acl_vector) {
 }
 
 VALUE zkrb_string_vector_to_ruby(struct String_vector *string_vector) {
-  int i = 0;
-  VALUE ary = rb_ary_new();
+  int i;
+  VALUE ary = rb_ary_new2(string_vector->count);
   for(i = 0; i < string_vector->count; i++) {
     rb_ary_push(ary, rb_str_new2(string_vector->data[i]));
   }
@@ -516,23 +578,20 @@ struct ACL_vector * zkrb_clone_acl_vector(struct ACL_vector * src) {
   int k;
   for (k = 0; k < src->count; ++k) {
     struct ACL * elt = &src->data[k];
-    dst->data[k].id.scheme = malloc(strlen(elt->id.scheme)+1);
-    dst->data[k].id.id     = malloc(strlen(elt->id.id)+1);
-    strcpy(dst->data[k].id.scheme, elt->id.scheme);
-    strcpy(dst->data[k].id.id, elt->id.id);
+    dst->data[k].id.scheme = strdup(elt->id.scheme);
+    dst->data[k].id.id     = strdup(elt->id.id);
     dst->data[k].perms = elt->perms;
   }
   return dst;
 }
 
 #warning [wickman] TODO test zkrb_clone_string_vector
-struct String_vector * zkrb_clone_string_vector(struct String_vector * src) {
+struct String_vector * zkrb_clone_string_vector(const struct String_vector * src) {
   struct String_vector * dst = malloc(sizeof(struct String_vector));
   allocate_String_vector(dst, src->count);
   int k;
   for (k = 0; k < src->count; ++k) {
-    dst->data[k] = malloc(strlen(src->data[k]) + 1);
-    strcpy(dst->data[k], src->data[k]);
+    dst->data[k] = strdup(src->data[k]);
   }
   return dst;
 }

data/ext/zookeeper_lib.h

@@ -22,6 +22,7 @@
 #endif
 
 extern int ZKRBDebugging;
+extern pthread_mutex_t zkrb_q_mutex;
 
 struct zkrb_data_completion {
   char *data;
@@ -94,6 +95,8 @@ struct zkrb_event_ll_t {
 typedef struct {
   struct zkrb_event_ll_t *head;
   struct zkrb_event_ll_t *tail;
+  int                     pipe_read;
+  int                     pipe_write;
 } zkrb_queue_t;
 
 zkrb_queue_t * zkrb_queue_alloc(void);
@@ -104,7 +107,7 @@ void           zkrb_event_free(zkrb_event_t *ptr);
 /* push/pop is a misnomer, this is a queue */
 void                 zkrb_enqueue(zkrb_queue_t *queue, zkrb_event_t *elt);
 zkrb_event_t *       zkrb_peek(zkrb_queue_t *queue);
-zkrb_event_t *       zkrb_dequeue(zkrb_queue_t *queue);
+zkrb_event_t *       zkrb_dequeue(zkrb_queue_t *queue, int need_lock);
 
 void zkrb_print_stat(const struct Stat *s);
 
@@ -154,7 +157,7 @@ VALUE zkrb_stat_to_rhash(const struct Stat* stat);
 
 struct ACL_vector *    zkrb_ruby_to_aclvector(VALUE acl_ary);
 struct ACL_vector *    zkrb_clone_acl_vector(struct ACL_vector * src);
-struct String_vector * zkrb_clone_string_vector(struct String_vector * src);
+struct String_vector * zkrb_clone_string_vector(const struct String_vector * src);
 struct ACL             zkrb_ruby_to_acl(VALUE rubyacl);
 struct Id              zkrb_ruby_to_id(VALUE rubyid);
 

data/lib/zookeeper.rb

@@ -156,14 +156,12 @@ private
     @dispatcher = Thread.new {
       while true do
         dispatch_next_callback
-        sleep 0.1
       end
     }
   end
 
   def dispatch_next_callback
     hash = get_next_event
-    return nil unless hash
 
     is_completion = hash.has_key?(:rc)
     

data/test/test_basic.rb

@@ -1,8 +1,5 @@
 require 'rubygems'
-
-HERE = File.expand_path(File.dirname(__FILE__))
-
-require "#{HERE}/../lib/zookeeper"
+require 'zookeeper'
 
 z = Zookeeper.new("localhost:2181")
 

data/zookeeper.gemspec

@@ -2,26 +2,25 @@
 
 Gem::Specification.new do |s|
   s.name = %q{zookeeper}
-  s.version = "0.4.2"
+  s.version = "0.4.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Phillip Pearson, Eric Maland, Evan Weaver, Brian Wickman"]
-  s.date = %q{2011-01-06}
+  s.date = %q{2011-02-09}
   s.description = %q{An interface to the Zookeeper distributed configuration server.}
   s.email = %q{}
   s.extensions = ["ext/extconf.rb"]
   s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README", "ext/zookeeper_c.c", "lib/zookeeper.rb"]
   s.files = ["CHANGELOG", "LICENSE", "README", "Rakefile", "examples/cloud_config.rb", "ext/extconf.rb", "ext/zkc-3.3.2.tar.gz", "ext/zookeeper_c.c", "ext/zookeeper_lib.c", "ext/zookeeper_lib.h", "lib/zookeeper.rb", "lib/zookeeper/acls.rb", "lib/zookeeper/callbacks.rb", "lib/zookeeper/constants.rb", "lib/zookeeper/exceptions.rb", "lib/zookeeper/stat.rb", "test/test_basic.rb", "test/test_callback1.rb", "test/test_close.rb", "test/test_esoteric.rb", "test/test_watcher1.rb", "test/test_watcher2.rb", "Manifest", "zookeeper.gemspec"]
-  s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/zookeeper/}
+  s.homepage = %q{https://github.com/twitter/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.7}
+  s.rubygems_version = %q{1.5.0}
   s.summary = %q{An interface to the Zookeeper distributed configuration server.}
   s.test_files = ["test/test_basic.rb", "test/test_callback1.rb", "test/test_close.rb", "test/test_esoteric.rb", "test/test_watcher1.rb", "test/test_watcher2.rb"]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zookeeper
 version: !ruby/object:Gem::Version 
-  hash: 11
-  prerelease: false
+  hash: 9
+  prerelease: 
   segments: 
   - 0
   - 4
-  - 2
-  version: 0.4.2
+  - 3
+  version: 0.4.3
 platform: ruby
 authors: 
 - Phillip Pearson, Eric Maland, Evan Weaver, Brian Wickman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-06 00:00:00 -08:00
+date: 2011-02-09 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -57,7 +57,7 @@ files:
 - Manifest
 - zookeeper.gemspec
 has_rdoc: true
-homepage: http://blog.evanweaver.com/files/doc/fauna/zookeeper/
+homepage: https://github.com/twitter/zookeeper
 licenses: []
 
 post_install_message: 
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: fauna
-rubygems_version: 1.3.7
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
 summary: An interface to the Zookeeper distributed configuration server.