iodine 0.7.5 → 0.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21610266b95f78b98341f1cfad626edec6f6aa903befe8c8ba6defa863c650ed
-  data.tar.gz: 2260a4db63a0a833d2d6902d3f54aed522d67f33378904caedd1c77eb6517c3f
+  metadata.gz: 978b528f65f3a43372f47339c6f76ced52bfc12264665bf57c0d2f285b2a4ad2
+  data.tar.gz: b75b56ceebbda9a80510740f3d11425980a3562d46542e308e818fcf0fd9b219
 SHA512:
-  metadata.gz: b9b5ac545d5b135548e5c781fb0212afba358b55b7e7b497212cfabd07924b56549fdb85a892162ae1c7e0f0be0d93d0d18c38bdb36d7f64c67fd5266fa1c307
-  data.tar.gz: ae58b456d93c90037847867d62b4f2243599618f5a9445a8c5b143c747567c96479881ee4571eea3ba58ea92d54091c76141eb33d96693fd5baf65333c9c98ea
+  metadata.gz: bf003b8b3ddf3a1be5c81cee28588a31ed9af159ad5e2b49d69d3e1a8bc6cf75149ba4191bc80c8e55e55cf5a9fae6b47d7c615662a6073824086b91d1a5811f
+  data.tar.gz: 923b37d94efd4e31d96743df37425334268c1c3a9fd51d44265f8a9603ff92346cc4d793e24a39203a93e5aabadf64981190ad88f843fb50fc276452ee6cb38e

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.6
+
+**Fix**: (facil.io edge) timeout review was experiencing some errors that could cause timeouts to be ignored. This was fixed in the facil.io edge branch.
+
+**Fix**: (Ruby 2.2) fixed a possible error with the Mustache parser on Ruby 2.2. I don't run Ruby 2.2, but this came up as a warning during CI tests.
+
+**Fix**: `on_worker_boot` was mistakenly updated to a pre-fork callback (instead of a post fork callback) when attempting to fix the `on_worker_fork` behavior. This timing issue is now fixed and `on_worker_boot` is called **after** forking (both on the master process and the worker).
+
 #### Change log v.0.7.5
 
 **Fix**: fixed issue with direct calls to `publish` in the pre-defined pub/sub engines. These direct calls are used by custom engines when the default engine was replaced and would attempt (erroneously) direct engine access rather than use the `fio_publish` function.

data/ext/iodine/fio.c

@@ -1939,8 +1939,8 @@ postpone:
 static void deferred_ping(void *arg, void *arg2) {
   if (!uuid_data(arg).protocol ||
       (uuid_data(arg).timeout &&
-       (uuid_data(arg).timeout >
-        (fio_data->last_cycle.tv_sec - uuid_data(arg).active)))) {
+       (uuid_data(arg).timeout + uuid_data(arg).active >
+        (fio_data->last_cycle.tv_sec)))) {
     return;
   }
   fio_protocol_s *pr = protocol_try_lock(fio_uuid2fd(arg), FIO_PR_LOCK_WRITE);
@@ -2578,6 +2578,9 @@ void fio_force_close(intptr_t uuid) {
     errno = EBADF;
     return;
   }
+  /* make sure the close marker is set */
+  if (!uuid_data(uuid).close)
+    uuid_data(uuid).close = 1;
   /* clear away any packets in case we want to cut the connection short. */
   fio_packet_s *packet;
   fio_lock(&uuid_data(uuid).sock_lock);
@@ -2592,8 +2595,9 @@ void fio_force_close(intptr_t uuid) {
     fio_packet_free(tmp);
   }
   /* check for rw-hooks termination packet */
-  if (uuid_data(uuid).open &&
-      uuid_data(uuid).rw_hooks->close(uuid, uuid_data(uuid).rw_udata)) {
+  if (uuid_data(uuid).open && (uuid_data(uuid).close & 1) &&
+      uuid_data(uuid).rw_hooks->before_close(uuid, uuid_data(uuid).rw_udata)) {
+    uuid_data(uuid).close = 2; /* don't repeat the before_close callback */
     fio_touch(uuid);
     fio_poll_add_write(fio_uuid2fd(uuid));
     return;
@@ -2629,24 +2633,25 @@ ssize_t fio_flush(intptr_t uuid) {
   if (fio_trylock(&uuid_data(uuid).sock_lock))
     goto would_block;
 
-  flushed = uuid_data(uuid).rw_hooks->flush(uuid, uuid_data(uuid).rw_udata);
-  if (flushed < 0) {
-    goto test_errno;
-  }
-  if (flushed) {
-    goto flushed;
-  }
-
   if (uuid_data(uuid).packet) {
     tmp = uuid_data(uuid).packet->write_func(fio_uuid2fd(uuid),
                                              uuid_data(uuid).packet);
     if (tmp == 0) {
       errno = ECONNRESET;
       fio_unlock(&uuid_data(uuid).sock_lock);
+      uuid_data(uuid).close = 1;
       goto closed;
     } else if (tmp < 0) {
       goto test_errno;
     }
+  } else {
+    flushed = uuid_data(uuid).rw_hooks->flush(uuid, uuid_data(uuid).rw_udata);
+    if (flushed < 0) {
+      goto test_errno;
+    }
+    if (flushed) {
+      goto flushed;
+    }
   }
 
   /* end critical section */
@@ -2663,7 +2668,6 @@ would_block:
   errno = EWOULDBLOCK;
   return -1;
 closed:
-  uuid_data(uuid).close = 1;
   fio_force_close(uuid);
   return -1;
 test_errno:
@@ -2685,7 +2689,7 @@ void fio_flush_all(void) {
   if (!fio_data)
     return;
   for (uintptr_t i = 0; i < fio_data->max_protocol_fd; ++i) {
-    if (fd_data(i).packet)
+    if (fd_data(i).open || fd_data(i).packet)
       fio_flush(fd2uuid(i));
   }
 }
@@ -2705,10 +2709,10 @@ static ssize_t fio_hooks_default_write(intptr_t uuid, void *udata,
   (void)(udata);
 }
 
-static ssize_t fio_hooks_default_close(intptr_t uuid, void *udata) {
-  close(fio_uuid2fd(uuid));
+static ssize_t fio_hooks_default_before_close(intptr_t uuid, void *udata) {
   return 0;
   (void)udata;
+  (void)uuid;
 }
 
 static ssize_t fio_hooks_default_flush(intptr_t uuid, void *udata) {
@@ -2723,7 +2727,7 @@ const fio_rw_hook_s FIO_DEFAULT_RW_HOOKS = {
     .read = fio_hooks_default_read,
     .write = fio_hooks_default_write,
     .flush = fio_hooks_default_flush,
-    .close = fio_hooks_default_close,
+    .before_close = fio_hooks_default_before_close,
     .cleanup = fio_hooks_default_cleanup,
 };
 
@@ -2737,8 +2741,8 @@ int fio_rw_hook_set(intptr_t uuid, fio_rw_hook_s *rw_hooks, void *udata) {
     rw_hooks->write = fio_hooks_default_write;
   if (!rw_hooks->flush)
     rw_hooks->flush = fio_hooks_default_flush;
-  if (!rw_hooks->close)
-    rw_hooks->close = fio_hooks_default_close;
+  if (!rw_hooks->before_close)
+    rw_hooks->before_close = fio_hooks_default_before_close;
   if (!rw_hooks->cleanup)
     rw_hooks->cleanup = fio_hooks_default_cleanup;
   uuid = fio_uuid2fd(uuid);
@@ -2856,6 +2860,8 @@ void fio_timeout_set(intptr_t uuid, uint8_t timeout) {
   if (uuid_is_valid(uuid)) {
     uuid_data(uuid).active = fio_data->last_cycle.tv_sec;
     uuid_data(uuid).timeout = timeout;
+  } else {
+    FIO_LOG_DEBUG("Called fio_timeout_set for invalid uuid %p", (void *)uuid);
   }
 }
 /** Gets a timeout for a specific connection. Returns 0 if there's no set
@@ -3245,7 +3251,6 @@ static void fio_review_timeout(void *arg, void *ignr) {
   uint16_t timeout = fd_data(fd).timeout;
   if (!timeout)
     timeout = 300; /* enforced timout settings */
-
   if (!fd_data(fd).protocol || (fd_data(fd).active + timeout >= review))
     goto finish;
   tmp = protocol_try_lock(fd, FIO_PR_LOCK_STATE);
@@ -3262,7 +3267,7 @@ finish:
     fd++;
   } while (!fd_data(fd).protocol && (fd <= fio_data->max_protocol_fd));
 
-  if (fio_data->max_protocol_fd <= fd) {
+  if (fio_data->max_protocol_fd < fd) {
     fio_data->need_review = 1;
     return;
   }
@@ -3347,6 +3352,9 @@ static void fio_worker_startup(void) {
     fio_data->threads = 1;
   }
 
+  /* require timeout review */
+  fio_data->need_review = 1;
+
   /* the cycle task will loop by re-scheduling until it's time to finish */
   fio_defer(fio_cycle, NULL, NULL);
 

data/ext/iodine/fio.h

@@ -410,7 +410,7 @@ extern int FIO_LOG_LEVEL;
 #endif
 
 #if FIO_PRINT_STATE
-#define FIO_LOG_STATE(...) FIO_LOG_PRINT(0, __VA_ARGS__)
+#define FIO_LOG_STATE(...) FIO_LOG_PRINT(FIO_LOG_LEVEL_INFO, __VA_ARGS__)
 #else
 #define FIO_LOG_STATE(...)
 #endif
@@ -1193,20 +1193,27 @@ typedef struct fio_rw_hook_s {
    * Implement writing to a file descriptor. Should behave like the file system
    * `write` call.
    *
+   * If an internal buffer is implemented and it is full, errno should be set to
+   * EWOULDBLOCK and the function should return -1.
+   *
+   * The function is expected to call the `flush` callback (or it's logic)
+   * internally. Either `write` OR `flush` are called.
+   *
    * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
    * deadlock might occur.
    */
   ssize_t (*write)(intptr_t uuid, void *udata, const void *buf, size_t count);
   /**
-   * The `close` callback should close the underlying socket / file descriptor.
+   * The `before_close` callback is called only once before closing the `uuid`.
    *
-   * If the function returns a non-zero value, it will be called again after an
-   * attempt to flush the socket and any pending outgoing buffer.
+   * If the function returns a non-zero value, than closure will be delayed
+   * until the `flush` returns 0 (or less). This allows a closure signal to be
+   * sent by the read/write hook when such a signal is required.
    *
    * Note: facil.io library functions MUST NEVER be called by any r/w hook, or a
    * deadlock might occur.
    * */
-  ssize_t (*close)(intptr_t uuid, void *udata);
+  ssize_t (*before_close)(intptr_t uuid, void *udata);
   /**
    * When implemented, this function will be called to flush any data remaining
    * in the internal buffer.

data/ext/iodine/fio_cli.c

@@ -33,12 +33,13 @@ typedef struct {
 
 static fio_cli_hash_s fio_aliases = FIO_SET_INIT;
 static fio_cli_hash_s fio_values = FIO_SET_INIT;
-static size_t fio_unknown_count = 0;
+static size_t fio_unnamed_count = 0;
 
 typedef struct {
-  int allow_unknown;
+  int unnamed_min;
+  int unnamed_max;
   int pos;
-  int unknown_count;
+  int unnamed_count;
   char const *description;
   char const **names;
 } fio_cli_parser_data_s;
@@ -112,19 +113,19 @@ found:
 
 static void fio_cli_set_arg(cstr_s arg, char const *value, char const *line,
                             fio_cli_parser_data_s *parser) {
-  /* handle unknown argument */
+  /* handle unnamed argument */
   if (!line || !arg.len) {
     if (!value) {
-      /*wtf?*/
-      return;
+      goto print_help;
     }
     if (!strcmp(value, "-?") || !strcasecmp(value, "-h") ||
         !strcasecmp(value, "-help") || !strcasecmp(value, "--help")) {
       goto print_help;
     }
-    cstr_s n = {.len = ++parser->unknown_count};
+    cstr_s n = {.len = ++parser->unnamed_count};
     fio_cli_hash_insert(&fio_values, n.len, n, value, NULL);
-    if (!parser->allow_unknown) {
+    if (parser->unnamed_max >= 0 &&
+        parser->unnamed_count > parser->unnamed_max) {
       arg.len = 0;
       goto error;
     }
@@ -287,10 +288,14 @@ print_help:
   exit(0);
 }
 
-void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int allow_unknown,
-                               char const *description, char const **names) {
+void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int unnamed_min,
+                               int unnamed_max, char const *description,
+                               char const **names) {
+  if (unnamed_max >= 0 && unnamed_max < unnamed_min)
+    unnamed_max = unnamed_min;
   fio_cli_parser_data_s parser = {
-      .allow_unknown = allow_unknown,
+      .unnamed_min = unnamed_min,
+      .unnamed_max = unnamed_max,
       .description = description,
       .names = names,
       .pos = 0,
@@ -338,13 +343,16 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int allow_unknown,
 
   /* Cleanup and save state for API */
   fio_cli_hash_free(&fio_aliases);
-  fio_unknown_count = parser.unknown_count;
+  fio_unnamed_count = parser.unnamed_count;
+  /* test for required unnamed arguments */
+  if (parser.unnamed_count < parser.unnamed_min)
+    fio_cli_set_arg((cstr_s){.len = 0}, NULL, NULL, &parser);
 }
 
 void fio_cli_end(void) {
   fio_cli_hash_free(&fio_values);
   fio_cli_hash_free(&fio_aliases);
-  fio_unknown_count = 0;
+  fio_unnamed_count = 0;
 }
 /* *****************************************************************************
 CLI Data Access
@@ -383,13 +391,13 @@ int fio_cli_get_i(char const *name) {
 }
 
 /** Returns the number of unrecognized argument. */
-unsigned int fio_cli_unknown_count(void) {
-  return (unsigned int)fio_unknown_count;
+unsigned int fio_cli_unnamed_count(void) {
+  return (unsigned int)fio_unnamed_count;
 }
 
 /** Returns the unrecognized argument using a 0 based `index`. */
-char const *fio_cli_unknown(unsigned int index) {
-  if (!fio_cli_hash_count(&fio_values) || !fio_unknown_count) {
+char const *fio_cli_unnamed(unsigned int index) {
+  if (!fio_cli_hash_count(&fio_values) || !fio_unnamed_count) {
     return NULL;
   }
   cstr_s n = {.data = NULL, .len = index + 1};

data/ext/iodine/fio_cli.h

@@ -31,6 +31,14 @@ CLI API
  * provided and the provided arument fails to match the required type, execution
  * will end and an error message will be printed along with a short "help".
  *
+ * The function / macro accepts the following arguments:
+ * - `argc`: command line argument count.
+ * - `argv`: command line argument list (array).
+ * - `unnamed_min`: the required minimum of un-named arguments.
+ * - `unnamed_max`: the maximum limit of un-named arguments.
+ * - `description`: a C string containing the program's description.
+ * - named arguments list: a list of C strings describing named arguments.
+ *
  * The following optional type requirements are:
  *
  * * FIO_CLI_TYPE_STRING - (default) string argument.
@@ -43,9 +51,11 @@ CLI API
  * The arguments "-?", "-h", "-help" and "--help" are automatically handled
  * unless overridden.
  *
+ * Un-named arguments shouldn't be listed in the named arguments list.
+ *
  * Example use:
  *
- *    fio_cli_start(argc, argv, 0, "this example accepts the following:",
+ *    fio_cli_start(argc, argv, 0, 0, "this example accepts the following:",
  *                  "-t -thread number of threads to run.", FIO_CLI_TYPE_INT,
  *                  "-w -workers number of workers to run.", FIO_CLI_TYPE_INT,
  *                  "-b, -address the address to bind to.",
@@ -68,16 +78,16 @@ CLI API
  *
  * This function is NOT thread safe.
  */
-#define fio_cli_start(argc, argv, allow_unknown, description, ...)             \
-  fio_cli_start((argc), (argv), (allow_unknown), (description),                \
+#define fio_cli_start(argc, argv, unnamed_min, unnamed_max, description, ...)  \
+  fio_cli_start((argc), (argv), (unnamed_min), (unnamed_max), (description),   \
                 (char const *[]){__VA_ARGS__, NULL})
 #define FIO_CLI_IGNORE
 /**
  * Never use the function directly, always use the MACRO, because the macro
  * attaches a NULL marker at the end of the `names` argument collection.
  */
-void fio_cli_start FIO_CLI_IGNORE(int argc, char const *argv[],
-                                  int allow_unknown, char const *description,
+void fio_cli_start FIO_CLI_IGNORE(int argc, char const *argv[], int unnamed_min,
+                                  int unnamed_max, char const *description,
                                   char const **names);
 /**
  * Clears the memory used by the CLI dictionary, removing all parsed data.
@@ -95,11 +105,11 @@ int fio_cli_get_i(char const *name);
 /** This MACRO returns the argument's value as a boolean. */
 #define fio_cli_get_bool(name) (fio_cli_get((name)) != NULL)
 
-/** Returns the number of unrecognized argument. */
-unsigned int fio_cli_unknown_count(void);
+/** Returns the number of unnamed argument. */
+unsigned int fio_cli_unnamed_count(void);
 
-/** Returns the unrecognized argument using a 0 based `index`. */
-char const *fio_cli_unknown(unsigned int index);
+/** Returns the unnamed argument using a 0 based `index`. */
+char const *fio_cli_unnamed(unsigned int index);
 
 /**
  * Sets the argument's value as a NUL terminated C String (no copy!).

data/ext/iodine/http.c

@@ -39,6 +39,32 @@ static inline int patch_clock_gettime(int clk_id, struct timespec *t) {
 }
 #endif
 
+/* *****************************************************************************
+SSL/TLS patch
+***************************************************************************** */
+void __attribute__((weak)) fio_tls_accept(intptr_t uuid, void *tls) {
+  FIO_LOG_FATAL("HTTP SSL/TLS required but unavailable!");
+  exit(-1);
+  (void)uuid;
+  (void)tls;
+}
+#pragma weak fio_tls_accept
+
+/**
+ * Establishes an SSL/TLS connection as an SSL/TLS Server, using the specified
+ * conetext / settings object.
+ *
+ * The `uuid` should be a socket UUID that is already connected to a peer (i.e.,
+ * the result of `fio_accept`).
+ */
+void __attribute__((weak)) fio_tls_connect(intptr_t uuid, void *tls) {
+  FIO_LOG_FATAL("HTTP SSL/TLS required but unavailable!");
+  exit(-1);
+  (void)uuid;
+  (void)tls;
+}
+#pragma weak fio_tls_connect
+
 /* *****************************************************************************
 Small Helpers
 ***************************************************************************** */
@@ -883,6 +909,8 @@ Listening to HTTP connections
 
 static void http_on_open(intptr_t uuid, void *set) {
   static uint8_t at_capa;
+  if (((http_settings_s *)set)->tls)
+    fio_tls_accept(uuid, ((http_settings_s *)set)->tls);
   fio_timeout_set(uuid, ((http_settings_s *)set)->timeout);
   if (fio_uuid2fd(uuid) >= ((http_settings_s *)set)->max_clients) {
     if (!at_capa)
@@ -972,6 +1000,8 @@ static void http_on_open_client(intptr_t uuid, void *set_) {
   http_settings_s *set = set_;
   http_s *h = set->udata;
   set->udata = h->udata;
+  if (set->tls)
+    fio_tls_connect(uuid, set->tls);
   fio_timeout_set(uuid, set->timeout);
   fio_protocol_s *pr = http1_new(uuid, set, NULL, 0);
   if (!pr) {

data/ext/iodine/http.h

@@ -355,14 +355,14 @@ struct http_settings_s {
    *       sockets count towards a server's limit.
    */
   intptr_t max_clients;
+  /** reserved for future SSL/TLS support. */
+  void *tls;
   /** reserved for future use. */
   intptr_t reserved1;
   /** reserved for future use. */
   intptr_t reserved2;
   /** reserved for future use. */
   intptr_t reserved3;
-  /** reserved for future use. */
-  intptr_t reserved4;
   /**
    * The maximum websocket message size/buffer (in bytes) for Websocket
    * connections. Defaults to ~250KB.

data/ext/iodine/iodine_mustache.c

@@ -231,7 +231,7 @@ static int32_t mustache_on_section_test(mustache_section_s *section,
     return 0;
   }
   if (RB_TYPE_P(o, T_ARRAY)) {
-    return rb_array_len(o);
+    return RARRAY_LEN(o);
   }
   return 1;
 }
@@ -363,7 +363,8 @@ error:
 
 /**
 Renders the mustache template found in `filename`, using the data provided in
-the `data` argument.
+the `data` argument. If `template` is provided it will be used instead of
+reading the file's content.
 
     Iodine::Mustache.render(filename, data, template = nil)
 

data/lib/iodine.rb

@@ -140,6 +140,12 @@ end
 if(!defined?(on_worker_boot))
   # 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)
+  end
+end
+if(!defined?(on_worker_fork))
+  # 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)
   end
 end
@@ -150,4 +156,9 @@ if(!defined?(before_fork))
   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.5'.freeze
+  VERSION = '0.7.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.7.6
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-17 00:00:00.000000000 Z
+date: 2018-11-05 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.5.
+post_install_message: 'Thank you for installing Iodine 0.7.6.
 
 '
 rdoc_options: []