slyphon-zookeeper 0.3.0-java → 0.8.0-java

data/ext/zookeeper_c.c

@@ -2,6 +2,7 @@
  * Phillip Pearson <pp@myelin.co.nz>
  * Eric Maland <eric@twitter.com>
  * Brian Wickman <wickman@twitter.com>
+ * Jonathan D. Simms <slyphon@gmail.com>
  *
  * This fork is a 90% rewrite of the original.  It takes a more evented
  * approach to isolate the ZK state machine from the ruby interpreter via an
@@ -108,6 +109,7 @@ static int zkrb_dup(int orig) {
     return fd;
 }
 
+#if 0
 static VALUE create_selectable_io(zkrb_queue_t *q) {
   // rb_cIO is the ruby IO class?
 
@@ -127,8 +129,11 @@ static VALUE create_selectable_io(zkrb_queue_t *q) {
 
   return reader;
 }
+#endif
 
-static VALUE method_init(int argc, VALUE* argv, VALUE self) {
+#define session_timeout_msec(self) rb_iv_get(self, "@_session_timeout_msec")
+
+static VALUE method_zkrb_init(int argc, VALUE* argv, VALUE self) {
   VALUE hostPort;
   VALUE options;
 
@@ -157,6 +162,9 @@ static VALUE method_init(int argc, VALUE* argv, VALUE self) {
   data = Data_Make_Struct(Zookeeper, struct zkrb_instance_data, 0, free_zkrb_instance_data, zk_local_ctx);
   zk_local_ctx->queue = zkrb_queue_alloc();
 
+  if (zk_local_ctx->queue == NULL)
+    rb_raise(rb_eRuntimeError, "could not allocate zkrb queue!");
+
   zoo_deterministic_conn_order(0);
 
   zkrb_calling_context *ctx =
@@ -168,7 +176,7 @@ static VALUE method_init(int argc, VALUE* argv, VALUE self) {
       zookeeper_init(
           RSTRING_PTR(hostPort),
           zkrb_state_callback,
-          10000,
+          session_timeout_msec(self),
           &zk_local_ctx->myid,
           ctx,
           0);
@@ -179,10 +187,9 @@ static VALUE method_init(int argc, VALUE* argv, VALUE self) {
   }
 
   rb_iv_set(self, "@_data", data);
-  rb_iv_set(self, "@selectable_io", create_selectable_io(zk_local_ctx->queue));
-  rb_iv_set(self, "@_running", Qtrue);
-
+  rb_funcall(self, rb_intern("zkc_set_running_and_notify!"), 0);
 
+error:
   return Qnil;
 }
 
@@ -282,6 +289,19 @@ static VALUE method_exists(VALUE self, VALUE reqid, VALUE path, VALUE async, VAL
   return output;
 }
 
+// this method is *only* called asynchronously
+static VALUE method_sync(VALUE self, VALUE reqid, VALUE path) {
+  VALUE async = Qtrue;
+  VALUE watch = Qfalse;
+  int rc;
+
+  STANDARD_PREAMBLE(self, zk, reqid, path, async, watch, data_ctx, watch_ctx, call_type);
+
+  rc = zoo_async(zk->zh, RSTRING_PTR(path), zkrb_string_callback, data_ctx);
+
+  return INT2FIX(rc);
+}
+
 static VALUE method_create(VALUE self, VALUE reqid, VALUE path, VALUE data, VALUE async, VALUE acls, VALUE flags) {
   VALUE watch = Qfalse;
   STANDARD_PREAMBLE(self, zk, reqid, path, async, watch, data_ctx, watch_ctx, call_type);
@@ -477,46 +497,39 @@ static VALUE method_get_acl(VALUE self, VALUE reqid, VALUE path, VALUE async) {
   return output;
 }
 
-static int is_running(VALUE self) {
-  VALUE rval = rb_iv_get(self, "@_running");
-  return RTEST(rval);
-}
-
-static int is_closed(VALUE self) {
-  VALUE rval = rb_iv_get(self, "@_closed");
-  return RTEST(rval);
-}
-
-/* slyphon: NEED TO PROTECT THIS AGAINST SHUTDOWN */
+#define is_running(self) RTEST(rb_iv_get(self, "@_running"))
+#define is_closed(self) RTEST(rb_iv_get(self, "@_closed"))
+#define is_shutting_down(self) RTEST(rb_iv_get(self, "@_shutting_down"))
 
 static VALUE method_get_next_event(VALUE self, VALUE blocking) {
+  // dbg.h 
+  check_debug(!is_closed(self), "we are closed, not trying to get event");
+
   char buf[64];
   FETCH_DATA_PTR(self, zk);
 
   for (;;) {
-
-    // we use the is_running(self) method here because it allows us to have a
-    // ruby-land semaphore that we can also use in the java extension
-    //
-    if (is_closed(self) || !is_running(self)) {
-      zkrb_debug_inst(self, "is_closed(self): %d, is_running(self): %d, method_get_next_event is exiting loop", is_closed(self), is_running(self));
-      return Qnil;  // this case for shutdown
-    }
+    check_debug(!is_closed(self), "we're closed in the middle of method_get_next_event, bailing");
 
     zkrb_event_t *event = zkrb_dequeue(zk->queue, 1);
 
     /* Wait for an event using rb_thread_select() on the queue's pipe */
     if (event == NULL) {
       if (NIL_P(blocking) || (blocking == Qfalse)) { 
-        return Qnil; // no event for us
+        goto error;
       } 
       else {
+        // if we're shutting down, don't enter this section, we don't want to block
+        check_debug(!is_shutting_down(self), "method_get_next_event, we're shutting down, don't enter blocking section");
+
         int fd = zk->queue->pipe_read;
         ssize_t bytes_read = 0;
 
         // wait for an fd to become readable, opposite of rb_thread_fd_writable
         rb_thread_wait_fd(fd);
 
+        // clear all bytes here, we'll catch all the events on subsequent calls
+        // (until we run out of events)
         bytes_read = read(fd, buf, sizeof(buf));
 
         if (bytes_read == -1) {
@@ -533,6 +546,9 @@ static VALUE method_get_next_event(VALUE self, VALUE blocking) {
     zkrb_event_free(event);
     return hash;
   }
+
+  error: 
+    return Qnil;
 }
 
 static VALUE method_has_events(VALUE self) {
@@ -554,15 +570,6 @@ static VALUE method_wake_event_loop_bang(VALUE self) {
   return Qnil;
 };
 
-// static VALUE method_signal_pending_close(VALUE self) {
-//   FETCH_DATA_PTR(self, zk);
-// 
-//   zk->pending_close = 1;
-//   zkrb_signal(zk->queue);
-// 
-//   return Qnil;
-// }
-
 static VALUE method_close_handle(VALUE self) {
   FETCH_DATA_PTR(self, zk);
 
@@ -597,7 +604,7 @@ static VALUE method_is_unrecoverable(VALUE self) {
   return is_unrecoverable(zk->zh) == ZINVALIDSTATE ? Qtrue : Qfalse;
 }
 
-static VALUE method_state(VALUE self) {
+static VALUE method_zkrb_state(VALUE self) {
   FETCH_DATA_PTR(self, zk);
   return INT2NUM(zoo_state(zk->zh));
 }
@@ -630,7 +637,7 @@ static VALUE method_client_id(VALUE self) {
   return client_id_obj;
 }
 
-static VALUE klass_method_set_debug_level(VALUE klass, VALUE level) {
+static VALUE klass_method_zkrb_set_debug_level(VALUE klass, VALUE level) {
   Check_Type(level, T_FIXNUM);
   ZKRBDebugging = (FIX2INT(level) == ZOO_LOG_LEVEL_DEBUG);
   zoo_set_debug_level(FIX2INT(level));
@@ -647,7 +654,8 @@ static void zkrb_define_methods(void) {
 #define DEFINE_CLASS_METHOD(method, args) { \
     rb_define_singleton_method(Zookeeper, #method, method_ ## method, args); }
 
-  DEFINE_METHOD(init, -1);
+  // the number after the method name should be actual arity of C function - 1
+  DEFINE_METHOD(zkrb_init, -1);
   DEFINE_METHOD(get_children, 4);
   DEFINE_METHOD(exists, 4);
   DEFINE_METHOD(create, 6);
@@ -661,10 +669,11 @@ static void zkrb_define_methods(void) {
   DEFINE_METHOD(deterministic_conn_order, 1);
   DEFINE_METHOD(is_unrecoverable, 0);
   DEFINE_METHOD(recv_timeout, 1);
-  DEFINE_METHOD(state, 0);
+  DEFINE_METHOD(zkrb_state, 0);
+  DEFINE_METHOD(sync, 2);
+
   // TODO
   // DEFINE_METHOD(add_auth, 3);
-  // DEFINE_METHOD(async, 1);
 
   // methods for the ruby-side event manager
   DEFINE_METHOD(get_next_event, 1);
@@ -673,11 +682,11 @@ static void zkrb_define_methods(void) {
   // Make these class methods?
   DEFINE_METHOD(zerror, 1);
 
-  rb_define_singleton_method(Zookeeper, "set_debug_level", klass_method_set_debug_level, 1);
+  rb_define_singleton_method(Zookeeper, "set_zkrb_debug_level", klass_method_zkrb_set_debug_level, 1);
 
   rb_attr(Zookeeper, rb_intern("selectable_io"), 1, 0, Qtrue);
-
   rb_define_method(Zookeeper, "wake_event_loop!", method_wake_event_loop_bang, 0);
+
 }
 
 // class CZookeeper::ClientId
@@ -695,8 +704,10 @@ static VALUE zkrb_client_id_method_initialize(VALUE self) {
   return Qnil;
 }
 
+
 void Init_zookeeper_c() {
   ZKRBDebugging = 0;
+
   /* initialize Zookeeper class */
   Zookeeper = rb_define_class("CZookeeper", rb_cObject);
   zkrb_define_methods();

data/ext/zookeeper_lib.c

@@ -6,6 +6,17 @@ This file contains three sets of helpers:
   - functions for translating between Ruby and C versions of ZK datatypes
 
 wickman@twitter.com
+
+*********************************************************************************
+*
+* NOTE: be *very careful* in these functions, calling *ANY* ruby interpreter
+* function when you're not in an interpreter thread can hork ruby, trigger a
+* [BUG], corrupt the stack, kill your dog, knock up your daughter, etc. etc.
+*
+*********************************************************************************
+
+slyphon@gmail.com
+
 */
 
 #include "ruby.h"
@@ -23,104 +34,117 @@ wickman@twitter.com
 
 int ZKRBDebugging;
 
+// XXX(slyphon): need to check these for error, but what to do if they fail?
 pthread_mutex_t zkrb_q_mutex = PTHREAD_MUTEX_INITIALIZER;
 
+#define LOG_PTHREAD_ERR(A, M, ...) if (A) { log_err(M, ##__VA_ARGS__); errno=0; }
+
+#define GLOBAL_MUTEX_LOCK(F)   LOG_PTHREAD_ERR(pthread_mutex_lock(&zkrb_q_mutex), F)
+#define GLOBAL_MUTEX_UNLOCK(F) LOG_PTHREAD_ERR(pthread_mutex_unlock(&zkrb_q_mutex), F)
 
-/********************************************************************************
- *
- * NOTE: be *very careful* in these functions, calling *ANY* ruby interpreter
- * function when you're not in an interpreter thread can hork ruby, trigger a
- * [BUG], corrupt the stack, kill your dog, knock up your daughter, etc. etc.
- *
- *********************************************************************************
-*/
 
-/* push/pop is a misnomer, this is a queue */
 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;
-  }
+  GLOBAL_MUTEX_LOCK("zkrb_enqueue");
+
+  check_debug(q != NULL && q->tail != NULL,  "zkrb_enqueue: queue ptr or tail was NULL\n");
+
   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);
 
   // XXX(slyphon): can't raise a ruby exception here as we may not be calling
   // this from a ruby thread. Calling into the interpreter from a non-ruby
   // thread is bad, mm'kay?
 
-  if ((ret == -1)) {
-    fprintf(stderr, "WARNING: write to queue (%p) pipe failed!\n", q);
-  }
+  check(ret != -1, "write to queue (%p) pipe failed!\n", q);
+
+error:
+  GLOBAL_MUTEX_UNLOCK("zkrb_enqueue");
 }
 
+// NOTE: the zkrb_event_t* returned *is* the same pointer that's part of the
+// queue, the only place this is used is in method_has_events, and it is simply
+// tested for null-ness. it's probably better to make the null-test here and
+// not return the pointer
+//
 zkrb_event_t * zkrb_peek(zkrb_queue_t *q) {
-  pthread_mutex_lock(&zkrb_q_mutex);
   zkrb_event_t *event = NULL;
+
+  GLOBAL_MUTEX_LOCK("zkrb_peek");
+
   if (q != NULL && q->head != NULL && q->head->event != NULL) {
     event = q->head->event;
   }
-  pthread_mutex_unlock(&zkrb_q_mutex);
+
+  GLOBAL_MUTEX_UNLOCK("zkrb_peek");
   return event;
 }
 
+#define ZKRB_QUEUE_EMPTY(q) (q == NULL || q->head == NULL || q->head->event == NULL)
+
 zkrb_event_t* zkrb_dequeue(zkrb_queue_t *q, int need_lock) {
+  zkrb_event_t *rv = NULL;
+
   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 {
+    GLOBAL_MUTEX_LOCK("zkrb_dequeue");
+
+  if (!ZKRB_QUEUE_EMPTY(q)) {
     struct zkrb_event_ll_t *old_root = q->head;
     q->head = q->head->next;
-    zkrb_event_t *rv = old_root->event;
+    rv = old_root->event;
     free(old_root);
-    if (need_lock)
-      pthread_mutex_unlock(&zkrb_q_mutex);
-    return rv;
   }
+
+  if (need_lock)
+    GLOBAL_MUTEX_UNLOCK("zkrb_dequeue");
+
+  return rv;
 }
 
 void zkrb_signal(zkrb_queue_t *q) {
-  pthread_mutex_lock(&zkrb_q_mutex);
-  ssize_t ret = write(q->pipe_write, "0", 1);   /* Wake up Ruby listener */
-  pthread_mutex_unlock(&zkrb_q_mutex);
-  if (ret == -1)
-    log_err("write to pipe failed");
+  GLOBAL_MUTEX_LOCK("zkrb_signal");
+
+  if (!write(q->pipe_write, "0", 1))      /* Wake up Ruby listener */
+    log_err("zkrb_signal: write to pipe failed, could not wake");
+
+  GLOBAL_MUTEX_UNLOCK("zkrb_signal");
 }
 
 zkrb_queue_t *zkrb_queue_alloc(void) {
-  int pfd[2];
+  // some of the locking is a little coarse, but it 
+  // eases the logic of releasing in case of error.
+  GLOBAL_MUTEX_LOCK("zkrb_queue_alloc"); 
 
-  // XXX(slyphon): close-on-exec settings?
+  int pfd[2];
+  zkrb_queue_t *rq = NULL;
+ 
+  check(pipe(pfd) == 0, "creating the signal pipe failed");
 
-  if (pipe(pfd) == -1)
-    rb_raise(rb_eRuntimeError, "create of pipe failed: %d", errno);
+  rq = malloc(sizeof(zkrb_queue_t));
+  check_mem(rq);
 
-  pthread_mutex_lock(&zkrb_q_mutex);
-  zkrb_queue_t *rq = malloc(sizeof(zkrb_queue_t));
   rq->head = malloc(sizeof(struct zkrb_event_ll_t));
+  check_mem(rq->head);
+
   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);
 
+  GLOBAL_MUTEX_UNLOCK("zkrb_queue_alloc");
   return rq;
+
+error:
+  GLOBAL_MUTEX_UNLOCK("zkrb_queue_alloc");
+  return NULL;
 }
 
 void zkrb_queue_free(zkrb_queue_t *queue) {
-  pthread_mutex_lock(&zkrb_q_mutex);
-  if (queue == NULL) {
-    pthread_mutex_unlock(&zkrb_q_mutex);
-    return;
-  }
+  GLOBAL_MUTEX_LOCK("zkrb_queue_free");
+  check_debug(queue != NULL, "zkrb_queue_free: queue was NULL");
 
   zkrb_event_t *elt;
   while ((elt = zkrb_dequeue(queue, 0)) != NULL) {
@@ -130,7 +154,9 @@ void zkrb_queue_free(zkrb_queue_t *queue) {
   close(queue->pipe_read);
   close(queue->pipe_write);
   free(queue);
-  pthread_mutex_unlock(&zkrb_q_mutex);
+
+error:
+  GLOBAL_MUTEX_UNLOCK("zkrb_queue_free");
 }
 
 zkrb_event_t *zkrb_event_alloc(void) {
@@ -324,12 +350,10 @@ void zkrb_print_calling_context(zkrb_calling_context *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 "
+
+  zkrb_debug("ZOOKEEPER_C_STATE WATCHER "
                     "type = %d, state = %d, path = %p, value = %s\n",
       type, state, (void *) path, path ? path : "NULL");
-  }
 
   /* save callback context */
   struct zkrb_watcher_completion *wc = malloc(sizeof(struct zkrb_watcher_completion));
@@ -358,11 +382,10 @@ void zkrb_state_callback(
 
 void zkrb_data_callback(
     int rc, const char *value, int value_len, const struct Stat *stat, const void *calling_ctx) {
-  if (ZKRBDebugging) {
-    fprintf(stderr, "ZOOKEEPER_C_DATA WATCHER "
-                    "rc = %d (%s), value = %s, len = %d\n",
-      rc, zerror(rc), value ? value : "NULL", value_len);
-  }
+
+  zkrb_debug("ZOOKEEPER_C_DATA WATCHER "
+                "rc = %d (%s), value = %s, len = %d\n",
+                rc, zerror(rc), value ? value : "NULL", value_len);
 
   /* copy data completion */
   struct zkrb_data_completion *dc = malloc(sizeof(struct zkrb_data_completion));
@@ -388,10 +411,8 @@ void zkrb_data_callback(
 
 void zkrb_stat_callback(
     int rc, const struct Stat *stat, const void *calling_ctx) {
-  if (ZKRBDebugging) {
-    fprintf(stderr, "ZOOKEEPER_C_STAT WATCHER "
+  zkrb_debug("ZOOKEEPER_C_STAT WATCHER "
                     "rc = %d (%s)\n", rc, zerror(rc));
-  }
 
   struct zkrb_stat_completion *sc = malloc(sizeof(struct zkrb_stat_completion));
   sc->stat = NULL;
@@ -407,10 +428,9 @@ void zkrb_stat_callback(
 
 void zkrb_string_callback(
     int rc, const char *string, const void *calling_ctx) {
-  if (ZKRBDebugging) {
-    fprintf(stderr, "ZOOKEEPER_C_STRING WATCHER "
+
+  zkrb_debug("ZOOKEEPER_C_STRING WATCHER "
                     "rc = %d (%s)\n", rc, zerror(rc));
-  }
 
   struct zkrb_string_completion *sc = malloc(sizeof(struct zkrb_string_completion));
   sc->value = NULL;
@@ -427,10 +447,8 @@ void zkrb_string_callback(
 
 void zkrb_strings_callback(
     int rc, const struct String_vector *strings, const void *calling_ctx) {
-  if (ZKRBDebugging) {
-    fprintf(stderr, "ZOOKEEPER_C_STRINGS WATCHER "
+  zkrb_debug("ZOOKEEPER_C_STRINGS WATCHER "
                     "rc = %d (%s), calling_ctx = %p\n", rc, zerror(rc), calling_ctx);
-  }
 
   /* copy string vector */
   struct zkrb_strings_completion *sc = malloc(sizeof(struct zkrb_strings_completion));
@@ -446,10 +464,8 @@ void zkrb_strings_callback(
 
 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 "
+  zkrb_debug("ZOOKEEPER_C_STRINGS_STAT WATCHER "
                     "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));
   sc->stat = NULL;
@@ -465,12 +481,9 @@ void zkrb_strings_stat_callback(
   zkrb_enqueue(queue, event);
 }
 
-void zkrb_void_callback(
-    int rc, const void *calling_ctx) {
-  if (ZKRBDebugging) {
-    fprintf(stderr, "ZOOKEEPER_C_VOID WATCHER "
+void zkrb_void_callback(int rc, const void *calling_ctx) {
+  zkrb_debug("ZOOKEEPER_C_VOID WATCHER "
                     "rc = %d (%s)\n", rc, zerror(rc));
-  }
 
   ZKH_SETUP_EVENT(queue, event);
   event->rc = rc;
@@ -482,10 +495,7 @@ void zkrb_void_callback(
 
 void zkrb_acl_callback(
     int rc, struct ACL_vector *acls, struct Stat *stat, const void *calling_ctx) {
-  if (ZKRBDebugging) {
-    fprintf(stderr, "ZOOKEEPER_C_ACL WATCHER "
-                    "rc = %d (%s)\n", rc, zerror(rc));
-  }
+  zkrb_debug("ZOOKEEPER_C_ACL WATCHER rc = %d (%s)\n", rc, zerror(rc));
 
   struct zkrb_acl_completion *ac = malloc(sizeof(struct zkrb_acl_completion));
   ac->acl = NULL;
@@ -644,3 +654,5 @@ struct String_vector * zkrb_clone_string_vector(const struct String_vector * src
   }
   return dst;
 }
+
+// vim:sts=2:sw=2:et

data/ext/zookeeper_lib.h

@@ -105,7 +105,6 @@ void           zkrb_queue_free(zkrb_queue_t *queue);
 zkrb_event_t * zkrb_event_alloc(void);
 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, int need_lock);