iodine 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5dd781b994de37f715d28a0bb3d2116d0130ec7
-  data.tar.gz: ef6e1fb31118a909c479c5b3a5eca55984794cfa
+  metadata.gz: 765b6fa27478c971c926fe4010ebde8c95d970a3
+  data.tar.gz: 740963e010629bb812d6de4e4167375bed0b0bf3
 SHA512:
-  metadata.gz: dcc16cec26d57a181e7883fef1772abff857f07c5d20ef7900f3ea1c63e953061567185d0456be14b6dfa8e827f7637720555455e38b5146ddcba26ca2d41eee
-  data.tar.gz: 1ca3bb3ccd3d45ad069e9093af6cecdd73c08ccb9b6018394f4ca1467cc7ae157cdcee248da32c5f5e82e91f5042a98d6173f10eeecf073225415c67bf9c7d97
+  metadata.gz: 9ebd38a0c3442d787af596ca73a26481673697727e891026355722a33e897d3a631c4569669bfb041c61653df0c2248a3b51a20780002c9603e36fa538ea67e0
+  data.tar.gz: 2e31973b2bc6ec931001c8cdac8a09bd3e3d3ac6fb74e8c7749d80f0daf4419057f95db0151c3205eb441c4a3ac07c3938ea5e9a52c98944ea1b39c8a86328fc

data/.travis.yml

@@ -5,9 +5,10 @@ os:
 before_install:
   - gem install bundler -v 1.10.6
 rvm:
-  - 2.2.4
-  - 2.3.0
+  - ruby-2.4.0-rc1
   - 2.3.1
+  - 2.3.0
+  - 2.2.4
   - 2.2.2
 notifications:
   email: false

data/CHANGELOG.md

@@ -8,6 +8,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+Change log v.0.2.5
+
+**Fix:**: fix for issue #9 (credit to Jack Christensen for exposing the issue) caused by an unlocked critical section's "window of opportunity" that allowed asynchronous Websocket `each` blocks to run during the tail of the Websocket handshake (while the `on_open` callback was running in parallel).
+
+**Minor Fix**: Fix Iodine::Rack's startup message's `fprint` call to fit correct argument sizes (Linux warnings).
+
+***
+
 Change log v.0.2.4
 
 **Minor Fix**: Patched Iodine against Apple's broken `getrlimit` on macOS. This allows correct auto-setting of open file limits for the socket layer.

data/SPEC-Websocket-Draft.md

@@ -60,11 +60,11 @@ Server settings **MAY** (not required) be provided to allow for customization an
 
 ## Upgrading
 
-* **Server**: When an upgrade request is received, the server will set the `env['upgrade.websockets?']` flag to `true`, indicating that: 1. this specific request is upgradable; and 2. this server supports specification.
+* **Server**: When an upgrade request is received, the server will set the `env['upgrade.websocket?']` flag to `true`, indicating that: 1. this specific request is upgradable; and 2. this server supports specification.
 
-* **Client**: When a client decides to upgrade a request, they will place a Websocket Callback Object (either a class or an instance) in the `env['upgrade.websockets']` Hash key.
+* **Client**: When a client decides to upgrade a request, they will place a Websocket Callback Object (either a class or an instance) in the `env['upgrade.websocket']` Hash key.
 
-* **Server**: The server will review the `env` Hash *before* sending the response. If the `env['upgrade.websockets']` was set, the server will perform the upgrade.
+* **Server**: The server will review the `env` Hash *before* sending the response. If the `env['upgrade.websocket']` was set, the server will perform the upgrade.
 
  * **Server**: The server will send the correct response status and headers, as will as any headers present in the response. The server will also perform any required housekeeping, such as closing the response body, if exists.
 

data/ext/iodine/iodine_http.c

@@ -553,22 +553,22 @@ int iodine_http_review(void) {
     if (public_folder)
       fprintf(stderr, "Starting up Iodine Http Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
-                      " * %d processes X %d thread%s\n"
-                      " * %d max concurrent connections / open files\n"
+                      " * %lu processes X %lu thread%s\n"
+                      " * %lu max concurrent connections / open files\n"
                       " * Serving static files from:\n"
                       "           %s\n\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
-              processes, threads, (threads > 1 ? "s" : ""), sock_max_capacity(),
-              public_folder);
+              (size_t)processes, (size_t)threads, (threads > 1 ? "s" : ""),
+              (size_t)sock_max_capacity(), public_folder);
     else
       fprintf(stderr, "Starting up Iodine Http Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
-                      " * %d processes X %d thread%s\n"
-                      " * %d max concurrent connections / open files\n"
+                      " * %lu processes X %lu thread%s\n"
+                      " * %lu max concurrent connections / open files\n"
                       "\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
-              processes, threads, (threads > 1 ? "s" : ""),
-              sock_max_capacity());
+              (size_t)processes, (size_t)threads, (threads > 1 ? "s" : ""),
+              (size_t)sock_max_capacity());
 
     // listen
     return http1_listen(port, address, .on_request = on_rack_request,

data/ext/iodine/iodine_websocket.c

@@ -1,10 +1,10 @@
+#include "iodine_websocket.h"
 #include "iodine_core.h"
 #include "iodine_http.h"
-#include "iodine_websocket.h"
 #include "rb-call.h"
 #include "rb-registry.h"
-#include <ruby/io.h>
 #include <arpa/inet.h>
+#include <ruby/io.h>
 
 /* *****************************************************************************
 Core helpers and data
@@ -31,6 +31,8 @@ inline static intptr_t get_uuid(VALUE obj) {
 
 inline static ws_s *get_ws(VALUE obj) {
   VALUE i = rb_ivar_get(obj, ws_var_id);
+  if (i == Qnil)
+    return NULL;
   return (ws_s *)FIX2ULONG(i);
 }
 
@@ -126,8 +128,14 @@ static VALUE iodine_ws_close(VALUE self) {
  * global `write` buffer is full, `write` will block until a buffer "packet"
  * becomes available and can be assigned to the socket. */
 static VALUE iodine_ws_write(VALUE self, VALUE data) {
+  Check_Type(data, T_STRING);
   ws_s *ws = get_ws(self);
-  if (((protocol_s *)ws)->service != WEBSOCKET_ID_STR)
+  // if ((void *)ws == (void *)0x04 || (void *)data == (void *)0x04 ||
+  //     RSTRING_PTR(data) == (void *)0x04)
+  //   fprintf(stderr, "iodine_ws_write: self = %p ; data = %p\n"
+  //                   "\t\tString ptr: %p, String length: %lu\n",
+  //           (void *)ws, (void *)data, RSTRING_PTR(data), RSTRING_LEN(data));
+  if (!ws || ((protocol_s *)ws)->service != WEBSOCKET_ID_STR)
     return Qfalse;
   websocket_write(ws, RSTRING_PTR(data), RSTRING_LEN(data),
                   rb_enc_get(data) == UTF8Encoding);
@@ -252,6 +260,11 @@ i.e.:
         msg = data.dup; # data will be overwritten once the function exists.
         each {|ws| ws.write msg}
       end
+
+
+The block of code will be executed asynchronously, to avoid having two blocks
+of code running at the same time and minimizing race conditions when using
+multilple threads.
  */
 static VALUE iodine_ws_each(VALUE self) {
   // requires a block to be passed
@@ -268,7 +281,8 @@ static VALUE iodine_ws_each(VALUE self) {
 /**
 Runs the required block for each dynamic protocol connection.
 
-Tasks will be performed within each connections lock, so no connection will have
+Tasks will be performed asynchronously, within each connections lock, so no
+connection will have
 more then one task being performed at the same time (similar to {#defer}).
 
 Also, unlike {Iodine.run}, the block will **not** be called unless the
@@ -425,8 +439,8 @@ static VALUE empty_func(VALUE self) { return Qnil; }
 // initialize the class and the whole of the Iodine/http library
 void Init_iodine_websocket(void) {
   // get IDs and data that's used often
-  ws_var_id = rb_intern("ws_ptr"); // when upgrading
-  dup_func_id = rb_intern("dup");  // when upgrading
+  ws_var_id = rb_intern("iodine_ws_ptr"); // when upgrading
+  dup_func_id = rb_intern("dup");         // when upgrading
 
   // the Ruby websockets protocol class.
   rWebsocket = rb_define_module_under(Iodine, "Websocket");

data/ext/iodine/libasync.c

@@ -11,17 +11,17 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include "libasync.h"
 
-#include <stdlib.h>
-#include <stdio.h>
 #include <errno.h>
-#include <signal.h>
-#include <unistd.h>
 #include <execinfo.h>
-#include <pthread.h>
 #include <fcntl.h>
+#include <pthread.h>
 #include <sched.h>
-#include <sys/mman.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
 
 /* *****************************************************************************
 Performance options.
@@ -43,7 +43,7 @@ Performance options.
 
 /* Sentinal thread to respawn crashed threads - limited crash resistance. */
 #ifndef ASYNC_USE_SENTINEL
-#define ASYNC_USE_SENTINEL 0
+#define ASYNC_USE_SENTINEL 1
 #endif
 
 /* *****************************************************************************
@@ -457,11 +457,13 @@ Test
 
 #define ASYNC_SPEED_TEST_THREAD_COUNT 120
 
-static size_t _Atomic i_count = 0;
+static spn_lock_i i_lock = SPN_LOCK_INIT;
+static size_t i_count = 0;
 
 static void sample_task(void *_) {
-  __asm__ volatile("" ::: "memory");
-  atomic_fetch_add(&i_count, 1);
+  spn_lock(&i_lock);
+  i_count++;
+  spn_unlock(&i_lock);
 }
 
 static void sched_sample_task(void *_) {
@@ -471,8 +473,9 @@ static void sched_sample_task(void *_) {
 }
 
 static void text_task_text(void *_) {
-  __asm__ volatile("" ::: "memory");
+  spn_lock(&i_lock);
   fprintf(stderr, "this text should print before async_finish returns\n");
+  spn_unlock(&i_lock);
 }
 
 static void text_task(void *_) {
@@ -491,7 +494,9 @@ static void evil_task(void *_) {
 #endif
 
 void async_test_library_speed(void) {
-  atomic_store(&i_count, 0);
+  spn_lock(&i_lock);
+  i_count = 0;
+  spn_unlock(&i_lock);
   time_t start, end;
   fprintf(stderr, "Starting Async testing\n");
   if (async_start(ASYNC_SPEED_TEST_THREAD_COUNT) == 0) {
@@ -506,7 +511,7 @@ void async_test_library_speed(void) {
     async_finish();
     end = clock();
     fprintf(stderr, "Async performance test %lu cycles with i_count = %lu\n",
-            end - start, atomic_load(&i_count));
+            end - start, i_count);
   } else {
     fprintf(stderr, "Async test couldn't be initialized\n");
     exit(-1);

data/ext/iodine/libserver.c

@@ -8,12 +8,12 @@ Feel free to copy, use and enjoy according to the license provided.
 #define _GNU_SOURCE
 #endif
 #include "libserver.h"
-#include <string.h>
-#include <signal.h>
+#include <errno.h>
 #include <pthread.h>
+#include <signal.h>
+#include <string.h>
 #include <sys/mman.h>
 #include <sys/wait.h>
-#include <errno.h>
 
 /* *****************************************************************************
 Connection Data

data/ext/iodine/rb-call.c

@@ -1,18 +1,15 @@
 #include "rb-call.h"
+#include <pthread.h>
 #include <ruby.h>
 #include <ruby/thread.h>
-#include <pthread.h>
+
+#if __STDC_VERSION__ < 201112L || __STDC_NO_THREADS__
+#define _Thread_local __thread
+#endif
 
 ///////////////
 // this is a simple helper that calls Ruby methods on Ruby objects while within
 // a non-GVL ruby thread zone.
-
-// a structure for Ruby API calls
-struct RubySimpleCall {
-  VALUE obj;
-  VALUE returned;
-  ID method;
-};
 struct RubyArgCall {
   VALUE obj;
   int argc;
@@ -21,25 +18,10 @@ struct RubyArgCall {
   ID method;
 };
 
-#if __STDC_VERSION__ < 201112L || __STDC_NO_THREADS__
-#define _Thread_local __thread
-#endif
-
-// a thread specific global variable that lets us know if we're in the GVL
-static _Thread_local char in_gvl = 0;
-static char check_in_gvl(void) { return in_gvl; }
-
-////////////////////////////////////////////////////////////////////////////
-// Calling C functions.
-static void *call_c(void *(*func)(void *), void *arg) {
-  if (in_gvl) {
-    return func(arg);
-  }
-  void *ret;
-  in_gvl = 1;
-  ret = rb_thread_call_with_gvl(func, arg);
-  in_gvl = 0;
-  return ret;
+// running the actual method call
+static VALUE run_ruby_method_unsafe(VALUE _tsk) {
+  struct RubyArgCall *task = (void *)_tsk;
+  return rb_funcall2(task->obj, task->method, task->argc, task->argv);
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -67,18 +49,9 @@ static void *handle_exception(void *_) {
   return (void *)Qnil;
 }
 
-////////////////////////////////////////////////////////////////////////////
-// A simple (and a bit lighter) design for when there's no need for arguments.
-
-// running the actual method call
-static VALUE run_ruby_method_unsafe(VALUE _tsk) {
-  struct RubySimpleCall *task = (void *)_tsk;
-  return rb_funcall2(task->obj, task->method, 0, NULL);
-}
-
 // GVL gateway
 static void *run_ruby_method_within_gvl(void *_tsk) {
-  struct RubySimpleCall *task = _tsk;
+  struct RubyArgCall *task = _tsk;
   int state = 0;
   task->returned = rb_protect(run_ruby_method_unsafe, (VALUE)(task), &state);
   if (state)
@@ -86,9 +59,32 @@ static void *run_ruby_method_within_gvl(void *_tsk) {
   return task;
 }
 
+////////////////////////////////////////////////////////////////////////////
+// GVL state.
+
+// a thread specific global variable that lets us know if we're in the GVL
+static _Thread_local char in_gvl = 0;
+static char check_in_gvl(void) { return in_gvl; }
+
+////////////////////////////////////////////////////////////////////////////
+// Calling C functions.
+static void *call_c(void *(*func)(void *), void *arg) {
+  if (in_gvl) {
+    return func(arg);
+  }
+  void *ret;
+  in_gvl = 1;
+  ret = rb_thread_call_with_gvl(func, arg);
+  in_gvl = 0;
+  return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// A simple (and a bit lighter) design for when there's no need for arguments.
+
 // wrapping any API calls for exception management AND GVL entry
 static VALUE call(VALUE obj, ID method) {
-  struct RubySimpleCall task = {.obj = obj, .method = method};
+  struct RubyArgCall task = {.obj = obj, .method = method};
   call_c(run_ruby_method_within_gvl, &task);
   return task.returned;
 }
@@ -96,32 +92,20 @@ static VALUE call(VALUE obj, ID method) {
 ////////////////////////////////////////////////////////////////////////////
 // A heavier (memory) design for when we're passing arguments around.
 
-// running the actual method call
-static VALUE run_argv_method_unsafe(VALUE _tsk) {
-  struct RubyArgCall *task = (void *)_tsk;
-  return rb_funcall2(task->obj, task->method, task->argc, task->argv);
-}
-
-// GVL gateway
-static void *run_argv_method_within_gvl(void *_tsk) {
-  struct RubyArgCall *task = _tsk;
-  int state = 0;
-  task->returned = rb_protect(run_argv_method_unsafe, (VALUE)(task), &state);
-  if (state)
-    handle_exception(NULL);
-  return task;
-}
-
 // wrapping any API calls for exception management AND GVL entry
 static VALUE call_arg(VALUE obj, ID method, int argc, VALUE *argv) {
   struct RubyArgCall task = {
       .obj = obj, .method = method, .argc = argc, .argv = argv};
-  call_c(run_argv_method_within_gvl, &task);
+  call_c(run_ruby_method_within_gvl, &task);
   return task.returned;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // the API interface
 struct _Ruby_Method_Caller_Class_ RubyCaller = {
-    .call = call, .call2 = call_arg, .call_c = call_c, .in_gvl = check_in_gvl,
+    .call = call,
+    .call2 = call_arg,
+    .call_c = call_c,
+    // .leave_gvl = leave_gvl,
+    .in_gvl = check_in_gvl,
 };

data/ext/iodine/rb-call.c_old

@@ -0,0 +1,127 @@
+#include "rb-call.h"
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <pthread.h>
+
+///////////////
+// this is a simple helper that calls Ruby methods on Ruby objects while within
+// a non-GVL ruby thread zone.
+
+// a structure for Ruby API calls
+struct RubySimpleCall {
+  VALUE obj;
+  VALUE returned;
+  ID method;
+};
+struct RubyArgCall {
+  VALUE obj;
+  int argc;
+  VALUE *argv;
+  VALUE returned;
+  ID method;
+};
+
+#if __STDC_VERSION__ < 201112L || __STDC_NO_THREADS__
+#define _Thread_local __thread
+#endif
+
+// a thread specific global variable that lets us know if we're in the GVL
+static _Thread_local char in_gvl = 0;
+static char check_in_gvl(void) { return in_gvl; }
+
+////////////////////////////////////////////////////////////////////////////
+// Calling C functions.
+static void *call_c(void *(*func)(void *), void *arg) {
+  if (in_gvl) {
+    return func(arg);
+  }
+  void *ret;
+  in_gvl = 1;
+  ret = rb_thread_call_with_gvl(func, arg);
+  in_gvl = 0;
+  return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// Handling exceptions (printing the backtrace doesn't really work well).
+static void *handle_exception(void *_) {
+  VALUE exc = rb_errinfo();
+  if (exc != Qnil) {
+    VALUE msg = RubyCaller.call(exc, rb_intern("message"));
+    VALUE exc_class = rb_class_name(CLASS_OF(exc));
+    VALUE bt = RubyCaller.call(exc, rb_intern("backtrace"));
+    if (TYPE(bt) == T_ARRAY) {
+      bt = rb_ary_join(bt, rb_str_new_literal("\n"));
+      fprintf(stderr, "Iodine caught an unprotected exception - %.*s: %.*s\n%s",
+              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
+              (int)RSTRING_LEN(msg), RSTRING_PTR(msg), StringValueCStr(bt));
+    } else {
+      fprintf(stderr, "Iodine caught an unprotected exception - %.*s: %.*s\n"
+                      "No backtrace available.\n",
+              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
+              (int)RSTRING_LEN(msg), RSTRING_PTR(msg));
+    }
+    rb_backtrace();
+    rb_set_errinfo(Qnil);
+  }
+  return (void *)Qnil;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// A simple (and a bit lighter) design for when there's no need for arguments.
+
+// running the actual method call
+static VALUE run_ruby_method_unsafe(VALUE _tsk) {
+  struct RubySimpleCall *task = (void *)_tsk;
+  return rb_funcall2(task->obj, task->method, 0, NULL);
+}
+
+// GVL gateway
+static void *run_ruby_method_within_gvl(void *_tsk) {
+  struct RubySimpleCall *task = _tsk;
+  int state = 0;
+  task->returned = rb_protect(run_ruby_method_unsafe, (VALUE)(task), &state);
+  if (state)
+    handle_exception(NULL);
+  return task;
+}
+
+// wrapping any API calls for exception management AND GVL entry
+static VALUE call(VALUE obj, ID method) {
+  struct RubySimpleCall task = {.obj = obj, .method = method};
+  call_c(run_ruby_method_within_gvl, &task);
+  return task.returned;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// A heavier (memory) design for when we're passing arguments around.
+
+// running the actual method call
+static VALUE run_argv_method_unsafe(VALUE _tsk) {
+  struct RubyArgCall *task = (void *)_tsk;
+  return rb_funcall2(task->obj, task->method, task->argc, task->argv);
+}
+
+// GVL gateway
+static void *run_argv_method_within_gvl(void *_tsk) {
+  struct RubyArgCall *task = _tsk;
+  int state = 0;
+  task->returned = rb_protect(run_argv_method_unsafe, (VALUE)(task), &state);
+  if (state)
+    handle_exception(NULL);
+  return task;
+}
+
+// wrapping any API calls for exception management AND GVL entry
+static VALUE call_arg(VALUE obj, ID method, int argc, VALUE *argv) {
+  struct RubyArgCall task = {
+      .obj = obj, .method = method, .argc = argc, .argv = argv};
+  call_c(run_argv_method_within_gvl, &task);
+  return task.returned;
+}
+
+////////////////////////////////////////////////////////////////////////////
+// the API interface
+struct _Ruby_Method_Caller_Class_ RubyCaller = {
+    .call = call, .call2 = call_arg, .call_c = call_c, .in_gvl = check_in_gvl,
+};

data/ext/iodine/rb-registry.c

@@ -1,11 +1,20 @@
 #include "rb-registry.h"
-#include <ruby.h>
 #include "spnlock.h"
+#include <ruby.h>
 
 // #define RUBY_REG_DBG
 
+#define REGISTRY_POOL_SIZE 1024
+// the references struct (bin-tree)
+struct Object {
+  struct Object *next;
+  VALUE obj;
+  int count;
+};
+
 // the registry global
 static struct Registry {
+  struct Object pool_mem[REGISTRY_POOL_SIZE];
   struct Object *obj_pool;
   struct Object *first;
   VALUE owner;
@@ -17,28 +26,14 @@ static struct Registry {
 #define unlock_registry() spn_unlock(&registry.lock)
 #define lock_registry() spn_lock(&registry.lock)
 
-// the references struct (bin-tree)
-struct Object {
-  struct Object *next;
-  VALUE obj;
-  int count;
-};
-
-// manage existing objects - add a reference
-int add_reference(VALUE obj) {
-  struct Object *line;
-  lock_registry();
-  line = registry.first;
-  while (line) {
-    if (line->obj == obj) {
-      line->count++;
-      unlock_registry();
-      return 1;
-    }
-    line = line->next;
+inline static void free_node(struct Object *to_free) {
+  if (to_free >= registry.pool_mem &&
+      (intptr_t)to_free <= (intptr_t)(&registry.obj_pool)) {
+    to_free->next = registry.obj_pool;
+    registry.obj_pool = to_free;
+  } else {
+    free(to_free);
   }
-  unlock_registry();
-  return 0;
 }
 
 // add an object to the registry
@@ -47,25 +42,30 @@ int add_reference(VALUE obj) {
 static VALUE register_object(VALUE obj) {
   if (!obj || obj == Qnil)
     return 0;
-  if (add_reference(obj))
-    return obj;
-  struct Object *line;
+  struct Object *line = registry.first;
   lock_registry();
+  while (line) {
+    if (line->obj == obj) {
+      line->count++;
+      goto finish;
+    }
+    line = line->next;
+  }
   if (registry.obj_pool) {
     line = registry.obj_pool;
     registry.obj_pool = registry.obj_pool->next;
   } else {
     line = malloc(sizeof(struct Object));
   }
-  if (!line) {
-    perror("No Memory");
-    unlock_registry();
-    return 0;
+  if (line == NULL) {
+    perror("No Memory!");
+    exit(1);
   }
   line->obj = obj;
   line->next = registry.first;
   line->count = 1;
   registry.first = line;
+finish:
   unlock_registry();
   return obj;
 }
@@ -77,24 +77,18 @@ static void unregister_object(VALUE obj) {
   if (!obj || obj == Qnil)
     return;
   lock_registry();
-  struct Object *line = registry.first;
-  struct Object *prev = NULL;
-  while (line) {
-    if (line->obj == obj) {
-      line->count--;
-      if (!line->count) {
-        if (line == registry.first)
-          registry.first = line->next;
-        else if (prev) // must be true, really
-          prev->next = line->next;
-        // move the object container to the discarded object pool
-        line->next = registry.obj_pool;
-        registry.obj_pool = line;
+  struct Object **line = &registry.first;
+  while (*line) {
+    if ((*line)->obj == obj) {
+      (*line)->count -= 1;
+      if ((*line)->count <= 0) {
+        struct Object *to_free = *line;
+        *line = (*line)->next;
+        free_node(to_free);
+        goto finish;
       }
-      goto finish;
     }
-    prev = line;
-    line = line->next;
+    line = &((*line)->next);
   }
 finish:
   unlock_registry();
@@ -148,17 +142,9 @@ static void registry_clear(void *ignore) {
   while (line) {
     to_free = line;
     line = line->next;
-    free(to_free);
+    free_node(to_free);
   }
   registry.first = NULL;
-  // free container pool
-  line = registry.obj_pool;
-  while (line) {
-    to_free = line;
-    line = line->next;
-    free(to_free);
-  }
-  registry.obj_pool = NULL;
   registry.owner = 0;
   unlock_registry();
 }
@@ -174,6 +160,7 @@ static struct rb_data_type_struct my_registry_type_struct = {
 // initialize the registry
 static void init(VALUE owner) {
   lock_registry();
+  // only one registry
   if (registry.owner)
     goto finish;
   if (!owner)
@@ -184,6 +171,12 @@ static void init(VALUE owner) {
   VALUE r_registry =
       TypedData_Wrap_Struct(rReferences, &my_registry_type_struct, &registry);
   rb_ivar_set(owner, rb_intern("registry"), r_registry);
+  // initialize memory pool
+  for (size_t i = 0; i < REGISTRY_POOL_SIZE - 1; i++) {
+    registry.pool_mem[i].next = registry.pool_mem + i + 1;
+  }
+  registry.pool_mem[REGISTRY_POOL_SIZE - 1].next = NULL;
+  registry.obj_pool = registry.pool_mem;
 finish:
   unlock_registry();
 }

data/ext/iodine/rb-registry_old.c_old

@@ -0,0 +1,213 @@
+#include "rb-registry.h"
+#include "spnlock.h"
+#include <ruby.h>
+
+// #define RUBY_REG_DBG
+
+// the registry global
+static struct Registry {
+  struct Object *obj_pool;
+  struct Object *first;
+  VALUE owner;
+  spn_lock_i lock;
+} registry = {
+    .obj_pool = NULL, .first = NULL, .owner = 0, .lock = SPN_LOCK_INIT};
+
+#define try_lock_registry() spn_trylock(&registry.lock)
+#define unlock_registry() spn_unlock(&registry.lock)
+#define lock_registry() spn_lock(&registry.lock)
+
+// the references struct (bin-tree)
+struct Object {
+  struct Object *next;
+  VALUE obj;
+  int count;
+};
+
+// manage existing objects - add a reference
+int add_reference(VALUE obj) {
+  struct Object *line;
+  lock_registry();
+  line = registry.first;
+  while (line) {
+    if (line->obj == obj) {
+      line->count++;
+      unlock_registry();
+      return 1;
+    }
+    line = line->next;
+  }
+  unlock_registry();
+  return 0;
+}
+
+// add an object to the registry
+//
+// allow multiple registrartions (bag)
+static VALUE register_object(VALUE obj) {
+  if (!obj || obj == Qnil)
+    return 0;
+  if (add_reference(obj))
+    return obj;
+  struct Object *line;
+  lock_registry();
+  if (registry.obj_pool) {
+    line = registry.obj_pool;
+    registry.obj_pool = registry.obj_pool->next;
+  } else {
+    line = malloc(sizeof(struct Object));
+  }
+  if (!line) {
+    perror("No Memory!");
+    unlock_registry();
+    return 0;
+  }
+  line->obj = obj;
+  line->next = registry.first;
+  line->count = 1;
+  registry.first = line;
+  unlock_registry();
+  return obj;
+}
+
+// free a single registry
+//
+// free only one.
+static void unregister_object(VALUE obj) {
+  if (!obj || obj == Qnil)
+    return;
+  lock_registry();
+  struct Object *line = registry.first;
+  struct Object *prev = NULL;
+  while (line) {
+    if (line->obj == obj) {
+      line->count--;
+      if (!line->count) {
+        if (line == registry.first)
+          registry.first = line->next;
+        else if (prev) // must be true, really
+          prev->next = line->next;
+        // move the object container to the discarded object pool
+        line->next = registry.obj_pool;
+        registry.obj_pool = line;
+      }
+      goto finish;
+    }
+    prev = line;
+    line = line->next;
+  }
+finish:
+  unlock_registry();
+}
+
+// // Replaces one registry object with another,
+// // allowing updates to the Registry with no memory allocations.
+// //
+// // returns 0 if all OK, returns -1 if it couldn't replace the object.
+// static int replace_object(VALUE obj, VALUE new_obj) {
+//   int ret = -1;
+//   if (obj == new_obj)
+//     return 0;
+//   pthread_mutex_lock(&registry_lock);
+//   struct Object* line = registry.first;
+//   while (line) {
+//     if (line->obj == obj) {
+//       line->obj = new_obj;
+//       ret = 0;
+//       goto finish;
+//     }
+//     line = line->next;
+//   }
+// finish:
+//   pthread_mutex_unlock(&registry_lock);
+//   return ret;
+// }
+
+// a callback for the GC (marking active objects)
+static void registry_mark(void *ignore) {
+#ifdef RUBY_REG_DBG
+  Registry.print();
+#endif
+  lock_registry();
+  struct Object *line = registry.first;
+  while (line) {
+    if (line->obj)
+      rb_gc_mark(line->obj);
+    line = line->next;
+  }
+  unlock_registry();
+}
+
+// clear the registry (end of lifetime)
+static void registry_clear(void *ignore) {
+  lock_registry();
+  struct Object *line;
+  struct Object *to_free;
+  // free active object references
+  line = registry.first;
+  while (line) {
+    to_free = line;
+    line = line->next;
+    free(to_free);
+  }
+  registry.first = NULL;
+  // free container pool
+  line = registry.obj_pool;
+  while (line) {
+    to_free = line;
+    line = line->next;
+    free(to_free);
+  }
+  registry.obj_pool = NULL;
+  registry.owner = 0;
+  unlock_registry();
+}
+
+// the data-type used to identify the registry
+// this sets the callbacks.
+static struct rb_data_type_struct my_registry_type_struct = {
+    .wrap_struct_name = "RubyReferencesIn_C_Land",
+    .function.dfree = (void (*)(void *))registry_clear,
+    .function.dmark = (void (*)(void *))registry_mark,
+};
+
+// initialize the registry
+static void init(VALUE owner) {
+  lock_registry();
+  if (registry.owner)
+    goto finish;
+  if (!owner)
+    owner = rb_cObject;
+  registry.owner = owner;
+  VALUE rReferences =
+      rb_define_class_under(owner, "RubyObjectRegistry_for_C_land", rb_cData);
+  VALUE r_registry =
+      TypedData_Wrap_Struct(rReferences, &my_registry_type_struct, &registry);
+  rb_ivar_set(owner, rb_intern("registry"), r_registry);
+finish:
+  unlock_registry();
+}
+
+// print data, for testing
+static void print(void) {
+  lock_registry();
+  struct Object *line = registry.first;
+  fprintf(stderr, "Registry owner is %lu\n", registry.owner);
+  long index = 0;
+  while (line) {
+    fprintf(stderr, "[%lu] => %d X obj %lu type %d at %p\n", index++,
+            line->count, line->obj, TYPE(line->obj), line);
+    line = line->next;
+  }
+  fprintf(stderr, "Total of %lu registered objects being marked\n", index);
+  unlock_registry();
+}
+
+////////////////////////////////////////////
+// The API gateway
+struct ___RegistryClass___ Registry = {
+    .init = init,
+    .remove = unregister_object,
+    .add = register_object,
+    .print = print,
+};

data/ext/iodine/websockets.c

@@ -1,10 +1,10 @@
-#include "libserver.h"
 #include "websockets.h"
 #include "bscrypt.h"
-#include <stdlib.h>
+#include "libserver.h"
+#include <arpa/inet.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <arpa/inet.h>
 
 #if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
 #include <endian.h>
@@ -593,8 +593,12 @@ refuse:
   // set the negative response
   response->status = 400;
 cleanup:
-  http_response_finish(response);
   if (response->status == 101) {
+    // set the protocol lock
+    ws->protocol.callback_lock = SPN_LOCK_INIT;
+    spn_lock(&ws->protocol.callback_lock);
+    // send the response
+    http_response_finish(response);
     // update the protocol object, cleanning up the old one
     server_switch_protocol(ws->fd, (void *)ws);
     // we have an active websocket connection - prep the connection buffer
@@ -604,8 +608,10 @@ cleanup:
     // call the on_open callback
     if (settings.on_open)
       server_task(ws->fd, on_open, settings.on_open, NULL);
+    spn_unlock(&ws->protocol.callback_lock);
     return 0;
   }
+  http_response_finish(response);
   destroy_ws(ws);
   return -1;
 }

data/iodine.gemspec

@@ -37,7 +37,7 @@ Gem::Specification.new do |spec|
   spec.requirements << 'A Unix based system: Linux / macOS / BSD.'
   spec.requirements << 'An updated C compiler.'
   spec.requirements << 'Ruby >= 2.2.2'
-  spec.requirements << 'Ruby >= 2.0.0 is recommended.'
+  spec.requirements << 'Ruby >= 2.3.0 is recommended.'
 
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.4'.freeze
+  VERSION = '0.2.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-14 00:00:00.000000000 Z
+date: 2016-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -150,12 +150,14 @@ files:
 - ext/iodine/random.c
 - ext/iodine/random.h
 - ext/iodine/rb-call.c
+- ext/iodine/rb-call.c_old
 - ext/iodine/rb-call.h
 - ext/iodine/rb-libasync.h
 - ext/iodine/rb-rack-io.c
 - ext/iodine/rb-rack-io.h
 - ext/iodine/rb-registry.c
 - ext/iodine/rb-registry.h
+- ext/iodine/rb-registry_old.c_old
 - ext/iodine/sha1.c
 - ext/iodine/sha1.h
 - ext/iodine/sha2.c
@@ -198,7 +200,7 @@ requirements:
 - 'A Unix based system: Linux / macOS / BSD.'
 - An updated C compiler.
 - Ruby >= 2.2.2
-- Ruby >= 2.0.0 is recommended.
+- Ruby >= 2.3.0 is recommended.
 rubyforge_project: 
 rubygems_version: 2.5.2
 signing_key: