iodine 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddc0f34881258b83f214f4809227c826c6bc8f1e259a29fecc0d583c2d6c9a69
-  data.tar.gz: 58686f504218966ed558172cca8176c05fde580c122d8d2dc8196253f31c8d14
+  metadata.gz: '0801b0def77514bb565e4330fba285d1a35fc84fb039e8931791f3f49af164f7'
+  data.tar.gz: 2f17d26fbae2495c70f1b4d9f822641ad8501940c872a4cd3e1d7636bbfdb1a9
 SHA512:
-  metadata.gz: 608097ab4f29ed39435098c4b2930379d164b4e6d76634032ea056efc8b7f55dad2092cc28ab4bdf4172630eb3c707f68eecfd31f0a43c5e3b6511d9268994f6
-  data.tar.gz: d36b60bc3a67815afa9b2be2c1a2a00a773264146d4ecb5f796e12ab7c143664e2dd3e66f535272ba1c74a6e381e27ff57752d7f88dc3ba4f0d40a7032a6bc19
+  metadata.gz: abbb75f0b612e43054d2c1e0725a8bcb7c70815be580fe1b62d6f64ae203a30ac41508f8652b9a005b8d65de17bf0e9f404b9b73a5b6899e2115dfca51bc9d1a
+  data.tar.gz: a1cc7e4f532b93c33e3cdb29040eef2ce02b2c3d6b03d13fb3daa96bbce3bc986dae0132694feb41cbc7b0c5c8d689cfe393b0b44cbce1a93ede3745f6d87219

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.5.1 (next release)
+
+**Fix**: fixed compilation issues on OS X version < 10.12 and Alpine Linux. Credit to @jdickey (Jeff Dickey) for opening issue #32.
+
+**Fix**: fixed some documentation errors. Credit to @janko-m (Janko Marohnić) for catching typos in the README.
+
 #### Change log v.0.5.0
 
 Changed... everything. At least all the internal bits and some of the API.

data/README.md

