slyphon-zookeeper 0.9.1 → 0.9.2

data/ext/zookeeper_lib.c

@@ -49,7 +49,7 @@ void zkrb_enqueue(zkrb_queue_t *q, zkrb_event_t *elt) {
   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->next = (zkrb_event_ll_t *) malloc(sizeof(zkrb_event_ll_t));
   q->tail = q->tail->next;
   q->tail->event = NULL;
   q->tail->next = NULL;
@@ -87,20 +87,21 @@ zkrb_event_t * zkrb_peek(zkrb_queue_t *q) {
 
 zkrb_event_t* zkrb_dequeue(zkrb_queue_t *q, int need_lock) {
   zkrb_event_t *rv = NULL;
-
+  zkrb_event_ll_t *old_root = NULL;
+    
   if (need_lock)
     GLOBAL_MUTEX_LOCK("zkrb_dequeue");
 
   if (!ZKRB_QUEUE_EMPTY(q)) {
-    struct zkrb_event_ll_t *old_root = q->head;
+    old_root = q->head;
     q->head = q->head->next;
     rv = old_root->event;
-    free(old_root);
   }
 
   if (need_lock)
     GLOBAL_MUTEX_UNLOCK("zkrb_dequeue");
 
+  free(old_root);
   return rv;
 }
 
@@ -113,6 +114,17 @@ void zkrb_signal(zkrb_queue_t *q) {
   GLOBAL_MUTEX_UNLOCK("zkrb_signal");
 }
 
+zkrb_event_ll_t *zkrb_event_ll_t_alloc(void) {
+  zkrb_event_ll_t *rv = malloc(sizeof(zkrb_event_ll_t));
+
+  if (!rv) return NULL;
+
+  rv->event = NULL;
+  rv->next = NULL;
+
+  return rv;
+}
+
 zkrb_queue_t *zkrb_queue_alloc(void) {
   // some of the locking is a little coarse, but it 
   // eases the logic of releasing in case of error.
@@ -126,10 +138,9 @@ zkrb_queue_t *zkrb_queue_alloc(void) {
   rq = malloc(sizeof(zkrb_queue_t));
   check_mem(rq);
 
-  rq->head = malloc(sizeof(struct zkrb_event_ll_t));
+  rq->head = zkrb_event_ll_t_alloc();
   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];
@@ -139,6 +150,7 @@ zkrb_queue_t *zkrb_queue_alloc(void) {
 
 error:
   GLOBAL_MUTEX_UNLOCK("zkrb_queue_alloc");
+  free(rq);
   return NULL;
 }
 
@@ -160,7 +172,7 @@ error:
 }
 
 zkrb_event_t *zkrb_event_alloc(void) {
-  zkrb_event_t *rv = (zkrb_event_t *) malloc(sizeof(zkrb_event_t));
+  zkrb_event_t *rv = malloc(sizeof(zkrb_event_t));
   return rv;
 }
 
@@ -225,11 +237,10 @@ void zkrb_event_free(zkrb_event_t *event) {
     case ZKRB_VOID: {
       break;
     }
-
     default:
-#warning [wickman] TODO raise an exception?
-      fprintf(stderr, "ERROR?\n");
+      log_err("unrecognized event in event_free!");
   }
+
   free(event);
 }
 
@@ -238,6 +249,11 @@ void zkrb_event_free(zkrb_event_t *event) {
 VALUE zkrb_event_to_ruby(zkrb_event_t *event) {
   VALUE hash = rb_hash_new();
 
+  if (!event) {
+    log_err("event was NULL in zkrb_event_to_ruby");
+    return hash;
+  }
+
   rb_hash_aset(hash, GET_SYM("req_id"), LL2NUM(event->req_id));
   if (event->type != ZKRB_WATCHER)
     rb_hash_aset(hash, GET_SYM("rc"), INT2FIX(event->rc));
@@ -251,39 +267,39 @@ VALUE zkrb_event_to_ruby(zkrb_event_t *event) {
       break;
     }
     case ZKRB_STAT: {
-      if (ZKRBDebugging) fprintf(stderr, "zkrb_event_to_ruby ZKRB_STAT\n");
+      zkrb_debug("zkrb_event_to_ruby ZKRB_STAT\n");
       struct zkrb_stat_completion *stat_ctx = event->completion.stat_completion;
       rb_hash_aset(hash, GET_SYM("stat"), stat_ctx->stat ? zkrb_stat_to_rarray(stat_ctx->stat) : Qnil);
       break;
     }
     case ZKRB_STRING: {
-      if (ZKRBDebugging) fprintf(stderr, "zkrb_event_to_ruby ZKRB_STRING\n");
+      zkrb_debug("zkrb_event_to_ruby ZKRB_STRING\n");
       struct zkrb_string_completion *string_ctx = event->completion.string_completion;
       rb_hash_aset(hash, GET_SYM("string"), string_ctx->value ? rb_str_new2(string_ctx->value) : Qnil);
       break;
     }
     case ZKRB_STRINGS: {
-      if (ZKRBDebugging) fprintf(stderr, "zkrb_event_to_ruby ZKRB_STRINGS\n");
+      zkrb_debug("zkrb_event_to_ruby ZKRB_STRINGS\n");
       struct zkrb_strings_completion *strings_ctx = event->completion.strings_completion;
       rb_hash_aset(hash, GET_SYM("strings"), strings_ctx->values ? zkrb_string_vector_to_ruby(strings_ctx->values) : Qnil);
       break;
     }
     case ZKRB_STRINGS_STAT: {
-      if (ZKRBDebugging) fprintf(stderr, "zkrb_event_to_ruby ZKRB_STRINGS_STAT\n");
+      zkrb_debug("zkrb_event_to_ruby ZKRB_STRINGS_STAT\n");
       struct zkrb_strings_stat_completion *strings_stat_ctx = event->completion.strings_stat_completion;
       rb_hash_aset(hash, GET_SYM("strings"), strings_stat_ctx->values ? zkrb_string_vector_to_ruby(strings_stat_ctx->values) : Qnil);
       rb_hash_aset(hash, GET_SYM("stat"), strings_stat_ctx->stat ? zkrb_stat_to_rarray(strings_stat_ctx->stat) : Qnil);
       break;
     }
     case ZKRB_ACL: {
-      if (ZKRBDebugging) fprintf(stderr, "zkrb_event_to_ruby ZKRB_ACL\n");
+      zkrb_debug("zkrb_event_to_ruby ZKRB_ACL\n");
       struct zkrb_acl_completion *acl_ctx = event->completion.acl_completion;
       rb_hash_aset(hash, GET_SYM("acl"), acl_ctx->acl ? zkrb_acl_vector_to_ruby(acl_ctx->acl) : Qnil);
       rb_hash_aset(hash, GET_SYM("stat"), acl_ctx->stat ? zkrb_stat_to_rarray(acl_ctx->stat) : Qnil);
       break;
     }
     case ZKRB_WATCHER: {
-      if (ZKRBDebugging) fprintf(stderr, "zkrb_event_to_ruby ZKRB_WATCHER\n");
+      zkrb_debug("zkrb_event_to_ruby ZKRB_WATCHER\n");
       struct zkrb_acl_completion *acl_ctx = event->completion.acl_completion;
       struct zkrb_watcher_completion *watcher_ctx = event->completion.watcher_completion;
       rb_hash_aset(hash, GET_SYM("type"), INT2FIX(watcher_ctx->type));
@@ -321,8 +337,11 @@ void zkrb_print_stat(const struct Stat *s) {
 
 zkrb_calling_context *zkrb_calling_context_alloc(int64_t req_id, zkrb_queue_t *queue) {
   zkrb_calling_context *ctx = malloc(sizeof(zkrb_calling_context));
+  if (!ctx) return NULL;
+
   ctx->req_id = req_id;
   ctx->queue  = queue;
+
   return ctx;
 }
 

data/ext/zookeeper_lib.h

@@ -11,6 +11,11 @@
 #define ZK_FALSE 0
 #define ZKRB_GLOBAL_REQ -1
 
+// (slyphon): this RC value does not conflict with any of the ZOO_ERRORS
+// but need to find a better way of formalizing and defining this stuff
+#define ZKRB_ERR_REQ -2
+#define ZKRB_ERR_RC -15
+
 #ifndef RSTRING_LEN
 # define RSTRING_LEN(x) RSTRING(x)->len
 #endif
@@ -88,14 +93,16 @@ typedef struct {
   } completion;
 } zkrb_event_t;
 
-struct zkrb_event_ll_t {
-  zkrb_event_t           *event;
-  struct zkrb_event_ll_t *next;
+struct zkrb_event_ll {
+  zkrb_event_t         *event;
+  struct zkrb_event_ll *next;
 };
 
+typedef struct zkrb_event_ll zkrb_event_ll_t;
+
 typedef struct {
-  struct zkrb_event_ll_t *head;
-  struct zkrb_event_ll_t *tail;
+  zkrb_event_ll_t *head;
+  zkrb_event_ll_t *tail;
   int                     pipe_read;
   int                     pipe_write;
 } zkrb_queue_t;

data/slyphon-zookeeper.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "slyphon-zookeeper"
-  s.version     = '0.9.1'
+  s.version     = '0.9.2'
 
   s.authors     = ["Phillip Pearson", "Eric Maland", "Evan Weaver", "Brian Wickman", "Neil Conway", "Jonathan D. Simms"]
   s.email       = ["slyphon@gmail.com"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: slyphon-zookeeper
 version: !ruby/object:Gem::Version 
-  hash: 57
+  hash: 63
   prerelease: 
   segments: 
   - 0
   - 9
-  - 1
-  version: 0.9.1
+  - 2
+  version: 0.9.2
 platform: ruby
 authors: 
 - Phillip Pearson
@@ -20,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-26 00:00:00 Z
+date: 2012-04-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -62,7 +62,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 1122853127
+        hash: 2025692189
         segments: 
         - 1
         - 0