iodine 0.7.8 → 0.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ab6a6656db6e8d26002bb029212f5d5d65b8cfeaddf5550416ce796dc16dc70
-  data.tar.gz: aa23fa7aab530a3b448c2a52e63dffe52c8d8aee1e9259b53c7523e81b379876
+  metadata.gz: abc090d98d50e754078aabdc8e46065b7e56b5d79f563866e563365c133ba088
+  data.tar.gz: 03e59675043f7b7f7e31aa640bff7f8ef01912cc074bc0d576461dc31f3a38ca
 SHA512:
-  metadata.gz: 51e9ac58a76b225d55ad354de3a1c25b25f7b286e88e819c3d067ddbc568521bdd9b87d1da9b7528b24528ccf7517f4762ef11a39894dfcacda8584d812526ee
-  data.tar.gz: 2623b6ea0a7957f92d8686ca80c2f8e6bbf61cf1a04dd0b1d49e20f6e25aa8b6dfdf35f2faa68d9929ec67cecdce0618c57abdf584038713b2e26d75a316bcb2
+  metadata.gz: 513c570195901322763ec71076bc9697a8d365885db8b4b10fbd072aee9f36500cecaf33b5b9cd0df198558a512fdef318b83c72c7e1d452fece7c2ca70bf22d
+  data.tar.gz: a6ab97b226cca87200be69507910951ba7f0036e2283fbc8b4b9d67926e4c4ddaa1b87e193aa7776e87d411b7ea371987a1e434c1017c804f17cd9eba6872a92

data/CHANGELOG.md

@@ -6,6 +6,17 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.9
+
+**Fix**: fixed the background IO backup thread initialization and sleep interval. This thread isn't critical. It's only used to (slowly) flush sockets when all the actual threads are blocked by long running Ruby application code.
+
+**Feature**: added the `Iodine.worker?` and `Iodine.master?` methods, for process identification.
+
+**Update**: Updated the automatic ActiveRecord `fork` handling code and added automatic Sequel `fork` handling, to protect against possible database communication errors related to the risk of connection sharing across worker processes.
+
+**Update**: Moved the command line option parsing code, to leverage facil.io's `fio_cli`... It appears more flexible than Ruby's `optparse` (where command line naming is concerned).
+
+**Deprecation**: deprecated the global namespace DSL (`after_fork`, etc'). Use the new `Iodine.on_state(:after_fork)` method instead.
 
 #### Change log v.0.7.8
 

data/README.md

@@ -17,6 +17,7 @@ Iodine is a fast concurrent web server for real-time Ruby applications, with nat
 * Hot Restart (using the USR1 signal);
 * Client connectivity (attach client sockets to make them evented);
 * Custom protocol authoring;
+* Optimized Logging to `stderr`.
 * and more!
 
 Iodine is an **evented** framework with a simple API that ports much of the [C facil.io framework](https://github.com/boazsegev/facil.io) to Ruby. This means that:
@@ -53,6 +54,12 @@ The common model of 16 threads and 4 processes can be easily adopted:
 bundler exec iodine -p $PORT -t 16 -w 4
 ```
 
+During development, it's more common to use a single process and a few threads:
+
+```bash
+bundler exec iodine -p $PORT -t 16 -w 1
+```
+
 ### Static file serving support
 
 Iodine supports an internal static file service that bypasses the Ruby layer  and serves static files directly from "C-land".
@@ -118,7 +125,9 @@ Go to [localhost:3000/source](http://localhost:3000/source) to experience the `X
 
 #### Pre-Compressed assets / files
 
-Simply `gzip` your static files and iodine will automatically recognize and send the `gz` version if the client (browser) supports the `gzip` transfer-encoding.
+Rails does this automatically when compiling assets - simply `gzip` your static files.
+
+Iodine will automatically recognize and send the `gz` version if the client (browser) supports the `gzip` transfer-encoding.
 
 For example, to offer a compressed version of `style.css`, run (in the terminal):
 
@@ -184,8 +193,7 @@ APP = Proc.new do |env|
   end
 end
 # Pus/Sub can be server oriented as well as connection bound
-root_pid = Process.pid
-Iodine.subscribe(:chat) {|ch, msg| puts msg if Process.pid == root_pid }
+Iodine.subscribe(:chat) {|ch, msg| puts msg if Iodine.master? }
 # By default, Pub/Sub performs in process cluster mode.
 Iodine.workers = 4
 # # in irb:
@@ -226,9 +234,63 @@ end
 
 * The iodine Redis client will use a single Redis connection per process (for publishing data) and an extra Redis connection for subscriptions (owned by the master process). Connections will be automatically re-established if timeouts or errors occur.
 
+#### Hot Restart
+
+Iodine will "hot-restart" the application by shutting down and re-spawning the worker processes.
+
+This will clear away any memory fragmentation concerns and other issues that might plague a long running worker process or ruby application.
+
+To hot-restart iodine, send the `SIGUSR1` signal to the root process.
+
+The following code will hot-restart iodine every 4 hours when iodine is running in cluster mode:
+
+```ruby
+Iodine.run_every(2 * 60 * 60 * 1000) do
+  Process.kill("SIGUSR1", Process.pid) unless Iodine.worker?
+end
+```
+
+Since the master / root process doesn't handle any requests (it only handles pub/sub and house-keeping), it's memory map and process data shouldn't be as affected and the new worker processes should be healthier and more performant.
+
+**Note**: This will **not** re-load the application (any changes to the Ruby code require an actual restart).
+
+#### Optimized HTTP logging
+
+By default, iodine is pretty quite. Some messages are logged to `stderr`, but not many.
+
+However, HTTP requests can be logged using iodine's optimized logger to `stderr`. Iodine will optimize the log output by caching the output time string which updates every second rather than every request.
+
+This can be performed by setting the `-v` flag during startup, i.e.:
+
+```bash
+bundler exec iodine -p $PORT -t 16 -w 4 -v -www /my/public/folder
+```
+
+The log output can be redirected to a file:
+
+```bash
+bundler exec iodine -p $PORT -v  2>my_log.log
+```
+
+The log output can also be redirected to a `stdout`:
+
+```bash
+bundler exec iodine -p $PORT -v  2>&1
+```
+
+#### Built-in support for Sequel and ActiveRecord
+
+It's a well known fact that Database connections require special attention when using `fork`-ing servers (multi-process servers) such as Puma, Passenger and iodine.
+
+However, it's also true that these issues go unnoticed by many developers, since application developers are (rightfully) focused on the application rather than the infrastructure.
+
+With iodine, there's no need to worry.
+
+Iodine provides built-in `fork` handling for both ActiveRecord and Sequel, in order to protect against these possible errors.
+
 #### TCP/IP (raw) sockets
 
-Upgrading to a custom protocol (i.e., in order to implement your own Websocket protocol with special extensions) is available when neither WebSockets nor SSE connection upgrades were requested. In the following (terminal) example, we'll use an echo server without direct socket echo:
+Upgrading to a custom protocol (i.e., in order to implement your own WebSocket protocol with special extensions) is available when neither WebSockets nor SSE connection upgrades were requested. In the following (terminal) example, we'll use an echo server without direct socket echo:
 
 ```ruby
 require 'iodine'

data/exe/iodine

@@ -8,59 +8,17 @@ module Iodine
     # Command line interface. The Ruby CLI might be changed in future versions.
     module CLI
 
-      def print_help
-        puts <<-EOS
-
-Iodine's HTTP/Websocket server version #{Iodine::VERSION}
-
-Use:
-
-    iodine <options> <filename>
-
-Both <options> and <filename> are optional.
-
-Available options:
- -b          Binding address. Default: nil (same as 0.0.0.0).
- -p          Port number. Default: 3000.
- -t          Number of threads. Default: CPU core count.
- -w          Number of worker processes. Default: CPU core count.
- -www        Public folder for static file serving. Default: nil (none).
- -v          Log responses. Default: never log responses.
- -warmup     Warmup invokes autoloading (lazy loading) during server startup.
- -tout       HTTP inactivity connection timeout. Default: 40 seconds.
- -maxhead    Maximum total headers length per HTTP request. Default: 32Kb.
- -maxbd      Maximum Mb per HTTP message (max body size). Default: 50Mb.
- -maxms      Maximum Bytes per Websocket message. Default: 250Kb.
- -ping       WebSocket / SSE ping interval in seconds. Default: 40 seconds.
- -logging    Server level logging (not HTTP), values between 0..5. Defaults to 4.
- <filename>  Defaults to: config.ru
-
-Example:
-
-    iodine -p 80
-
-    iodine -p 8080 path/to/app/conf.ru
-
-    iodine -p 8080 -w 4 -t 16
-
-EOS
-      end
-
-
-      def try_file filename
+      def self.try_file filename
         return nil unless File.exist? filename
         return ::Rack::Builder.parse_file filename
       end
 
-      def filename_argument
-        return ((ARGV[-2].to_s[0] != '-' || ARGV[-2].to_s == '-warmup' || ARGV[-2].to_s == '-v' || ARGV[-2].to_s == '-q' || (ARGV[-2].to_s[0] == '-' && ARGV[-2].to_i.to_s == ARGV[-2].to_s)) && ARGV[-1].to_s[0] != '-' && ARGV[-1])
-      end
-
-      def get_app_opts
+      def self.get_app_opts
         app, opt = nil, nil
-        filename = filename_argument
+        filename = Iodine::DEFAULT_HTTP_ARGS[:filename_]
         if filename
-          app, opt = try_file filename;
+          app, opt = try_file filename
+          app, opt = try_file "#{filename}.ru" unless opt
           unless opt
             puts "* Couldn't find #{filename}\n  testing for config.ru\n"
             app, opt = try_file "config.ru"
@@ -75,15 +33,14 @@ EOS
             puts "         Running only static file service."
             opt = ::Rack::Server::Options.new.parse!([])
           else
-            puts "For help run:"
-            puts "       iodine -?"
+            puts cli_parser
             exit(0);
           end
         end
         return app, opt
       end
 
-      def perform_warmup
+      def self.perform_warmup
         # load anything marked with `autoload`, since autoload isn't thread safe nor fork friendly.
         Iodine.run do
           Module.constants.each do |n|
@@ -101,19 +58,11 @@ EOS
         end
       end
 
-      def call
-        if ARGV[0] =~ /(\-\?)|(help)|(\?)|(h)|(\-h)$/
-          return print_help
-        end
-
+      def self.call
         app, opt = get_app_opts
-
-        perform_warmup if ARGV.index('-warmup')
-
+        perform_warmup if Iodine::DEFAULT_HTTP_ARGS[:warmup_]
         Iodine::Rack.run(app, opt)
       end
-
-      extend self
     end
   end
 end

data/ext/iodine/fio.c

@@ -2685,13 +2685,15 @@ flushed:
 }
 
 /** `fio_flush_all` attempts flush all the open connections. */
-void fio_flush_all(void) {
+size_t fio_flush_all(void) {
   if (!fio_data)
-    return;
+    return 0;
+  size_t count = 0;
   for (uintptr_t i = 0; i < fio_data->max_protocol_fd; ++i) {
-    if (fd_data(i).open || fd_data(i).packet)
-      fio_flush(fd2uuid(i));
+    if ((fd_data(i).open || fd_data(i).packet) && fio_flush(fd2uuid(i)) > 0)
+      ++count;
   }
+  return count;
 }
 
 /* *****************************************************************************
@@ -3283,12 +3285,6 @@ reschedule:
   fio_defer(fio_review_timeout, (void *)fd, NULL);
 }
 
-static void fio_perform_idle(void *arg, void *ignr) {
-  fio_state_callback_force(FIO_CALL_ON_IDLE);
-  (void)arg;
-  (void)ignr;
-}
-
 /* reactor pattern cycling - common actions */
 static void fio_cycle_schedule_events(void) {
   static int idle = 0;
@@ -3309,7 +3305,7 @@ static void fio_cycle_schedule_events(void) {
   } else {
     /* events == 0 */
     if (idle) {
-      fio_defer(fio_perform_idle, NULL, NULL);
+      fio_state_callback_force(FIO_CALL_ON_IDLE);
       idle = 0;
     }
   }

data/ext/iodine/fio.h

@@ -109,15 +109,23 @@ Version and helper macros
 #define FIO_VERSION_MAJOR 0
 #define FIO_VERSION_MINOR 7
 #define FIO_VERSION_PATCH 0
+#define FIO_VERSION_BETA 2
 
 /* Automatically convert version data to a string constant - ignore these two */
 #define FIO_MACRO2STR_STEP2(macro) #macro
 #define FIO_MACRO2STR(macro) FIO_MACRO2STR_STEP2(macro)
 
 /** The facil.io version as a String literal */
+#if FIO_VERSION_BETA
+#define FIO_VERSION_STRING                                                     \
+  FIO_MACRO2STR(FIO_VERSION_MAJOR)                                             \
+  "." FIO_MACRO2STR(FIO_VERSION_MINOR) "." FIO_MACRO2STR(                      \
+      FIO_VERSION_PATCH) ".beta" FIO_MACRO2STR(FIO_VERSION_BETA)
+#else
 #define FIO_VERSION_STRING                                                     \
   FIO_MACRO2STR(FIO_VERSION_MAJOR)                                             \
   "." FIO_MACRO2STR(FIO_VERSION_MINOR) "." FIO_MACRO2STR(FIO_VERSION_PATCH)
+#endif
 
 #ifndef FIO_MAX_SOCK_CAPACITY
 /**
@@ -1102,8 +1110,12 @@ ssize_t fio_flush(intptr_t uuid);
     errno = 0;                                                                 \
   } while (fio_flush(uuid) > 0 || errno == EWOULDBLOCK)
 
-/** `fio_flush_all` attempts flush all the open connections. */
-void fio_flush_all(void);
+/**
+ * `fio_flush_all` attempts flush all the open connections.
+ *
+ * Returns the number of sockets still in need to be flushed.
+ */
+size_t fio_flush_all(void);
 
 /**
  * Convert between a facil.io connection's identifier (uuid) and system's fd.
@@ -1872,11 +1884,16 @@ typedef uint8_t volatile fio_lock_i;
 /** The initail value of an unlocked spinlock. */
 #define FIO_LOCK_INIT 0
 
-/** returns 0 if the lock was acquired and -1 on failure. */
+/** returns 0 if the lock was acquired and a non-zero value on failure. */
 FIO_FUNC inline int fio_trylock(fio_lock_i *lock);
 
-/** Releases a spinlock. Releasing an unacquired lock will break it. */
-FIO_FUNC inline void fio_unlock(fio_lock_i *lock);
+/**
+ * Releases a spinlock. Releasing an unacquired lock will break it.
+ *
+ * Returns a non-zero value on success, or 0 if the lock was in an unloacked
+ * state.
+ */
+FIO_FUNC inline int fio_unlock(fio_lock_i *lock);
 
 /** Returns a spinlock's state (non 0 == Busy). */
 FIO_FUNC inline int fio_is_locked(fio_lock_i *lock);
@@ -2611,7 +2628,7 @@ FIO_FUNC inline void fio_throttle_thread(size_t nano_sec) {
   nanosleep(&tm, NULL);
 }
 
-/** returns 0 if the lock was acquired and -1 on failure. */
+/** returns 0 if the lock was acquired and another value on failure. */
 FIO_FUNC inline int fio_trylock(fio_lock_i *lock) {
   __asm__ volatile("" ::: "memory");
   fio_lock_i ret = fio_atomic_xchange(lock, 1);
@@ -2619,10 +2636,16 @@ FIO_FUNC inline int fio_trylock(fio_lock_i *lock) {
   return ret;
 }
 
-/** Releases a spinlock. Releasing an unacquired lock will break it. */
-FIO_FUNC inline void fio_unlock(fio_lock_i *lock) {
+/**
+ * Releases a spinlock. Releasing an unacquired lock will break it.
+ *
+ * Returns a non-zero value on success, or 0 if the lock was in an unloacked
+ * state.
+ */
+FIO_FUNC inline int fio_unlock(fio_lock_i *lock) {
   __asm__ volatile("" ::: "memory");
-  fio_atomic_xchange(lock, 0);
+  fio_lock_i ret = fio_atomic_xchange(lock, 0);
+  return ret;
 }
 
 /** Returns a spinlock's state (non 0 == Busy). */

data/ext/iodine/fio_cli.c

@@ -92,6 +92,7 @@ char const *fio_cli_get_line_type(fio_cli_parser_data_s *parser,
     case /* FIO_CLI_TYPE_STRING */ 0x1: /* fallthrough */
     case /* FIO_CLI_TYPE_BOOL */ 0x2:   /* fallthrough */
     case /* FIO_CLI_TYPE_INT */ 0x3:    /* fallthrough */
+    case /* FIO_CLI_TYPE_PRINT */ 0x4:  /* fallthrough */
       ++pos;
       continue;
     }
@@ -106,6 +107,7 @@ found:
   case /* FIO_CLI_TYPE_STRING */ 0x1: /* fallthrough */
   case /* FIO_CLI_TYPE_BOOL */ 0x2:   /* fallthrough */
   case /* FIO_CLI_TYPE_INT */ 0x3:    /* fallthrough */
+  case /* FIO_CLI_TYPE_PRINT */ 0x4:  /* fallthrough */
     return pos[1];
   }
   return NULL;
@@ -206,11 +208,17 @@ print_help:
     case /* FIO_CLI_TYPE_STRING */ 0x1: /* fallthrough */
     case /* FIO_CLI_TYPE_BOOL */ 0x2:   /* fallthrough */
     case /* FIO_CLI_TYPE_INT */ 0x3:    /* fallthrough */
+    case /* FIO_CLI_TYPE_PRINT */ 0x4:  /* fallthrough */
       ++pos;
       continue;
     }
     type = FIO_CLI_TYPE_STRING;
     switch ((intptr_t)pos[1]) {
+    case /* FIO_CLI_TYPE_PRINT */ 0x4:
+      fprintf(stderr, "%s\n", pos[0]);
+      pos += 2;
+      continue;
+
     case /* FIO_CLI_TYPE_STRING */ 0x1: /* fallthrough */
     case /* FIO_CLI_TYPE_BOOL */ 0x2:   /* fallthrough */
     case /* FIO_CLI_TYPE_INT */ 0x3:    /* fallthrough */
@@ -234,16 +242,15 @@ print_help:
     }
     switch ((size_t)type) {
     case /* FIO_CLI_TYPE_STRING */ 0x1:
-      fprintf(stderr, "\t\x1B[1m%.*s\x1B[0m\x1B[2m <val>\x1B[0m\t%s\n",
-              first_len, p, p + tmp);
+      fprintf(stderr, " \x1B[1m%.*s\x1B[0m\x1B[2m <>\x1B[0m\t%s\n", first_len,
+              p, p + tmp);
       break;
     case /* FIO_CLI_TYPE_BOOL */ 0x2:
-      fprintf(stderr, "\t\x1B[1m%.*s\x1B[0m      \t%s\n", first_len, p,
-              p + tmp);
+      fprintf(stderr, " \x1B[1m%.*s\x1B[0m   \t%s\n", first_len, p, p + tmp);
       break;
     case /* FIO_CLI_TYPE_INT */ 0x3:
-      fprintf(stderr, "\t\x1B[1m%.*s\x1B[0m\x1B[2m ###  \x1B[0m\t%s\n",
-              first_len, p, p + tmp);
+      fprintf(stderr, " \x1B[1m%.*s\x1B[0m\x1B[2m ##\x1B[0m\t%s\n", first_len,
+              p, p + tmp);
       break;
     }
     /* print aliase information */
@@ -256,23 +263,26 @@ print_help:
       while (p[tmp] && p[tmp] != ' ' && p[tmp] != ',') {
         ++tmp;
       }
+      int padding = first_len - (tmp - start);
+      if (padding < 0)
+        padding = 0;
       switch ((size_t)type) {
       case /* FIO_CLI_TYPE_STRING */ 0x1:
         fprintf(stderr,
-                "\t\x1B[1m%.*s\x1B[0m\x1B[2m <val>\x1B[0m\t(same as "
+                " \x1B[1m%.*s\x1B[0m\x1B[2m <>\x1B[0m%*s\t(same as "
                 "\x1B[1m%.*s\x1B[0m)\n",
-                (int)(tmp - start), p + start, first_len, p);
+                (int)(tmp - start), p + start, padding, "", first_len, p);
         break;
       case /* FIO_CLI_TYPE_BOOL */ 0x2:
         fprintf(stderr,
-                "\t\x1B[1m%.*s\x1B[0m      \t(same as \x1B[1m%.*s\x1B[0m)\n",
-                (int)(tmp - start), p + start, first_len, p);
+                " \x1B[1m%.*s\x1B[0m   %*s\t(same as \x1B[1m%.*s\x1B[0m)\n",
+                (int)(tmp - start), p + start, padding, "", first_len, p);
         break;
       case /* FIO_CLI_TYPE_INT */ 0x3:
         fprintf(stderr,
-                "\t\x1B[1m%.*s\x1B[0m\x1B[2m ###  \x1B[0m\t(same as "
+                " \x1B[1m%.*s\x1B[0m\x1B[2m ##\x1B[0m%*s\t(same as "
                 "\x1B[1m%.*s\x1B[0m)\n",
-                (int)(tmp - start), p + start, first_len, p);
+                (int)(tmp - start), p + start, padding, "", first_len, p);
         break;
       }
     }
@@ -313,10 +323,12 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int unnamed_min,
     case /* FIO_CLI_TYPE_STRING */ 0x1: /* fallthrough */
     case /* FIO_CLI_TYPE_BOOL */ 0x2:   /* fallthrough */
     case /* FIO_CLI_TYPE_INT */ 0x3:    /* fallthrough */
+    case /* FIO_CLI_TYPE_PRINT */ 0x4:  /* fallthrough */
       ++line;
       continue;
     }
-    fio_cli_map_line2alias(*line);
+    if (line[1] != FIO_CLI_TYPE_PRINT)
+      fio_cli_map_line2alias(*line);
     ++line;
   }
 

data/ext/iodine/fio_cli.h

@@ -22,6 +22,8 @@ CLI API
 #define FIO_CLI_TYPE_BOOL ((char *)0x2)
 /** Indicates the previous CLI argument should be an Integer (numerical). */
 #define FIO_CLI_TYPE_INT ((char *)0x3)
+/** Indicates the previous CLI argument should be an Integer (numerical). */
+#define FIO_CLI_TYPE_PRINT ((char *)0x4)
 
 /**
  * This function parses the Command Line Interface (CLI), creating a temporary

data/ext/iodine/iodine.c

@@ -4,6 +4,7 @@
 
 #define FIO_INCLUDE_LINKED_LIST
 #include "fio.h"
+#include "fio_cli.h"
 /* *****************************************************************************
 OS specific patches
 ***************************************************************************** */
@@ -161,13 +162,15 @@ static VALUE iodine_logging_set(VALUE self, VALUE val) {
 }
 
 /**
- *Returns the number of worker processes that will be used when {Iodine.start}
+ * Returns the number of worker processes that will be used when {Iodine.start}
  * is called.
  *
  * Negative numbers are translated as fractions of the number of CPU cores.
  * i.e., -2 == half the number of detected CPU cores.
  *
  * Zero values promise nothing (iodine will decide what to do with them).
+ *
+ * 1 == single process mode, the msater process acts as a worker process.
  */
 static VALUE iodine_workers_get(VALUE self) {
   VALUE i = rb_ivar_get(self, rb_intern2("@workers", 8));
@@ -184,6 +187,8 @@ static VALUE iodine_workers_get(VALUE self) {
  * i.e., -2 == half the number of detected CPU cores.
  *
  * Zero values promise nothing (iodine will decide what to do with them).
+ *
+ * 1 == single process mode, the msater process acts as a worker process.
  */
 static VALUE iodine_workers_set(VALUE self, VALUE val) {
   Check_Type(val, T_FIXNUM);
@@ -194,7 +199,7 @@ static VALUE iodine_workers_set(VALUE self, VALUE val) {
   return val;
 }
 
-/** Prints the Iodine startup message */
+/** Logs the Iodine startup message */
 static void iodine_print_startup_message(iodine_start_params_s params) {
   VALUE iodine_version = rb_const_get(IodineModule, rb_intern("VERSION"));
   VALUE ruby_version = rb_const_get(IodineModule, rb_intern("RUBY_VERSION"));
@@ -251,6 +256,178 @@ static VALUE iodine_stop(VALUE self) {
   return self;
 }
 
+/**
+ * Returns `true` if this process is the master / root process, `false`
+ * otherwise.
+ *
+ * Note that the master process might be a worker process as well, when running
+ * in single process mode (see {Iodine.workers}).
+ */
+static VALUE iodine_master_is(VALUE self) {
+  return fio_is_master() ? Qtrue : Qfalse;
+}
+
+/**
+ * Returns `true` if this process is a worker process or if iodine is running in
+ * a single process mode (the master is also a worker), `false` otherwise.
+ */
+static VALUE iodine_worker_is(VALUE self) {
+  return fio_is_master() ? Qtrue : Qfalse;
+}
+
+/* *****************************************************************************
+CLI parser (Ruby's OptParser is more limiting than I knew...)
+***************************************************************************** */
+
+/**
+ * Parses the CLI argnumnents, returning the Rack filename (if provided).
+ *
+ * Unknown arguments are ignored.
+ *
+ * @params [String] desc a String containg the iodine server's description.
+ */
+static VALUE iodine_cli_parse(VALUE self, VALUE desc) {
+  (void)self;
+  Check_Type(desc, T_STRING);
+  VALUE ARGV = rb_get_argv();
+  VALUE ret = Qtrue;
+  VALUE defaults = iodine_default_args;
+  if (!defaults || !ARGV || TYPE(ARGV) != T_ARRAY || TYPE(defaults) != T_HASH) {
+    FIO_LOG_ERROR("CLI parsing initialization error "
+                  "ARGV=%p, Array?(%d), defaults == %p (%d)",
+                  (void *)ARGV, (int)(TYPE(ARGV) == T_ARRAY), (void *)defaults,
+                  (int)(TYPE(defaults) == T_HASH));
+    return Qnil;
+  }
+  /* Copy the Ruby ARGV to a C valid ARGV */
+  int argc = (int)rb_array_len(ARGV) + 1;
+  if (argc <= 1) {
+    FIO_LOG_DEBUG("CLI: No arguments to parse...\n");
+    return Qnil;
+  } else {
+    FIO_LOG_DEBUG("Iodine CLI parsing %d arguments", argc);
+  }
+  char **argv = calloc(argc, sizeof(*argv));
+  FIO_ASSERT_ALLOC(argv);
+  argv[0] = "iodine";
+  for (int i = 1; i < argc; ++i) {
+    VALUE tmp = rb_ary_entry(ARGV, (long)(i - 1));
+    if (TYPE(tmp) != T_STRING) {
+      FIO_LOG_ERROR("ARGV Array contains a non-String object.");
+      ret = Qnil;
+      goto finish;
+    }
+    fio_str_info_s s = IODINE_RSTRINFO(tmp);
+    argv[i] = malloc(s.len + 1);
+    FIO_ASSERT_ALLOC(argv[i]);
+    memcpy(argv[i], s.data, s.len);
+    argv[i][s.len] = 0;
+  }
+  /* Levarage the facil.io CLI library */
+  fio_cli_start(
+      argc, (const char **)argv, 0, -1, StringValueCStr(desc),
+      "\x1B[1m\x1B[4mAddress Binding:\x1B[0m", FIO_CLI_TYPE_PRINT,
+      "-bind -b -address address to listen to. defaults any available.",
+      "-port -p port number to listen to. defaults port 3000", FIO_CLI_TYPE_INT,
+      "\n\x1B[1m\x1B[4mConcurrency:\x1B[0m", FIO_CLI_TYPE_PRINT,
+      "-workers -w number of processes to use.", FIO_CLI_TYPE_INT,
+      "-threads -t number of threads per process.", FIO_CLI_TYPE_INT,
+      "\n\x1B[1m\x1B[4mHTTP Server:\x1B[0m", FIO_CLI_TYPE_PRINT,
+      "-public -www public folder, for static file service.",
+      "-log -v HTTP request logging.", FIO_CLI_TYPE_BOOL,
+      "-keep-alive -k -tout HTTP keep-alive timeout (0..255). Default: 40s",
+      FIO_CLI_TYPE_INT, "-ping websocket ping interval (0..255). Default: 40s",
+      FIO_CLI_TYPE_INT,
+      "-max-body -maxbd HTTP upload limit in Mega-Bytes. Default: 50Mb",
+      FIO_CLI_TYPE_INT,
+      "-max-header -maxhd header limit per HTTP request in Kb."
+      " Default: 32Kb.",
+      FIO_CLI_TYPE_INT, "\n\x1B[1m\x1B[4mWebSocket Server:\x1B[0m",
+      FIO_CLI_TYPE_PRINT,
+      "-max-msg -maxms incoming WebSocket message limit in Kb. "
+      "Default: 250Kb",
+      FIO_CLI_TYPE_INT, "\n\x1B[1m\x1B[4mConnecting Iodine to Redis:\x1B[0m",
+      FIO_CLI_TYPE_PRINT,
+      "-redis -r an optional Redis URL server address. Default: none.",
+      "-redis-ping -rp websocket ping interval (0..255). Default: 5 minutes",
+      FIO_CLI_TYPE_INT, "\n\x1B[1m\x1B[4mMisc:\x1B[0m", FIO_CLI_TYPE_PRINT,
+      "-warmup warm up the application. CAREFUL! iodine might fork.",
+      FIO_CLI_TYPE_BOOL,
+      "-verbosity -V 0..5 server verbosity level. Default: 4",
+      FIO_CLI_TYPE_INT);
+  /* copy values from CLI library to iodine */
+  if (fio_cli_get("-V")) {
+    int level = fio_cli_get_i("-V");
+    if (level > 0 && level < 100)
+      FIO_LOG_LEVEL = level;
+  }
+  if (fio_cli_get("-w")) {
+    iodine_workers_set(IodineModule, INT2NUM(fio_cli_get_i("-w")));
+  }
+  if (fio_cli_get("-t")) {
+    iodine_threads_set(IodineModule, INT2NUM(fio_cli_get_i("-t")));
+  }
+  if (fio_cli_get_bool("-v")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("log")), Qtrue);
+  }
+  if (fio_cli_get_bool("-warmup")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("warmup_")), Qtrue);
+  }
+  if (fio_cli_get("-p")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("port")),
+                 rb_str_new_cstr(fio_cli_get("-p")));
+  }
+  if (fio_cli_get("-b")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("address")),
+                 rb_str_new_cstr(fio_cli_get("-b")));
+  }
+  if (fio_cli_get("-www")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("public")),
+                 rb_str_new_cstr(fio_cli_get("-www")));
+  }
+  if (fio_cli_get("-redis")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("redis_")),
+                 rb_str_new_cstr(fio_cli_get("-redis")));
+  }
+  if (fio_cli_get("-k")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("timeout")),
+                 INT2NUM(fio_cli_get_i("-k")));
+  }
+  if (fio_cli_get("-ping")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("ping")),
+                 INT2NUM(fio_cli_get_i("-ping")));
+  }
+  if (fio_cli_get("-redis-ping")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("redis_ping_")),
+                 INT2NUM(fio_cli_get_i("-redis-ping")));
+  }
+  if (fio_cli_get("-max-body")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("max_body")),
+                 INT2NUM((fio_cli_get_i("-max-body") * 1024 * 1024)));
+  }
+  if (fio_cli_get("-max-message")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("max_msg")),
+                 INT2NUM((fio_cli_get_i("-max-message") * 1024)));
+  }
+  if (fio_cli_get("-max-headers")) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("max_headers")),
+                 INT2NUM((fio_cli_get_i("-max-headers") * 1024)));
+  }
+  if (fio_cli_unnamed_count()) {
+    rb_hash_aset(defaults, ID2SYM(rb_intern("filename_")),
+                 rb_str_new_cstr(fio_cli_unnamed(0)));
+  }
+
+  /* create `filename` String, cleanup and return */
+  fio_cli_end();
+finish:
+  for (int i = 1; i < argc; ++i) {
+    free(argv[i]);
+  }
+  free(argv);
+  return ret;
+}
+
 /* *****************************************************************************
 Ruby loads the library and invokes the Init_<lib_name> function...
 
@@ -267,6 +444,7 @@ void Init_iodine(void) {
   // Create the Iodine module (namespace)
   IodineModule = rb_define_module("Iodine");
   IodineBaseModule = rb_define_module_under(IodineModule, "Base");
+  VALUE IodineCLIModule = rb_define_module_under(IodineBaseModule, "CLI");
   call_id = rb_intern2("call", 4);
 
   // register core methods
@@ -279,6 +457,11 @@ void Init_iodine(void) {
   rb_define_module_function(IodineModule, "start", iodine_start, 0);
   rb_define_module_function(IodineModule, "stop", iodine_stop, 0);
   rb_define_module_function(IodineModule, "on_idle", iodine_sched_on_idle, 0);
+  rb_define_module_function(IodineModule, "master?", iodine_master_is, 0);
+  rb_define_module_function(IodineModule, "worker?", iodine_worker_is, 0);
+
+  // register CLI methods
+  rb_define_module_function(IodineCLIModule, "parse", iodine_cli_parse, 1);
 
   // initialize Object storage for GC protection
   iodine_storage_init();

data/ext/iodine/iodine_connection.c

@@ -249,8 +249,10 @@ static VALUE iodine_connection_pending(VALUE self) {
   return SIZET2NUM((fio_pending(c->info.uuid)));
 }
 
-/** Returns the connection's protocol Symbol (`:sse`, `:websocket`, etc'). */
+// clang-format off
+/** Returns the connection's protocol Symbol (`:sse`, `:websocket`, etc'), if originated in HTTP (`rack.upgrade`). */
 static VALUE iodine_connection_protocol_name(VALUE self) {
+  // clang-format on
   iodine_connection_data_s *c = iodine_connection_validate_data(self);
   if (c) {
     switch (c->info.type) {

data/ext/iodine/iodine_defer.c

@@ -10,11 +10,22 @@
 
 #include <pthread.h>
 
+static ID STATE_PRE_START;
+static ID STATE_BEFORE_FORK;
+static ID STATE_AFTER_FORK;
+static ID STATE_ENTER_CHILD;
+static ID STATE_ENTER_MASTER;
+static ID STATE_ON_START;
+static ID STATE_ON_PARENT_CRUSH;
+static ID STATE_ON_CHILD_CRUSH;
+static ID STATE_START_SHUTDOWN;
+static ID STATE_ON_FINISH;
+
 /* *****************************************************************************
 IO flushing dedicated thread for protection against blocking code
 ***************************************************************************** */
 
-static fio_lock_i sock_io_thread = 0;
+static fio_lock_i sock_io_thread_flag = 0;
 static pthread_t sock_io_pthread;
 typedef struct {
   size_t threads;
@@ -23,29 +34,29 @@ typedef struct {
 
 static void *iodine_io_thread(void *arg) {
   (void)arg;
-  while (sock_io_thread) {
-    fio_flush_all();
-    fio_throttle_thread(100);
+  while (sock_io_thread_flag) {
+    if (fio_flush_all() > 1)
+      fio_throttle_thread(500000UL);
+    else
+      fio_throttle_thread(150000000UL);
   }
   return NULL;
 }
 static void iodine_start_io_thread(void *a_) {
-  if (!fio_atomic_add(&sock_io_thread, 1)) {
-    pthread_create(&sock_io_pthread, NULL, iodine_io_thread, NULL);
+  if (!fio_trylock(&sock_io_thread_flag)) {
+    if (pthread_create(&sock_io_pthread, NULL, iodine_io_thread, NULL)) {
+      FIO_LOG_ERROR("Couldn't spawn IO thread.");
+    };
+    FIO_LOG_DEBUG("IO thread started.");
   }
   (void)a_;
 }
 
-static void iodine_start_io_thread2(void *a_, void *b_) {
-  iodine_start_io_thread(a_);
-  (void)b_;
-}
-
 static void iodine_join_io_thread(void) {
-  if (fio_atomic_sub(&sock_io_thread, 1) == 0) {
-    sock_io_thread = 0;
+  if (fio_unlock(&sock_io_thread_flag) && sock_io_pthread) {
     pthread_join(sock_io_pthread, NULL);
     sock_io_pthread = (pthread_t)NULL;
+    FIO_LOG_DEBUG("IO thread stopped and joined.");
   }
 }
 
@@ -108,8 +119,6 @@ static void *fork_using_ruby(void *ignr) {
   if (!pid) {
     IodineStore.after_fork();
   }
-  // re-initiate IO thread
-  fio_defer(iodine_start_io_thread2, NULL, NULL);
   return (void *)pid;
   (void)ignr;
 }
@@ -288,83 +297,78 @@ static void iodine_perform_state_callback_persist(void *blk_) {
 
 // clang-format off
 /**
-Sets a block of code to run before a new worker process is forked (cluster mode only).
+Sets a block of code to run when Iodine's core state is updated.
 
-Code runs within the master (root) process.
-*/
-static VALUE iodine_before_fork_add(VALUE self) {
-  // clang-format on
-  rb_need_block();
-  VALUE block = rb_block_proc();
-  IodineStore.add(block);
-  fio_state_callback_add(FIO_CALL_BEFORE_FORK,
-                         iodine_perform_state_callback_persist, (void *)block);
-  return block;
-  (void)self;
-}
+@param [Symbol] event the state event for which the block should run (see list).
+@since 0.7.9
 
-// clang-format off
-/**
-Sets a block of code to run after a new worker process is forked (cluster mode only).
+The state event Symbol can be any of the following:
 
-Code runs in both the parent and the child.
-*/
-static VALUE iodine_after_fork_add(VALUE self) {
-  // clang-format on
-  rb_need_block();
-  VALUE block = rb_block_proc();
-  IodineStore.add(block);
-  fio_state_callback_add(FIO_CALL_AFTER_FORK,
-                         iodine_perform_state_callback_persist, (void *)block);
-  return block;
-  (void)self;
-}
-
-// clang-format off
-/**
-Sets a block of code to run after a new worker process is forked (cluster mode only).
+:pre_start :: the block will be called once before starting up the IO reactor.
+:before_fork :: the block will be called before each time the IO reactor forks a new worker.
+:after_fork :: the block will be called after each fork (both in parent and workers).
+:enter_child :: the block will be called by a worker process right after forking.
+:enter_master :: the block will be called by the master process after spawning a worker (after forking).
+:on_start :: the block will be called every time a *worker* proceess starts. In single process mode, the master process is also a worker.
+:on_parent_crush :: the block will be called by each worker the moment it detects the master process crashed.
+:on_child_crush :: the block will be called by the parent (master) after a worker process crashed.
+:start_shutdown :: the block will be called before starting the shutdown sequence.
+:on_finish :: the block will be called just before finishing up (both on chlid and parent processes).
 
 Code runs in both the parent and the child.
 */
-static VALUE iodine_after_fork_in_worker_add(VALUE self) {
+static VALUE iodine_on_state(VALUE self, VALUE event) {
   // clang-format on
   rb_need_block();
+  Check_Type(event, T_SYMBOL);
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  fio_state_callback_add(FIO_CALL_IN_CHILD,
-                         iodine_perform_state_callback_persist, (void *)block);
-  return block;
-  (void)self;
-}
-
-// clang-format off
-/**
-Sets a block of code to run after a new worker process is forked (cluster mode only).
-
-Code runs in both the parent and the child.
-*/
-static VALUE iodine_after_fork_in_master_add(VALUE self) {
-  // clang-format on
-  rb_need_block();
-  VALUE block = rb_block_proc();
-  IodineStore.add(block);
-  fio_state_callback_add(FIO_CALL_IN_MASTER,
-                         iodine_perform_state_callback_persist, (void *)block);
-  return block;
-  (void)self;
-}
-
-// clang-format off
-/**
-Sets a block of code to run once a Worker process shuts down (both in single process mode and cluster mode).
-*/
-static VALUE iodine_on_shutdown_add(VALUE self) {
-  // clang-format on
-  rb_need_block();
-  VALUE block = rb_block_proc();
-  IodineStore.add(block);
-  fio_state_callback_add(FIO_CALL_ON_FINISH,
-                         iodine_perform_state_callback_persist, (void *)block);
+  ID state = rb_sym2id(event);
+
+  if (state == STATE_PRE_START) {
+    fio_state_callback_add(FIO_CALL_PRE_START,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_BEFORE_FORK) {
+    fio_state_callback_add(FIO_CALL_BEFORE_FORK,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_AFTER_FORK) {
+    fio_state_callback_add(FIO_CALL_AFTER_FORK,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_ENTER_CHILD) {
+    fio_state_callback_add(FIO_CALL_IN_CHILD,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_ENTER_MASTER) {
+    fio_state_callback_add(FIO_CALL_IN_MASTER,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_ON_START) {
+    fio_state_callback_add(FIO_CALL_ON_START,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_ON_PARENT_CRUSH) {
+    fio_state_callback_add(FIO_CALL_ON_PARENT_CRUSH,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_ON_CHILD_CRUSH) {
+    fio_state_callback_add(FIO_CALL_ON_CHILD_CRUSH,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_START_SHUTDOWN) {
+    fio_state_callback_add(FIO_CALL_ON_SHUTDOWN,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else if (state == STATE_ON_FINISH) {
+    fio_state_callback_add(FIO_CALL_ON_FINISH,
+                           iodine_perform_state_callback_persist,
+                           (void *)block);
+  } else {
+    IodineStore.remove(block);
+    rb_raise(rb_eTypeError, "unknown event in Iodine.on_state");
+  }
   return block;
   (void)self;
 }
@@ -372,6 +376,7 @@ static VALUE iodine_on_shutdown_add(VALUE self) {
 /* Performs any cleanup before worker dies */
 static void iodine_defer_on_finish(void *ignr) {
   (void)ignr;
+
   iodine_join_io_thread();
 }
 
@@ -388,16 +393,20 @@ void iodine_defer_initialize(void) {
                             1);
   rb_define_module_function(IodineModule, "run_every", iodine_defer_run_every,
                             -1);
-  rb_define_module_function(IodineModule, "before_fork", iodine_before_fork_add,
-                            0);
-  rb_define_module_function(IodineModule, "after_fork", iodine_after_fork_add,
-                            0);
-  rb_define_module_function(IodineModule, "after_fork_in_worker",
-                            iodine_after_fork_in_worker_add, 0);
-  rb_define_module_function(IodineModule, "after_fork_in_master",
-                            iodine_after_fork_in_master_add, 0);
-  rb_define_module_function(IodineModule, "on_shutdown", iodine_on_shutdown_add,
-                            0);
+  rb_define_module_function(IodineModule, "on_state", iodine_on_state, 1);
+
+  STATE_PRE_START = rb_intern("pre_start");
+  STATE_BEFORE_FORK = rb_intern("before_fork");
+  STATE_AFTER_FORK = rb_intern("after_fork");
+  STATE_ENTER_CHILD = rb_intern("enter_child");
+  STATE_ENTER_MASTER = rb_intern("enter_master");
+  STATE_ON_START = rb_intern("on_start");
+  STATE_ON_PARENT_CRUSH = rb_intern("on_parent_crush");
+  STATE_ON_CHILD_CRUSH = rb_intern("on_child_crush");
+  STATE_START_SHUTDOWN = rb_intern("start_shutdown");
+  STATE_ON_FINISH = rb_intern("on_finish");
+
   fio_state_callback_add(FIO_CALL_ON_FINISH, iodine_defer_on_finish, NULL);
   fio_state_callback_add(FIO_CALL_PRE_START, iodine_start_io_thread, NULL);
+  fio_state_callback_add(FIO_CALL_AFTER_FORK, iodine_start_io_thread, NULL);
 }

data/ext/iodine/iodine_http.c

@@ -55,7 +55,7 @@ static rb_encoding *IodineBinaryEncoding;
 static uint8_t support_xsendfile = 0;
 
 /** Used by {listen2http} to set missing arguments. */
-static VALUE iodine_default_args;
+VALUE iodine_default_args;
 
 #define rack_declare(rack_name) static VALUE rack_name
 
@@ -803,7 +803,7 @@ address:: the address to bind to. Default: binds to all possible addresses.
 log:: enable response logging (Hijacked sockets aren't logged). Default: off.
 public:: The root public folder for static file service. Default: none.
 timeout:: Timeout for inactive HTTP/1.x connections. Defaults: 40 seconds.
-max_body:: The maximum body size for incoming HTTP messages. Default: ~50Mib.
+max_body:: The maximum body size for incoming HTTP messages in bytes. Default: ~50Mib.
 max_headers:: The maximum total header length for incoming HTTP messages. Default: ~64Kib.
 max_msg:: The maximum Websocket message size allowed. Default: ~250Kib.
 ping:: The Websocket `ping` interval. Default: 40 seconds.
@@ -958,6 +958,7 @@ static VALUE iodine_http_listen(VALUE self, VALUE opt) {
           .public_folder = (www ? StringValueCStr(www) : NULL)) == -1) {
     FIO_LOG_ERROR("Failed to initialize a listening HTTP socket for port %s",
                   port ? StringValueCStr(port) : "3000");
+    rb_raise(rb_eRuntimeError, "Listening socket initialization failed");
     return Qfalse;
   }
 

data/ext/iodine/iodine_http.h

@@ -12,7 +12,7 @@ Feel free to copy, use and enjoy according to the license provided.
 extern VALUE IODINE_R_HIJACK;
 extern VALUE IODINE_R_HIJACK_IO;
 extern VALUE IODINE_R_HIJACK_CB;
-
+extern VALUE iodine_default_args;
 void iodine_init_http(void);
 
 #endif

data/lib/iodine.rb

@@ -41,7 +41,7 @@ require 'iodine/iodine'
 #
 # Methods for setting up and starting {Iodine} include {start}, {threads}, {threads=}, {workers} and {workers=}.
 #
-# Methods for setting startup / operational callbacks include {on_idle}, {on_shutdown}, {before_fork} and {after_fork}.
+# Methods for setting startup / operational callbacks include {on_idle}, {on_state}.
 #
 # Methods for asynchronous execution include {run} (same as {defer}), {run_after} and {run_every}.
 #
@@ -71,94 +71,138 @@ module Iodine
       end
     end
 
-end
 
-require 'rack/handler/iodine' unless defined? ::Iodine::Rack::IODINE_RACK_LOADED
+    # @deprecated use {Iodine.on_state}.
+    #
+    # Sets a block of code to run before a new worker process is forked (cluster mode only).
+    def self.before_fork(&block)
+      warn "Iodine.before_fork is deprecated, use Iodine.on_state(:before_fork)."
+      Iodine.on_state(:before_fork, &block)
+    end
+    # @deprecated use {Iodine.on_state}.
+    #
+    # Sets a block of code to run after a new worker process is forked (cluster mode only).
+    #
+    # Code runs in both the parent and the child.
+    def self.after_fork(&block)
+      warn "Iodine.after_fork is deprecated, use Iodine.on_state(:after_fork)."
+      Iodine.on_state(:after_fork, &block)
+    end
+    # @deprecated use {Iodine.on_state}.
+    #
+    # Sets a block of code to run in the worker process, after a new worker process is forked (cluster mode only).
+    def self.after_fork_in_worker(&block)
+      warn "Iodine.after_fork_in_worker is deprecated, use Iodine.on_state(:enter_child)."
+      Iodine.on_state(:enter_child, &block)
+    end
+    # @deprecated use {Iodine.on_state}.
+    #
+    # Sets a block of code to run in the master / root process, after a new worker process is forked (cluster mode only).
+    def self.after_fork_in_master(&block)
+      warn "Iodine.after_fork_in_master is deprecated, use Iodine.on_state(:enter_master)."
+      Iodine.on_state(:enter_master, &block)
+    end
+    # @deprecated use {Iodine.on_state}.
+    #
+    # Sets a block of code to run once a Worker process shuts down (both in single process mode and cluster mode).
+    def self.on_shutdown(&block)
+      warn "Iodine.on_shutdown is deprecated, use Iodine.on_state(:on_finish)."
+      Iodine.on_state(:on_finish, &block)
+    end
 
+end
 
-### CLI argument parsing
+require 'rack/handler/iodine' unless defined? ::Iodine::Rack::IODINE_RACK_LOADED
 
-if ARGV.index('-b') && ARGV[ARGV.index('-b') + 1]
-  Iodine::DEFAULT_HTTP_ARGS[:address] = ARGV[ARGV.index('-b') + 1]
-end
-if ARGV.index('-p') && ARGV[ARGV.index('-p') + 1]
-  Iodine::DEFAULT_HTTP_ARGS[:port] = ARGV[ARGV.index('-p') + 1]
-end
 
-if ARGV.index('-maxbd') && ARGV[ARGV.index('-maxbd') + 1]
-  Iodine::DEFAULT_HTTP_ARGS[:max_body_size] = ARGV[ARGV.index('-maxbd') + 1].to_i
-end
-if ARGV.index('-maxms') && ARGV[ARGV.index('-maxms') + 1]
-  Iodine::DEFAULT_HTTP_ARGS[:max_msg_size] = ARGV[ARGV.index('-maxms') + 1].to_i
-end
-if ARGV.index('-maxhead') && ARGV[ARGV.index('-maxhead') + 1]  && ARGV[ARGV.index('-maxhead') + 1].to_i > 0
-  Iodine::DEFAULT_HTTP_ARGS[:max_headers] = ARGV[ARGV.index('-maxhead') + 1].to_i
-end
-if ARGV.index('-ping') && ARGV[ARGV.index('-ping') + 1]
-  Iodine::DEFAULT_HTTP_ARGS[:ping] = ARGV[ARGV.index('-ping') + 1].to_i
-end
-if ARGV.index('-www') && ARGV[ARGV.index('-www') + 1]
-  Iodine::DEFAULT_HTTP_ARGS[:public] = ARGV[ARGV.index('-www') + 1]
+### Automatic ActiveRecord and Sequel fix
+Iodine.on_state(:before_fork)  do
+  if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:connection)
+    begin
+      ActiveRecord::Base.connection.disconnect!
+    rescue
+    end
+  end
+  if defined?(Sequel)
+    begin
+      Sequel::DATABASES.each { |database| database.disconnect }
+    rescue
+    end
+  end
 end
-if ARGV.index('-tout') && ARGV[ARGV.index('-tout') + 1]
-  Iodine::DEFAULT_HTTP_ARGS[:timeout] = ARGV[ARGV.index('-tout') + 1].to_i
-  puts "WARNNING: timeout set to 0 (ignored, timeout will be ~5 seconds)." if (Iodine::DEFAULT_HTTP_ARGS[:timeout].to_i <= 0 || Iodine::DEFAULT_HTTP_ARGS[:timeout].to_i > 255)
+Iodine.on_state(:after_fork)  do
+  if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:establish_connection)
+    begin
+      ActiveRecord::Base.establish_connection
+    rescue
+    end
+  end
 end
-Iodine::DEFAULT_HTTP_ARGS[:log] = true if ARGV.index('-v')
 
-if ARGV.index('-logging') && ARGV[ARGV.index('-logging') + 1] && ARGV[ARGV.index('-logging') + 1].to_s[0] >= '0' && ARGV[ARGV.index('-logging') + 1].to_s[0] <= '9'
-  Iodine.verbosity = ARGV[ARGV.index('-logging') + 1].to_i
-end
+### Parse CLI for default HTTP settings
+Iodine::Base::CLI.parse("Iodine's HTTP/WebSocket server version #{Iodine::VERSION}\r\n\r\nUse:\r\n    iodine <options> <filename>\r\n\r\nBoth <options> and <filename> are optional. i.e.,:\r\n    iodine -p 0 -b /tmp/my_unix_sock\r\n    iodine -p 8080 path/to/app/conf.ru\r\n    iodine -p 8080 -w 4 -t 16\r\n    iodine -w -1 -t 4 -r redis://usr:pass@localhost:6379/\r\n")
 
-if ARGV.index('-t') && ARGV[ARGV.index('-t') + 1].to_i != 0
-  Iodine.threads = ARGV[ARGV.index('-t') + 1].to_i
-end
-if ARGV.index('-w') && ARGV[ARGV.index('-w') + 1].to_i != 0
-  Iodine.workers = ARGV[ARGV.index('-w') + 1].to_i
-end
+### Initialize Redis if set in CLI
+Iodine::PubSub.default = Iodine::PubSub::Redis.new(Iodine::DEFAULT_HTTP_ARGS[:redis_], ping: Iodine::DEFAULT_HTTP_ARGS[:redis_ping_]) if Iodine::DEFAULT_HTTP_ARGS[:redis_]
 
-### Puma / Thin DSL compatibility
+### Puma / Thin DSL compatibility - depracated (DSLs are evil)
 
 if(!defined?(after_fork))
+  # @deprecated use {Iodine.on_state}.
+  #
   # 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)
+    warn "after_fork is deprecated, use Iodine.on_state(:after_fork)."
+    Iodine.on_state(:after_fork, &block)
   end
 end
 if(!defined?(after_fork_in_worker))
+  # @deprecated use {Iodine.on_state}.
+  #
   # Performs a block of code whenever a new worker process spins up (performed once per worker).
   def after_fork_in_worker(*args, &block)
-    Iodine.after_fork_in_worker(*args, &block)
+    warn "after_fork_in_worker is deprecated, use Iodine.on_state(:enter_child)."
+    Iodine.on_state(:enter_child, &block)
   end
 end
 if(!defined?(after_fork_in_master))
+  # @deprecated use {Iodine.on_state}.
+  #
   # Performs a block of code whenever a new worker process spins up (performed once per worker).
   def after_fork_in_master(*args, &block)
-    Iodine.after_fork_in_master(*args, &block)
+    warn "after_fork_in_master is deprecated, use Iodine.on_state(:enter_master)."
+    Iodine.on_state(:enter_master, &block)
   end
 end
 if(!defined?(on_worker_boot))
+  # @deprecated use {Iodine.on_state}.
+  #
   # Performs a block of code before a new worker process spins up (performed once per worker).
   def on_worker_boot(*args, &block)
-    Iodine.after_fork(*args, &block)
+    warn "on_worker_boot is deprecated, use Iodine.on_state(:after_fork)."
+    Iodine.on_state(:after_fork, &block)
   end
 end
 if(!defined?(on_worker_fork))
+  # @deprecated use {Iodine.on_state}.
+  #
   # Performs a block of code before a new worker process spins up (performed once per worker).
   def on_worker_fork(*args, &block)
-    Iodine.before_fork(*args, &block)
+    warn "on_worker_fork is deprecated, use Iodine.on_state(:before_fork)."
+    Iodine.on_state(:before_fork, &block)
   end
 end
 if(!defined?(before_fork))
+  # @deprecated use {Iodine.on_state}.
+  #
   # Performs a block of code just before a new worker process spins up (performed once per worker, in the master thread).
   def before_fork(*args, &block)
-    Iodine.before_fork(*args, &block)
+    warn "before_fork is deprecated, use Iodine.on_state(:before_fork)."
+    Iodine.on_state(:before_fork, &block)
   end
 end
 
-Iodine.after_fork_in_worker do
-   ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
-end
+
 
 
 

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.8'.freeze
+  VERSION = '0.7.9'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.7.9
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-12 00:00:00.000000000 Z
+date: 2018-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -244,7 +244,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.8.
+post_install_message: 'Thank you for installing Iodine 0.7.9.
 
 '
 rdoc_options: []