@@ -7,8 +7,6 @@
 
 [![Logo](https://github.com/boazsegev/iodine/raw/master/logo.png)](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)***.
-
 Iodine is a fast concurrent web server for real-time Ruby applications, with native support for:
 
 * Websockets and EventSource (SSE);
@@ -25,7 +23,7 @@ Iodine is an **evented** framework with a simple API that builds off the low lev
 
 * Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections)!
 
-* Iodine supports only **Linux/Unix** based systems (i.e. macOS, Ubuntu, FreeBSD etc'), which are ideal for evented IO (while Windows and Solaris are better at IO *completion* events, which are totally different).
+* Iodine supports only **Linux/Unix** based systems (i.e. macOS, Ubuntu, FreeBSD etc'), which are ideal for evented IO (while Windows and Solaris are better at IO *completion* events, which are totally different). Currently, macOS support is limited to 10.12 or higher (see [issue #32](https://github.com/boazsegev/iodine/issues/32))
 
 Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but Rack requires Ruby 2.2.2, and so iodine matches this requirement.
 
@@ -145,13 +143,13 @@ Upgrading an HTTP connection can be performed either using iodine's native WebSo
 
 Iodine treats EventSource / SSE connections as if they were a half-duplex WebSocket connection, using the exact same API and callbacks as WebSockets.
 
-When an EventSource / SSE request is received, iodine will set the Rack Hash's upgrade property to `:sse`, so that: `env[rack.upgrade?] == :sse`.
+When an EventSource / SSE request is received, iodine will set the Rack Hash's upgrade property to `:sse`, so that: `env['rack.upgrade?'] == :sse`.
 
 The rest is detailed in the WebSocket support section.
 
 #### WebSockets
 
-When a WebSocket connection request is received, iodine will set the Rack Hash's upgrade property to `:websocket`, so that: `env[rack.upgrade?] == :websocket`
+When a WebSocket connection request is received, iodine will set the Rack Hash's upgrade property to `:websocket`, so that: `env['rack.upgrade?'] == :websocket`
 
 To "upgrade" the HTTP request to the WebSockets protocol (or SSE), simply provide iodine with a WebSocket Callback Object instance or class: `env['rack.upgrade'] = MyWebsocketClass` or `env['rack.upgrade'] = MyWebsocketClass.new(args)`
 

data/examples/info.md

@@ -1,5 +1,7 @@
 # Ruby's Rack Push: Decoupling the real-time web application from the web
 
+![](https://bowild.files.wordpress.com/2018/05/6865783407_84f470ec02_o.jpg)
+
 Something exciting is coming.
 
 Everyone is talking about WebSockets and their older cousin EventSource / Server Sent Events (SSE). Faye and ActionCable are all the rage and real-time updates are becoming easier than ever.
@@ -56,7 +58,7 @@ Using `require 'faye'` will add WebSockets to your application, but it will take
 
 On the other hand, using the `agoo` or `iodine` HTTP servers will add both WebScokets and SSE to your application without any extra memory consumption.
 
-To be more specific, using `iodine` will consume about 2Mb of memory, less than Puma, while providing both HTTP and real-time capabilities.
+To be more specific, using `iodine` will consume about 2Mb of memory, marginally less than Puma, while providing both HTTP and real-time capabilities.
 
 ### The hidden `hijack` price
 
@@ -111,7 +113,7 @@ To set a callback object, the `env['rack.upgrade']` is introduced (notice the mi
 Now the design might look like this:
 
 ```ruby
-# place in config.ru
+# Place in config.ru
 RESPONSE = [200, { 'Content-Type' => 'text/html',
           'Content-Length' => '12' }, [ 'Hello World!' ] ]
 # a Callback class
@@ -130,7 +132,7 @@ end
 APP = Proc.new do |env|
   if(env['rack.upgrade?'])
     env['rack.upgrade'] = MyCallbacks.new
-    [0, {}, []]
+    [200, {}, []]
   else
     RESPONSE
   end
@@ -150,7 +152,7 @@ gem install iodine
 iodine -t 1
 ```
 
-Now open the browser, visit [localhost:3000](http://localhost:3000) and open the browser console to test some Javascript.
+Now open the browser, visit [localhost:3000](http://localhost:3000) and open the browser console to test some JavaScript.
 
 First try an EventSource (SSE) connection (run in browser console):
 
@@ -198,7 +200,7 @@ So far, it's so simple, it's hard to notice how powerful this is.
 Consider implementing a stock ticker, or in this case, a timer:
 
 ```ruby
-# place in config.ru
+# Place in config.ru
 RESPONSE = [200, { 'Content-Type' => 'text/html',
           'Content-Length' => '12' }, [ 'Hello World!' ] ]
 
@@ -212,10 +214,31 @@ module LiveList
   def self.>>(connection)
     @lock.synchronize { @list.delete connection }
   end
+  def any?
+    # remove connection to the "live list"
+    @lock.synchronize { @list.any? }
+  end
+  # this will send a message to all the connections that share the same process.
+  # (in cluster mode we get partial broadcasting only and this doesn't scale)
   def self.broadcast(data)
-    @lock.synchronize {
-      @list.each {|c| c.write data }
-    }
+    @lock.synchronize do
+      @list.each do |c|
+        begin
+          c.write data
+        rescue IOError => _e
+          # An IOError can occur if the connection was closed during the loop.
+        end
+      end
+    end
+  end
+end
+
+# Broadcast the time very second... but...
+# Threads will BREAK in cluster mode.
+@thread = Thread.new do
+  while(LiveList.any?) do
+    sleep(1)
+    LiveList.broadcast "The time is: #{Time.now}"
   end
 end
 
@@ -235,19 +258,11 @@ class MyCallbacks
   end
 end
 
-# Broadcast the time very second
-Thread.new do
-  while(true) do 
-    sleep(1)
-    LiveList.broadcast "The time is: #{Time.now}"
-  end
-end
-
 # The Rack application
 APP = Proc.new do |env|
   if(env['rack.upgrade?'])
     env['rack.upgrade'] = MyCallbacks.new
-    [0, {}, []]
+    [200, {}, []]
   else
     RESPONSE
   end
@@ -256,12 +271,22 @@ end
 run APP
 ```
 
-For this next example, I will use Iodine's pub/sub extension API to demonstrate the power offered by the new `env['rack.upgrade']` approach. This avoids the LiveList object and will make scaling easier.
+Run the iodine server in single process mode: `iodine -w 1` and the little timer is ticking.
+
+Honestly, I don't love the code I just wrote for the previous example. It's a little long, it's slightly iffy and we can't use iodine's cluster mode.
+
+For my next example, I'll author a chat room in 32 lines (including comments).
+
+I will use Iodine's pub/sub extension API to avoid the LiveList module and the timer thread (I don't need a timer, so I'll skip the [`Iodine.run_every` method](https://www.rubydoc.info/github/boazsegev/iodine/master/Iodine#run_every-class_method)).
+
+Also, I'll limit the interaction to WebSocket clients. Why? to show I can.
+
+This will better demonstrate the power offered by the new `env['rack.upgrade']` approach and it will also work in cluster mode.
 
-Here is a simple chat room, but in this case I limit the interaction to WebSocket client. Why? because I can.
+Sadly, this means that the example won't run on Agoo for now.
 
 ```ruby
-# place in config.ru
+# Place in config.ru
 RESPONSE = [200, { 'Content-Type' => 'text/html',
           'Content-Length' => '12' }, [ 'Hello World!' ] ]
 # a Callback class
@@ -281,11 +306,11 @@ class MyCallbacks
     publish :chat, "#{@name} left the chat."
   end
 end
-# note the `env` variable
+# The actual Rack application
 APP = Proc.new do |env|
   if(env['rack.upgrade?'] == :websocket)
     env['rack.upgrade'] = MyCallbacks.new(env)
-    [0, {}, []]
+    [200, {}, []]
   else
     RESPONSE
   end
@@ -294,6 +319,12 @@ end
 run APP
 ```
 
+Start the application from the command line (in terminal):
+
+```bash
+iodine
+```
+
 Now try (in the browser console):
 
 ```js

data/ext/iodine/defer.c

@@ -278,15 +278,18 @@ error:
  */
 #pragma weak defer_free_thread
 void defer_free_thread(void *p_thr) {
-  pthread_detach(*((pthread_t *)p_thr));
+  if (*((pthread_t *)p_thr)) {
+    pthread_detach(*((pthread_t *)p_thr));
+  }
   free(p_thr);
 }
 
 #pragma weak defer_join_thread
 int defer_join_thread(void *p_thr) {
-  if (!p_thr)
+  if (!p_thr || !(*((pthread_t *)p_thr)))
     return -1;
   pthread_join(*((pthread_t *)p_thr), NULL);
+  *((pthread_t *)p_thr) = NULL;
   defer_free_thread(p_thr);
   return 0;
 }

data/ext/iodine/extconf.rb

@@ -1,11 +1,5 @@
 require 'mkmf'
 
-def check_for_stdatomics
-  RbConfig::MAKEFILE_CONFIG['CC'] = $CC = ENV['CC'] if ENV['CC']
-  RbConfig::MAKEFILE_CONFIG['CPP'] = $CPP = ENV['CPP'] if ENV['CPP']
-  puts 'Missing support for atomic operations (support for C11) - is your compiler updated?' unless have_header('stdatomic.h')
-end
-
 abort 'Missing a Linux/Unix OS evented API (epoll/kqueue).' unless have_func('kevent') || have_func('epoll_ctl')
 
 if ENV['CC']
@@ -16,6 +10,10 @@ elsif find_executable('clang') && puts('testing clang for stdatomic support...')
   $CC = ENV['CC'] = 'clang'
   $CPP = ENV['CPP'] = 'clang'
   puts "using clang compiler v. #{`clang -dumpversion`}."
+elsif find_executable('gcc') && (`gcc -dumpversion 2>&1`.to_i >= 5)
+  $CC = ENV['CC'] = 'gcc'
+  $CPP = ENV['CPP'] = find_executable('g++') ? 'g++' : 'gcc'
+  puts "using gcc #{ `gcc -dumpversion 2>&1`.to_i }"
 elsif find_executable('gcc-6')
   $CC = ENV['CC'] = 'gcc-6'
   $CPP = ENV['CPP'] = find_executable('g++-6') ? 'g++-6' : 'gcc-6'
@@ -29,7 +27,6 @@ elsif find_executable('gcc-4.9')
   $CPP = ENV['CPP'] = find_executable('g++-4.9') ? 'g++-4.9' : 'gcc-4.9'
   puts 'using gcc-4.9 compiler.'
 else
-  # check_for_stdatomics
   puts 'using an unknown (old?) compiler... who knows if this will work out... we hope.'
 end
 

data/ext/iodine/facil.c

@@ -27,6 +27,27 @@ Feel free to copy, use and enjoy according to the license provided.
 #define __attribute__(...)
 #endif
 
+/* *****************************************************************************
+Patch for OSX version < 10.12 from https://stackoverflow.com/a/9781275/4025095
+***************************************************************************** */
+#if defined(__MACH__) && !defined(CLOCK_REALTIME)
+#include <sys/time.h>
+#define CLOCK_REALTIME 0
+#define clock_gettime patch_clock_gettime
+// clock_gettime is not implemented on older versions of OS X (< 10.12).
+// If implemented, CLOCK_REALTIME will have already been defined.
+static inline int patch_clock_gettime(int clk_id, struct timespec *t) {
+  struct timeval now;
+  int rv = gettimeofday(&now, NULL);
+  if (rv)
+    return rv;
+  t->tv_sec = now.tv_sec;
+  t->tv_nsec = now.tv_usec * 1000;
+  return 0;
+  (void)clk_id;
+}
+#endif
+
 /* *****************************************************************************
 Data Structures
 ***************************************************************************** */
@@ -426,9 +447,9 @@ static void facil_lib_init(void) {
   spn_lock(&facil_libinit_lock);
   if (facil_data)
     goto finish;
-  facil_data = mmap(NULL, mem_size, PROT_READ | PROT_WRITE | PROT_EXEC,
+  facil_data = mmap(NULL, mem_size, PROT_READ | PROT_WRITE,
                     MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-  if (!facil_data) {
+  if (!facil_data || facil_data == MAP_FAILED) {
     perror("ERROR: Couldn't initialize the facil.io library");
     exit(0);
   }

data/ext/iodine/fio_mem.c

@@ -141,18 +141,17 @@ static inline void *sys_alloc(size_t len, uint8_t is_indi) {
 /* hope for the best? */
 #ifdef MAP_ALIGNED
   result = mmap(
-      next_alloc, len, PROT_READ | PROT_WRITE | PROT_EXEC,
+      next_alloc, len, PROT_READ | PROT_WRITE,
       MAP_PRIVATE | MAP_ANONYMOUS | MAP_ALIGNED(FIO_MEMORY_BLOCK_SIZE), -1, 0);
 #else
-  result = mmap(next_alloc, len, PROT_READ | PROT_WRITE | PROT_EXEC,
+  result = mmap(next_alloc, len, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
 #endif
   if (result == MAP_FAILED)
     return NULL;
   if (((uintptr_t)result & FIO_MEMORY_BLOCK_MASK)) {
     munmap(result, len);
-    result = mmap(NULL, len + FIO_MEMORY_BLOCK_SIZE,
-                  PROT_READ | PROT_WRITE | PROT_EXEC,
+    result = mmap(NULL, len + FIO_MEMORY_BLOCK_SIZE, PROT_READ | PROT_WRITE,
                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (result == MAP_FAILED)
       return NULL;
@@ -180,9 +179,9 @@ static void *sys_realloc(void *mem, size_t prev_len, size_t new_len) {
     if (result == MAP_FAILED)
       return NULL;
 #else
-    void *result = mmap((void *)((uintptr_t)mem + prev_len), new_len - prev_len,
-                        PROT_READ | PROT_WRITE | PROT_EXEC,
-                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+    void *result =
+        mmap((void *)((uintptr_t)mem + prev_len), new_len - prev_len,
+             PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (result == (void *)((uintptr_t)mem + prev_len)) {
       result = mem;
     } else {
@@ -391,8 +390,11 @@ Non-Block allocations (direct from the system)
 static inline void *big_alloc(size_t size) {
   size = sys_round_size(size + 16);
   size_t *mem = sys_alloc(size, 1);
-  *mem = size;
-  return (void *)(((uintptr_t)mem) + 16);
+  if (mem) { /* likely */
+    *mem = size;
+    return (void *)(((uintptr_t)mem) + 16);
+  }
+  return NULL;
 }
 
 static inline void big_free(void *ptr) {

data/ext/iodine/http.c

@@ -21,6 +21,27 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include "fio_mem.h"
 
+/* *****************************************************************************
+Patch for OSX version < 10.12 from https://stackoverflow.com/a/9781275/4025095
+***************************************************************************** */
+#if defined(__MACH__) && !defined(CLOCK_REALTIME)
+#include <sys/time.h>
+#define CLOCK_REALTIME 0
+#define clock_gettime patch_clock_gettime
+// clock_gettime is not implemented on older versions of OS X (< 10.12).
+// If implemented, CLOCK_REALTIME will have already been defined.
+static inline int patch_clock_gettime(int clk_id, struct timespec *t) {
+  struct timeval now;
+  int rv = gettimeofday(&now, NULL);
+  if (rv)
+    return rv;
+  t->tv_sec = now.tv_sec;
+  t->tv_nsec = now.tv_usec * 1000;
+  return 0;
+  (void)clk_id;
+}
+#endif
+
 /* *****************************************************************************
 Small Helpers
 ***************************************************************************** */

data/ext/iodine/iodine.c

@@ -217,20 +217,23 @@ static void *iodine_io_thread(void *arg) {
   }
   return NULL;
 }
-static void iodine_start_io_thread(void *a1, void *a2) {
+void iodine_start_io_thread(void *a1, void *a2) {
   (void)a1;
   (void)a2;
   pthread_create(&sock_io_pthread, NULL, iodine_io_thread, NULL);
 }
 static void iodine_join_io_thread(void) {
   sock_io_thread = 0;
-  pthread_join(sock_io_pthread, NULL);
+  if (sock_io_pthread) {
+    pthread_join(sock_io_pthread, NULL);
+  }
+  sock_io_pthread = NULL;
 }
 
 static void *srv_start_no_gvl(void *s_) {
   iodine_start_settings_s *s = s_;
   sock_io_thread = 1;
-  defer(iodine_start_io_thread, NULL, NULL);
+  iodine_start_io_thread(NULL, NULL);
   fprintf(stderr, "\n");
   if (s->processes == 1 || (s->processes == 0 && s->threads > 0)) {
     /* single worker */

data/ext/iodine/iodine_http.c

@@ -20,7 +20,6 @@ Feel free to copy, use and enjoy according to the license provided.
 /* *****************************************************************************
 Available Globals
 ***************************************************************************** */
-static VALUE IodineHTTP;
 
 typedef struct {
   VALUE app;
@@ -160,7 +159,8 @@ static inline VALUE copy2env(iodine_http_request_handle_s *handle) {
   case IODINE_UPGRADE_SSE:
     env = rb_hash_dup(env_template_sse);
     break;
-  case IODINE_UPGRADE_NONE:
+  case IODINE_UPGRADE_NONE: /* fallthrough */
+  default:
     env = rb_hash_dup(env_template_no_upgrade);
     break;
   }

data/ext/iodine/iodine_pubsub.c

@@ -795,7 +795,6 @@ engine is used.
 */
 VALUE iodine_publish(int argc, VALUE *argv, VALUE self) {
   VALUE rb_ch, rb_msg, rb_engine = Qnil;
-  uint8_t use_pattern = 0;
   const pubsub_engine_s *engine = NULL;
   switch (argc) {
   case 3:
@@ -810,8 +809,7 @@ VALUE iodine_publish(int argc, VALUE *argv, VALUE self) {
     Check_Type(argv[0], T_HASH);
     rb_ch = rb_hash_aref(argv[0], to_sym_id);
     if (rb_ch == Qnil || rb_ch == Qfalse) {
-      use_pattern = 1;
-      rb_ch = rb_hash_aref(argv[0], match_sym_id);
+      rb_ch = rb_hash_aref(argv[0], channel_sym_id);
     }
     rb_msg = rb_hash_aref(argv[0], message_sym_id);
     rb_engine = rb_hash_aref(argv[0], engine_varid);
@@ -826,7 +824,7 @@ VALUE iodine_publish(int argc, VALUE *argv, VALUE self) {
   Check_Type(rb_msg, T_STRING);
 
   if (rb_ch == Qnil || rb_ch == Qfalse)
-    rb_raise(rb_eArgError, "channel is required .");
+    rb_raise(rb_eArgError, "target / channel is required .");
   if (TYPE(rb_ch) == T_SYMBOL)
     rb_ch = rb_sym2str(rb_ch);
   Check_Type(rb_ch, T_STRING);

data/ext/iodine/iodine_websockets.c

@@ -209,6 +209,7 @@ static VALUE iodine_defer(int argc, VALUE *argv, VALUE self) {
   return block;
 }
 
+#if 0 /* deprecated */
 /**
 Schedules a block of code to run for the specified websocket at a later time,
 (**if** the connection is open). The block will run within the connection's
@@ -240,6 +241,8 @@ static VALUE iodine_class_defer(VALUE self, VALUE ws_uuid) {
   return block;
 }
 
+#endif
+
 /* *****************************************************************************
 Websocket Pub/Sub API
 ***************************************************************************** */

data/ext/iodine/rb-call.c

@@ -45,6 +45,7 @@ static VALUE iodine_ruby_caller_perform(VALUE tsk_) {
     return (VALUE)task->func(task->arg);
   }
   }
+  return Qnil;
 }
 
 ////////////////////////////////////////////////////////////////////////////

data/ext/iodine/rb-defer.c

@@ -54,6 +54,9 @@ static void *create_ruby_thread_gvl(void *args) {
   return (void *)Registry.add(rb_thread_create(defer_thread_inGVL, args));
 }
 
+/* used during fork */
+void iodine_start_io_thread(void *a1, void *a2);
+
 static void *fork_using_ruby(void *ignr) {
   RubyCaller.call(Iodine, rb_intern("before_fork"));
   const VALUE ProcessClass = rb_const_get(rb_cObject, rb_intern("Process"));
@@ -68,6 +71,7 @@ static void *fork_using_ruby(void *ignr) {
   if (!pid) {
     Registry.on_fork();
     RubyCaller.call(Iodine, rb_intern("after_fork"));
+    iodine_start_io_thread(NULL, NULL);
   }
   return (void *)pid;
   (void)ignr;

data/ext/iodine/rb-fiobj2rb.h

@@ -28,9 +28,6 @@ static inline VALUE fiobj2rb(FIOBJ o, uint8_t str2sym) {
   case FIOBJ_T_NUMBER:
     rb = LONG2FIX(fiobj_obj2num(o));
     break;
-  case FIOBJ_T_NULL:
-    rb = Qnil;
-    break;
   case FIOBJ_T_TRUE:
     rb = Qtrue;
     break;
@@ -58,6 +55,10 @@ static inline VALUE fiobj2rb(FIOBJ o, uint8_t str2sym) {
   case FIOBJ_T_HASH:
     rb = rb_hash_new();
     break;
+  case FIOBJ_T_NULL: /* fallthrough */
+  default:
+    rb = Qnil;
+    break;
   };
   return rb;
 }

data/ext/iodine/sock.c

@@ -27,7 +27,6 @@ Includes and state
 #include <sys/resource.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
-#include <sys/sysctl.h>
 #include <sys/types.h>
 #include <sys/un.h>
 

data/lib/iodine.rb

@@ -190,6 +190,7 @@ module Iodine
 
 
   @after_fork_blocks = []
+  # Performs a block of code whenever a new worker process spins up (performed once per worker).
   def self.after_fork(*args, &block)
     if(block)
       @after_fork_blocks << [args, block]
@@ -199,6 +200,7 @@ module Iodine
   end
 
   @before_fork_blocks = []
+  # Performs a block of code just before a new worker process spins up (performed once per worker).
   def self.before_fork(*args, &block)
     if(block)
       @before_fork_blocks << [args, block]
@@ -211,16 +213,19 @@ module Iodine
 end
 
 if(!defined?(after_fork))
+  # Performs a block of code whenever a new worker process spins up (performed once per worker).
   def after_fork(*args, &block)
     Iodine.after_fork(*args, &block)
   end
 end
 if(!defined?(on_worker_boot))
+  # Performs a block of code whenever a new worker process spins up (performed once per worker).
   def on_worker_boot(*args, &block)
     Iodine.after_fork(*args, &block)
   end
 end
 if(!defined?(before_fork))
+  # Performs a block of code just before a new worker process spins up (performed once per worker).
   def before_fork(*args, &block)
     Iodine.before_fork(*args, &block)
   end

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.5.0'.freeze
+  VERSION = '0.5.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-30 00:00:00.000000000 Z
+date: 2018-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack