iodine 0.4.16 → 0.4.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05830f6522c10a7287f298b6e4b7036ae90c958e28764f485f3e1b231fe8e953'
-  data.tar.gz: 41cfef0ab58ccdcb11f7d9437e6cc9a8454580073c89ad98701dfe9604abba74
+  metadata.gz: 5178eaf9e2ee165e6c1d0dbb166b8c07696152ec5102e897599c16e893171bfe
+  data.tar.gz: d5bfe18ca14d60aef0d2122ce32f216600b44a51d70295fa929693ac10966f04
 SHA512:
-  metadata.gz: e3ff1d96d782bbf698ea13bd23a57972abcc94e2ce155f4863395efc67a91694997d9f44e1d2dd35e4ec5fd181064242e1ff6fb9f08e3208694b2e582a440b23
-  data.tar.gz: c4a014449954157add87616fa7ffe376499204c02b10d313a44b7edba5ccf1a2e865e98ed883e4b9fbf0be8c00f16d0a7def400f30cb84cc4b391f882d2582b4
+  metadata.gz: c982ce0213871aca6041636d5091d09522e6485b31b699ce80aed70ad3d9bf13daeca857d89f6f697b73b401f4bee8ca7a7c0aa5e554c13e2785ebcb21f3c198
+  data.tar.gz: 6a304583f391cbaaa41271277ab291f50c37d34984069e8531cf068d382f2490eaaab4bce488262aa78c8230e6d6cd34e9827500bd5d30bf678fd024d5d55d00

data/CHANGELOG.md

@@ -8,6 +8,10 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ---
 
+#### Change log v.0.4.17
+
+**Fix**: (`iodine RubyCaller`) fixed issue #26 that exposed an issue in the exception handling logic. This fix enforces exception handling whenever entering the Ruby GVL (GIL), allowing C functions to safely enter the user's Ruby code (where before C functions were assumed to be safe and user code would be executed unprotected when routed through certain functions). Credit to @haukot for exposing this issue (issue #26).
+
 #### Change log v.0.4.16
 
 **Fix**: (`websocket_parser`) The websocket parser had a memory offset and alignment handling issue in it's unmasking (XOR) logic and the new memory alignment protection code. The issue would impact the parser in rare occasions when multiple messages where pipelined in the internal buffer and their length produced an odd alignment (the issue would occur with very fast clients, or a very stressed server).

data/README.md

