iodine 0.7.1 → 0.7.2

data/ext/iodine/iodine.c

@@ -33,18 +33,19 @@ static ID call_id;
 Idling
 ***************************************************************************** */
 
-static fio_lock_i iodine_on_idle_lock = FIO_LOCK_INIT;
-static fio_ls_s iodine_on_idle_list = FIO_LS_INIT(iodine_on_idle_list);
-
-static void iodine_perform_deferred(void *block, void *ignr) {
-  IodineCaller.call((VALUE)block, call_id);
-  (void)ignr;
+/* 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, 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, simply reschedule the event at the end of it's
+To schedule a reoccuring event, reschedule the event at the end of it's
 run.
 
 i.e.
@@ -52,28 +53,17 @@ i.e.
       IDLE_PROC = Proc.new { puts "idle"; Iodine.on_idle &IDLE_PROC }
       Iodine.on_idle &IDLE_PROC
 */
-VALUE iodine_sched_on_idle(VALUE self) {
+static VALUE iodine_sched_on_idle(VALUE self) {
+  // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  fio_lock(&iodine_on_idle_lock);
-  fio_ls_push(&iodine_on_idle_list, (void *)block);
-  fio_unlock(&iodine_on_idle_lock);
+  fio_state_callback_add(FIO_CALL_ON_IDLE, iodine_perform_on_idle_callback,
+                         (void *)block);
   return block;
   (void)self;
 }
 
-static void iodine_on_idle(void *arg) {
-  (void)arg;
-  fio_lock(&iodine_on_idle_lock);
-  while (fio_ls_any(&iodine_on_idle_list)) {
-    VALUE block = (VALUE)fio_ls_shift(&iodine_on_idle_list);
-    fio_defer(iodine_perform_deferred, (void *)block, NULL);
-    IodineStore.remove(block);
-  }
-  fio_unlock(&iodine_on_idle_lock);
-}
-
 /* *****************************************************************************
 Running Iodine
 ***************************************************************************** */
@@ -272,7 +262,4 @@ void Init_iodine(void) {
 
   // initialize Pub/Sub extension (for Engines)
   iodine_pubsub_init();
-
-  // register idle and finish callbacks
-  fio_state_callback_add(FIO_CALL_ON_IDLE, iodine_on_idle, NULL);
 }

data/ext/iodine/iodine_defer.c

@@ -89,15 +89,11 @@ static void *create_ruby_thread_gvl(void *args) {
   return (void *)IodineStore.add(rb_thread_create(defer_thread_inGVL, args));
 }
 
-/* Runs the before / after fork callbacks (if `before` is true, before runs) */
-static void iodine_perform_fork_callbacks(uint8_t before);
-
 static void *fork_using_ruby(void *ignr) {
   // stop IO thread and call before_fork callbacks
   if (sock_io_pthread) {
     iodine_join_io_thread();
   }
-  iodine_perform_fork_callbacks(1);
   // fork
   const VALUE ProcessClass = rb_const_get(rb_cObject, rb_intern2("Process", 7));
   const VALUE rb_pid = IodineCaller.call(ProcessClass, rb_intern2("fork", 4));
@@ -112,7 +108,6 @@ static void *fork_using_ruby(void *ignr) {
   if (!pid) {
     IodineStore.after_fork();
   }
-  iodine_perform_fork_callbacks(0);
   // re-initiate IO thread
   fio_defer(iodine_start_io_thread2, NULL, NULL);
   return (void *)pid;
@@ -285,93 +280,99 @@ static VALUE iodine_defer_run_every(int argc, VALUE *argv, VALUE self) {
 Pre/Post `fork`
 ***************************************************************************** */
 
-static fio_lock_i iodine_before_fork_lock = FIO_LOCK_INIT;
-static fio_ls_s iodine_before_fork_list = FIO_LS_INIT(iodine_before_fork_list);
-static fio_lock_i iodine_after_fork_lock = FIO_LOCK_INIT;
-static fio_ls_s iodine_after_fork_list = FIO_LS_INIT(iodine_after_fork_list);
-static fio_lock_i iodine_on_shutdown_lock = FIO_LOCK_INIT;
-static fio_ls_s iodine_on_shutdown_list = FIO_LS_INIT(iodine_on_shutdown_list);
+/* performs a Ruby state callback without clearing the Ruby object's memory */
+static void iodine_perform_state_callback_persist(void *blk_) {
+  VALUE blk = (VALUE)blk_;
+  IodineCaller.call(blk, call_id);
+}
 
+// clang-format off
 /**
-Sets a block of code to run before a new worker process is forked (cluster mode
-only).
+Sets a block of code to run before a new worker process is forked (cluster mode only).
+
+Code runs within the master (root) process.
 */
 VALUE iodine_before_fork_add(VALUE self) {
+  // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  fio_lock(&iodine_before_fork_lock);
-  fio_ls_push(&iodine_before_fork_list, (void *)block);
-  fio_unlock(&iodine_before_fork_lock);
+  fio_state_callback_add(FIO_CALL_BEFORE_FORK,
+                         iodine_perform_state_callback_persist, (void *)block);
   return block;
   (void)self;
 }
 
+// clang-format off
 /**
-Sets a block of code to run after a new worker process is forked (cluster mode
-only).
+Sets a block of code to run after a new worker process is forked (cluster mode only).
+
+Code runs in both the parent and the child.
 */
 VALUE iodine_after_fork_add(VALUE self) {
+  // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  fio_lock(&iodine_after_fork_lock);
-  fio_ls_push(&iodine_after_fork_list, (void *)block);
-  fio_unlock(&iodine_after_fork_lock);
+  fio_state_callback_add(FIO_CALL_AFTER_FORK,
+                         iodine_perform_state_callback_persist, (void *)block);
   return block;
   (void)self;
 }
 
 // clang-format off
 /**
-Sets a block of code to run once a Worker process shuts down (both in single process mode and cluster mode).
+Sets a block of code to run after a new worker process is forked (cluster mode only).
+
+Code runs in both the parent and the child.
 */
-VALUE iodine_on_shutdown_add(VALUE self) {
+VALUE iodine_after_fork_in_worker_add(VALUE self) {
+  // clang-format on
+  rb_need_block();
+  VALUE block = rb_block_proc();
+  IodineStore.add(block);
+  fio_state_callback_add(FIO_CALL_IN_CHILD,
+                         iodine_perform_state_callback_persist, (void *)block);
+  return block;
+  (void)self;
+}
+
+// clang-format off
+/**
+Sets a block of code to run after a new worker process is forked (cluster mode only).
+
+Code runs in both the parent and the child.
+*/
+VALUE iodine_after_fork_in_master_add(VALUE self) {
   // clang-format on
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  fio_lock(&iodine_on_shutdown_lock);
-  fio_ls_push(&iodine_on_shutdown_list, (void *)block);
-  fio_unlock(&iodine_on_shutdown_lock);
+  fio_state_callback_add(FIO_CALL_IN_MASTER,
+                         iodine_perform_state_callback_persist, (void *)block);
   return block;
   (void)self;
 }
 
-/* Runs the before / after fork callbacks (if `before` is true, before runs) */
-static void iodine_perform_fork_callbacks(uint8_t before) {
-  fio_ls_s *ls = before ? &iodine_before_fork_list : &iodine_after_fork_list;
-  fio_lock_i *lock =
-      before ? &iodine_before_fork_lock : &iodine_after_fork_lock;
-  fio_lock(lock);
-  FIO_LS_FOR(ls, pos) { IodineCaller.call((VALUE)(pos->obj), call_id); }
-  fio_unlock(lock);
+// clang-format off
+/**
+Sets a block of code to run once a Worker process shuts down (both in single process mode and cluster mode).
+*/
+VALUE iodine_on_shutdown_add(VALUE self) {
+  // clang-format on
+  rb_need_block();
+  VALUE block = rb_block_proc();
+  IodineStore.add(block);
+  fio_state_callback_add(FIO_CALL_ON_FINISH,
+                         iodine_perform_state_callback_persist, (void *)block);
+  return block;
+  (void)self;
 }
 
 /* Performs any cleanup before worker dies */
 static void iodine_defer_on_finish(void *ignr) {
   (void)ignr;
   iodine_join_io_thread();
-  /* perform and clear away shutdown Procs */
-  fio_lock(&iodine_on_shutdown_lock);
-  while (fio_ls_any(&iodine_on_shutdown_list)) {
-    void *obj = fio_ls_shift(&iodine_on_shutdown_list);
-    IodineCaller.call((VALUE)(obj), call_id);
-    IodineStore.remove((VALUE)(obj));
-  }
-  fio_unlock(&iodine_on_shutdown_lock);
-  /* clear away forking Procs */
-  fio_lock(&iodine_before_fork_lock);
-  while (fio_ls_any(&iodine_before_fork_list)) {
-    IodineStore.remove((VALUE)fio_ls_shift(&iodine_before_fork_list));
-  }
-  fio_unlock(&iodine_before_fork_lock);
-
-  fio_lock(&iodine_after_fork_lock);
-  while (fio_ls_any(&iodine_after_fork_list)) {
-    IodineStore.remove((VALUE)fio_ls_shift(&iodine_after_fork_list));
-  }
-  fio_unlock(&iodine_after_fork_lock);
 }
 
 /* *****************************************************************************
@@ -391,6 +392,10 @@ void iodine_defer_initialize(void) {
                             0);
   rb_define_module_function(IodineModule, "after_fork", iodine_after_fork_add,
                             0);
+  rb_define_module_function(IodineModule, "after_fork_in_worker",
+                            iodine_after_fork_in_worker_add, 0);
+  rb_define_module_function(IodineModule, "after_fork_in_master",
+                            iodine_after_fork_in_master_add, 0);
   rb_define_module_function(IodineModule, "on_shutdown", iodine_on_shutdown_add,
                             0);
   fio_state_callback_add(FIO_CALL_ON_FINISH, iodine_defer_on_finish, NULL);

data/ext/iodine/iodine_http.c

@@ -776,37 +776,6 @@ Listenninng to HTTP
 *****************************************************************************
 */
 
-void *iodine_print_http_msg_in_gvl(void *d_) {
-  // Write message
-  struct {
-    VALUE www;
-    VALUE port;
-  } *arg = d_;
-  if (arg->www) {
-    fprintf(stderr,
-            "Iodine HTTP Server on port %s:\n"
-            " *    Serving static files from %s\n\n",
-            (arg->port ? StringValueCStr(arg->port) : "----"),
-            StringValueCStr(arg->www));
-  }
-  return NULL;
-}
-
-static void iodine_print_http_msg(void *www, void *port) {
-  if (!fio_is_master())
-    goto finish;
-  struct {
-    void *www;
-    void *port;
-  } data = {.www = www, .port = port};
-  IodineCaller.enterGVL(iodine_print_http_msg_in_gvl, (void *)&data);
-finish:
-  if (www) {
-    IodineStore.remove((VALUE)www);
-  }
-  IodineStore.remove((VALUE)port);
-}
-
 static void free_iodine_http(http_settings_s *s) {
   IodineStore.remove((VALUE)s->udata);
 }
@@ -995,7 +964,10 @@ VALUE iodine_http_listen(VALUE self, VALUE opt) {
             "static files.\n",
             (port ? StringValueCStr(port) : "3000"));
   }
-  fio_defer(iodine_print_http_msg, (www ? (void *)www : NULL), (void *)port);
+  if (www) {
+    fprintf(stderr, " *    Serving static files from %s\n",
+            StringValueCStr(www));
+  }
 
   return Qtrue;
   (void)self;

data/ext/iodine/iodine_mustache.c

@@ -1,4 +1,4 @@
-
+#include <ruby.h>
 #define INCLUDE_MUSTACHE_IMPLEMENTATION 1
 #include "mustache_parser.h"
 
@@ -7,8 +7,11 @@
 #define FIO_INCLUDE_STR
 #include <fio.h>
 
-ID call_func_id;
-ID to_s_func_id;
+static ID call_func_id;
+static ID to_s_func_id;
+static ID filename_id;
+static ID data_id;
+static ID template_id;
 /* *****************************************************************************
 C <=> Ruby Data allocation
 ***************************************************************************** */
@@ -18,10 +21,9 @@ static size_t iodine_mustache_data_size(const void *c_) {
   (void)c_;
 }
 
-static size_t iodine_mustache_data_free(const void *c_) {
+static void iodine_mustache_data_free(void *c_) {
   mustache_free(((mustache_s **)c_)[0]);
   free((void *)c_);
-  return sizeof(mustache_s *);
   (void)c_;
 }
 
@@ -30,7 +32,7 @@ const rb_data_type_t iodine_mustache_data_type = {
     .function =
         {
             .dmark = NULL,
-            .dfree = free,
+            .dfree = iodine_mustache_data_free,
             .dsize = iodine_mustache_data_size,
         },
     .data = NULL,
@@ -44,14 +46,6 @@ static VALUE iodine_mustache_data_alloc_c(VALUE self) {
   return TypedData_Wrap_Struct(self, &iodine_mustache_data_type, m);
 }
 
-static inline mustache_s *iodine_mustache_ruby2C(VALUE self) {
-  mustache_s **m = NULL;
-  TypedData_Get_Struct(self, mustache_s *, &iodine_mustache_data_type, m);
-  if (!m)
-    return NULL;
-  return m[0];
-}
-
 /* *****************************************************************************
 Parser Callbacks
 ***************************************************************************** */
@@ -338,7 +332,7 @@ Rendering
 /**
 Renders the mustache template using the data provided in the `data` argument.
 
-Returns a String.
+Returns a String with the rendered template.
 
 Raises an exception on error.
 
@@ -367,6 +361,130 @@ error:
   rb_raise(rb_eRuntimeError, "Couldn't build template frome data.");
 }
 
+/**
+Renders the mustache template found in `filename`, using the data provided in
+the `data` argument.
+
+    Iodine::Mustache.render(filename, data, template = nil)
+
+Returns a String with the rendered template.
+
+Raises an exception on error.
+
+    template = "<h1>{{title}}</h1>"
+    filename = "templates/index"
+    data = {title: "Home"}
+    result = Iodine::Mustache.render(filename, data)
+
+    # filename will be used to resolve the path to any partials:
+    result = Iodine::Mustache.render(filename, data, template)
+
+    # OR, if we don't need partial template path resolution
+    result = Iodine::Mustache.render(template: template, data: data)
+
+NOTE 1:
+
+This function doesn't cache the template data.
+
+The more complext the template the higher the cost of the template parsing
+stage.
+
+Consider creating a persistent template object using a new object and using the
+instance {#render} method.
+
+NOTE 2:
+
+As one might notice, no binding is provided. Instead, a `data` Hash is assumed.
+Iodine will search the Hash for any data while protecting against code
+execution.
+*/
+static VALUE iodine_mustache_render_klass(int argc, VALUE *argv, VALUE self) {
+  VALUE filename = Qnil, data = Qnil, template = Qnil;
+  if (argc == 1) {
+    /* named arguments */
+    Check_Type(argv[0], T_HASH);
+    filename = rb_hash_aref(argv[0], filename_id);
+    data = rb_hash_aref(argv[0], data_id);
+    template = rb_hash_aref(argv[0], template_id);
+  } else {
+    /* regular arguments */
+    if (argc < 2 || argc > 3)
+      rb_raise(rb_eArgError, "expecting 2..3 arguments or named arguments.");
+    filename = argv[0];
+    data = argv[1];
+    if (argc > 2) {
+      template = argv[2];
+    }
+  }
+  if (filename == Qnil && template == Qnil)
+    rb_raise(rb_eArgError, "missing both template contents and file name.");
+
+  if (template != Qnil)
+    Check_Type(template, T_STRING);
+  if (filename != Qnil)
+    Check_Type(filename, T_STRING);
+
+  fio_str_s str = FIO_STR_INIT;
+
+  mustache_s *m = NULL;
+  mustache_error_en err;
+  m = mustache_load(.filename =
+                        (filename == Qnil ? NULL : RSTRING_PTR(filename)),
+                    .filename_len =
+                        (filename == Qnil ? 0 : RSTRING_LEN(filename)),
+                    .data = (template == Qnil ? NULL : RSTRING_PTR(template)),
+                    .data_len = (template == Qnil ? 0 : RSTRING_LEN(template)),
+                    .err = &err);
+  if (!m)
+    goto error;
+
+  int e = mustache_build(m, .udata1 = &str, .udata2 = (void *)data);
+  mustache_free(m);
+  if (e)
+    goto render_error;
+  fio_str_info_s i = fio_str_info(&str);
+  VALUE ret = rb_str_new(i.data, i.len);
+  fio_str_free(&str);
+  return ret;
+
+error:
+  switch (err) {
+  case MUSTACHE_OK:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template ok, unknown error.");
+    break;
+  case MUSTACHE_ERR_TOO_DEEP:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache element nesting too deep.");
+    break;
+  case MUSTACHE_ERR_CLOSURE_MISMATCH:
+    rb_raise(rb_eRuntimeError,
+             "Iodine::Mustache template error, closure mismatch.");
+    break;
+  case MUSTACHE_ERR_FILE_NOT_FOUND:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template not found.");
+    break;
+  case MUSTACHE_ERR_FILE_TOO_BIG:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template too big.");
+    break;
+  case MUSTACHE_ERR_FILE_NAME_TOO_LONG:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template name too long.");
+    break;
+  case MUSTACHE_ERR_EMPTY_TEMPLATE:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache template is empty.");
+    break;
+  case MUSTACHE_ERR_UNKNOWN:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache unknown error.");
+    break;
+  case MUSTACHE_ERR_USER_ERROR:
+    rb_raise(rb_eRuntimeError, "Iodine::Mustache internal error.");
+    break;
+  }
+  return Qnil;
+
+render_error:
+  fio_str_free(&str);
+  rb_raise(rb_eRuntimeError, "Couldn't build template frome data.");
+}
+
 /* *****************************************************************************
 Initialize Iodine::Mustache
 ***************************************************************************** */
@@ -374,6 +492,9 @@ Initialize Iodine::Mustache
 void iodine_init_mustache(void) {
   call_func_id = rb_intern2("call", 4);
   to_s_func_id = rb_intern2("to_s", 4);
+  filename_id = rb_intern2("filename", 8);
+  data_id = rb_intern2("data", 4);
+  template_id = rb_intern2("template", 8);
   /**
   Iodine::Mustache offers a logicless mustache template engine with strict HTML
   escaping (more than the basic `"<>'$`).
@@ -419,5 +540,6 @@ void iodine_init_mustache(void) {
   rb_define_alloc_func(tmp, iodine_mustache_data_alloc_c);
   rb_define_method(tmp, "initialize", iodine_mustache_new, 1);
   rb_define_method(tmp, "render", iodine_mustache_render, 1);
-  // rb_define_module_function(tmp, "parse", iodine_json_parse, -1);
+  rb_define_singleton_method(tmp, "render", iodine_mustache_render_klass, -1);
+  // rb_define_module_function(tmp, "render", iodine_mustache_render_klass, 2);
 }