iodine 0.7.2 → 0.7.3

data/ext/iodine/fio_cli.c

@@ -62,14 +62,15 @@ static void fio_cli_map_line2alias(char const *line) {
     while (n.data[n.len] && n.data[n.len] != ' ' && n.data[n.len] != ',') {
       ++n.len;
     }
-    const char **old = fio_hash_find(&fio_aliases, FIO_CLI_HASH_VAL(n), n);
+    const char *old = NULL;
+    fio_hash_insert(&fio_aliases, FIO_CLI_HASH_VAL(n), n, (void *)line, &old);
     if (old) {
       FIO_LOG_WARNING("CLI argument name conflict detected\n"
                       "         The following two directives conflict:\n"
                       "\t%s\n\t%s\n",
-                      *old, line);
+                      old, line);
     }
-    fio_hash_insert(&fio_aliases, FIO_CLI_HASH_VAL(n), n, (void *)line);
+
     while (n.data[n.len] && (n.data[n.len] == ' ' || n.data[n.len] == ',')) {
       ++n.len;
     }
@@ -121,7 +122,7 @@ static void fio_cli_set_arg(cstr_s arg, char const *value, char const *line,
       goto print_help;
     }
     cstr_s n = {.len = ++parser->unknown_count};
-    fio_hash_insert(&fio_values, n.len, n, value);
+    fio_hash_insert(&fio_values, n.len, n, value, NULL);
     if (!parser->allow_unknown) {
       arg.len = 0;
       goto error;
@@ -169,7 +170,7 @@ static void fio_cli_set_arg(cstr_s arg, char const *value, char const *line,
       while (n.data[n.len] && n.data[n.len] != ' ' && n.data[n.len] != ',') {
         ++n.len;
       }
-      fio_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value);
+      fio_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value, NULL);
       while (n.data[n.len] && (n.data[n.len] == ' ' || n.data[n.len] == ',')) {
         ++n.len;
       }
@@ -321,7 +322,7 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int allow_unknown,
     if (parser.pos + 1 < argc) {
       value = argv[parser.pos + 1];
     }
-    const char **l = NULL;
+    const char *l = NULL;
     while (n.len &&
            !(l = fio_hash_find(&fio_aliases, FIO_CLI_HASH_VAL(n), n))) {
       --n.len;
@@ -331,7 +332,7 @@ void fio_cli_start AVOID_MACRO(int argc, char const *argv[], int allow_unknown,
       ++value;
     }
     // fprintf(stderr, "Setting %.*s to %s\n", (int)n.len, n.data, value);
-    fio_cli_set_arg(n, value, (l ? (*l) : NULL), &parser);
+    fio_cli_set_arg(n, value, l, &parser);
   }
 
   /* Cleanup and save state for API */
@@ -354,10 +355,7 @@ char const *fio_cli_get(char const *name) {
   if (!fio_hash_count(&fio_values)) {
     return NULL;
   }
-  const char **val = fio_hash_find(&fio_values, FIO_CLI_HASH_VAL(n), n);
-  if (val)
-    return *val;
-  return NULL;
+  return fio_hash_find(&fio_values, FIO_CLI_HASH_VAL(n), n);
 }
 
 /** Returns the argument's value as an integer. */
@@ -394,10 +392,7 @@ char const *fio_cli_unknown(unsigned int index) {
     return NULL;
   }
   cstr_s n = {.data = NULL, .len = index + 1};
-  const char **val = fio_hash_find(&fio_values, index + 1, n);
-  if (val)
-    return *val;
-  return NULL;
+  return fio_hash_find(&fio_values, index + 1, n);
 }
 
 /**
@@ -408,5 +403,5 @@ char const *fio_cli_unknown(unsigned int index) {
  */
 void fio_cli_set(char const *name, char const *value) {
   cstr_s n = (cstr_s){.data = name, .len = strlen(name)};
-  fio_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value);
+  fio_hash_insert(&fio_values, FIO_CLI_HASH_VAL(n), n, value, NULL);
 }

data/ext/iodine/fiobj_hash.c

@@ -199,7 +199,7 @@ int fiobj_hash_set(FIOBJ hash, FIOBJ key, FIOBJ obj) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   if (FIOBJ_TYPE_IS(key, FIOBJ_T_STRING))
     fiobj_str_freeze(key);
-  fio_hash_insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj);
+  fio_hash_insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, NULL);
   return 0;
 }
 
@@ -216,11 +216,11 @@ int fiobj_hash_set(FIOBJ hash, FIOBJ key, FIOBJ obj) {
 FIOBJ fiobj_hash_pop(FIOBJ hash, FIOBJ *key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old;
-  if (!fio_hash_last(&obj2hash(hash)->hash))
+  if (fio_hash_count(&obj2hash(hash)->hash))
     return FIOBJ_INVALID;
-  old = fiobj_dup(fio_hash_last(&obj2hash(hash)->hash)->obj);
+  old = fiobj_dup(fio_hash_last(&obj2hash(hash)->hash).obj);
   if (key)
-    *key = fiobj_dup(fio_hash_last(&obj2hash(hash)->hash)->key);
+    *key = fiobj_dup(fio_hash_last(&obj2hash(hash)->hash).key);
   fio_hash_pop(&obj2hash(hash)->hash);
   return old;
 }
@@ -237,7 +237,7 @@ FIOBJ fiobj_hash_pop(FIOBJ hash, FIOBJ *key) {
 FIOBJ fiobj_hash_replace(FIOBJ hash, FIOBJ key, FIOBJ obj) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old = FIOBJ_INVALID;
-  fio_hash_insert2(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, &old);
+  fio_hash_insert(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, obj, &old);
   return old;
 }
 
@@ -247,7 +247,7 @@ FIOBJ fiobj_hash_replace(FIOBJ hash, FIOBJ key, FIOBJ obj) {
 FIOBJ fiobj_hash_remove(FIOBJ hash, FIOBJ key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old = FIOBJ_INVALID;
-  fio_hash_remove2(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, &old);
+  fio_hash_remove(&obj2hash(hash)->hash, fiobj_obj2hash(key), key, &old);
   return old;
 }
 
@@ -258,7 +258,7 @@ FIOBJ fiobj_hash_remove(FIOBJ hash, FIOBJ key) {
 FIOBJ fiobj_hash_remove2(FIOBJ hash, uint64_t hash_value) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
   FIOBJ old = FIOBJ_INVALID;
-  fio_hash_remove2(&obj2hash(hash)->hash, hash_value, -1, &old);
+  fio_hash_remove(&obj2hash(hash)->hash, hash_value, -1, &old);
   return old;
 }
 
@@ -283,7 +283,7 @@ int fiobj_hash_delete(FIOBJ hash, FIOBJ key) {
  * Returns -1 on type error or if the object never existed.
  */
 int fiobj_hash_delete2(FIOBJ hash, uint64_t key_hash) {
-  return fio_hash_remove(&obj2hash(hash)->hash, key_hash, -1);
+  return fio_hash_remove(&obj2hash(hash)->hash, key_hash, -1, NULL);
 }
 
 /**
@@ -292,10 +292,8 @@ int fiobj_hash_delete2(FIOBJ hash, uint64_t key_hash) {
  */
 FIOBJ fiobj_hash_get(const FIOBJ hash, FIOBJ key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  FIOBJ *old = fio_hash_find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key);
-  if (old)
-    return *old;
-  return FIOBJ_INVALID;
+  return fio_hash_find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key);
+  ;
 }
 
 /**
@@ -308,10 +306,8 @@ FIOBJ fiobj_hash_get(const FIOBJ hash, FIOBJ key) {
  */
 FIOBJ fiobj_hash_get2(const FIOBJ hash, uint64_t key_hash) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  FIOBJ *old = fio_hash_find(&obj2hash(hash)->hash, key_hash, -1);
-  if (old)
-    return *old;
-  return FIOBJ_INVALID;
+  return fio_hash_find(&obj2hash(hash)->hash, key_hash, -1);
+  ;
 }
 
 /**
@@ -319,7 +315,8 @@ FIOBJ fiobj_hash_get2(const FIOBJ hash, uint64_t key_hash) {
  */
 int fiobj_hash_haskey(const FIOBJ hash, FIOBJ key) {
   assert(hash && FIOBJ_TYPE_IS(hash, FIOBJ_T_HASH));
-  return fio_hash_find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key) != NULL;
+  return fio_hash_find(&obj2hash(hash)->hash, fiobj_obj2hash(key), key) !=
+         FIOBJ_INVALID;
 }
 
 /**

data/ext/iodine/http.c

@@ -1270,8 +1270,7 @@ uintptr_t http_sse_subscribe(http_sse_s *sse_,
     return 0;
 
   fio_lock(&sse->lock);
-  fio_ls_push(&sse->subscriptions, sub);
-  fio_ls_s *pos = sse->subscriptions.prev;
+  fio_ls_s *pos = fio_ls_push(&sse->subscriptions, sub);
   fio_unlock(&sse->lock);
   return (uintptr_t)pos;
 }
@@ -2641,10 +2640,10 @@ void http_mimetype_register(char *file_ext, size_t file_ext_len,
                             FIOBJ mime_type_str) {
   uintptr_t hash = fio_siphash(file_ext, file_ext_len);
   if (mime_type_str == FIOBJ_INVALID) {
-    fio_mime_set_remove(&mime_types, hash, FIOBJ_INVALID);
+    fio_mime_set_remove(&mime_types, hash, FIOBJ_INVALID, NULL);
   } else {
     FIOBJ old = FIOBJ_INVALID;
-    fio_mime_set_replace(&mime_types, hash, mime_type_str, &old);
+    fio_mime_set_overwrite(&mime_types, hash, mime_type_str, &old);
     if (old != FIOBJ_INVALID) {
       FIO_LOG_WARNING("mime-type collision: %.*s was %s, now %s",
                       (int)file_ext_len, file_ext, fiobj_obj2cstr(old).data,
@@ -2660,10 +2659,7 @@ void http_mimetype_register(char *file_ext, size_t file_ext_len,
  */
 FIOBJ http_mimetype_find(char *file_ext, size_t file_ext_len) {
   uintptr_t hash = fio_siphash(file_ext, file_ext_len);
-  FIOBJ *result = fio_mime_set_find(&mime_types, hash, FIOBJ_INVALID);
-  if (result)
-    return fiobj_dup(*result);
-  return FIOBJ_INVALID;
+  return fiobj_dup(fio_mime_set_find(&mime_types, hash, FIOBJ_INVALID));
 }
 
 /**

data/ext/iodine/iodine.c

@@ -117,6 +117,49 @@ static VALUE iodine_threads_set(VALUE self, VALUE 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.
+ *
+ * NOTE: this does NOT effect HTTP logging.
+ */
+static VALUE iodine_logging_get(VALUE self) {
+  return INT2FIX(FIO_LOG_LEVEL);
+  (void)self;
+}
+
+/**
+ * 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.
+ *
+ * NOTE: this does NOT effect HTTP logging.
+ */
+static VALUE iodine_logging_set(VALUE self, VALUE val) {
+  Check_Type(val, T_FIXNUM);
+  FIO_LOG_LEVEL = FIX2ULONG(val);
+  return self;
+}
+
 /**
  *Returns the number of worker processes that will be used when {Iodine.start}
  * is called.
@@ -156,13 +199,13 @@ 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);
-  fprintf(stderr,
-          "\nStarting up Iodine:\n"
-          " * Iodine %s\n * Ruby %s\n * facil.io " FIO_VERSION_STRING " (%s)\n"
-          " * %d Workers X %d Threads per worker.\n"
-          "\n",
-          StringValueCStr(iodine_version), StringValueCStr(ruby_version),
-          fio_engine(), params.workers, params.threads);
+  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"
+               " * Master (root) process: %d.\n",
+               StringValueCStr(iodine_version), StringValueCStr(ruby_version),
+               fio_engine(), params.workers, params.threads, fio_parent_pid());
   (void)params;
 }
 
@@ -229,6 +272,8 @@ void Init_iodine(void) {
   // 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);

data/ext/iodine/iodine_caller.c

@@ -3,6 +3,8 @@
 #include <ruby/thread.h>
 #include <string.h>
 
+#include <fio.h>
+
 static __thread volatile uint8_t iodine_GVL_state;
 
 /* *****************************************************************************
@@ -28,18 +30,18 @@ static void *iodine_handle_exception(void *ignr) {
     VALUE bt = rb_funcall2(exc, rb_intern("backtrace"), 0, NULL);
     if (TYPE(bt) == T_ARRAY) {
       bt = rb_ary_join(bt, rb_str_new_literal("\n"));
-      fprintf(stderr, "Iodine caught an unprotected exception - %.*s: %.*s\n%s",
-              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
-              (int)RSTRING_LEN(msg), RSTRING_PTR(msg), StringValueCStr(bt));
+      FIO_LOG_ERROR("Iodine caught an unprotected exception - %.*s: %.*s\n%s",
+                    (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
+                    (int)RSTRING_LEN(msg), RSTRING_PTR(msg),
+                    StringValueCStr(bt));
     } else {
-      fprintf(stderr,
-              "Iodine caught an unprotected exception - %.*s: %.*s\n"
-              "No backtrace available.\n",
-              (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
-              (int)RSTRING_LEN(msg), RSTRING_PTR(msg));
+      FIO_LOG_ERROR("Iodine caught an unprotected exception - %.*s: %.*s\n"
+                    "No backtrace available.\n",
+                    (int)RSTRING_LEN(exc_class), RSTRING_PTR(exc_class),
+                    (int)RSTRING_LEN(msg), RSTRING_PTR(msg));
     }
     rb_backtrace();
-    fprintf(stderr, "\n\n");
+    FIO_LOG_ERROR("\n");
     rb_set_errinfo(Qnil);
   }
   return (void *)Qnil;

data/ext/iodine/iodine_connection.c

@@ -51,14 +51,14 @@ Pub/Sub storage
 
 static inline VALUE iodine_sub_unsubscribe(fio_subhash_s *store,
                                            fio_str_info_s channel) {
-  if (fio_subhash_remove(store, fio_siphash(channel.data, channel.len),
-                         channel))
+  if (fio_subhash_remove(store, fio_siphash(channel.data, channel.len), channel,
+                         NULL))
     return Qfalse;
   return Qtrue;
 }
 static inline void iodine_sub_add(fio_subhash_s *store, subscription_s *sub) {
   fio_str_info_s ch = fio_subscription_channel(sub);
-  fio_subhash_insert(store, fio_siphash(ch.data, ch.len), ch, sub);
+  fio_subhash_insert(store, fio_siphash(ch.data, ch.len), ch, sub, NULL);
 }
 static inline void iodine_sub_clear_all(fio_subhash_s *store) {
   fio_subhash_free(store);
@@ -404,8 +404,7 @@ static iodine_sub_args_s iodine_subscribe_args(int argc, VALUE *argv) {
         /* temporary backport support */
         ret.channel = rb_hash_aref(argv[0], channel_id);
         if (ret.channel != Qnil) {
-          fprintf(stderr,
-                  "WARNING: use of :channel in subscribe is deprecated.\n");
+          FIO_LOG_WARNING("use of :channel in subscribe is deprecated.");
         }
       }
     } else {
@@ -652,9 +651,7 @@ VALUE iodine_connection_new(iodine_connection_s args) {
   IodineStore.add(connection);
   iodine_connection_data_s *data = iodine_connection_ruby2C(connection);
   if (data == NULL) {
-    fprintf(
-        stderr,
-        "ERROR: (iodine) internal error, connection object has no C data!\n");
+    FIO_LOG_ERROR("(iodine) internal error, connection object has no C data!");
     return Qnil;
   }
   *data = (iodine_connection_data_s){
@@ -677,17 +674,15 @@ void iodine_connection_fire_event(VALUE connection,
                                   iodine_connection_event_type_e ev,
                                   VALUE msg) {
   if (connection == Qnil) {
-    fprintf(
-        stderr,
-        "ERROR: (iodine) nil connection handle used by an internal API call\n");
+    FIO_LOG_ERROR(
+        "(iodine) nil connection handle used by an internal API call");
     return;
   }
   iodine_connection_data_s *data = iodine_connection_validate_data(connection);
   if (!data) {
-    fprintf(stderr,
-            "ERROR: (iodine) invalid connection handle used by an "
-            "internal API call: %p\n",
-            (void *)connection);
+    FIO_LOG_ERROR("(iodine) invalid connection handle used by an "
+                  "internal API call: %p",
+                  (void *)connection);
     return;
   }
   VALUE args[2] = {connection, msg};

data/ext/iodine/iodine_http.c

@@ -952,21 +952,19 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
           .max_header_size = max_headers, .on_finish = free_iodine_http,
           .log = log_http, .max_body_size = max_body,
           .public_folder = (www ? StringValueCStr(www) : NULL)) == -1) {
-    fprintf(stderr,
-            "ERROR: Failed to initialize a listening HTTP socket for port %s\n",
-            port ? StringValueCStr(port) : "3000");
+    FIO_LOG_ERROR("Failed to initialize a listening HTTP socket for port %s",
+                  port ? StringValueCStr(port) : "3000");
     return Qfalse;
   }
 
   if ((app == Qnil || app == Qfalse)) {
-    fprintf(stderr,
-            "* Iodine: (no app) the HTTP service on port %s will only serve "
-            "static files.\n",
-            (port ? StringValueCStr(port) : "3000"));
+    FIO_LOG_WARNING(
+        "(listen2http) no app, the HTTP service on port %s will only serve "
+        "static files.",
+        (port ? StringValueCStr(port) : "3000"));
   }
   if (www) {
-    fprintf(stderr, " *    Serving static files from %s\n",
-            StringValueCStr(www));
+    FIO_LOG_INFO("Serving static files from %s", StringValueCStr(www));
   }
 
   return Qtrue;

data/ext/iodine/iodine_json.c

@@ -114,8 +114,8 @@ static int fio_json_on_start_object(json_parser_s *p) {
 static void fio_json_on_end_object(json_parser_s *p) {
   iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
   if (pr->key) {
-    fprintf(stderr, "WARNING: (JSON parsing) malformed JSON, "
-                    "ignoring dangling Hash key.\n");
+    FIO_LOG_WARNING("(JSON parsing) malformed JSON, "
+                    "ignoring dangling Hash key.");
     IodineStore.remove(pr->key);
     pr->key = (VALUE)0;
   }
@@ -146,7 +146,7 @@ static void fio_json_on_json(json_parser_s *p) { (void)p; /* do nothing */ }
 static void fio_json_on_error(json_parser_s *p) {
   iodine_json_parser_s *pr = (iodine_json_parser_s *)p;
 #if DEBUG
-  fprintf(stderr, "ERROR: JSON on error called.\n");
+  FIO_LOG_ERROR("JSON on error called.");
 #endif
   IodineStore.remove((VALUE)fio_ary_index(&pr->stack, 0));
   IodineStore.remove(pr->key);
@@ -192,20 +192,16 @@ static inline void iodine_json_update_settings(VALUE h,
                                                fiobj2rb_settings_s *s) {
   VALUE tmp;
   if (rb_hash_aref(h, max_nesting) != Qnil)
-    fprintf(stderr,
-            "WARNING: max_nesting ignored on this JSON implementation.\n");
+    FIO_LOG_WARNING("max_nesting ignored on this JSON implementation.");
   if (rb_hash_aref(h, allow_nan) != Qnil)
     fprintf(stderr, "WARNING: allow_nan ignored on this JSON implementation. "
                     "NaN always allowed.\n");
   if (rb_hash_aref(h, create_additions) != Qnil)
-    fprintf(stderr,
-            "WARNING: create_additions ignored on this JSON implementation.\n");
+    FIO_LOG_WARNING("create_additions ignored on this JSON implementation.");
   if (rb_hash_aref(h, object_class) != Qnil)
-    fprintf(stderr,
-            "WARNING: object_class ignored on this JSON implementation.\n");
+    FIO_LOG_WARNING("object_class ignored on this JSON implementation.");
   if (rb_hash_aref(h, array_class) != Qnil)
-    fprintf(stderr,
-            "WARNING: array_class ignored on this JSON implementation.\n");
+    FIO_LOG_WARNING("array_class ignored on this JSON implementation.");
   if ((tmp = rb_hash_aref(h, symbolize_names)) != Qnil) {
     if (tmp == Qtrue)
       s->str2sym = 1;