@@ -6,6 +6,10 @@
 [![Inline docs](http://inch-ci.org/github/boazsegev/iodine.svg?branch=master)](http://www.rubydoc.info/github/boazsegev/iodine/master/frames)
 [![GitHub](https://img.shields.io/badge/GitHub-Open%20Source-blue.svg)](https://github.com/boazsegev/iodine)
 
+***Notice*: iodine's core library, [facil.io](https://github.com/boazsegev/facil.io) is being re-vamped with many updates and changes. This is a time to ask - what features are important for you? [let me know here](https://github.com/boazsegev/facil.io/issues/24)**.
+
+**The development branch is the `v.0.5-rewrite` branch.**
+
 Iodine is a fast concurrent web server for real-time Ruby applications, with native support for:
 
 * Websockets;
@@ -31,7 +35,7 @@ Iodine includes a light and fast HTTP and Websocket server written in C that was
 
 With `Iodine.listen2http` it's possible to run multiple HTTP applications in addition to (or instead of) the default `Iodine::Rack` HTTP service.
 
-Iodine also supports native process cluster Pub/Sub and a native RedisEngins to easily scale iodine's Pub/Sub horizontally.
+Iodine also supports native process cluster Pub/Sub and a native RedisEngine to easily scale iodine's Pub/Sub horizontally.
 
 ### Running the web server
 
@@ -214,7 +218,7 @@ end
 
     Another added bonus is pattern publishing (is addition to pattern subscriptions) which isn't available when using Redis (since Redis doesn't support this feature).
 
-* Iodine's Redis client does *not* support multiple databases. This is both becasue [database scoping is ignored by Redis during pub/sub](https://redis.io/topics/pubsub#database-amp-scoping) and because [Redis Cluster doesn't support multiple databases](https://redis.io/topics/cluster-spec). This indicated that multiple database support just isn't worth the extra effort.
+* Iodine's Redis client does *not* support multiple databases. This is both because [database scoping is ignored by Redis during pub/sub](https://redis.io/topics/pubsub#database-amp-scoping) and because [Redis Cluster doesn't support multiple databases](https://redis.io/topics/cluster-spec). This indicated that multiple database support just isn't worth the extra effort.
 
 * The iodine Redis client will use two Redis connections per process (one for subscriptions and the other for publishing and commands). Both connections will be automatically re-established if timeouts or errors occur.
 

data/SPEC-Websocket-Draft.md

@@ -99,7 +99,7 @@ The requirement that the server extends the class of the Websocket Callback Obje
 
 ## Iodine's Collection Extension to the Rack Websockets
 
-The biggest benefit from Iodine's Collection Extension is that it allows the creation of pub/sub plugins and other similar extensions that require access to all the connected Websockets - no nee for the plugin to ask "where's the list" or "add this code to `on_open`" or anything at all, truly "plug and play".
+The biggest benefit from Iodine's Collection Extension is that it allows the creation of pub/sub plugins and other similar extensions that require access to all the connected Websockets - no need for the plugin to ask "where's the list" or "add this code to `on_open`" or anything at all, truly "plug and play".
 
 This extension should be easy enough to implement using a loop or an array within each process context. These methods do **not** cross process boundaries and they are meant to help implement more advanced features (they aren't a feature as much as an "access point").
 

data/ext/iodine/rb-call.c

@@ -13,21 +13,39 @@ Feel free to copy, use and enjoy according to the license provided.
 #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.
-struct RubyArgCall {
+typedef enum {
+  RUBY_TASK,
+  C_TASK,
+} iodine_task_type_en;
+
+typedef struct {
+  iodine_task_type_en type;
   VALUE obj;
   int argc;
   VALUE *argv;
   VALUE returned;
   ID method;
-};
+  int exception;
+} iodine_rb_task_s;
+
+typedef struct {
+  iodine_task_type_en type;
+  void *(*func)(void *);
+  void *arg;
+} iodine_c_task_s;
 
 // 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);
+static VALUE iodine_ruby_caller_perform(VALUE tsk_) {
+  switch (*(iodine_task_type_en *)tsk_) {
+  case RUBY_TASK: {
+    iodine_rb_task_s *task = (void *)tsk_;
+    return rb_funcall2(task->obj, task->method, task->argc, task->argv);
+  }
+  case C_TASK: {
+    iodine_c_task_s *task = (void *)tsk_;
+    return (VALUE)task->func(task->arg);
+  }
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -52,19 +70,20 @@ static void *handle_exception(void *ignr) {
               (int)RSTRING_LEN(msg), RSTRING_PTR(msg));
     }
     rb_backtrace();
+    fprintf(stderr, "\n");
     rb_set_errinfo(Qnil);
   }
   return (void *)Qnil;
 }
 
-// GVL gateway
-static void *run_ruby_method_within_gvl(void *tsk_) {
-  struct RubyArgCall *task = tsk_;
+/* wrap the function call in the exception handling code */
+static void *iodine_protected_call(void *tsk_) {
   int state = 0;
-  task->returned = rb_protect(run_ruby_method_unsafe, (VALUE)(task), &state);
-  if (state)
+  VALUE ret = rb_protect(iodine_ruby_caller_perform, (VALUE)(tsk_), &state);
+  if (state) {
     handle_exception(NULL);
-  return task;
+  }
+  return (void *)ret;
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -72,44 +91,65 @@ static void *run_ruby_method_within_gvl(void *tsk_) {
 
 // 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; }
+static char iodine_rb_check_in_gvl(void) { return in_gvl; }
+
+static void iodine_rb_set_gvl_state(char state) { in_gvl = state; }
 
 ////////////////////////////////////////////////////////////////////////////
 // Calling C functions.
-static void *call_c(void *(*func)(void *), void *arg) {
+static inline void *iodine_rb_call_c(void *(*func)(void *), void *arg) {
   if (in_gvl) {
     return func(arg);
   }
+  iodine_c_task_s task = {.type = C_TASK, .func = func, .arg = arg};
   void *ret;
   in_gvl = 1;
-  ret = rb_thread_call_with_gvl(func, arg);
+  ret = rb_thread_call_with_gvl(iodine_protected_call, &task);
   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 RubyArgCall task = {.obj = obj, .method = method};
-  call_c(run_ruby_method_within_gvl, &task);
-  return task.returned;
+static void *iodine_rb_leave_gvl(void *(*func)(void *), void *arg) {
+  if (!in_gvl) {
+    return func(arg);
+  }
+  in_gvl = 0;
+  void *ret = rb_thread_call_without_gvl(func, arg, NULL, NULL);
+  in_gvl = 1;
+  return ret;
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // A heavier (memory) design for when we're passing arguments around.
 
 // 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_ruby_method_within_gvl, &task);
-  return task.returned;
+static VALUE iodin_rb_call_arg(VALUE obj, ID method, int argc, VALUE *argv) {
+  iodine_rb_task_s task = {.type = RUBY_TASK,
+                           .obj = obj,
+                           .method = method,
+                           .argc = argc,
+                           .argv = argv};
+  void *ret;
+  if (in_gvl)
+    return (VALUE)rb_funcall2(obj, method, argc, argv);
+  in_gvl = 1;
+  ret = rb_thread_call_with_gvl(iodine_protected_call, &task);
+  in_gvl = 0;
+  return (VALUE)ret;
+}
+
+// wrapping any API calls for exception management AND GVL entry
+static VALUE iodin_rb_call(VALUE obj, ID method) {
+  return iodin_rb_call_arg(obj, method, 0, NULL);
 }
 
 ////////////////////////////////////////////////////////////////////////////
 // the API interface
 struct _Ruby_Method_Caller_Class_ RubyCaller = {
-    .call = call, .call2 = call_arg, .call_c = call_c, .in_gvl = check_in_gvl,
+    .call = iodin_rb_call,
+    .call2 = iodin_rb_call_arg,
+    .call_c = iodine_rb_call_c,
+    .leave_gvl = iodine_rb_leave_gvl,
+    .in_gvl = iodine_rb_check_in_gvl,
+    .set_gvl_state = iodine_rb_set_gvl_state,
 };

data/ext/iodine/rb-call.h

@@ -36,25 +36,35 @@ This library keeps track of the thread, adjusting the method to be called in
 case the thread is already within the GVL.
 
 The library assums that it is within a Ruby thread that is was released of
-the GVL using `rb_thread_call_without_gvl2` or `rb_thread_call_without_gvl`.
+the GVL using `rb_thread_call_without_gvl`. If this isn t the case, use the
+`RubyCaller.set_gvl_state` function to manually set the GVL state assumption.
 */
 extern struct _Ruby_Method_Caller_Class_ {
   /** calls a Object's ruby method, adjusting for the GVL if needed */
   VALUE (*call)(VALUE object, ID method_id);
   /**
-calls a Object's ruby method with arguments, adjusting for the GVL if needed
-  */
+   * calls a Object's ruby method with arguments, adjusting for the GVL if
+   * needed
+   */
   VALUE (*call2)(VALUE obj, ID method, int argc, VALUE *argv);
   /**
-calls a C method that requires the GVL for access to the Ruby API, managing the
-GVL state as required.
-  */
+   * calls a C method that requires the GVL for access to the Ruby API, managing
+   * the GVL state as required.
+   */
   void *(*call_c)(void *(*func)(void *), void *arg);
   /**
-returns the thread's GVL status (1 if inside a GVL and 0 if free from the
-GVL).
-  */
+   * Exits the GVL (if the thread is withing the GVL) and calls a C function.
+   */
+  void *(*leave_gvl)(void *(*func)(void *), void *arg);
+  /**
+   * returns the thread's GVL status (1 if inside a GVL and 0 if free from the
+   * GVL).
+   */
   char (*in_gvl)(void);
+  /**
+   * forces a thread's GVL state flag (ignoring the actual GVL state) - careful!
+   */
+  void (*set_gvl_state)(char state);
 } RubyCaller;
 
 #endif /* RB_CALL_H */

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.16'.freeze
+  VERSION = '0.4.17'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.16
+  version: 0.4.17
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-29 00:00:00.000000000 Z
+date: 2018-03-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack