iodine 0.7.59 → 0.8.0

data/ext/iodine/iodine.c

@@ -1,1430 +1,250 @@
+/* core include */
 #include "iodine.h"
 
-#include <ruby/version.h>
-
-#define FIO_INCLUDE_LINKED_LIST
-#include "fio.h"
-#include "fio_cli.h"
 /* *****************************************************************************
-OS specific patches
+Deprecation Warnings
 ***************************************************************************** */
 
-#ifdef __APPLE__
-#include <dlfcn.h>
-#endif
-
-/** Any patches required by the running environment for consistent behavior */
-static void patch_env(void) {
-#ifdef __APPLE__
-  /* patch for dealing with the High Sierra `fork` limitations */
-  void *obj_c_runtime = dlopen("Foundation.framework/Foundation", RTLD_LAZY);
-  (void)obj_c_runtime;
-#endif
-}
+/** @deprecated use {Iodine::TLS.add_cert}. */
+static VALUE iodine_tls_cert_add_old_name(int argc, VALUE *argv, VALUE self);
 
 /* *****************************************************************************
-Constants and State
+Initialize module
 ***************************************************************************** */
 
-VALUE IodineModule;
-VALUE IodineBaseModule;
-
-/** Default connection settings for {Iodine.listen} and {Iodine.connect}. */
-VALUE iodine_default_args;
-
-ID iodine_call_id;
-ID iodine_to_s_id;
-
-static VALUE address_sym;
-static VALUE app_sym;
-static VALUE body_sym;
-static VALUE cookies_sym;
-static VALUE handler_sym;
-static VALUE headers_sym;
-static VALUE log_sym;
-static VALUE max_body_sym;
-static VALUE max_clients_sym;
-static VALUE max_headers_sym;
-static VALUE max_msg_sym;
-static VALUE method_sym;
-static VALUE path_sym;
-static VALUE ping_sym;
-static VALUE port_sym;
-static VALUE public_sym;
-static VALUE service_sym;
-static VALUE timeout_sym;
-static VALUE tls_sym;
-static VALUE url_sym;
-
-/* *****************************************************************************
-Idling
-***************************************************************************** */
-
-/* performs a Ruby state callback and clears the Ruby object's memory */
-static void iodine_perform_on_idle_callback(void *blk_) {
-  VALUE blk = (VALUE)blk_;
-  IodineCaller.call(blk, iodine_call_id);
-  IodineStore.remove(blk);
-  fio_state_callback_remove(FIO_CALL_ON_IDLE, iodine_perform_on_idle_callback,
-                            blk_);
-}
-
-/**
-Schedules a single occuring event for the next idle cycle.
-
-To schedule a reoccuring event, reschedule the event at the end of it's
-run.
-
-i.e.
-
-      IDLE_PROC = Proc.new { puts "idle"; Iodine.on_idle &IDLE_PROC }
-      Iodine.on_idle &IDLE_PROC
-*/
-static VALUE iodine_sched_on_idle(VALUE self) {
-  // clang-format on
-  rb_need_block();
-  VALUE block = rb_block_proc();
-  IodineStore.add(block);
-  fio_state_callback_add(FIO_CALL_ON_IDLE, iodine_perform_on_idle_callback,
-                         (void *)block);
-  return block;
-  (void)self;
+static void Init_Iodine(void) {
+  rb_define_singleton_method(iodine_rb_IODINE, "start", iodine_start, 0);
+  rb_define_singleton_method(iodine_rb_IODINE, "stop", iodine_stop, 0);
+
+  rb_define_singleton_method(iodine_rb_IODINE,
+                             "running?",
+                             iodine_is_running,
+                             0);
+  rb_define_singleton_method(iodine_rb_IODINE, "master?", iodine_is_master, 0);
+  rb_define_singleton_method(iodine_rb_IODINE, "worker?", iodine_is_worker, 0);
+
+  rb_define_singleton_method(iodine_rb_IODINE, "workers", iodine_workers, 0);
+  rb_define_singleton_method(iodine_rb_IODINE,
+                             "workers=",
+                             iodine_workers_set,
+                             1);
+
+  rb_define_singleton_method(iodine_rb_IODINE, "threads", iodine_threads, 0);
+  rb_define_singleton_method(iodine_rb_IODINE,
+                             "threads=",
+                             iodine_threads_set,
+                             1);
+
+  rb_define_singleton_method(iodine_rb_IODINE, "secret", iodine_secret, 0);
+  rb_define_singleton_method(iodine_rb_IODINE, "secret=", iodine_secret_set, 1);
+
+  rb_define_singleton_method(iodine_rb_IODINE,
+                             "shutdown_timeout",
+                             iodine_shutdown_timeout,
+                             0);
+  rb_define_singleton_method(iodine_rb_IODINE,
+                             "shutdown_timeout=",
+                             iodine_shutdown_timeout_set,
+                             1);
+
+  rb_define_module_function(iodine_rb_IODINE, "run", iodine_defer_run, 0);
+  rb_define_module_function(iodine_rb_IODINE,
+                            "async",
+                            iodine_defer_run_async,
+                            0);
+
+  rb_define_module_function(iodine_rb_IODINE,
+                            "run_after",
+                            iodine_defer_run_after,
+                            -1);
+  rb_define_module_function(iodine_rb_IODINE, "on_state", iodine_on_state, 1);
+
+  rb_define_singleton_method(iodine_rb_IODINE, "listen", iodine_listen_rb, -1);
 }
 
 /* *****************************************************************************
-Running Iodine
+Cleanup
 ***************************************************************************** */
 
-typedef struct {
-  int16_t threads;
-  int16_t workers;
-} iodine_start_params_s;
-
-static void *iodine_run_outside_GVL(void *params_) {
-  iodine_start_params_s *params = params_;
-  fio_start(.threads = params->threads, .workers = params->workers);
+FIO_SFUNC void *iodine___perform_exit_outside_gvl(void *ignr_) {
+  (void)ignr_;
+  fio_queue_perform_all(fio_io_queue());
+  fio_cli_end();
+  fio_state_callback_force(FIO_CALL_AT_EXIT);
+  fio_state_callback_clear(FIO_CALL_AT_EXIT);
+  STORE.destroy();
   return NULL;
 }
 
-/* *****************************************************************************
-Core API
-***************************************************************************** */
-
-/**
- * Returns the number of worker threads 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).
- *
- * @return [FixNum] Thread Count
- */
-static VALUE iodine_threads_get(VALUE self) {
-  VALUE i = rb_ivar_get(self, rb_intern2("@threads", 8));
-  if (i == Qnil)
-    i = INT2NUM(0);
-  return i;
-}
-
-/**
- * Sets the number of worker threads 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).
- *
- * @param thread_count [FixNum] The number of worker threads to use
- */
-static VALUE iodine_threads_set(VALUE self, VALUE val) {
-  Check_Type(val, T_FIXNUM);
-  if (NUM2SSIZET(val) >= (1 << 12)) {
-    rb_raise(rb_eRangeError, "requsted thread count is out of range.");
-  }
-  rb_ivar_set(self, rb_intern2("@threads", 8), val);
-  return val;
-}
-
-/**
- * Gets the logging level used for Iodine messages.
- *
- * Levels range from 0-5, where:
- *
- * 0 == Quite (no messages)
- * 1 == Fatal Errors only.
- * 2 == Errors only (including fatal errors).
- * 3 == Warnings and errors only.
- * 4 == Informational messages, warnings and errors (default).
- * 5 == Everything, including debug information.
- *
- * Logging is always performed to the process's STDERR and can be piped away.
- *
- * @return [FixNum] Logging Level
- *
- * NOTE: this does NOT effect HTTP logging.
- */
-static VALUE iodine_logging_get(VALUE self) {
-  return INT2FIX(FIO_LOG_LEVEL);
-  (void)self;
+/* Workers end with the C STL's `exit(0)`, which skips Ruby's VM cleanup (the
+ * step that frees every remaining TypedData object). Without it, objects that
+ * are already unreferenced but not yet collected look like leaks. ON_STOP runs
+ * after all IO is closed and the thread pool stopped, so collect them here. */
+FIO_SFUNC void *iodine___worker_gc_in_gvl(void *ignr_) {
+  rb_gc();
+  return ignr_;
 }
 
-/**
- * Gets the logging level used for Iodine messages.
- *
- * Levels range from 0-5, where:
- *
- * 0 == Quite (no messages)
- * 1 == Fatal Errors only.
- * 2 == Errors only (including fatal errors).
- * 3 == Warnings and errors only.
- * 4 == Informational messages, warnings and errors (default).
- * 5 == Everything, including debug information.
- *
- * Logging is always performed to the process's STDERR and can be piped away.
- *
- * @param log_level [FixNum] Sets the logging level
- *
- * NOTE: this does NOT effect HTTP logging.
- */
-static VALUE iodine_logging_set(VALUE self, VALUE val) {
-  Check_Type(val, T_FIXNUM);
-  FIO_LOG_LEVEL = FIX2INT(val);
-  return self;
-}
-
-/**
- * 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.
- *
- * @return [FixNum] Worker Count
- */
-static VALUE iodine_workers_get(VALUE self) {
-  VALUE i = rb_ivar_get(self, rb_intern2("@workers", 8));
-  if (i == Qnil)
-    i = INT2NUM(0);
-  return i;
-}
-
-/**
- * Sets 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.
- *
- * @param worker_count [FixNum] Number of worker processes
- */
-static VALUE iodine_workers_set(VALUE self, VALUE val) {
-  Check_Type(val, T_FIXNUM);
-  if (NUM2SSIZET(val) >= (1 << 9)) {
-    rb_raise(rb_eRangeError, "requsted worker process count is out of range.");
-  }
-  rb_ivar_set(self, rb_intern2("@workers", 8), val);
-  return val;
-}
-
-/** 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"));
-  fio_expected_concurrency(&params.threads, &params.workers);
-  FIO_LOG_INFO("Starting up Iodine:\n"
-               " * Iodine %s\n * Ruby %s\n"
-               " * facil.io " FIO_VERSION_STRING " (%s)\n"
-               " * %d Workers X %d Threads per worker.\n"
-               " * Maximum %zu open files / sockets per worker.\n"
-               " * Master (root) process: %d.\n",
-               StringValueCStr(iodine_version), StringValueCStr(ruby_version),
-               fio_engine(), params.workers, params.threads, fio_capa(),
-               fio_parent_pid());
-  (void)params;
-}
-
-/**
- * This will block the calling (main) thread and start the Iodine reactor.
- *
- * When using cluster mode (2 or more worker processes), it is important that no
- * other threads are active.
- *
- * For many reasons, `fork` should NOT be called while multi-threading, so
- * cluster mode must always be initiated from the main thread in a single thread
- * environment.
- *
- * For information about why forking in multi-threaded environments should be
- * avoided, see (for example):
- * http://www.linuxprogrammingblog.com/threads-and-fork-think-twice-before-using-them
- *
- */
-static VALUE iodine_start(VALUE self) {
-  if (fio_is_running()) {
-    rb_raise(rb_eRuntimeError, "Iodine already running!");
-  }
-  IodineCaller.set_GVL(1);
-  VALUE threads_rb = iodine_threads_get(self);
-  VALUE workers_rb = iodine_workers_get(self);
-  iodine_start_params_s params = {
-      .threads = NUM2SHORT(threads_rb),
-      .workers = NUM2SHORT(workers_rb),
-  };
-  iodine_print_startup_message(params);
-  IodineCaller.leaveGVL(iodine_run_outside_GVL, &params);
-  return self;
-}
-
-/**
- * This will stop the iodine server, shutting it down.
- *
- * If called within a worker process (rather than the root/master process), this
- * will cause a hot-restart for the worker.
- */
-static VALUE iodine_stop(VALUE self) {
-  fio_stop();
-  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_worker() ? Qtrue : Qfalse;
-}
-
-/**
- * Returns `true` if Iodine is currently running a server
- */
-static VALUE iodine_running(VALUE self) {
-  if (fio_is_running()) {
-    return Qtrue;
-  } else {
-    return Qfalse;
-  }
+FIO_SFUNC void iodine___worker_gc_on_stop(void *ignr_) {
+  if (fio_io_is_master()) /* the master process exits through Ruby */
+    return;
+  iodine_c_call_with(iodine___worker_gc_in_gvl, ignr_);
 }
 
-/* *****************************************************************************
-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) {
-  (void)self;
-  VALUE ARGV = rb_get_argv();
-  VALUE ret = Qtrue;
-  VALUE defaults = iodine_default_args;
-  VALUE iodine_version = rb_const_get(IodineModule, rb_intern("VERSION"));
-  char desc[1024];
-  if (!defaults || !ARGV || TYPE(ARGV) != T_ARRAY || TYPE(defaults) != T_HASH ||
-      TYPE(iodine_version) != T_STRING || RSTRING_LEN(iodine_version) > 512) {
-    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)RARRAY_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] = (char *)"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 */
-  memcpy(desc, "Iodine's HTTP/WebSocket server version ", 39);
-  memcpy(desc + 39, StringValueCStr(iodine_version),
-         RSTRING_LEN(iodine_version));
-  memcpy(desc + 39 + RSTRING_LEN(iodine_version),
-         "\r\n\r\nUse:\r\n    iodine <options> <filename>\r\n\r\n"
-         "Both <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/",
-         263);
-  desc[39 + 263 + RSTRING_LEN(iodine_version)] = 0;
-  fio_cli_start(
-      argc, (const char **)argv, 0, -1, desc,
-      FIO_CLI_PRINT_HEADER("Address Binding:"),
-      "-bind -b -address address to listen to. defaults to any available.",
-      FIO_CLI_INT("-port -p port number to listen to. defaults port 3000"),
-      FIO_CLI_PRINT("\t\t\x1B[4mNote\x1B[0m: to bind to a Unix socket, set "
-                    "\x1B[1mport\x1B[0m to 0."),
-      FIO_CLI_PRINT_HEADER("Concurrency:"),
-      FIO_CLI_INT("-threads -t number of threads per process."),
-      FIO_CLI_INT("-workers -w number of processes to use."),
-      FIO_CLI_PRINT("Negative concurrency values "
-                    "map to fractions of available CPU cores."),
-      FIO_CLI_PRINT_HEADER("HTTP Settings:"),
-      FIO_CLI_STRING("-public -www public folder, for static file service."),
-      FIO_CLI_INT("-keep-alive -k -tout HTTP keep-alive timeout in seconds "
-                  "(0..255). Default: 40s"),
-      FIO_CLI_BOOL("-log -v HTTP request logging."),
-      FIO_CLI_INT(
-          "-max-body -maxbd HTTP upload limit in Mega-Bytes. Default: 50Mb"),
-      FIO_CLI_INT("-max-header -maxhd header limit per HTTP request in Kb. "
-                  "Default: 32Kb."),
-      FIO_CLI_PRINT_HEADER("WebSocket Settings:"),
-      FIO_CLI_INT("-max-msg -maxms incoming WebSocket message limit in Kb. "
-                  "Default: 250Kb"),
-      FIO_CLI_INT("-ping websocket ping interval (1..255). Default: 40s"),
-      FIO_CLI_PRINT_HEADER("SSL/TLS:"),
-      FIO_CLI_BOOL("-tls enable SSL/TLS using a self-signed certificate."),
-      FIO_CLI_STRING(
-          "-tls-cert -cert the SSL/TLS public certificate file name."),
-      FIO_CLI_STRING("-tls-key -key the SSL/TLS private key file name."),
-      FIO_CLI_STRING(
-          "-tls-pass -tls-password the password (if any) protecting the "
-          "private key file."),
-      FIO_CLI_PRINT("\t\t\x1B[1m-tls-password\x1B[0m is deprecated, use "
-                    "\x1B[1m-tls-pass\x1B[0m"),
-      FIO_CLI_PRINT_HEADER("Connecting Iodine to Redis:"),
-      FIO_CLI_STRING(
-          "-redis -r an optional Redis URL server address. Default: none."),
-      FIO_CLI_INT(
-          "-redis-ping -rp websocket ping interval (0..255). Default: 300s"),
-      FIO_CLI_PRINT_HEADER("Misc:"),
-      FIO_CLI_STRING("-config -C configuration file to be loaded."),
-      FIO_CLI_STRING("-pid -pidfile name for the pid file to be created."),
-      FIO_CLI_INT("-verbosity -V 0..5 server verbosity level. Default: 4"),
-      FIO_CLI_BOOL(
-          "-warmup --preload warm up the application. CAREFUL! with workers."));
-
-  /* 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") && getenv("WEB_CONCURRENCY")) {
-    fio_cli_set("-w", getenv("WEB_CONCURRENCY"));
-  }
-  if (!fio_cli_get("-w") && getenv("WORKERS")) {
-    fio_cli_set("-w", getenv("WORKERS"));
-  }
-  if (fio_cli_get("-w")) {
-    iodine_workers_set(IodineModule, INT2NUM(fio_cli_get_i("-w")));
-  }
-  if (!fio_cli_get("-t") && getenv("THREADS")) {
-    fio_cli_set("-t", getenv("THREADS"));
-  }
-  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, log_sym, Qtrue);
-  }
-  if (fio_cli_get_bool("-warmup")) {
-    rb_hash_aset(defaults, ID2SYM(rb_intern("warmup_")), Qtrue);
-  }
-  // if (!fio_cli_get("-b") && getenv("ADDRESS")) {
-  //   fio_cli_set("-b", getenv("ADDRESS"));
-  // }
-  if (fio_cli_get("-b")) {
-    if (fio_cli_get("-b")[0] == '/' ||
-        (fio_cli_get("-b")[0] == '.' && fio_cli_get("-b")[1] == '/')) {
-      if (fio_cli_get("-p") &&
-          (fio_cli_get("-p")[0] != '0' || fio_cli_get("-p")[1])) {
-        FIO_LOG_WARNING(
-            "Detected a Unix socket binding (-b) conflicting with port.\n"
-            "            Port settings (-p %s) are ignored",
-            fio_cli_get("-p"));
-      }
-      fio_cli_set("-p", "0");
-    } else {
-      // if (!fio_cli_get("-p") && getenv("PORT")) {
-      //   fio_cli_set("-p", getenv("PORT"));
-      // }
-    }
-    rb_hash_aset(defaults, address_sym, rb_str_new_cstr(fio_cli_get("-b")));
-  }
-  if (fio_cli_get("-p")) {
-    rb_hash_aset(defaults, port_sym, rb_str_new_cstr(fio_cli_get("-p")));
-  }
-  if (fio_cli_get("-www")) {
-    rb_hash_aset(defaults, public_sym, rb_str_new_cstr(fio_cli_get("-www")));
-  }
-  if (!fio_cli_get("-redis") && getenv("IODINE_REDIS_URL")) {
-    fio_cli_set("-redis", getenv("IODINE_REDIS_URL"));
-  }
-  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, timeout_sym, INT2NUM(fio_cli_get_i("-k")));
-  }
-  if (fio_cli_get("-ping")) {
-    rb_hash_aset(defaults, ping_sym, 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, max_body_sym,
-                 INT2NUM((fio_cli_get_i("-max-body") /* * 1024 * 1024 */)));
-  }
-  if (fio_cli_get("-maxms")) {
-    rb_hash_aset(defaults, max_msg_sym,
-                 INT2NUM((fio_cli_get_i("-maxms") /* * 1024 */)));
-  }
-  if (fio_cli_get("-maxhd")) {
-    rb_hash_aset(defaults, max_headers_sym,
-                 INT2NUM((fio_cli_get_i("-maxhd") /* * 1024 */)));
-  }
-#ifndef __MINGW32__
-  if (fio_cli_get_bool("-tls") || fio_cli_get("-key") || fio_cli_get("-cert")) {
-    VALUE rbtls = IodineCaller.call(IodineTLSClass, rb_intern2("new", 3));
-    if (rbtls == Qnil) {
-      FIO_LOG_FATAL("Iodine internal error, Ruby TLS object is nil.");
-      exit(-1);
-    }
-    fio_tls_s *tls = iodine_tls2c(rbtls);
-    if (!tls) {
-      FIO_LOG_FATAL("Iodine internal error, TLS object NULL.");
-      exit(-1);
-    }
-    if (fio_cli_get("-tls-key") && fio_cli_get("-tls-cert")) {
-      fio_tls_cert_add(tls, NULL, fio_cli_get("-tls-cert"),
-                       fio_cli_get("-tls-key"), fio_cli_get("-tls-pass"));
-    } else {
-      if (!fio_cli_get_bool("-tls"))
-        FIO_LOG_ERROR("TLS support requires both key and certificate."
-                      "\r\n\t\tfalling back on a self signed certificate.");
-      char name[1024];
-      fio_local_addr(name, 1024);
-      fio_tls_cert_add(tls, name, NULL, NULL, NULL);
-    }
-    rb_hash_aset(defaults, tls_sym, rbtls);
-  }
-#endif
-  if (fio_cli_unnamed_count()) {
-    rb_hash_aset(defaults, ID2SYM(rb_intern("filename_")),
-                 rb_str_new_cstr(fio_cli_unnamed(0)));
-  }
-  if (fio_cli_get("-pid")) {
-    VALUE pid_filename = rb_str_new_cstr(fio_cli_get("-pid"));
-    rb_hash_aset(defaults, ID2SYM(rb_intern("pid_")), pid_filename);
-    rb_hash_aset(defaults, ID2SYM(rb_intern("pid")), pid_filename);
-  }
-  if (fio_cli_get("-config")) {
-    VALUE conf_filename = rb_str_new_cstr(fio_cli_get("-config"));
-    rb_hash_aset(defaults, ID2SYM(rb_intern("conf_")), conf_filename);
-  }
-
-  /* create `filename` String, cleanup and return */
-  fio_cli_end();
-finish:
-  for (int i = 1; i < argc; ++i) {
-    free(argv[i]);
-  }
-  free(argv);
-  return ret;
+FIO_SFUNC void iodine___perform_exit(VALUE ignr_) {
+  (void)ignr_;
+  // rb_gc();
+  /* iodine runs outside of GVL, but at_exit runs in GVL.. so... */
+  rb_thread_call_without_gvl(iodine___perform_exit_outside_gvl,
+                             NULL,
+                             NULL,
+                             NULL);
 }
 
 /* *****************************************************************************
-Argument support for `connect` / `listen`
+OS specific patches
 ***************************************************************************** */
 
-static int for_each_header_value(VALUE key, VALUE val, VALUE h_) {
-  FIOBJ h = h_;
-  if (RB_TYPE_P(key, T_SYMBOL))
-    key = rb_sym2str(key);
-  if (!RB_TYPE_P(key, T_STRING)) {
-    FIO_LOG_WARNING("invalid key type in header hash, ignored.");
-    return ST_CONTINUE;
-  }
-  if (RB_TYPE_P(val, T_SYMBOL))
-    val = rb_sym2str(val);
-  if (RB_TYPE_P(val, T_STRING)) {
-    FIOBJ k = fiobj_str_new(RSTRING_PTR(key), RSTRING_LEN(key));
-    fiobj_hash_set(h, k, fiobj_str_new(RSTRING_PTR(val), RSTRING_LEN(val)));
-    fiobj_free(k);
-  } else if (RB_TYPE_P(val, T_ARRAY)) {
-    FIOBJ k = fiobj_str_new(RSTRING_PTR(key), RSTRING_LEN(key));
-    size_t len = rb_array_len(val);
-    FIOBJ v = fiobj_ary_new2(len);
-    fiobj_hash_set(h, k, v);
-    fiobj_free(k);
-    for (size_t i = 0; i < len; ++i) {
-      VALUE tmp = rb_ary_entry(val, i);
-      if (RB_TYPE_P(tmp, T_SYMBOL))
-        tmp = rb_sym2str(tmp);
-      if (RB_TYPE_P(tmp, T_STRING))
-        fiobj_ary_push(v, fiobj_str_new(RSTRING_PTR(tmp), RSTRING_LEN(tmp)));
-    }
-  } else {
-    FIO_LOG_WARNING("invalid header value type, ignored.");
-  }
-  return ST_CONTINUE;
-}
-
-static int for_each_cookie(VALUE key, VALUE val, VALUE h_) {
-  FIOBJ h = h_;
-  if (RB_TYPE_P(key, T_SYMBOL))
-    key = rb_sym2str(key);
-  if (!RB_TYPE_P(key, T_STRING)) {
-    FIO_LOG_WARNING("invalid key type in cookie hash, ignored.");
-    return ST_CONTINUE;
-  }
-  if (RB_TYPE_P(val, T_SYMBOL))
-    val = rb_sym2str(val);
-  if (RB_TYPE_P(val, T_STRING)) {
-    FIOBJ k = fiobj_str_new(RSTRING_PTR(key), RSTRING_LEN(key));
-    fiobj_hash_set(h, k, fiobj_str_new(RSTRING_PTR(val), RSTRING_LEN(val)));
-    fiobj_free(k);
-  } else {
-    FIO_LOG_WARNING("invalid cookie value type, ignored.");
-  }
-  return ST_CONTINUE;
-}
-
-/* cleans up any resources used by the argument list processing */
-FIO_FUNC void iodine_connect_args_cleanup(iodine_connection_args_s *s) {
-  if (!s)
-    return;
-  fiobj_free(s->cookies);
-  fiobj_free(s->headers);
-  if (s->port.capa)
-    fio_free(s->port.data);
-  if (s->address.capa)
-    fio_free(s->address.data);
-#ifndef __MINGW32__
-  if (s->tls)
-    fio_tls_destroy(s->tls);
-#endif
-}
-
-/*
-Accepts:
-
-     func(settings)
-
-Supported Settigs:
-- `:url`
-- `:handler` (deprecated: `app`)
-- `:service` (raw / ws / wss / http / https )
-- `:address`
-- `:port`
-- `:path` (HTTP/WebSocket client)
-- `:method` (HTTP client)
-- `:headers` (HTTP/WebSocket client)
-- `:cookies` (HTTP/WebSocket client)
-- `:body` (HTTP client)
-- `:tls`
-- `:log` (HTTP only)
-- `:public` (public folder, HTTP server only)
-- `:timeout` (HTTP only)
-- `:ping` (`:raw` clients and WebSockets only)
-- `:max_headers` (HTTP only)
-- `:max_body` (HTTP only)
-- `:max_msg` (WebSockets only)
-
-*/
-FIO_FUNC iodine_connection_args_s iodine_connect_args(VALUE s, uint8_t is_srv) {
-  Check_Type(s, T_HASH);
-  iodine_connection_args_s r = {.ping = 0}; /* set all to 0 */
-  /* Collect argument values */
-  VALUE address = rb_hash_aref(s, address_sym);
-  VALUE app = rb_hash_aref(s, app_sym);
-  VALUE body = rb_hash_aref(s, body_sym);
-  VALUE cookies = rb_hash_aref(s, cookies_sym);
-  VALUE handler = rb_hash_aref(s, handler_sym);
-  VALUE headers = rb_hash_aref(s, headers_sym);
-  VALUE log = rb_hash_aref(s, log_sym);
-  VALUE max_body = rb_hash_aref(s, max_body_sym);
-  VALUE max_clients = rb_hash_aref(s, max_clients_sym);
-  VALUE max_headers = rb_hash_aref(s, max_headers_sym);
-  VALUE max_msg = rb_hash_aref(s, max_msg_sym);
-  VALUE method = rb_hash_aref(s, method_sym);
-  VALUE path = rb_hash_aref(s, path_sym);
-  VALUE ping = rb_hash_aref(s, ping_sym);
-  VALUE port = rb_hash_aref(s, port_sym);
-  VALUE r_public = rb_hash_aref(s, public_sym);
-  VALUE service = rb_hash_aref(s, service_sym);
-  VALUE timeout = rb_hash_aref(s, timeout_sym);
-#ifndef __MINGW32__
-  VALUE tls = rb_hash_aref(s, tls_sym);
-#endif
-  VALUE r_url = rb_hash_aref(s, url_sym);
-  fio_str_info_s service_str = {.data = NULL};
-
-  /* Complete using default values */
-  if (address == Qnil)
-    address = rb_hash_aref(iodine_default_args, address_sym);
-  if (app == Qnil)
-    app = rb_hash_aref(iodine_default_args, app_sym);
-  if (cookies == Qnil)
-    cookies = rb_hash_aref(iodine_default_args, cookies_sym);
-  if (handler == Qnil)
-    handler = rb_hash_aref(iodine_default_args, handler_sym);
-  if (headers == Qnil)
-    headers = rb_hash_aref(iodine_default_args, headers_sym);
-  if (log == Qnil)
-    log = rb_hash_aref(iodine_default_args, log_sym);
-  if (max_body == Qnil)
-    max_body = rb_hash_aref(iodine_default_args, max_body_sym);
-  if (max_clients == Qnil)
-    max_clients = rb_hash_aref(iodine_default_args, max_clients_sym);
-  if (max_headers == Qnil)
-    max_headers = rb_hash_aref(iodine_default_args, max_headers_sym);
-  if (max_msg == Qnil)
-    max_msg = rb_hash_aref(iodine_default_args, max_msg_sym);
-  if (method == Qnil)
-    method = rb_hash_aref(iodine_default_args, method_sym);
-  if (path == Qnil)
-    path = rb_hash_aref(iodine_default_args, path_sym);
-  if (ping == Qnil)
-    ping = rb_hash_aref(iodine_default_args, ping_sym);
-  if (port == Qnil)
-    port = rb_hash_aref(iodine_default_args, port_sym);
-  if (r_public == Qnil) {
-    r_public = rb_hash_aref(iodine_default_args, public_sym);
-  }
-  // if (service == Qnil) // not supported by default settings...
-  //   service = rb_hash_aref(iodine_default_args, service_sym);
-  if (timeout == Qnil)
-    timeout = rb_hash_aref(iodine_default_args, timeout_sym);
-#ifndef __MINGW32__
-  if (tls == Qnil)
-    tls = rb_hash_aref(iodine_default_args, tls_sym);
+#ifdef __APPLE__
+#include <dlfcn.h>
 #endif
 
-  /* TODO: deprecation */
-  if (handler == Qnil) {
-    handler = rb_hash_aref(s, app_sym);
-    if (handler != Qnil)
-      FIO_LOG_WARNING(":app is deprecated in Iodine.listen and Iodine.connect. "
-                      "Use :handler");
-  }
-
-  /* specific for HTTP */
-  if (is_srv && handler == Qnil && rb_block_given_p()) {
-    handler = rb_block_proc();
-  }
-
-  /* Raise exceptions on errors (last chance) */
-  if (handler == Qnil) {
-    rb_raise(rb_eArgError, "a :handler is required.");
-  }
-
-  /* Set existing values */
-  if (handler != Qnil) {
-    r.handler = handler;
-  }
-  if (address != Qnil && RB_TYPE_P(address, T_STRING)) {
-    r.address = IODINE_RSTRINFO(address);
-  }
-  if (body != Qnil && RB_TYPE_P(body, T_STRING)) {
-    r.body = IODINE_RSTRINFO(body);
-  }
-  if (cookies != Qnil && RB_TYPE_P(cookies, T_HASH)) {
-    r.cookies = fiobj_hash_new2(rb_hash_size(cookies));
-    rb_hash_foreach(cookies, for_each_cookie, r.cookies);
-  }
-  if (headers != Qnil && RB_TYPE_P(headers, T_HASH)) {
-    r.headers = fiobj_hash_new2(rb_hash_size(headers));
-    rb_hash_foreach(headers, for_each_header_value, r.headers);
-  }
-  if (log != Qnil && log != Qfalse) {
-    r.log = 1;
-  }
-  if (max_body != Qnil && RB_TYPE_P(max_body, T_FIXNUM)) {
-    r.max_body = FIX2ULONG(max_body) * 1024 * 1024;
-  }
-  if (max_clients != Qnil && RB_TYPE_P(max_clients, T_FIXNUM)) {
-    r.max_clients = FIX2ULONG(max_clients);
-  }
-  if (max_headers != Qnil && RB_TYPE_P(max_headers, T_FIXNUM)) {
-    r.max_headers = FIX2ULONG(max_headers) * 1024;
-  }
-  if (max_msg != Qnil && RB_TYPE_P(max_msg, T_FIXNUM)) {
-    r.max_msg = FIX2ULONG(max_msg) * 1024;
-  }
-  if (method != Qnil && RB_TYPE_P(method, T_STRING)) {
-    r.method = IODINE_RSTRINFO(method);
-  }
-  if (path != Qnil && RB_TYPE_P(path, T_STRING)) {
-    r.path = IODINE_RSTRINFO(path);
-  }
-  if (ping != Qnil && RB_TYPE_P(ping, T_FIXNUM)) {
-    if (FIX2ULONG(ping) > 255)
-      FIO_LOG_WARNING(":ping value over 255 will be silently ignored.");
-    else
-      r.ping = FIX2ULONG(ping);
-  }
-  if (port != Qnil) {
-    if (RB_TYPE_P(port, T_STRING)) {
-      char *tmp = RSTRING_PTR(port);
-      if (fio_atol(&tmp))
-        r.port = IODINE_RSTRINFO(port);
-    } else if (RB_TYPE_P(port, T_FIXNUM) && FIX2UINT(port)) {
-      if (FIX2UINT(port) >= 65536) {
-        FIO_LOG_WARNING("Port number %u is too high, quietly ignored.",
-                        FIX2UINT(port));
-      } else {
-        r.port = (fio_str_info_s){.data = fio_malloc(16), .len = 0, .capa = 1};
-        r.port.len = fio_ltoa(r.port.data, FIX2INT(port), 10);
-        r.port.data[r.port.len] = 0;
-      }
-    }
-  }
-
-  if (r_public != Qnil && RB_TYPE_P(r_public, T_STRING)) {
-    r.public = IODINE_RSTRINFO(r_public);
-  }
-  if (service != Qnil && RB_TYPE_P(service, T_STRING)) {
-    service_str = IODINE_RSTRINFO(service);
-  } else if (service != Qnil && RB_TYPE_P(service, T_SYMBOL)) {
-    service = rb_sym2str(service);
-    service_str = IODINE_RSTRINFO(service);
-  }
-  if (timeout != Qnil && RB_TYPE_P(ping, T_FIXNUM)) {
-    if (FIX2ULONG(timeout) > 255)
-      FIO_LOG_WARNING(":timeout value over 255 will be silently ignored.");
-    else
-      r.timeout = FIX2ULONG(timeout);
-  }
-#ifndef __MINGW32__
-  if (tls != Qnil) {
-    r.tls = iodine_tls2c(tls);
-    if (r.tls)
-      fio_tls_dup(r.tls);
-  }
-#endif
-  /* URL parsing */
-  if (r_url != Qnil && RB_TYPE_P(r_url, T_STRING)) {
-    r.url = IODINE_RSTRINFO(r_url);
-    fio_url_s u = fio_url_parse(r.url.data, r.url.len);
-    /* set service string */
-    if (u.scheme.data) {
-      service_str = u.scheme;
-    }
-    /* copy port number */
-    if (u.port.data) {
-      char *tmp = u.port.data;
-      if (fio_atol(&tmp) == 0) {
-        if (r.port.capa)
-          fio_free(r.port.data);
-        r.port = (fio_str_info_s){.data = NULL};
-      } else {
-        if (u.port.len > 5)
-          FIO_LOG_WARNING("Port number error (%.*s too long to be valid).",
-                          (int)u.port.len, u.port.data);
-        if (r.port.capa && u.port.len >= 16) {
-          fio_free(r.port.data);
-          r.port = (fio_str_info_s){.data = NULL};
-        }
-        if (!r.port.capa)
-          r.port = (fio_str_info_s){
-              .data = fio_malloc(u.port.len + 1), .len = u.port.len, .capa = 1};
-        memcpy(r.port.data, u.port.data, u.port.len);
-        r.port.len = u.port.len;
-        r.port.data[r.port.len] = 0;
-      }
-    } else {
-      if (r.port.capa)
-        fio_free(r.port.data);
-      r.port = (fio_str_info_s){.data = NULL};
-    }
-    /* copy host / address */
-    if (u.host.data) {
-      r.address = (fio_str_info_s){
-          .data = fio_malloc(u.host.len + 1), .len = u.host.len, .capa = 1};
-      memcpy(r.address.data, u.host.data, u.host.len);
-      r.address.len = u.host.len;
-      r.address.data[r.address.len] = 0;
-    } else {
-      if (r.address.capa)
-        fio_free(r.address.data);
-      r.address = (fio_str_info_s){.data = NULL};
-    }
-    /* set path */
-    if (u.path.data) {
-      /* support possible Unix address as "raw://:0/my/sock.sock" */
-      if (r.address.data || r.port.data)
-        r.path = u.path;
-      else
-        r.address = u.path;
-    }
-  }
-  /* test/set service type */
-  r.service = IODINE_SERVICE_RAW;
-  if (service_str.data) {
-#ifdef __MINGW32__
-    switch (service_str.data[0]) {
-    case 't': /* overflow */
-              /* tcp or tls */
-      if (service_str.data[1] == 'l') {
-        char *local = NULL;
-        char buf[1024];
-        buf[1023] = 0;
-        if (is_srv) {
-          local = buf;
-          if (fio_local_addr(buf, 1023) >= 1022)
-            local = NULL;
-        }
-      }
-      /* overflow */
-    case 'u': /* overflow */
-    /* unix */
-    case 'r':
-      /* raw */
-      r.service = IODINE_SERVICE_RAW;
-      break;
-    case 'h':
-      /* http(s) */
-      r.service = IODINE_SERVICE_HTTP;
-      if (service_str.len == 5) {
-        char *local = NULL;
-        char buf[1024];
-        buf[1023] = 0;
-        if (is_srv) {
-          local = buf;
-          if (fio_local_addr(buf, 1023) >= 1022)
-            local = NULL;
-        }
-      }
-    case 'w':
-      /* ws(s) */
-      r.service = IODINE_SERVICE_WS;
-      if (service_str.len == 3) {
-        char *local = NULL;
-        char buf[1024];
-        buf[1023] = 0;
-        if (is_srv) {
-          local = buf;
-          if (fio_local_addr(buf, 1023) >= 1022)
-            local = NULL;
-        }
-      }
-      break;
-    }
-#else
-    switch (service_str.data[0]) {
-    case 't': /* overflow */
-              /* tcp or tls */
-      if (service_str.data[1] == 'l' && !r.tls) {
-        char *local = NULL;
-        char buf[1024];
-        buf[1023] = 0;
-        if (is_srv) {
-          local = buf;
-          if (fio_local_addr(buf, 1023) >= 1022)
-            local = NULL;
-        }
-        r.tls = fio_tls_new(local, NULL, NULL, NULL);
-      }
-      /* overflow */
-    case 'u': /* overflow */
-    /* unix */
-    case 'r':
-      /* raw */
-      r.service = IODINE_SERVICE_RAW;
-      break;
-    case 'h':
-      /* http(s) */
-      r.service = IODINE_SERVICE_HTTP;
-      if (service_str.len == 5 && !r.tls) {
-        char *local = NULL;
-        char buf[1024];
-        buf[1023] = 0;
-        if (is_srv) {
-          local = buf;
-          if (fio_local_addr(buf, 1023) >= 1022)
-            local = NULL;
-        }
-        r.tls = fio_tls_new(local, NULL, NULL, NULL);
-      }
-    case 'w':
-      /* ws(s) */
-      r.service = IODINE_SERVICE_WS;
-      if (service_str.len == 3 && !r.tls) {
-        char *local = NULL;
-        char buf[1024];
-        buf[1023] = 0;
-        if (is_srv) {
-          local = buf;
-          if (fio_local_addr(buf, 1023) >= 1022)
-            local = NULL;
-        }
-        r.tls = fio_tls_new(local, NULL, NULL, NULL);
-      }
-      break;
-    }
+/** Any patches required by the running environment for consistent behavior */
+static void patch_env(void) {
+#ifdef __APPLE__
+  /* patch for dealing with the High Sierra `fork` limitations */
+  void *obj_c_runtime = dlopen("Foundation.framework/Foundation", RTLD_LAZY);
+  (void)obj_c_runtime;
 #endif
-  }
-  return r;
-}
-
-/* *****************************************************************************
-Listen function routing
-***************************************************************************** */
-
-// clang-format off
-/*
-{Iodine.listen} can be used to listen to any incoming connections, including HTTP and raw (tcp/ip and unix sockets) connections.
-
-     Iodine.listen(settings)
-
-Supported Settigs:
-
-|  |  |
-|---|---|
-| `:url` | URL indicating service type, host name and port. Path will be parsed as a Unix socket. |
-| `:handler` | (deprecated: `:app`) see details below. |
-| `:address` | an IP address or a unix socket address. Only relevant if `:url` is missing. |
-| `:log` |  (HTTP only) request logging. For global verbosity see {Iodine.verbosity} |
-| `:max_body` | (HTTP only) maximum upload size allowed per request before disconnection (in Mb). |
-| `:max_headers` |  (HTTP only) maximum total header length allowed per request (in Kb). |
-| `:max_msg` |  (WebSockets only) maximum message size pre message (in Kb). |
-| `:ping` |  (`:raw` clients and WebSockets only) ping interval (in seconds). Up to 255 seconds. |
-| `:port` | port number to listen to either a String or Number) |
-| `:public` | (HTTP server only) public folder for static file service. |
-| `:service` | (`:raw` / `:tls` / `:ws` / `:wss` / `:http` / `:https` ) a supported service this socket will listen to. |
-| `:timeout` |  (HTTP only) keep-alive timeout in seconds. Up to 255 seconds. |
-| `:tls` | an {Iodine::TLS} context object for encrypted connections. |
-
-Some connection settings are only valid when listening to HTTP / WebSocket connections.
-
-If `:url` is provided, it will overwrite the `:address` and `:port` settings (if provided).
-
-For HTTP connections, the `:handler` **must** be a valid Rack application object (answers `.call(env)`).
-
-Here's an example for an HTTP hello world application:
-
-      require 'iodine'
-      # a handler can be a block
-      Iodine.listen(service: :http, port: "3000") {|env| [200, {"Content-Length" => "12"}, ["Hello World!"]] }
-      # start the service
-      Iodine.threads = 1
-      Iodine.start
-
-
-Here's another example, using a Unix Socket instead of a TCP/IP socket for an HTTP hello world application.
-
-This example shows how the `:url` option can be used, but the `:address` settings could have been used for the same effect (with `port: 0`).
-
-      require 'iodine'
-      # note that unix sockets in URL form use an absolute path.
-      Iodine.listen(url: "http://:0/tmp/sock.sock") {|env| [200, {"Content-Length" => "12"}, ["Hello World!"]] }
-      # start the service
-      Iodine.threads = 1
-      Iodine.start
-
-
-For raw connections, the `:handler` object should be an object that answer `.call` and returns a valid callback object that supports the following callbacks (see also {Iodine::Connection}):
-
-|  |  |
-|---|---|
-| `on_open(client)` | called after a connection was established |
-| `on_message(client,data)` | called when incoming data is available. Data may be fragmented. |
-| `on_drained(client)` | called after pending `client.write` events have been processed (see {Iodine::Connection#pending}). |
-| `ping(client)` | called whenever a timeout has occured (see {Iodine::Connection#timeout=}). |
-| `on_shutdown(client)` | called if the server is shutting down. This is called before the connection is closed. |
-| `on_close(client)` | called when the connection with the client was closed. |
-
-The `client` argument passed to the `:handler` callbacks is an {Iodine::Connection} instance that represents the connection / the client.
-
-Here's an example for a telnet based chat-room example:
-
-      require 'iodine'
-      # define the protocol for our service
-      module ChatHandler
-        def self.on_open(client)
-          # Set a connection timeout
-          client.timeout = 10
-          # subscribe to the chat channel.
-          client.subscribe :chat
-          # Write a welcome message
-          client.publish :chat, "new member entered the chat\r\n"
-        end
-        # this is called for incoming data - note data might be fragmented.
-        def self.on_message(client, data)
-          # publish the data we received
-          client.publish :chat, data
-          # close the connection when the time comes
-          client.close if data =~ /^bye[\n\r]/
-        end
-        # called whenever timeout occurs.
-        def self.ping(client)
-          client.write "System: quite, isn't it...?\r\n"
-        end
-        # called if the connection is still open and the server is shutting down.
-        def self.on_shutdown(client)
-          # write the data we received
-          client.write "Chat server going away. Try again later.\r\n"
-        end
-        # returns the callback object (self).
-        def self.call
-          self
-        end
-      end
-      # we use can both the `handler` keyword or a block, anything that answers #call.
-      Iodine.listen(service: :raw, port: "3000", handler: ChatHandler)
-      # we can listen to more than a single socket at a time.
-      Iodine.listen(url: "raw://:3030", handler: ChatHandler)
-      # start the service
-      Iodine.threads = 1
-      Iodine.start
-
-
-
-Returns the handler object used.
-*/
-static VALUE iodine_listen(VALUE self, VALUE args) {
-  // clang-format on
-  iodine_connection_args_s s = iodine_connect_args(args, 1);
-  intptr_t uuid = -1;
-  switch (s.service) {
-  case IODINE_SERVICE_RAW:
-    uuid = iodine_tcp_listen(s);
-    break;
-  case IODINE_SERVICE_HTTP: /* overflow */
-  case IODINE_SERVICE_WS:
-    uuid = iodine_http_listen(s);
-    break;
-  }
-  iodine_connect_args_cleanup(&s);
-  if (uuid == -1)
-    rb_raise(rb_eRuntimeError, "Couldn't open listening socket.");
-  return s.handler;
-  (void)self;
-}
-
-/* *****************************************************************************
-Connect function routing
-***************************************************************************** */
-
-// clang-format off
-/*
-
-The {connect} method instructs iodine to connect to a server using either TCP/IP or Unix sockets.
-
-     Iodine.connect(settings)
-
-Supported Settigs:
-
-
-|  |  |
-|---|---|
-| `:url` | URL indicating service type, host name, port and optional path. |
-| `:handler` | see details below. |
-| `:address` | an IP address or a unix socket address. Only relevant if `:url` is missing. |
-| `:body` | (HTTP client) the body to be sent. |
-| `:cookies` | (HTTP/WebSocket client) cookie data. |
-| `:headers` | (HTTP/WebSocket client) custom headers. |
-| `:log` | (HTTP only) - logging the requests. |
-| `:max_body` | (HTTP only) - limits HTTP body in the response, see {listen}. |
-| `:max_headers` | (HTTP only) - limits the header length in the response, see {listen}. |
-| `:max_msg` |  (WebSockets only) maximum incoming message size pre message (in Kb). |
-| `:method` | (HTTP client) a String such as "GET" or "POST". |
-| `:path` |HTTP/WebSocket client) the HTTP path to be used. |
-| `:ping` | ping interval (in seconds). Up to 255 seconds. |
-| `:port` | port number to listen to either a String or Number) |
-| `:public` | (public folder, HTTP server only) |
-| `:service` | (`:raw` / `:tls` / `:ws` / `:wss` ) |
-| `:timeout` | (HTTP only) keep-alive timeout in seconds. Up to 255 seconds. |
-| `:tls` | an {Iodine::TLS} context object for encrypted connections. |
-
-Some connection settings are only valid for HTTP / WebSocket connections.
-
-If `:url` is provided, it will overwrite the `:address`, `:port` and `:path` settings (if provided).
-
-Unlike {Iodine.listen}, a block can't be used and a `:handler` object **must** be provided.
-
-If the connection fails, only the `on_close` callback will be called (with a `nil` client).
-
-Here's an example TCP/IP client that sends a simple HTTP GET request:
-
-      # use a secure connection?
-      USE_TLS = false
-
-      # remote server details
-      $port = USE_TLS ? 443 : 80
-      $address = "google.com"
-
-
-      # require iodine
-      require 'iodine'
-
-      # Iodine runtime settings
-      Iodine.threads = 1
-      Iodine.workers = 1
-      Iodine.verbosity = 3 # warnings only
-
-
-      # a client callback handler
-      module Client
-
-        def self.on_open(connection)
-          # Set a connection timeout
-          connection.timeout = 10
-          # subscribe to the chat channel.
-          puts "* Sending request..."
-          connection.write "GET / HTTP/1.1\r\nHost: #{$address}\r\n\r\n"
-        end
-
-        def self.on_message(connection, data)
-          # publish the data we received
-          STDOUT.write data
-          # close the connection after a second... we're not really parsing anything, so it's a guess.
-          Iodine.run_after(1000) { connection.close }
-        end
-
-        def self.on_close(connection)
-          # stop iodine
-          Iodine.stop
-          puts "Done."
-        end
-
-        # returns the callback object (self).
-        def self.call
-          self
-        end
-      end
-
-
-
-      if(USE_TLS)
-        tls = Iodine::TLS.new
-        # ALPN blocks should return a valid calback object
-        tls.on_protocol("http/1.1") { Client }
-      end
-
-      Iodine.connect(address: $address, port: $port, handler: Client, tls: tls)
-
-      # start the iodine reactor
-      Iodine.start
-
-Iodine also supports WebSocket client connections, using either the `url` property or the `ws` and `wss` service names.
-
-The following example establishes a secure (TLS) connects to the WebSocket echo testing server at `wss://echo.websocket.org`:
-
-      # require iodine
-      require 'iodine'
-
-      # The client class
-      class EchoClient
-
-        def on_open(connection)
-          @messages = [ "Hello World!",
-            "I'm alive and sending messages",
-            "I also receive messages",
-            "now that we all know this...",
-            "I can stop.",
-            "Goodbye." ]
-          send_one_message(connection)
-        end
-
-        def on_message(connection, message)
-          puts "Received: #{message}"
-          send_one_message(connection)
-        end
-
-        def on_close(connection)
-          # in this example, we stop iodine once the client is closed
-          puts "* Client closed."
-          Iodine.stop
-        end
-
-        # We use this method to pop messages from the queue and send them
-        #
-        # When the queue is empty, we disconnect the client.
-        def send_one_message(connection)
-          msg = @messages.shift
-          if(msg)
-            connection.write msg
-          else
-            connection.close
-          end
-        end
-      end
-
-      Iodine.threads = 1
-      Iodine.connect url: "wss://echo.websocket.org", handler: EchoClient.new, ping: 40
-      Iodine.start
-
-**Note**: the `on_close` callback is always called, even if a connection couldn't be established.
-
-Returns the handler object used.
-*/
-static VALUE iodine_connect(VALUE self, VALUE args) {
-  // clang-format on
-  iodine_connection_args_s s = iodine_connect_args(args, 0);
-  intptr_t uuid = -1;
-  switch (s.service) {
-  case IODINE_SERVICE_RAW:
-    uuid = iodine_tcp_connect(s);
-    break;
-  case IODINE_SERVICE_HTTP:
-    iodine_connect_args_cleanup(&s);
-    rb_raise(rb_eRuntimeError, "HTTP client connections aren't supported yet.");
-    return Qnil;
-    break;
-  case IODINE_SERVICE_WS:
-    uuid = iodine_ws_connect(s);
-    break;
-  }
-  iodine_connect_args_cleanup(&s);
-  if (uuid == -1)
-    rb_raise(rb_eRuntimeError, "Couldn't open client socket.");
-  return self;
 }
 
 /* *****************************************************************************
-Ruby loads the library and invokes the Init_<lib_name> function...
-
-Here we connect all the C code to the Ruby interface, completing the bridge
-between Lib-Server and Ruby.
+Initialize Extension
 ***************************************************************************** */
-void Init_iodine_ext(void) {
-  /* common Symbol objects in use by Iodine */
-#define IODINE_MAKE_SYM(name)                                                  \
-  do {                                                                         \
-    name##_sym = rb_id2sym(rb_intern(#name));                                  \
-    rb_global_variable(&name##_sym);                                           \
-  } while (0)
-  IODINE_MAKE_SYM(address);
-  IODINE_MAKE_SYM(app);
-  IODINE_MAKE_SYM(body);
-  IODINE_MAKE_SYM(cookies);
-  IODINE_MAKE_SYM(handler);
-  IODINE_MAKE_SYM(headers);
-  IODINE_MAKE_SYM(log);
-  IODINE_MAKE_SYM(max_body);
-  IODINE_MAKE_SYM(max_clients);
-  IODINE_MAKE_SYM(max_headers);
-  IODINE_MAKE_SYM(max_msg);
-  IODINE_MAKE_SYM(method);
-  IODINE_MAKE_SYM(path);
-  IODINE_MAKE_SYM(ping);
-  IODINE_MAKE_SYM(port);
-  IODINE_MAKE_SYM(public);
-  IODINE_MAKE_SYM(service);
-  IODINE_MAKE_SYM(timeout);
-  IODINE_MAKE_SYM(tls);
-  IODINE_MAKE_SYM(url);
 
-  // load any environment specific patches
+void Init_iodine(void) {
   patch_env();
-
-  // force the GVL state for the main thread
-  IodineCaller.set_GVL(1);
-
-  // 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");
-  iodine_call_id = rb_intern2("call", 4);
-  iodine_to_s_id = rb_intern("to_s");
-
-  // register core methods
-  rb_define_module_function(IodineModule, "threads", iodine_threads_get, 0);
-  rb_define_module_function(IodineModule, "threads=", iodine_threads_set, 1);
-  rb_define_module_function(IodineModule, "verbosity", iodine_logging_get, 0);
-  rb_define_module_function(IodineModule, "verbosity=", iodine_logging_set, 1);
-  rb_define_module_function(IodineModule, "workers", iodine_workers_get, 0);
-  rb_define_module_function(IodineModule, "workers=", iodine_workers_set, 1);
-  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);
-  rb_define_module_function(IodineModule, "running?", iodine_running, 0);
-  rb_define_module_function(IodineModule, "listen", iodine_listen, 1);
-  rb_define_module_function(IodineModule, "connect", iodine_connect, 1);
-
-  // register CLI methods
-  rb_define_module_function(IodineCLIModule, "parse", iodine_cli_parse, 0);
-
-  /** Default connection settings for {listen} and {connect}. */
-  iodine_default_args = rb_hash_new();
-  /** Default connection settings for {listen} and {connect}. */
-  rb_const_set(IodineModule, rb_intern("DEFAULT_SETTINGS"),
-               iodine_default_args);
-
-  /** Depracated, use {Iodine::DEFAULT_SETTINGS}. */
-  rb_const_set(IodineModule, rb_intern("DEFAULT_HTTP_ARGS"),
-               iodine_default_args);
-
-  // initialize Object storage for GC protection
-  iodine_storage_init();
-
-  // initialize concurrency related methods
-  iodine_defer_initialize();
-
-  // initialize the connection class
-  iodine_connection_init();
-
-  // intialize the TCP/IP related module
-  iodine_init_tcp_connections();
-
-  // initialize the HTTP module
-  iodine_init_http();
-
-#ifndef __MINGW32__
-  // initialize SSL/TLS support module
-  iodine_init_tls();
+  IODINE_THREAD_POOL = (fio_io_async_s)FIO_IO_ASYN_INIT;
+  fio_state_callback_force(FIO_CALL_ON_INITIALIZE);
+
+  IodineUTF8Encoding = rb_enc_find("UTF-8");
+  IodineBinaryEncoding = rb_enc_find("binary");
+
+  /** The Iodine module is where it all happens. */
+  iodine_rb_IODINE = rb_define_module("Iodine");
+  STORE.hold(iodine_rb_IODINE);
+  /** The PubSub module contains Pub/Sub related classes / data. */
+  iodine_rb_IODINE_PUBSUB = rb_define_module_under(iodine_rb_IODINE, "PubSub");
+  STORE.hold(iodine_rb_IODINE_PUBSUB);
+  /** The Iodine::Base module is for internal concerns. */
+  iodine_rb_IODINE_BASE =
+      rb_define_class_under(iodine_rb_IODINE, "Base", rb_cObject);
+  rb_undef_alloc_func(iodine_rb_IODINE_BASE);
+  STORE.hold(iodine_rb_IODINE_BASE);
+  /** The Iodine::Base::App404 module is for static file only. */
+  iodine_rb_IODINE_BASE_APP404 =
+      rb_define_module_under(iodine_rb_IODINE_BASE, "App404");
+  STORE.hold(iodine_rb_IODINE_BASE_APP404);
+  { /** Initialize `STORE` and object reference counting. */
+    iodine_setup_value_reference_counter(iodine_rb_IODINE_BASE);
+    rb_define_singleton_method(iodine_rb_IODINE_BASE,
+                               "print_debug",
+                               iodine_store___print_debug,
+                               0);
+    rb_define_singleton_method(iodine_rb_IODINE_BASE,
+                               "store_size",
+                               iodine_store___held_count,
+                               0);
+  }
+
+  IODINE_CONST_ID_STORE(IODINE_CALL_ID, "call");
+  IODINE_CONST_ID_STORE(IODINE_CLOSE_ID, "close");
+  IODINE_CONST_ID_STORE(IODINE_EACH_ID, "each");
+  IODINE_CONST_ID_STORE(IODINE_FILENO_ID, "fileno");
+  IODINE_CONST_ID_STORE(IODINE_NEW_ID, "new");
+  IODINE_CONST_ID_STORE(IODINE_CURRENT_ID, "current");
+  IODINE_CONST_ID_STORE(IODINE_JOIN_ID, "join");
+  IODINE_CONST_ID_STORE(IODINE_TO_PATH_ID, "to_path");
+  IODINE_CONST_ID_STORE(IODINE_TO_S_ID, "to_s");
+  IODINE_CONST_ID_STORE(IODINE_TO_JSON_ID, "to_json");
+
+  IODINE_CONST_ID_STORE(IODINE_INDEX_ID, "index");
+  IODINE_CONST_ID_STORE(IODINE_SHOW_ID, "show");
+  IODINE_CONST_ID_STORE(IODINE_EDIT_ID, "edit");
+  IODINE_CONST_ID_STORE(IODINE_CREATE_ID, "create");
+  IODINE_CONST_ID_STORE(IODINE_UPDATE_ID, "update");
+  IODINE_CONST_ID_STORE(IODINE_DELETE_ID, "delete");
+
+  IODINE_CONST_ID_STORE(IODINE_RACK_HIJACK_ID, "rack_hijack");
+  IODINE_CONST_ID_STORE(IODINE_ON_AUTHENTICATE_ID, "on_authenticate");
+  IODINE_CONST_ID_STORE(IODINE_ON_AUTHENTICATE_SSE_ID, "on_authenticate_sse");
+  IODINE_CONST_ID_STORE(IODINE_ON_AUTHENTICATE_WEBSOCKET_ID,
+                        "on_authenticate_websocket");
+  IODINE_CONST_ID_STORE(IODINE_ON_CLOSE_ID, "on_close");
+  IODINE_CONST_ID_STORE(IODINE_ON_DATA_ID, "on_data");
+  IODINE_CONST_ID_STORE(IODINE_ON_DRAINED_ID, "on_drained");
+  IODINE_CONST_ID_STORE(IODINE_ON_EVENTSOURCE_ID, "on_eventsource");
+  IODINE_CONST_ID_STORE(IODINE_ON_EVENTSOURCE_RECONNECT_ID,
+                        "on_eventsource_reconnect");
+  IODINE_CONST_ID_STORE(IODINE_ON_FINISH_ID, "on_finish");
+  IODINE_CONST_ID_STORE(IODINE_ON_HTTP_ID, "on_http");
+  IODINE_CONST_ID_STORE(IODINE_ON_MESSAGE_ID, "on_message");
+  IODINE_CONST_ID_STORE(IODINE_ON_OPEN_ID, "on_open");
+  IODINE_CONST_ID_STORE(IODINE_ON_SHUTDOWN_ID, "on_shutdown");
+  IODINE_CONST_ID_STORE(IODINE_ON_TIMEOUT_ID, "on_timeout");
+  IODINE_CONST_ID_STORE(IODINE_QUERY_ID, "query");
+
+  IODINE_CONST_ID_STORE(IODINE_STATE_PRE_START, "pre_start");
+  IODINE_CONST_ID_STORE(IODINE_STATE_BEFORE_FORK, "before_fork");
+  IODINE_CONST_ID_STORE(IODINE_STATE_AFTER_FORK, "after_fork");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ENTER_CHILD, "enter_child");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ENTER_MASTER, "enter_master");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ON_START, "start");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ON_PARENT_CRUSH, "parent_crush");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ON_CHILD_CRUSH, "child_crush");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ON_SHUTDOWN, "shutdown");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ON_STOP, "stop");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ON_IDLE, "idle");
+  IODINE_CONST_ID_STORE(IODINE_STATE_ON_EXIT, "exit");
+
+  STORE.hold(IODINE_RACK_HIJACK_ID_SYM = rb_id2sym(IODINE_RACK_HIJACK_ID));
+  STORE.hold(IODINE_RACK_HIJACK_SYM = rb_id2sym(rb_intern("rack.hijack")));
+  STORE.hold(IODINE_RACK_HIJACK_STR = rb_sym_to_s(IODINE_RACK_HIJACK_SYM));
+
+  IODINE_RACK_PROTOCOL_STR =
+      STORE.frozen_str(FIO_STR_INFO1((char *)"rack.protocol"));
+  IODINE_RACK_UPGRADE_STR =
+      STORE.frozen_str(FIO_STR_INFO1((char *)"rack.upgrade"));
+  IODINE_RACK_UPGRADE_Q_STR =
+      STORE.frozen_str(FIO_STR_INFO1((char *)"rack.upgrade?"));
+  STORE.hold(IODINE_RACK_UPGRADE_WS_SYM = rb_id2sym(rb_intern("websocket")));
+  STORE.hold(IODINE_RACK_UPGRADE_SSE_SYM = rb_id2sym(rb_intern("sse")));
+  STORE.hold(IODINE_RACK_AFTER_RPLY_STR =
+                 rb_str_new_static("rack.after_reply", 16));
+
+  Init_Iodine();
+  Init_Iodine_Base_CLI();
+  Init_Iodine_Compression();
+  Init_Iodine_Crypto();
+  Init_Iodine_Mustache();
+  Init_Iodine_Utils();
+  Init_Iodine_JSON();
+  Init_Iodine_Listener();
+  Init_Iodine_Logger();
+  Init_Iodine_MiniMap();
+  Init_Iodine_PubSub_Engine();
+  Init_Iodine_PubSub_Subscription();
+  Init_Iodine_PubSub_History();
+  Init_Iodine_RESP3();
+  Init_Iodine_PubSub_Message();
+  Init_Iodine_TLS();
+  Init_Iodine_Connection();
+  /* make sure the Iodine.run / async methods are available pre-start */
+  fio_io_async_attach(&IODINE_THREAD_POOL, (uint32_t)fio_cli_get_i("-t"));
+#ifdef SIGUSR1
+  /* support hot restarting of workers */
+  fio_io_restart_on_signal(SIGUSR1);
 #endif
-
-  // initialize JSON helpers
-  iodine_init_json();
-
-  // initialize Mustache engine
-  iodine_init_mustache();
-
-  // initialize Rack helpers and IO
-  iodine_init_helpers();
-  IodineRackIO.init();
-
-  // initialize Pub/Sub extension (for Engines)
-  iodine_pubsub_init();
+  fio_state_callback_add(FIO_CALL_ON_STOP, iodine___worker_gc_on_stop, NULL);
+  rb_set_end_proc(iodine___perform_exit, (VALUE)Qnil);
 }