zookeeper 1.1.0 → 1.1.1

data/CHANGELOG

@@ -1,3 +1,17 @@
+v1.1.1 Cleanup after code review (h/t @eric)
+
+  * While hunting down this bug: https://bugs.ruby-lang.org/issues/6438
+    Eric Lindvall made a number of helpful catches.
+
+  * Reduce syscall overhead by not using an unnecessary pipe in the event_lib.c
+    implementation
+
+  * More careful use of rb_raise, don't longjmp past necessary free() calls.
+
+  * More careful malloc in the get() implementation (we need to allocate 1MB
+    to hold the data in a znode, but only in the SYNC cases).
+
+
 v1.1.0 Rewrite C backend to use zookeeper_st, the async library
 
   * In order to ensure fork safety, a rewrite of the backend was necessary.

data/ext/event_lib.c

@@ -21,7 +21,6 @@ slyphon@gmail.com
 */
 
 #include "ruby.h"
-#include "event_lib.h"
 #include "c-client-src/zookeeper.h"
 #include <errno.h>
 #include <stdio.h>
@@ -30,82 +29,59 @@ slyphon@gmail.com
 #include <unistd.h>
 #include <inttypes.h>
 #include "common.h"
+#include "event_lib.h"
 #include "dbg.h"
 
+#ifndef THREADED
+#define USE_XMALLOC
+#endif
+
 #define GET_SYM(str) ID2SYM(rb_intern(str))
 
 int ZKRBDebugging;
 
-#ifdef THREADED
-
+#if THREADED
 pthread_mutex_t zkrb_q_mutex = PTHREAD_MUTEX_INITIALIZER;
+#endif
 
 inline static int global_mutex_lock() {
-  int rv = pthread_mutex_lock(&zkrb_q_mutex);
+  int rv=0;
+#if THREADED
+  rv = pthread_mutex_lock(&zkrb_q_mutex);
   if (rv != 0) log_err("global_mutex_lock error");
+#endif
   return rv;
 }
 
 inline static int global_mutex_unlock() {
-  int rv = pthread_mutex_unlock(&zkrb_q_mutex);
+  int rv=0;
+#if THREADED
+  rv = pthread_mutex_unlock(&zkrb_q_mutex);
   if (rv != 0) log_err("global_mutex_unlock error");
+#endif
   return rv;
 }
 
-void atfork_prepare() {
-  global_mutex_lock();
-}
-
-void atfork_parent() {
-  global_mutex_unlock();
-}
-
-void atfork_child() {
-  global_mutex_unlock();
-}
-
-// set up handlers to make sure the thread being forked holds the lock at the 
-// time the process is copied, then immediately unlock the mutex in both parent
-// and children
-/*pthread_atfork(atfork_prepare, atfork_parent, atfork_child);*/
-
-// delegates to the system malloc (we can't use xmalloc in the threaded case,
-// as we can't touch the interpreter)
-
-inline static void* zk_malloc(size_t size) {
-  return malloc(size);
-}
-
-inline static void zk_free(void *ptr) {
-  free(ptr);
-}
-
-#else
-
-inline static int global_mutex_lock() {
-  return 0;
-}
-
-inline static int global_mutex_unlock() {
-  return 0;
-}
-
 // we can use the ruby xmalloc/xfree that will raise errors
 // in the case of a failure to allocate memory, and can cycle
 // the garbage collector in some cases.
 
 inline static void* zk_malloc(size_t size) {
+#ifdef USE_XMALLOC
   return xmalloc(size);
+#else
+  return malloc(size);
+#endif
 }
 
 inline static void zk_free(void *ptr) {
+#ifdef USE_XMALLOC
   xfree(ptr);
+#else
+  free(ptr);
+#endif
 }
 
-
-#endif /* THREADED */
-
-
 void zkrb_enqueue(zkrb_queue_t *q, zkrb_event_t *elt) {
   if (q == NULL) {
     zkrb_debug("zkrb_enqueue, queue ptr was NULL");
@@ -125,13 +101,15 @@ void zkrb_enqueue(zkrb_queue_t *q, zkrb_event_t *elt) {
   q->tail->event = NULL;
   q->tail->next = NULL;
 
-  ssize_t ret = write(q->pipe_write, "0", 1);   /* Wake up Ruby listener */
-
   global_mutex_unlock();
 
-  if (ret < 0) {
+#if THREADED
+  ssize_t ret = write(q->pipe_write, "0", 1);   /* Wake up Ruby listener */
+
+  if (ret < 0)
     log_err("write to queue (%p) pipe failed!\n", q);
-  }
+#endif
+
 }
 
 // NOTE: the zkrb_event_t* returned *is* the same pointer that's part of the
@@ -182,8 +160,10 @@ void zkrb_signal(zkrb_queue_t *q) {
 
   global_mutex_lock();
 
+#if THREADED
   if (!write(q->pipe_write, "0", 1))      /* Wake up Ruby listener */
     log_err("zkrb_signal: write to pipe failed, could not wake");
+#endif
 
   global_mutex_unlock();
 }
@@ -200,10 +180,12 @@ zkrb_event_ll_t *zkrb_event_ll_t_alloc(void) {
 }
 
 zkrb_queue_t *zkrb_queue_alloc(void) {
-  int pfd[2];
   zkrb_queue_t *rq = NULL;
  
+#if THREADED
+  int pfd[2];
   check(pipe(pfd) == 0, "creating the signal pipe failed");
+#endif
 
   rq = zk_malloc(sizeof(zkrb_queue_t));
   check_mem(rq);
@@ -214,8 +196,11 @@ zkrb_queue_t *zkrb_queue_alloc(void) {
   check_mem(rq->head);
 
   rq->tail = rq->head;
+
+#if THREADED
   rq->pipe_read = pfd[0];
   rq->pipe_write = pfd[1];
+#endif
 
   return rq;
 
@@ -233,8 +218,11 @@ void zkrb_queue_free(zkrb_queue_t *queue) {
   }
 
   zk_free(queue->head);
+
+#if THREADED
   close(queue->pipe_read);
   close(queue->pipe_write);
+#endif
 
   zk_free(queue);
 }
@@ -268,21 +256,26 @@ void zkrb_event_free(zkrb_event_t *event) {
     case ZKRB_STRINGS: {
       struct zkrb_strings_completion *strings_ctx = event->completion.strings_completion;
       int k;
-      if (strings_ctx->values)
-        for (k = 0; k < strings_ctx->values->count; ++k) zk_free(strings_ctx->values->data[k]);
-      zk_free(strings_ctx->values);
+      if (strings_ctx->values) {
+        for (k = 0; k < strings_ctx->values->count; ++k) {
+          zk_free(strings_ctx->values->data[k]);
+        }
+        zk_free(strings_ctx->values);
+      }
       zk_free(strings_ctx);
       break;
     }
     case ZKRB_STRINGS_STAT: {
       struct zkrb_strings_stat_completion *strings_stat_ctx = event->completion.strings_stat_completion;
       int k;
-      if (strings_stat_ctx->values)
-        for (k = 0; k < strings_stat_ctx->values->count; ++k) zk_free(strings_stat_ctx->values->data[k]);
-      zk_free(strings_stat_ctx->values);
+      if (strings_stat_ctx->values) {
+        for (k = 0; k < strings_stat_ctx->values->count; ++k) {
+          zk_free(strings_stat_ctx->values->data[k]);
+        }
+        zk_free(strings_stat_ctx->values);
+      }
 
-      if (strings_stat_ctx->stat)
-	zk_free(strings_stat_ctx->stat);
+      if (strings_stat_ctx->stat) zk_free(strings_stat_ctx->stat);
       zk_free(strings_stat_ctx);
       break;
     }

data/ext/zkrb.c

@@ -107,16 +107,22 @@ typedef enum {
 } zkrb_call_type;
 
 inline static const char* call_type_to_str(zkrb_call_type ct) {
+  const char *rv = NULL;
   switch (ct) {
     case SYNC:
-      return "SYNC";
+      rv="SYNC";
+      break;
     case ASYNC:
-      return "ASYNC";
+      rv="ASYNC";
+      break;
     case SYNC_WATCH:
-      return "SYNC_WATCH";
+      rv="SYNC_WATCH";
+      break;
     case ASYNC_WATCH:
-      return "ASYNC_WATCH";
+      rv="ASYNC_WATCH";
+      break;
   }
+  return rv;
 }
 
 inline static void assert_valid_params(VALUE reqid, VALUE path) {
@@ -167,6 +173,17 @@ static void hexbufify(char *dest, const char *src, int len) {
   }
 }
 
+inline static int we_are_forked(zkrb_instance_data_t *zk) {
+  int rv=0;
+
+  if ((!!zk) && (zk->orig_pid != getpid())) {
+    rv=1;
+  }
+
+  return rv;
+}
+
+
 static int destroy_zkrb_instance(zkrb_instance_data_t* zk) {
   int rv = ZOK;
 
@@ -177,23 +194,23 @@ static int destroy_zkrb_instance(zkrb_instance_data_t* zk) {
     /* Note that after zookeeper_close() returns, ZK handle is invalid */
     zkrb_debug("obj_id: %lx, calling zookeeper_close", zk->object_id);
 
-    if (zk->orig_pid != getpid()) {
+    if (we_are_forked(zk)) {
       zkrb_debug("FORK DETECTED! orig_pid: %d, current pid: %d, "
           "using socket-closing hack before zookeeper_close", zk->orig_pid, getpid());
 
       int fd = ((int *)zk->zh)[0];  // nasty, brutish, and wonderfully effective hack (see above)
       close(fd);
+
     }
 
     rv = zookeeper_close(zk->zh);
 
-    zkrb_debug("obj_id: %lx, zookeeper_close returned %d", zk->object_id, rv); 
+    zkrb_debug("obj_id: %lx, zookeeper_close returned %d, calling context: %p", zk->object_id, rv, ctx); 
     zkrb_calling_context_free((zkrb_calling_context *) ctx);
   }
 
   zk->zh = NULL;
 
-// [wickman] TODO: fire off warning if queue is not empty
   if (zk->queue) {
     zkrb_debug("obj_id: %lx, freeing queue pointer: %p", zk->object_id, zk->queue);
     zkrb_queue_free(zk->queue);
@@ -222,7 +239,7 @@ static void print_zkrb_instance_data(zkrb_instance_data_t* ptr) {
 
 inline static void zkrb_debug_clientid_t(const clientid_t *cid) {
   int pass_len = sizeof(cid->passwd);
-  int hex_len = 2 * pass_len;
+  int hex_len = 2 * pass_len + 1;
   char buf[hex_len];
   hexbufify(buf, cid->passwd, pass_len);
 
@@ -230,8 +247,8 @@ inline static void zkrb_debug_clientid_t(const clientid_t *cid) {
 }
 
 static VALUE method_zkrb_init(int argc, VALUE* argv, VALUE self) {
-  VALUE hostPort;
-  VALUE options;
+  VALUE hostPort=Qnil;
+  VALUE options=Qnil;
 
   rb_scan_args(argc, argv, "11", &hostPort, &options);
 
@@ -249,7 +266,7 @@ static VALUE method_zkrb_init(int argc, VALUE* argv, VALUE self) {
     zoo_set_debug_level(0); // no log messages
   } else {
     Check_Type(log_level, T_FIXNUM);
-    zoo_set_debug_level((int)log_level);
+    zoo_set_debug_level(FIX2INT(log_level));
   }
 
   VALUE data;
@@ -270,12 +287,12 @@ static VALUE method_zkrb_init(int argc, VALUE* argv, VALUE self) {
 
   zk_local_ctx->zh =
       zookeeper_init(
-          RSTRING_PTR(hostPort),
-          zkrb_state_callback,
-          session_timeout_msec(self),
-          &zk_local_ctx->myid,
-          ctx,
-          0);
+          RSTRING_PTR(hostPort),        // const char *host
+          zkrb_state_callback,          // watcher_fn
+          session_timeout_msec(self),   // recv_timeout
+          &zk_local_ctx->myid,          // cilentid_t
+          ctx,                          // void *context
+          0);                           // flags
 
   zkrb_debug("method_zkrb_init, zk_local_ctx: %p, zh: %p, queue: %p, calling_ctx: %p",
       zk_local_ctx, zk_local_ctx->zh, zk_local_ctx->queue, ctx);
@@ -399,12 +416,14 @@ static VALUE method_create(VALUE self, VALUE reqid, VALUE path, VALUE data, VALU
   if (data != Qnil) Check_Type(data, T_STRING);
   Check_Type(flags, T_FIXNUM);
   const char *data_ptr = (data == Qnil) ? NULL : RSTRING_PTR(data);
-  size_t      data_len = (data == Qnil) ? -1   : RSTRING_LEN(data);
+  ssize_t     data_len = (data == Qnil) ? -1   : RSTRING_LEN(data);
 
   struct ACL_vector *aclptr = NULL;
   if (acls != Qnil) { aclptr = zkrb_ruby_to_aclvector(acls); }
   char realpath[16384];
 
+  int invalid_call_type=0;
+
   int rc;
   switch (call_type) {
 
@@ -420,7 +439,7 @@ static VALUE method_create(VALUE self, VALUE reqid, VALUE path, VALUE data, VALU
       break;
 
     default:
-      raise_invalid_call_type_err(call_type);
+      invalid_call_type=1;
       break;
   }
 
@@ -429,6 +448,8 @@ static VALUE method_create(VALUE self, VALUE reqid, VALUE path, VALUE data, VALU
     free(aclptr);
   }
 
+  if (invalid_call_type) raise_invalid_call_type_err(call_type);
+
   output = rb_ary_new();
   rb_ary_push(output, INT2FIX(rc));
   if (IS_SYNC(call_type) && rc == ZOK) {
@@ -472,9 +493,13 @@ static VALUE method_get(VALUE self, VALUE reqid, VALUE path, VALUE async, VALUE
   int data_len = MAX_ZNODE_SIZE;
   struct Stat stat;
 
-  char * data = xmalloc(MAX_ZNODE_SIZE); /* ugh */
+  char * data = NULL; 
+  if (IS_SYNC(call_type)) {
+    data = malloc(MAX_ZNODE_SIZE); /* ugh */
+    memset(data, 0, sizeof(data));
+  }
 
-  int rc;
+  int rc, invalid_call_type=0;
 
   switch (call_type) {
 
@@ -500,7 +525,8 @@ static VALUE method_get(VALUE self, VALUE reqid, VALUE path, VALUE async, VALUE
       break;
 
     default:
-      raise_invalid_call_type_err(call_type);
+      invalid_call_type=1;
+      goto cleanup;    
       break;
   }
 
@@ -514,7 +540,9 @@ static VALUE method_get(VALUE self, VALUE reqid, VALUE path, VALUE async, VALUE
     rb_ary_push(output, zkrb_stat_to_rarray(&stat));
   }
 
-  xfree(data);
+cleanup:
+  free(data);
+  if (invalid_call_type) raise_invalid_call_type_err(call_type);
   return output;
 }
 
@@ -527,9 +555,9 @@ static VALUE method_set(VALUE self, VALUE reqid, VALUE path, VALUE data, VALUE a
   if (data != Qnil) Check_Type(data, T_STRING);
 
   const char *data_ptr = (data == Qnil) ? NULL : RSTRING_PTR(data);
-  size_t      data_len = (data == Qnil) ? -1   : RSTRING_LEN(data);
+  ssize_t     data_len = (data == Qnil) ? -1   : RSTRING_LEN(data);
 
-  int rc;
+  int rc=ZOK;
   switch (call_type) {
 
 #ifdef THREADED
@@ -561,7 +589,7 @@ static VALUE method_set_acl(VALUE self, VALUE reqid, VALUE path, VALUE acls, VAL
 
   struct ACL_vector * aclptr = zkrb_ruby_to_aclvector(acls);
 
-  int rc;
+  int rc=ZOK, invalid_call_type=0;
   switch (call_type) {
     
 #ifdef THREADED
@@ -575,13 +603,15 @@ static VALUE method_set_acl(VALUE self, VALUE reqid, VALUE path, VALUE acls, VAL
       break;
 
     default:
-      raise_invalid_call_type_err(call_type);
+      invalid_call_type=1;
       break;
   }
 
   deallocate_ACL_vector(aclptr);
   free(aclptr);
 
+  if (invalid_call_type) raise_invalid_call_type_err(call_type);
+
   return INT2FIX(rc);
 }
 
@@ -592,7 +622,7 @@ static VALUE method_get_acl(VALUE self, VALUE reqid, VALUE path, VALUE async) {
   struct ACL_vector acls;
   struct Stat stat;
 
-  int rc;
+  int rc=ZOK;
   switch (call_type) {
 
 #ifdef THREADED
@@ -692,12 +722,14 @@ static VALUE method_zkrb_get_next_event_st(VALUE self) {
     rval = zkrb_event_to_ruby(event);
     zkrb_event_free(event);
 
+#if THREADED
     int fd = zk->queue->pipe_read;
 
     // we don't care in this case. this is just until i can remove the self
     // pipe from the queue
     char b[128];
     while(read(fd, b, sizeof(b)) == sizeof(b)){}
+#endif
   }
 
   return rval;
@@ -721,7 +753,6 @@ inline static int get_self_pipe_read_fd(VALUE self) {
 #endif
 }
 
-
 static VALUE method_zkrb_iterate_event_loop(VALUE self) {
   FETCH_DATA_PTR(self, zk);
 
@@ -730,7 +761,7 @@ static VALUE method_zkrb_iterate_event_loop(VALUE self) {
 
   int fd=0, interest=0, events=0, rc=0, maxfd=0;
   struct timeval tv;
-  
+
   zookeeper_interest(zk->zh, &fd, &interest, &tv);
 
   if (fd != -1) {
@@ -767,9 +798,12 @@ static VALUE method_zkrb_iterate_event_loop(VALUE self) {
 
     // we got woken up by the self-pipe
     if (FD_ISSET(pipe_r_fd, &rfds)) {
-      // flush the pipe (from mt_adaptor.c)
+      // one event has awoken us, so we clear one event from the pipe
       char b[1];
-      read(pipe_r_fd, b, 1); // one event has awoken us, so we clear one event from the pipe
+
+      if (read(pipe_r_fd, b, 1) < 0) {
+        rb_raise(rb_eRuntimeError, "read from pipe failed: %s", clean_errno());
+      }
     }
 
     rc = zookeeper_process(zk->zh, events);
@@ -793,18 +827,11 @@ static VALUE method_has_events(VALUE self) {
   return rb_event;
 }
 
-
-// wake up the event loop, used when shutting down
-#if 0
-static VALUE method_wake_event_loop_bang(VALUE self) {
-  FETCH_DATA_PTR(self, zk); 
-
-  zkrb_debug_inst(self, "Waking event loop: %p", zk->queue);
-  zkrb_signal(zk->queue);
-
+static VALUE method_zoo_set_log_level(VALUE self, VALUE level) {
+  Check_Type(level, T_FIXNUM);
+  zoo_set_debug_level(FIX2INT(level));
   return Qnil;
-};
-#endif
+}
 
 static VALUE method_close_handle(VALUE self) {
   FETCH_DATA_PTR(self, zk);
@@ -846,12 +873,6 @@ static VALUE method_recv_timeout(VALUE self) {
   return INT2NUM(zoo_recv_timeout(zk->zh));
 }
 
-/*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);*/
-/*}*/
-
 // returns a CZookeeper::ClientId object with the values set for session_id and passwd
 static VALUE method_client_id(VALUE self) {
   FETCH_DATA_PTR(self, zk);
@@ -859,7 +880,7 @@ static VALUE method_client_id(VALUE self) {
   const clientid_t *cid = zoo_client_id(zk->zh);
 
   if (strlen(cid->passwd) != 16) { 
-    zkrb_debug("passwd is not null-termniated");
+    zkrb_debug("passwd is not null-terminated");
   } else {
     hexbufify(buf, cid->passwd, 16);
     zkrb_debug("password in hex is: %s", buf);
@@ -910,6 +931,8 @@ static void zkrb_define_methods(void) {
   rb_define_method(CZookeeper, "zkrb_set_acl",      method_set_acl,       5);
   rb_define_method(CZookeeper, "zkrb_get_acl",      method_get_acl,       3);
 
+  rb_define_singleton_method(CZookeeper, "zoo_set_log_level", method_zoo_set_log_level, 1);
+
   DEFINE_METHOD(client_id, 0);
   DEFINE_METHOD(close_handle, 0);
   DEFINE_METHOD(deterministic_conn_order, 1);

data/lib/zookeeper/version.rb

@@ -1,4 +1,4 @@
 module Zookeeper
-  VERSION = '1.1.0'
+  VERSION = '1.1.1'
   DRIVER_VERSION = '3.3.5'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: zookeeper
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 1
   - 1
-  - 0
-  version: 1.1.0
+  - 1
+  version: 1.1.1
 platform: ruby
 authors: 
 - Phillip Pearson
@@ -20,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-14 00:00:00 Z
+date: 2012-05-15 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: backports
@@ -154,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Apache ZooKeeper driver for Rubies