iodine 0.6.5 → 0.7.0

data/ext/iodine/http1.h

@@ -5,7 +5,7 @@ License: MIT
 #ifndef H_HTTP1_H
 #define H_HTTP1_H
 
-#include "http.h"
+#include <http.h>
 
 #ifndef HTTP1_READ_BUFFER
 /**
@@ -17,13 +17,13 @@ License: MIT
 
 /** Creates an HTTP1 protocol object and handles any unread data in the buffer
  * (if any). */
-protocol_s *http1_new(uintptr_t uuid, http_settings_s *settings,
-                      void *unread_data, size_t unread_length);
+fio_protocol_s *http1_new(uintptr_t uuid, http_settings_s *settings,
+                          void *unread_data, size_t unread_length);
 
 /** Manually destroys the HTTP1 protocol object. */
-void http1_destroy(protocol_s *);
+void http1_destroy(fio_protocol_s *);
 
 /** returns the HTTP/1.1 protocol's VTable. */
-void * http1_vtable(void);
+void *http1_vtable(void);
 
 #endif

data/ext/iodine/http1_parser.c

@@ -8,7 +8,8 @@ Feel free to copy, use and enjoy according to the license provided.
 #define __GNU_SOURCE
 #endif
 
-#include "http1_parser.h"
+#include <http1_parser.h>
+
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
@@ -357,7 +358,7 @@ inline static int consume_body(struct http1_fio_parser_args_s *args,
 /* *****************************************************************************
 HTTP/1.1 parsre function
 ***************************************************************************** */
-#ifdef DEBUG
+#if DEBUG
 #include <assert.h>
 #else
 #define DEBUG 0

data/ext/iodine/http1_parser.h

@@ -57,7 +57,7 @@ typedef struct http1_parser_s {
 /**
  * Available options for the parsing function.
  *
- * Callbacks should return 0 unless an error occured.
+ * Callbacks should return 0 unless an error occurred.
  */
 struct http1_fio_parser_args_s {
   /** REQUIRED: the parser object that manages the parser's state. */
@@ -90,7 +90,7 @@ struct http1_fio_parser_args_s {
   /** called when a body chunk is parsed. */
   int (*const on_body_chunk)(http1_parser_s *parser, char *data,
                              size_t data_len);
-  /** called when a protocol error occured. */
+  /** called when a protocol error occurred. */
   int (*const on_error)(http1_parser_s *parser);
 };
 

data/ext/iodine/http_internal.c

@@ -4,11 +4,9 @@ License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-#include "http_internal.h"
+#include <http_internal.h>
 
-#include "fio_mem.h"
-
-#include "http1.h"
+#include <http1.h>
 
 /* *****************************************************************************
 Internal Request / Response Handlers
@@ -45,7 +43,7 @@ void http_on_request_handler______internal(http_s *h,
           HTTP_HVALUE_SSE_MIME))
     goto eventsource;
   if (settings->public_folder) {
-    fio_cstr_s path_str = fiobj_obj2cstr(h->path);
+    fio_str_info_s path_str = fiobj_obj2cstr(h->path);
     if (!http_sendfile2(h, settings->public_folder,
                         settings->public_folder_length, path_str.data,
                         path_str.len)) {
@@ -58,7 +56,7 @@ void http_on_request_handler______internal(http_s *h,
 upgrade:
   if (1) {
     fiobj_dup(t); /* allow upgrade name access after http_finish */
-    fio_cstr_s val = fiobj_obj2cstr(t);
+    fio_str_info_s val = fiobj_obj2cstr(t);
     if (val.data[0] == 'h' && val.data[1] == '2') {
       http_send_error(h, 400);
     } else {
@@ -82,7 +80,7 @@ void http_on_response_handler______internal(http_s *h,
     settings->on_response(h);
     return;
   } else {
-    fio_cstr_s val = fiobj_obj2cstr(t);
+    fio_str_info_s val = fiobj_obj2cstr(t);
     settings->on_upgrade(h, val.data, val.len);
   }
 }
@@ -94,12 +92,12 @@ Internal helpers
 int http_send_error2(size_t error, intptr_t uuid, http_settings_s *settings) {
   if (!uuid || !settings || !error)
     return -1;
-  protocol_s *pr = http1_new(uuid, settings, NULL, 0);
+  fio_protocol_s *pr = http1_new(uuid, settings, NULL, 0);
   http_s *r = fio_malloc(sizeof(*r));
   HTTP_ASSERT(pr, "Couldn't allocate response object for error report.")
-  http_s_new(r, (http_protocol_s *)pr, http1_vtable());
+  http_s_new(r, (http_fio_protocol_s *)pr, http1_vtable());
   int ret = http_send_error(r, error);
-  sock_close(uuid);
+  fio_close(uuid);
   return ret;
 }
 
@@ -138,7 +136,8 @@ FIOBJ HTTP_HVALUE_WS_UPGRADE;
 FIOBJ HTTP_HVALUE_WS_VERSION;
 FIOBJ HTTP_HVALUE_SSE_MIME;
 
-void http_lib_cleanup(void) {
+static void http_lib_cleanup(void *ignr) {
+  (void)ignr;
   http_mimetype_clear();
 #define HTTPLIB_RESET(x)                                                       \
   fiobj_free(x);                                                               \
@@ -180,6 +179,7 @@ void http_lib_cleanup(void) {
 void http_lib_init(void) {
   if (HTTP_HEADER_ACCEPT_RANGES)
     return;
+  fio_state_callback_add(FIO_CALL_AT_EXIT, http_lib_cleanup, NULL);
   HTTP_HEADER_ACCEPT = fiobj_str_new("accept", 6);
   HTTP_HEADER_ACCEPT_RANGES = fiobj_str_new("accept-ranges", 13);
   HTTP_HEADER_CACHE_CONTROL = fiobj_str_new("cache-control", 13);
@@ -244,7 +244,7 @@ void http_lib_init(void) {
 
 #define REGISTER_MIME(ext, type)                                               \
   http_mimetype_register(ext, sizeof(ext) - 1,                                 \
-                         fiobj_str_static(type, sizeof(type) - 1))
+                         fiobj_str_new(type, sizeof(type) - 1))
 
   REGISTER_MIME("123", "application/vnd.lotus-1-2-3");
   REGISTER_MIME("3dml", "text/vnd.in3d.3dml");
@@ -671,6 +671,7 @@ void http_lib_init(void) {
   REGISTER_MIME("maker", "application/vnd.framemaker");
   REGISTER_MIME("man", "text/troff");
   REGISTER_MIME("mar", "application/octet-stream");
+  REGISTER_MIME("markdown", "text/markdown");
   REGISTER_MIME("mathml", "application/mathml+xml");
   REGISTER_MIME("mb", "application/mathematica");
   REGISTER_MIME("mbk", "application/vnd.mobius.mbk");
@@ -678,6 +679,7 @@ void http_lib_init(void) {
   REGISTER_MIME("mc1", "application/vnd.medcalcdata");
   REGISTER_MIME("mcd", "application/vnd.mcd");
   REGISTER_MIME("mcurl", "text/vnd.curl.mcurl");
+  REGISTER_MIME("md", "text/markdown");
   REGISTER_MIME("mdb", "application/x-msaccess");
   REGISTER_MIME("mdi", "image/vnd.ms-modi");
   REGISTER_MIME("me", "text/troff");

data/ext/iodine/http_internal.h

@@ -7,22 +7,25 @@ Feel free to copy, use and enjoy according to the license provided.
 #ifndef H_HTTP_INTERNAL_H
 #define H_HTTP_INTERNAL_H
 
-#include "spnlock.inc"
+#define FIO_INCLUDE_LINKED_LIST
+#include <fio.h>
 
-#include "fio_llist.h"
-#include "http.h"
-#include "pubsub.h"
+#include <http.h>
 
-#include "fiobj4sock.h"
+#include <fiobj4sock.h>
 
 #include <arpa/inet.h>
 #include <errno.h>
 
+/* *****************************************************************************
+Library initialization
+***************************************************************************** */
+void http_lib_init(void);
 /* *****************************************************************************
 Types
 ***************************************************************************** */
 
-typedef struct http_protocol_s http_protocol_s;
+typedef struct http_fio_protocol_s http_fio_protocol_s;
 typedef struct http_vtable_s http_vtable_s;
 
 struct http_vtable_s {
@@ -39,16 +42,16 @@ struct http_vtable_s {
   int (*const http_push_data)(http_s *h, void *data, uintptr_t length,
                               FIOBJ mime_type);
   /** Upgrades a connection to Websockets. */
-  int (*const http2websocket)(websocket_settings_s *arg);
+  int (*const http2websocket)(http_s *h, websocket_settings_s *arg);
   /** Push for files. */
   int (*const http_push_file)(http_s *h, FIOBJ filename, FIOBJ mime_type);
   /** Pauses the request / response handling. */
-  void (*http_on_pause)(http_s *, http_protocol_s *);
+  void (*http_on_pause)(http_s *, http_fio_protocol_s *);
 
   /** Resumes a request / response handling. */
-  void (*http_on_resume)(http_s *, http_protocol_s *);
+  void (*http_on_resume)(http_s *, http_fio_protocol_s *);
   /** hijacks the socket aaway from the protocol. */
-  intptr_t (*http_hijack)(http_s *h, fio_cstr_s *leftover);
+  intptr_t (*http_hijack)(http_s *h, fio_str_info_s *leftover);
 
   /** Upgrades an HTTP connection to an EventSource (SSE) connection. */
   int (*http_upgrade2sse)(http_s *h, http_sse_s *sse);
@@ -58,13 +61,13 @@ struct http_vtable_s {
   int (*http_sse_close)(http_sse_s *sse);
 };
 
-struct http_protocol_s {
-  protocol_s protocol;       /* facil.io protocol */
+struct http_fio_protocol_s {
+  fio_protocol_s protocol;   /* facil.io protocol */
   intptr_t uuid;             /* socket uuid */
   http_settings_s *settings; /* pointer to HTTP settings */
 };
 
-#define http2protocol(h) ((http_protocol_s *)h->private_data.flag)
+#define http2protocol(h) ((http_fio_protocol_s *)h->private_data.flag)
 
 /* *****************************************************************************
 Constants that shouldn't be accessed by the users (`fiobj_dup` required).
@@ -90,7 +93,7 @@ extern FIOBJ HTTP_HVALUE_WS_VERSION;
 HTTP request/response object management
 ***************************************************************************** */
 
-static inline void http_s_new(http_s *h, http_protocol_s *owner,
+static inline void http_s_new(http_s *h, http_fio_protocol_s *owner,
                               http_vtable_s *vtbl) {
   *h = (http_s){
       .private_data =
@@ -100,7 +103,7 @@ static inline void http_s_new(http_s *h, http_protocol_s *owner,
               .out_headers = fiobj_hash_new(),
           },
       .headers = fiobj_hash_new(),
-      .received_at = facil_last_tick(),
+      .received_at = fio_last_tick(),
       .status = 200,
   };
 }
@@ -128,7 +131,8 @@ static inline void http_s_destroy(http_s *h, uint8_t log) {
 
 static inline void http_s_clear(http_s *h, uint8_t log) {
   http_s_destroy(h, log);
-  http_s_new(h, (http_protocol_s *)h->private_data.flag, h->private_data.vtbl);
+  http_s_new(h, (http_fio_protocol_s *)h->private_data.flag,
+             h->private_data.vtbl);
 }
 
 /** tests handle validity */
@@ -157,7 +161,7 @@ typedef struct http_sse_internal_s {
   http_vtable_s *vtable;  /* the protocol's vtable */
   uintptr_t id;           /* the SSE identifier */
   fio_ls_s subscriptions; /* Subscription List */
-  spn_lock_i lock;        /* Subscription List lock */
+  fio_lock_i lock;        /* Subscription List lock */
   size_t ref;             /* reference count */
 } http_sse_internal_s;
 
@@ -173,7 +177,7 @@ static inline void http_sse_init(http_sse_internal_s *sse, intptr_t uuid,
 }
 
 static inline void http_sse_try_free(http_sse_internal_s *sse) {
-  if (spn_sub(&sse->ref, 1))
+  if (fio_atomic_sub(&sse->ref, 1))
     return;
   free(sse);
 }
@@ -181,8 +185,10 @@ static inline void http_sse_try_free(http_sse_internal_s *sse) {
 static inline void http_sse_destroy(http_sse_internal_s *sse) {
   while (fio_ls_any(&sse->subscriptions)) {
     void *sub = fio_ls_pop(&sse->subscriptions);
-    pubsub_unsubscribe(sub);
+    fio_unsubscribe(sub);
   }
+  if (sse->sse.on_close)
+    sse->sse.on_close(&sse->sse);
   sse->uuid = -1;
   http_sse_try_free(sse);
 }

data/ext/iodine/iodine.c

@@ -2,7 +2,8 @@
 
 #include <ruby/version.h>
 
-#include "facil.h"
+#define FIO_INCLUDE_LINKED_LIST
+#include "fio.h"
 /* *****************************************************************************
 OS specific patches
 ***************************************************************************** */
@@ -31,10 +32,8 @@ static ID call_id;
 /* *****************************************************************************
 Idling
 ***************************************************************************** */
-#include "fio_llist.h"
-#include "spnlock.inc"
 
-static spn_lock_i iodine_on_idle_lock = SPN_LOCK_INIT;
+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) {
@@ -57,21 +56,22 @@ VALUE iodine_sched_on_idle(VALUE self) {
   rb_need_block();
   VALUE block = rb_block_proc();
   IodineStore.add(block);
-  spn_lock(&iodine_on_idle_lock);
+  fio_lock(&iodine_on_idle_lock);
   fio_ls_push(&iodine_on_idle_list, (void *)block);
-  spn_unlock(&iodine_on_idle_lock);
+  fio_unlock(&iodine_on_idle_lock);
   return block;
   (void)self;
 }
 
-static void iodine_on_idle(void) {
-  spn_lock(&iodine_on_idle_lock);
+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);
-    defer(iodine_perform_deferred, (void *)block, NULL);
+    fio_defer(iodine_perform_deferred, (void *)block, NULL);
     IodineStore.remove(block);
   }
-  spn_unlock(&iodine_on_idle_lock);
+  fio_unlock(&iodine_on_idle_lock);
 }
 
 /* *****************************************************************************
@@ -85,8 +85,7 @@ typedef struct {
 
 static void *iodine_run_outside_GVL(void *params_) {
   iodine_start_params_s *params = params_;
-  facil_run(.threads = params->threads, .processes = params->workers,
-            .on_idle = iodine_on_idle, .on_finish = iodine_defer_on_finish);
+  fio_start(.threads = params->threads, .workers = params->workers);
   return NULL;
 }
 
@@ -166,14 +165,14 @@ static VALUE iodine_workers_set(VALUE self, VALUE val) {
 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"));
-  facil_expected_concurrency(&params.threads, &params.workers);
+  fio_expected_concurrency(&params.threads, &params.workers);
   fprintf(stderr,
           "\nStarting up Iodine:\n"
-          " * Ruby v.%s\n * Iodine v.%s\n"
+          " * Iodine %s\n * Ruby %s\n * facil.io " FIO_VERSION_STRING " (%s)\n"
           " * %d Workers X %d Threads per worker.\n"
           "\n",
-          StringValueCStr(ruby_version), StringValueCStr(iodine_version),
-          params.workers, params.threads);
+          StringValueCStr(iodine_version), StringValueCStr(ruby_version),
+          fio_engine(), params.workers, params.threads);
   (void)params;
 }
 
@@ -193,19 +192,32 @@ static void iodine_print_startup_message(iodine_start_params_s params) {
  *
  */
 static VALUE iodine_start(VALUE self) {
-  if (facil_is_running()) {
+  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),
+      .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;
+}
+
 /* *****************************************************************************
 Ruby loads the library and invokes the Init_<lib_name> function...
 
@@ -230,6 +242,7 @@ void Init_iodine(void) {
   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);
 
   // initialize Object storage for GC protection
@@ -250,10 +263,16 @@ void Init_iodine(void) {
   // 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();
+
+  // register idle and finish callbacks
+  fio_state_callback_add(FIO_CALL_ON_IDLE, iodine_on_idle, NULL);
 }

data/ext/iodine/iodine.h

@@ -9,6 +9,7 @@
 #include "iodine_helpers.h"
 #include "iodine_http.h"
 #include "iodine_json.h"
+#include "iodine_mustache.h"
 #include "iodine_pubsub.h"
 #include "iodine_rack_io.h"
 #include "iodine_store.h"
@@ -20,4 +21,7 @@ Constants
 extern VALUE IodineModule;
 extern VALUE IodineBaseModule;
 
+#define IODINE_RSTRINFO(rstr)                                                  \
+  ((fio_str_info_s){.len = RSTRING_LEN(rstr), .data = RSTRING_PTR(rstr)})
+
 #endif

data/ext/iodine/iodine_caller.c

@@ -1,6 +1,7 @@
 #include "iodine_caller.h"
 
 #include <ruby/thread.h>
+#include <string.h>
 
 static __thread volatile uint8_t iodine_GVL_state;
 
@@ -91,7 +92,10 @@ static void *iodine_leaveGVL(void *(*func)(void *), void *arg) {
 /** Calls a Ruby method on a given object, protecting against exceptions. */
 static VALUE iodine_call(VALUE obj, ID method) {
   iodine_rb_task_s task = {
-      .obj = obj, .argc = 0, .argv = NULL, .method = method,
+      .obj = obj,
+      .argc = 0,
+      .argv = NULL,
+      .method = method,
   };
   void *rv = iodine_enterGVL(iodine_protect_ruby_call, &task);
   return (VALUE)rv;
@@ -100,7 +104,10 @@ static VALUE iodine_call(VALUE obj, ID method) {
 /** Calls a Ruby method on a given object, protecting against exceptions. */
 static VALUE iodine_call2(VALUE obj, ID method, int argc, VALUE *argv) {
   iodine_rb_task_s task = {
-      .obj = obj, .argc = argc, .argv = argv, .method = method,
+      .obj = obj,
+      .argc = argc,
+      .argv = argv,
+      .method = method,
   };
   void *rv = iodine_enterGVL(iodine_protect_ruby_call, &task);
   return (VALUE)rv;