slyphon-zookeeper 0.1.7-java → 0.2.0-java

data/.gitignore

@@ -6,3 +6,4 @@
 Makefile
 pkg
 zookeeper.gemspec
+Gemfile.lock

data/ext/zookeeper_base.rb

@@ -16,7 +16,8 @@ class ZookeeperBase < CZookeeper
   ZOO_LOG_LEVEL_WARN   = 2
   ZOO_LOG_LEVEL_INFO   = 3
   ZOO_LOG_LEVEL_DEBUG  = 4
-  
+
+ 
   def reopen(timeout = 10, watcher=nil)
     watcher ||= @default_watcher
 
@@ -26,13 +27,15 @@ class ZookeeperBase < CZookeeper
       set_default_global_watcher(&watcher)
     end
 
-    init(@host)
+    @start_stop_mutex.synchronize do
+      init(@host)
 
-    if timeout > 0
-      time_to_stop = Time.now + timeout
-      until state == Zookeeper::ZOO_CONNECTED_STATE
-        break if Time.now > time_to_stop
-        sleep 0.1
+      if timeout > 0
+        time_to_stop = Time.now + timeout
+        until state == Zookeeper::ZOO_CONNECTED_STATE
+          break if Time.now > time_to_stop
+          sleep 0.1
+        end
       end
     end
 
@@ -46,9 +49,12 @@ class ZookeeperBase < CZookeeper
     @current_req_id = 1
     @host = host
 
+    @start_stop_mutex = Mutex.new
+
     watcher ||= get_default_global_watcher
 
-    @_running = nil # used by the C layer
+    @_running = nil   # used by the C layer
+    @_closed = false  # also used by the C layer
 
     yield self if block_given?
 
@@ -76,12 +82,32 @@ class ZookeeperBase < CZookeeper
   end
 
   def close
-    @_running = false
-    wake_event_loop!
-    
-    @dispatcher.join
+    @start_stop_mutex.synchronize do
+      @_running = false if @_running
+    end
+
+    if @dispatcher
+      wake_event_loop! unless @_closed
+      @dispatcher.join 
+    end
+
+    @start_stop_mutex.synchronize do
+      unless @_closed
+        close_handle
+        
+        # this is set up in the C init method, but it's easier to 
+        # do the teardown here
+        begin
+          @selectable_io.close if @selectable_io
+        rescue IOError
+        end
+      end
+    end
+  end
 
-    super
+  def set_debug_level(int)
+    warn "DEPRECATION WARNING: #{self.class.name}#set_debug_level, it has moved to the class level and will be removed in a future release"
+    self.class.set_debug_level(int)
   end
 
   # set the watcher object/proc that will receive all global events (such as session/state events)
@@ -92,16 +118,20 @@ class ZookeeperBase < CZookeeper
     end
   end
 
-protected
+  def closed?
+    @start_stop_mutex.synchronize { false|@_closed }
+  end
+
   def running?
-    false|@_running
+    @start_stop_mutex.synchronize { false|@_running }
   end
 
+protected
   def setup_dispatch_thread!
     @dispatcher = Thread.new do
       while running?
         begin                     # calling user code, so protect ourselves
-          dispatch_next_callback 
+          dispatch_next_callback
         rescue Exception => e
           $stderr.puts "Error in dispatch thread, #{e.class}: #{e.message}\n" << e.backtrace.map{|n| "\t#{n}"}.join("\n")
         end

data/ext/zookeeper_c.c

@@ -17,11 +17,16 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
+#include <sys/fcntl.h>
+#include <pthread.h>
 
 #include "zookeeper_lib.h"
 
+
 static VALUE Zookeeper = Qnil;
 
+// slyphon: possibly add a lock to this for synchronizing during get_next_event
+
 struct zkrb_instance_data {
   zhandle_t            *zh;
   clientid_t          myid;
@@ -69,9 +74,53 @@ static void print_zkrb_instance_data(struct zkrb_instance_data* ptr) {
   fprintf(stderr, "}\n");
 }
 
+// cargo culted from io.c
+static VALUE zkrb_new_instance _((VALUE));
+
+static VALUE zkrb_new_instance(VALUE args) {
+    return rb_class_new_instance(2, (VALUE*)args+1, *(VALUE*)args);
+}
+
+static int zkrb_dup(int orig) {
+    int fd;
+
+    fd = dup(orig);
+    if (fd < 0) {
+        if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
+            rb_gc();
+            fd = dup(orig);
+        }
+        if (fd < 0) {
+            rb_sys_fail(0);
+        }
+    }
+    return fd;
+}
+
+static VALUE create_selectable_io(zkrb_queue_t *q) {
+  // rb_cIO is the ruby IO class?
+
+  int pipe, state, read_fd;
+  VALUE args[3], reader;
+
+  read_fd = zkrb_dup(q->pipe_read);
+
+  args[0] = rb_cIO;
+  args[1] = INT2NUM(read_fd);
+  args[2] = INT2FIX(O_RDONLY);
+  reader = rb_protect(zkrb_new_instance, (VALUE)args, &state);
+
+  if (state) {
+    rb_jump_tag(state);
+  }
+
+  return reader;
+}
+
 static VALUE method_init(int argc, VALUE* argv, VALUE self) {
   VALUE hostPort;
   VALUE options;
+
   rb_scan_args(argc, argv, "11", &hostPort, &options);
 
   if (NIL_P(options)) {
@@ -121,8 +170,10 @@ 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);
 
+
   return Qnil;
 }
 
@@ -421,7 +472,10 @@ static int is_running(VALUE self) {
   return RTEST(rval);
 }
 
-static VALUE method_get_next_event(VALUE self) {
+
+/* slyphon: NEED TO PROTECT THIS AGAINST SHUTDOWN */
+
+static VALUE method_get_next_event(VALUE self, VALUE blocking) {
   char buf[64];
   FETCH_DATA_PTR(self, zk);
 
@@ -439,19 +493,35 @@ static VALUE method_get_next_event(VALUE self) {
 
     /* Wait for an event using rb_thread_select() on the queue's pipe */
     if (event == NULL) {
-      int fd = zk->queue->pipe_read;
-      fd_set rset;
+      if (NIL_P(blocking) || (blocking == Qfalse)) { 
+        return Qnil; // no event for us
+      } 
+      else {
+        int fd = zk->queue->pipe_read;
+        ssize_t bytes_read = 0;
+
+        fd_set rset;        // a file descriptor set for use w/ select()
+
+        FD_ZERO(&rset);     // FD_ZERO clears the set
+        FD_SET(fd, &rset);  // FD_SET adds fd to the rset
 
-      FD_ZERO(&rset);
-      FD_SET(fd, &rset);
+        // first arg is nfds: "the highest-numbered file descriptor in any of the three sets, plus 1"
+        // why? F*** you, that's why!
 
-      if (rb_thread_select(fd + 1, &rset, NULL, NULL, NULL) == -1)
-        rb_raise(rb_eRuntimeError, "select failed: %d", errno);
+        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);
+        bytes_read = read(fd, buf, sizeof(buf));
 
-      continue;
+        if (bytes_read == -1) {
+          rb_raise(rb_eRuntimeError, "read failed: %d", errno);
+        }
+        else if (ZKRBDebugging) {
+          fprintf(stderr, "read %d bytes from the queue's pipe\n", bytes_read);
+        }
+
+        continue;
+      }
     }
 
     VALUE hash = zkrb_event_to_ruby(event);
@@ -493,11 +563,22 @@ static VALUE method_wake_event_loop_bang(VALUE self) {
 //   return Qnil;
 // }
 
-static VALUE method_close(VALUE self) {
+static VALUE method_close_handle(VALUE self) {
   FETCH_DATA_PTR(self, zk);
 
+  if (ZKRBDebugging) {
+    fprintf(stderr, "CLOSING ZK INSTANCE:");
+    print_zkrb_instance_data(zk);
+  }
+  
+  // this is a value on the ruby side we can check to see if destroy_zkrb_instance
+  // has been called
+  rb_iv_set(self, "@_closed", Qtrue);
+
+
   /* Note that after zookeeper_close() returns, ZK handle is invalid */
   int rc = destroy_zkrb_instance(zk);
+
   return INT2FIX(rc);
 }
 
@@ -521,8 +602,7 @@ static VALUE method_recv_timeout(VALUE self) {
   return INT2NUM(zoo_recv_timeout(zk->zh));
 }
 
-// how do you make a class method??
-static VALUE method_set_debug_level(VALUE self, VALUE level) {
+static VALUE klass_method_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));
@@ -549,7 +629,7 @@ static void zkrb_define_methods(void) {
   DEFINE_METHOD(set_acl, 5);
   DEFINE_METHOD(get_acl, 3);
   DEFINE_METHOD(client_id, 0);
-  DEFINE_METHOD(close, 0);
+  DEFINE_METHOD(close_handle, 0);
   DEFINE_METHOD(deterministic_conn_order, 1);
   DEFINE_METHOD(is_unrecoverable, 0);
   DEFINE_METHOD(recv_timeout, 1);
@@ -559,13 +639,16 @@ static void zkrb_define_methods(void) {
   // DEFINE_METHOD(async, 1);
 
   // methods for the ruby-side event manager
-  DEFINE_METHOD(get_next_event, 0);
+  DEFINE_METHOD(get_next_event, 1);
   DEFINE_METHOD(has_events, 0);
 
   // Make these class methods?
-  DEFINE_METHOD(set_debug_level, 1);
   DEFINE_METHOD(zerror, 1);
 
+  rb_define_singleton_method(Zookeeper, "set_debug_level", klass_method_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);
 }
 

data/ext/zookeeper_lib.c

@@ -140,18 +140,26 @@ void zkrb_event_free(zkrb_event_t *event) {
     }
     case ZKRB_STRINGS: {
       struct zkrb_strings_completion *strings_ctx = event->completion.strings_completion;
-      int k;
-      for (k = 0; k < strings_ctx->values->count; ++k) free(strings_ctx->values->data[k]);
-      free(strings_ctx->values);
+      if (strings_ctx->values != NULL) {
+        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: {
       struct zkrb_strings_stat_completion *strings_stat_ctx = event->completion.strings_stat_completion;
-      int k;
-      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);
+      if (strings_stat_ctx->values != NULL) {
+        int k;
+        for (k = 0; k < strings_stat_ctx->values->count; ++k) free(strings_stat_ctx->values->data[k]);
+        free(strings_stat_ctx->values);
+      }
+
+      if (strings_stat_ctx->stat != NULL) {
+        free(strings_stat_ctx->stat);
+      }
+
       free(strings_stat_ctx);
       break;
     }
@@ -200,33 +208,40 @@ VALUE zkrb_event_to_ruby(zkrb_event_t *event) {
       break;
     }
     case ZKRB_STAT: {
+      if (ZKRBDebugging) fprintf(stderr, "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");
       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");
       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");
       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");
       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");
+      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));
       rb_hash_aset(hash, GET_SYM("state"), INT2FIX(watcher_ctx->state));
@@ -422,6 +437,7 @@ void zkrb_strings_stat_callback(
   struct zkrb_strings_stat_completion *sc = malloc(sizeof(struct zkrb_strings_stat_completion));
   sc->stat = NULL;
   if (stat != NULL) { sc->stat = malloc(sizeof(struct Stat)); memcpy(sc->stat, stat, sizeof(struct Stat)); }
+
   sc->values = (strings != NULL) ? zkrb_clone_string_vector(strings) : NULL;
 
   ZKH_SETUP_EVENT(queue, event);