iodine 0.7.1 → 0.7.2

data/ext/iodine/iodine_mustache.h

@@ -1,6 +1,6 @@
-#ifndef H_IODINE_JSON_H
-#define H_IODINE_JSON_H
+#ifndef H_IODINE_MUSTACHE_H
+#define H_IODINE_MUSTACHE_H
 
-void iodine_init_json(void);
+void iodine_init_mustache(void);
 
 #endif

data/ext/iodine/iodine_store.c

@@ -1,14 +1,16 @@
 #include "iodine.h"
 
-#include "fio_hashmap.h"
 #include "iodine_store.h"
 
-#include <fio.h>
 #include <inttypes.h>
 #include <stdint.h>
 
+#define FIO_SET_NAME fio_hash
+#define FIO_SET_OBJ_TYPE uintptr_t
+#include <fio.h>
+
 fio_lock_i lock = FIO_LOCK_INIT;
-fio_hash_s storage = FIO_HASH_INIT;
+fio_hash_s storage = FIO_SET_INIT;
 
 #ifndef IODINE_DEBUG
 #define IODINE_DEBUG 0
@@ -23,10 +25,8 @@ static VALUE storage_add(VALUE obj) {
   if (obj == Qnil || obj == Qtrue || obj == Qfalse)
     return obj;
   fio_lock(&lock);
-  uintptr_t val = (uintptr_t)fio_hash_insert(&storage, obj, (void *)1);
-  if (val) {
-    fio_hash_insert(&storage, obj, (void *)(val + 1));
-  }
+  uintptr_t *val = fio_hash_insert(&storage, obj, 0);
+  ++val[0];
   fio_unlock(&lock);
   return obj;
 }
@@ -36,14 +36,9 @@ static VALUE storage_remove(VALUE obj) {
       storage.count == 0)
     return obj;
   fio_lock(&lock);
-  uintptr_t val = (uintptr_t)fio_hash_insert(&storage, obj, NULL);
-  if (val > 1) {
-    fio_hash_insert(&storage, obj, (void *)(val - 1));
-  }
-  if ((storage.count << 1) <= storage.pos &&
-      (storage.pos << 1) > storage.capa) {
-    fio_hash_compact(&storage);
-  }
+  uintptr_t *val = fio_hash_find(&storage, obj, 0);
+  if (val && *val <= 1)
+    fio_hash_remove(&storage, obj, 0);
   fio_unlock(&lock);
   return obj;
 }
@@ -55,10 +50,10 @@ static void storage_print(void) {
   fprintf(stderr, "Ruby <=> C Memory storage stats (pid: %d):\n", getpid());
   fio_lock(&lock);
   uintptr_t index = 0;
-  FIO_HASH_FOR_LOOP(&storage, pos) {
+  FIO_SET_FOR_LOOP(&storage, pos) {
     if (pos->obj) {
       fprintf(stderr, "[%" PRIuPTR "] => %" PRIuPTR " X obj %p type %d\n",
-              index++, (uintptr_t)pos->obj, (void *)pos->key, TYPE(pos->key));
+              index++, pos->obj, (void *)pos->hash, TYPE(pos->hash));
     }
   }
   fprintf(stderr, "Total of %" PRIuPTR " objects protected form GC\n", index);
@@ -88,9 +83,9 @@ static void storage_mark(void *ignore) {
 #endif
   fio_lock(&lock);
   // fio_hash_compact(&storage);
-  FIO_HASH_FOR_LOOP(&storage, pos) {
+  FIO_SET_FOR_LOOP(&storage, pos) {
     if (pos->obj) {
-      rb_gc_mark((VALUE)pos->key);
+      rb_gc_mark((VALUE)pos->hash);
     }
   }
   fio_unlock(&lock);
@@ -104,7 +99,7 @@ static void storage_clear(void *ignore) {
 #endif
   fio_lock(&lock);
   fio_hash_free(&storage);
-  storage = (fio_hash_s)FIO_HASH_INIT;
+  storage = (fio_hash_s)FIO_SET_INIT;
   fio_unlock(&lock);
 }
 
@@ -131,7 +126,7 @@ struct IodineStorage_s IodineStore = {
 
 /** Initializes the storage unit for first use. */
 void iodine_storage_init(void) {
-  fio_hash_new2(&storage, 512);
+  fio_hash_capa_require(&storage, 512);
   VALUE tmp =
       rb_define_class_under(rb_cObject, "IodineObjectStorage", rb_cData);
   VALUE storage_obj =

data/ext/iodine/mustache_parser.h

@@ -114,6 +114,10 @@ typedef struct {
   char const *filename;
   /** The file name's length. */
   size_t filename_len;
+  /** If data and data_len are set, they will be used as the file's contents. */
+  char const *data;
+  /** If data and data_len are set, they will be used as the file's contents. */
+  size_t data_len;
   /** Parsing error reporting (can be NULL). */
   mustache_error_en *err;
 } mustache_load_args_s;
@@ -551,7 +555,8 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
   }
 
   /* copy the path data (and resolve) into writable memory  */
-  if (args.filename[0] == '~' && args.filename[1] == '/' && getenv("HOME")) {
+  if (args.filename && args.filename[0] == '~' && args.filename[1] == '/' &&
+      getenv("HOME")) {
     const char *home = getenv("HOME");
     path_len = strlen(home);
     path_capa =
@@ -569,7 +574,6 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
     args.filename_len += path_len;
     args.filename = path;
   }
-  /* divide faile name from the root path to the file */
 
   /*
    * We need a dynamic array to hold the list of instructions...
@@ -759,7 +763,7 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
       }                                                                        \
       goto error;                                                              \
     }                                                                          \
-    if (pread(fd, (data + data_len + 4 + 3 + 3 + path_len), f_data.st_size,    \
+    if (pread(fd, (data + data_len + 4 + 2 + 4 + path_len), f_data.st_size,    \
               0) != (ssize_t)f_data.st_size) {                                 \
       if (args.err) {                                                          \
         *args.err = MUSTACHE_ERR_FILE_NOT_FOUND;                               \
@@ -794,8 +798,48 @@ MUSTACHE_FUNC mustache_s *(mustache_load)(mustache_load_args_s args) {
     (str) += (step);                                                           \
   }
 
-  /* Our first template to load is the root template */
-  LOAD_TEMPLATE(path, 0, args.filename, args.filename_len);
+  if (args.data_len) {
+    /* allocate data segment */
+    data_len = 4 + 2 + 4 + args.data_len + args.filename_len + 1;
+    data = malloc(data_len);
+    if (!data) {
+      perror("FATAL ERROR: couldn't reallocate memory for mustache "
+             "data segment");
+      exit(errno);
+    }
+    /* save instruction position length into template header */
+    data[0] = (instructions->head.u.read_only.intruction_count >> 3) & 0xFF;
+    data[1] = (instructions->head.u.read_only.intruction_count >> 2) & 0xFF;
+    data[2] = (instructions->head.u.read_only.intruction_count >> 1) & 0xFF;
+    data[3] = (instructions->head.u.read_only.intruction_count) & 0xFF;
+    /* Add section start marker (to support recursion or repeated partials) */
+    PUSH_INSTRUCTION(.instruction = MUSTACHE_SECTION_START);
+    /* save filename length */
+    data[4 + 0] = (args.filename_len >> 1) & 0xFF;
+    data[4 + 1] = args.filename_len & 0xFF;
+    /* save data length ("next" pointer) */
+    data[4 + 2 + 0] = ((uint32_t)data_len >> 3) & 0xFF;
+    data[4 + 2 + 1] = ((uint32_t)data_len >> 2) & 0xFF;
+    data[4 + 2 + 2] = ((uint32_t)data_len >> 1) & 0xFF;
+    data[4 + 2 + 3] = ((uint32_t)data_len) & 0xFF;
+    /* copy filename */
+    if (args.filename && args.filename_len)
+      memcpy(data + 4 + 2 + 4, args.filename, args.filename_len);
+    /* copy data */
+    memcpy(data + 4 + 2 + 4 + args.filename_len, args.data, args.data_len);
+    ++stack_pos;
+    template_stack[stack_pos].data_start = 0;
+    template_stack[stack_pos].data_pos = 4 + 3 + 3 + args.filename_len;
+    template_stack[stack_pos].data_end = data_len - 1;
+    template_stack[stack_pos].delimiter_start = (uint8_t *)"{{";
+    template_stack[stack_pos].delimiter_end = (uint8_t *)"}}";
+    template_stack[stack_pos].del_start_len = 2;
+    template_stack[stack_pos].del_end_len = 2;
+    data[data_len - 1] = 0;
+  } else {
+    /* Our first template to load is the root template */
+    LOAD_TEMPLATE(path, 0, args.filename, args.filename_len);
+  }
 
   /*** As long as the stack has templated to parse - parse the template ***/
   while (stack_pos) {

data/ext/iodine/redis_engine.c

@@ -182,8 +182,7 @@ RESP parser callbacks
 /** a local static callback, called when a parser / protocol error occurs. */
 static int resp_on_parser_error(resp_parser_s *parser) {
   struct redis_engine_internal_s *i = parser2data(parser);
-  FIO_LOG_STATE(
-      "ERROR: (redis) parser error - attempting to restart connection.\n");
+  FIO_LOG_ERROR("(redis) parser error - attempting to restart connection.\n");
   fio_close(i->uuid);
   return -1;
 }
@@ -339,9 +338,8 @@ static void resp_on_pub_message(struct redis_engine_internal_s *i, FIOBJ msg) {
   fio_unlock(&r->lock);
   if (!node) {
     /* TODO: possible ping? from server?! not likely... */
-    FIO_LOG_STATE(
-        "WARNING: (redis %d) received a reply when no command was sent.\n",
-        getpid());
+    FIO_LOG_WARNING("(redis %d) received a reply when no command was sent.",
+                    getpid());
     return;
   }
   node->next = (void *)fiobj_dup(msg);
@@ -360,8 +358,8 @@ static void resp_on_sub_message(struct redis_engine_internal_s *i, FIOBJ msg) {
   if (FIOBJ_TYPE(msg) != FIOBJ_T_ARRAY) {
     if (FIOBJ_TYPE(msg) != FIOBJ_T_STRING || fiobj_obj2cstr(msg).len != 4 ||
         fiobj_obj2cstr(msg).data[0] != 'P') {
-      FIO_LOG_STATE("WARNING: (redis) unexpected data format in "
-                    "subscription stream:\n");
+      FIO_LOG_WARNING("(redis) unexpected data format in "
+                      "subscription stream:");
       fio_str_info_s tmp = fiobj_obj2cstr(msg);
       FIO_LOG_STATE("     %s\n", tmp.data);
     }
@@ -429,9 +427,9 @@ static void redis_on_close(intptr_t uuid, fio_protocol_s *pr) {
     if (r->flag) {
       /* reconnection for subscription connection. */
       if (uuid != -1) {
-        FIO_LOG_STATE("WARNING: (redis %d) subscription connection lost. "
-                      "Reconnecting...\n",
-                      (int)getpid());
+        FIO_LOG_WARNING("(redis %d) subscription connection lost. "
+                        "Reconnecting...",
+                        (int)getpid());
       }
       fio_atomic_sub(&r->ref, 1);
       fio_defer(redis_connect, r, internal);
@@ -441,9 +439,9 @@ static void redis_on_close(intptr_t uuid, fio_protocol_s *pr) {
   } else {
     r = pub2redis(pr);
     if (r->flag && uuid != -1) {
-      FIO_LOG_STATE("WARNING: (redis %d) publication connection lost. "
-                    "Reconnecting...\n",
-                    (int)getpid());
+      FIO_LOG_WARNING("(redis %d) publication connection lost. "
+                      "Reconnecting...",
+                      (int)getpid());
     }
     r->pub_send = 0;
     fio_close(r->sub_data.uuid);
@@ -471,8 +469,7 @@ static void redis_sub_ping(intptr_t uuid, fio_protocol_s *pr) {
 static void redis_pub_ping(intptr_t uuid, fio_protocol_s *pr) {
   redis_engine_s *r = pub2redis(pr);
   if (fio_ls_embd_any(&r->queue)) {
-    FIO_LOG_STATE(
-        "WARNING: (redis) Redis server unresponsive, disconnecting.\n");
+    FIO_LOG_WARNING("(redis) Redis server unresponsive, disconnecting.");
     fio_close(uuid);
     return;
   }
@@ -489,9 +486,9 @@ Connecting to Redis
 static void redis_on_auth(fio_pubsub_engine_s *e, FIOBJ reply, void *udata) {
   if (FIOBJ_TYPE_IS(reply, FIOBJ_T_TRUE)) {
     fio_str_info_s s = fiobj_obj2cstr(reply);
-    FIO_LOG_STATE("WARNING: (redis) Authentication FAILED.\n"
-                  "        %.*s\n",
-                  (int)s.len, s.data);
+    FIO_LOG_WARNING("(redis) Authentication FAILED."
+                    "        %.*s",
+                    (int)s.len, s.data);
   }
   (void)e;
   (void)udata;
@@ -512,8 +509,8 @@ static void redis_on_connect(intptr_t uuid, void *i_) {
     if (r->pub_data.uuid == -1) {
       fio_defer(redis_connect, r, &r->pub_data);
     }
-    FIO_LOG_STATE("INFO: (redis %d) subscription connection established.\n",
-                  (int)getpid());
+    FIO_LOG_INFO("(redis %d) subscription connection established.",
+                 (int)getpid());
   } else {
     r = pub2redis(i);
     if (r->auth_len) {
@@ -535,8 +532,8 @@ static void redis_on_connect(intptr_t uuid, void *i_) {
     }
     r->pub_send = 1;
     fio_unlock(&r->lock);
-    FIO_LOG_STATE("INFO: (redis %d) publication connection established.\n",
-                  (int)getpid());
+    FIO_LOG_INFO("(redis %d) publication connection established.",
+                 (int)getpid());
   }
 
   i->protocol.rsv = 0;
@@ -639,7 +636,7 @@ static void redis_on_publish_root(const fio_pubsub_engine_s *eng,
   *buf++ = '\r';
   *buf++ = '\n';
   *buf = 0;
-  FIO_LOG_DEBUG("(%d) Publishing:\n%s\n", getpid(), cmd->cmd);
+  FIO_LOG_DEBUG("(%d) Publishing:\n%s", getpid(), cmd->cmd);
   cmd->cmd_len = (uintptr_t)buf - (uintptr_t)(cmd + 1);
   redis_attach_cmd(r, cmd);
   return;
@@ -690,7 +687,7 @@ static void redis_on_internal_publish(fio_msg_s *msg) {
   msg->channel.len -= 8;
   msg->channel.data += 8;
   /* forward to publishing */
-  FIO_LOG_DEBUG("Forwarding to engine %p, on channel %s\n", msg->udata1,
+  FIO_LOG_DEBUG("Forwarding to engine %p, on channel %s", msg->udata1,
                 msg->channel.data);
   redis_on_publish_root(msg->udata1, msg->channel, msg->msg, msg->is_json);
 }
@@ -706,7 +703,7 @@ static void redis_forward_reply(fio_pubsub_engine_s *e, FIOBJ reply,
   fio_pubsub_engine_s *engine = (fio_pubsub_engine_s *)fio_str2u64(data + 0);
   void *callback = (void *)fio_str2u64(data + 8);
   if (engine != e || !callback) {
-    FIO_LOG_DEBUG("Redis reply not forwarded (callback: %p)\n", callback);
+    FIO_LOG_DEBUG("Redis reply not forwarded (callback: %p)", callback);
     return;
   }
   int32_t pid = (int32_t)fio_str2u32(data + 24);
@@ -740,7 +737,7 @@ static void redis_on_internal_reply(fio_msg_s *msg) {
   fio_pubsub_engine_s *engine =
       (fio_pubsub_engine_s *)fio_str2u64(msg->channel.data + 0);
   if (engine != msg->udata1) {
-    FIO_LOG_DEBUG("Redis reply not forwarded (engine mismatch: %p != %p)\n",
+    FIO_LOG_DEBUG("Redis reply not forwarded (engine mismatch: %p != %p)",
                   (void *)engine, msg->udata1);
     return;
   }
@@ -759,8 +756,7 @@ intptr_t redis_engine_send(fio_pubsub_engine_s *engine, FIOBJ command,
                                             void *udata),
                            void *udata) {
   if ((uintptr_t)engine < 4) {
-    fprintf(stderr, "WARNING: (redis send) trying to use one of the "
-                    "core engines\n");
+    FIO_LOG_WARNING("(redis send) trying to use one of the core engines");
     return -1;
   }
   // if(fio_is_master()) {
@@ -830,8 +826,11 @@ static void redis_on_engine_fork(void *r_) {
 fio_pubsub_engine_s *redis_engine_create
 FIO_IGNORE_MACRO(struct redis_engine_create_args args) {
   if (getpid() != fio_parent_pid()) {
-    fprintf(stderr, "FATAL ERROR: (redis) Redis engine initialization can only "
-                    "be performed in the Root process.\n");
+    FIO_LOG_FATAL("(redis) Redis engine initialization can only "
+                  "be performed in the Root process.");
+    kill(0, SIGINT);
+    fio_stop();
+    return NULL;
   }
   if (!args.address.len && args.address.data)
     args.address.len = strlen(args.address.data);
@@ -911,6 +910,7 @@ FIO_IGNORE_MACRO(struct redis_engine_create_args args) {
   /* if restarting */
   fio_state_callback_add(FIO_CALL_PRE_START, redis_on_facil_start, r);
 
+  FIO_LOG_DEBUG("Redis engine initialized %p", (void *)r);
   return &r->en;
 }
 
@@ -925,6 +925,6 @@ void redis_engine_destroy(fio_pubsub_engine_s *engine) {
   fio_state_callback_remove(FIO_CALL_IN_CHILD, redis_on_engine_fork, r);
   fio_state_callback_remove(FIO_CALL_ON_SHUTDOWN, redis_on_facil_shutdown, r);
   fio_state_callback_remove(FIO_CALL_PRE_START, redis_on_facil_start, r);
-  FIO_LOG_DEBUG("Redis engine destroyed %p\n", (void *)r);
+  FIO_LOG_DEBUG("Redis engine destroyed %p", (void *)r);
   redis_free(r);
 }

data/ext/iodine/websockets.c

@@ -116,6 +116,7 @@ struct ws_s {
   size_t max_msg_size;
   /** active pub/sub subscriptions */
   fio_ls_s subscriptions;
+  fio_lock_i sub_lock;
   /** socket buffer. */
   struct buffer_s buffer;
   /** data length (how much of the buffer actually used). */
@@ -133,9 +134,11 @@ Create/Destroy the websocket subscription objects
 ***************************************************************************** */
 
 static inline void clear_subscriptions(ws_s *ws) {
+  fio_lock(&ws->sub_lock);
   while (fio_ls_any(&ws->subscriptions)) {
     fio_unsubscribe(fio_ls_pop(&ws->subscriptions));
   }
+  fio_unlock(&ws->sub_lock);
 }
 
 /* *****************************************************************************
@@ -325,7 +328,7 @@ void websocket_attach(intptr_t uuid, http_settings_s *http_settings,
                       websocket_settings_s *args, void *data, size_t length) {
   ws_s *ws = new_websocket(uuid);
   if (!ws) {
-    perror("FATAL ERROR: couldn't allocate Websocket protocol object");
+    FIO_LOG_FATAL("couldn't allocate Websocket protocol object");
     exit(errno);
   }
   // we have an active websocket connection - prep the connection buffer
@@ -615,10 +618,7 @@ uintptr_t websocket_subscribe(struct websocket_subscribe_s args) {
   if (!args.ws)
     goto error;
   websocket_sub_data_s *d = malloc(sizeof(*d));
-  if (!d) {
-    websocket_close(args.ws);
-    goto error;
-  }
+  FIO_ASSERT_ALLOC(d);
   *d = (websocket_sub_data_s){
       .udata = args.udata,
       .on_message = args.on_message,
@@ -640,7 +640,10 @@ uintptr_t websocket_subscribe(struct websocket_subscribe_s args) {
     /* don't free `d`, return (`d` freed by callback) */
     return 0;
   }
+  fio_lock(&args.ws->sub_lock);
   fio_ls_push(&args.ws->subscriptions, sub);
+  fio_unlock(&args.ws->sub_lock);
+
   return (uintptr_t)args.ws->subscriptions.prev;
 error:
   if (args.on_unsubscribe)
@@ -653,7 +656,10 @@ error:
  */
 void websocket_unsubscribe(ws_s *ws, uintptr_t subscription_id) {
   fio_unsubscribe((subscription_s *)((fio_ls_s *)subscription_id)->obj);
+  fio_lock(&ws->sub_lock);
   fio_ls_remove((fio_ls_s *)subscription_id);
+  fio_unlock(&ws->sub_lock);
+
   (void)ws;
 }
 

data/lib/iodine.rb

@@ -121,6 +121,18 @@ if(!defined?(after_fork))
     Iodine.after_fork(*args, &block)
   end
 end
+if(!defined?(after_fork_in_worker))
+  # Performs a block of code whenever a new worker process spins up (performed once per worker).
+  def after_fork_in_worker(*args, &block)
+    Iodine.after_fork_in_worker(*args, &block)
+  end
+end
+if(!defined?(after_fork_in_master))
+  # Performs a block of code whenever a new worker process spins up (performed once per worker).
+  def after_fork_in_master(*args, &block)
+    Iodine.after_fork_in_master(*args, &block)
+  end
+end
 if(!defined?(on_worker_boot))
   # Performs a block of code whenever a new worker process spins up (performed once per worker).
   def on_worker_boot(*args, &block)
@@ -128,7 +140,7 @@ if(!defined?(on_worker_boot))
   end
 end
 if(!defined?(before_fork))
-  # Performs a block of code just before a new worker process spins up (performed once per worker).
+  # Performs a block of code just before a new worker process spins up (performed once per worker, in the master thread).
   def before_fork(*args, &block)
     Iodine.before_fork(*args, &block)
   end