rage-iodine 1.7.58

data/ext/iodine/iodine.h

@@ -0,0 +1,64 @@
+#ifndef H_IODINE_H
+#define H_IODINE_H
+
+#include "ruby.h"
+
+#include "fio.h"
+#include "fio_tls.h"
+#include "fiobj.h"
+/* used for iodine_connect and iodine_listen routing */
+typedef struct {
+  fio_str_info_s address;
+  fio_str_info_s port;
+  fio_str_info_s method;
+  fio_str_info_s path;
+  fio_str_info_s body;
+  fio_str_info_s public;
+  fio_str_info_s url;
+#ifndef __MINGW32__
+  fio_tls_s *tls;
+#endif
+  VALUE handler;
+  FIOBJ headers;
+  FIOBJ cookies;
+  size_t max_headers;
+  size_t max_body;
+  intptr_t max_clients;
+  size_t max_msg;
+  uint8_t timeout;
+  uint8_t ping;
+  uint8_t log;
+  enum {
+    IODINE_SERVICE_RAW,
+    IODINE_SERVICE_HTTP,
+    IODINE_SERVICE_WS,
+  } service;
+} iodine_connection_args_s;
+
+#include "iodine_caller.h"
+#include "iodine_connection.h"
+#include "iodine_defer.h"
+#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"
+#include "iodine_tcp.h"
+#include "iodine_tls.h"
+#include "scheduler.h"
+
+/* *****************************************************************************
+Constants
+***************************************************************************** */
+extern VALUE IodineModule;
+extern VALUE IodineBaseModule;
+extern VALUE iodine_default_args;
+extern ID iodine_call_id;
+extern ID iodine_to_s_id;
+
+#define IODINE_RSTRINFO(rstr)                                                  \
+  ((fio_str_info_s){.len = RSTRING_LEN(rstr), .data = RSTRING_PTR(rstr)})
+
+#endif

data/ext/iodine/iodine_caller.c

@@ -0,0 +1,218 @@
+#include "iodine_caller.h"
+
+#include <ruby/thread.h>
+#include <string.h>
+
+#include <fio.h>
+
+#include <pthread.h>
+
+static pthread_key_t iodine_GVL_state_key;
+static pthread_once_t iodine_GVL_state_once = PTHREAD_ONCE_INIT;
+static void init_iodine_GVL_state_key(void) {
+  pthread_key_create(&iodine_GVL_state_key, NULL); 
+}
+static void init_iodine_GVL_state_init(void) {
+  uint8_t *gvl = malloc(sizeof(uint8_t));
+  FIO_ASSERT_ALLOC(gvl);
+  *gvl = 1;
+  pthread_setspecific(iodine_GVL_state_key, gvl);
+}
+
+/* *****************************************************************************
+Calling protected Ruby methods
+***************************************************************************** */
+
+/* task container */
+typedef struct {
+  VALUE obj;
+  int argc;
+  VALUE *argv;
+  ID method;
+  int exception;
+  VALUE (*protected_task)(VALUE tsk_);
+  VALUE (*each_func)(VALUE block_arg, VALUE data, int argc, VALUE *argv);
+  VALUE each_udata;
+} iodine_rb_task_s;
+
+/* printout backtrace in case of exceptions */
+static void *iodine_handle_exception(void *ignr) {
+  (void)ignr;
+  VALUE exc = rb_errinfo();
+  if (exc != Qnil && rb_respond_to(exc, rb_intern("message")) &&
+      rb_respond_to(exc, rb_intern("backtrace"))) {
+    VALUE msg = rb_funcall2(exc, rb_intern("message"), 0, NULL);
+    VALUE exc_class = rb_class_name(CLASS_OF(exc));
+    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"));
+      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 {
+      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();
+    FIO_LOG_ERROR("\n");
+    rb_set_errinfo(Qnil);
+  } else if (exc != Qnil) {
+    FIO_LOG_ERROR(
+        "Iodine caught an unprotected exception - NO MESSAGE / DATA AVAILABLE");
+  }
+  return (void *)Qnil;
+}
+
+/* calls the Ruby each method within the protection block */
+static VALUE iodine_ruby_caller_perform_block(VALUE tsk_) {
+  iodine_rb_task_s *task = (void *)tsk_;
+  return rb_block_call(task->obj, task->method, task->argc, task->argv,
+                       task->each_func, task->each_udata);
+}
+
+/* calls the Ruby method within the protection block */
+static VALUE iodine_ruby_caller_perform(VALUE tsk_) {
+  iodine_rb_task_s *task = (void *)tsk_;
+  return rb_funcall2(task->obj, task->method, task->argc, task->argv);
+}
+
+/* wrap the function call in exception handling block (uses longjmp) */
+static void *iodine_protect_ruby_call(void *task_) {
+  int state = 0;
+  VALUE ret = rb_protect(((iodine_rb_task_s *)task_)->protected_task,
+                         (VALUE)(task_), &state);
+  if (state) {
+    iodine_handle_exception(NULL);
+  }
+  return (void *)ret;
+}
+
+/* *****************************************************************************
+API
+***************************************************************************** */
+
+/** Calls a C function within the GVL. */
+static void *iodine_enterGVL(void *(*func)(void *), void *arg) {
+  pthread_once(&iodine_GVL_state_once, init_iodine_GVL_state_key);
+  uint8_t *iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  if (!iodine_GVL_state) {
+    init_iodine_GVL_state_init();
+    iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  }
+  if (*iodine_GVL_state) {
+    return func(arg);
+  }
+  void *rv = NULL;
+  *iodine_GVL_state = 1;
+  rv = rb_thread_call_with_gvl(func, arg);
+  *iodine_GVL_state = 0;
+  return rv;
+}
+
+/** Calls a C function outside the GVL. */
+static void *iodine_leaveGVL(void *(*func)(void *), void *arg) {
+  pthread_once(&iodine_GVL_state_once, init_iodine_GVL_state_key);
+  uint8_t *iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  if (!iodine_GVL_state) {
+    init_iodine_GVL_state_init();
+    iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  }
+  if (!*iodine_GVL_state) {
+    return func(arg);
+  }
+  void *rv = NULL;
+  *iodine_GVL_state = 0;
+  rv = rb_thread_call_without_gvl(func, arg, NULL, NULL);
+  *iodine_GVL_state = 1;
+  return rv;
+}
+
+/** 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,
+      .protected_task = iodine_ruby_caller_perform,
+  };
+  void *rv = iodine_enterGVL(iodine_protect_ruby_call, &task);
+  return (VALUE)rv;
+}
+
+/** 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,
+      .protected_task = iodine_ruby_caller_perform,
+  };
+  void *rv = iodine_enterGVL(iodine_protect_ruby_call, &task);
+  return (VALUE)rv;
+}
+
+/** Calls a Ruby method on a given object, protecting against exceptions. */
+static VALUE iodine_call_block(VALUE obj, ID method, int argc, VALUE *argv,
+                               VALUE udata,
+                               VALUE(each_func)(VALUE block_arg, VALUE udata,
+                                                int argc, VALUE *argv)) {
+  iodine_rb_task_s task = {
+      .obj = obj,
+      .argc = argc,
+      .argv = argv,
+      .method = method,
+      .protected_task = iodine_ruby_caller_perform_block,
+      .each_func = each_func,
+      .each_udata = udata,
+  };
+  void *rv = iodine_enterGVL(iodine_protect_ruby_call, &task);
+  return (VALUE)rv;
+}
+
+/** Returns the GVL state flag. */
+static uint8_t iodine_in_GVL(void) {
+  pthread_once(&iodine_GVL_state_once, init_iodine_GVL_state_key);
+  uint8_t *iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  if (!iodine_GVL_state) {
+    init_iodine_GVL_state_init();
+    iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  }
+  return *iodine_GVL_state;
+}
+
+/** Forces the GVL state flag. */
+static void iodine_set_GVL(uint8_t state) { 
+  pthread_once(&iodine_GVL_state_once, init_iodine_GVL_state_key);
+  uint8_t *iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  if (!iodine_GVL_state) {
+    init_iodine_GVL_state_init();
+    iodine_GVL_state = pthread_getspecific(iodine_GVL_state_key);
+  }
+  *iodine_GVL_state = state;
+}
+
+/* *****************************************************************************
+Caller Initialization
+***************************************************************************** */
+
+struct IodineCaller_s IodineCaller = {
+    /** Calls a C function within the GVL. */
+    .enterGVL = iodine_enterGVL,
+    /** Calls a C function outside the GVL. */
+    .leaveGVL = iodine_leaveGVL,
+    /** Calls a Ruby method on a given object, protecting against exceptions. */
+    .call_with_block = iodine_call_block,
+    /** Calls a Ruby method on a given object, protecting against exceptions. */
+    .call = iodine_call,
+    /** Calls a Ruby method on a given object, protecting against exceptions. */
+    .call2 = iodine_call2,
+    /** Returns the GVL state flag. */
+    .in_GVL = iodine_in_GVL,
+    /** Forces the GVL state flag. */
+    .set_GVL = iodine_set_GVL,
+};

data/ext/iodine/iodine_caller.h

@@ -0,0 +1,27 @@
+#ifndef H_IODINE_CALLER_H
+#define H_IODINE_CALLER_H
+
+#include "ruby.h"
+
+#include <stdint.h>
+
+extern struct IodineCaller_s {
+  /** Calls a C function within the GVL (unprotected). */
+  void *(*enterGVL)(void *(*func)(void *), void *arg);
+  /** Calls a C function outside the GVL (no Ruby API calls allowed). */
+  void *(*leaveGVL)(void *(*func)(void *), void *arg);
+  /** Calls a Ruby method on a given object, protecting against exceptions. */
+  VALUE (*call)(VALUE obj, ID method);
+  /** Calls a Ruby method on a given object, protecting against exceptions. */
+  VALUE (*call2)(VALUE obj, ID method, int argc, VALUE *argv);
+  /** Calls a Ruby method on a given object, protecting against exceptions. */
+  VALUE(*call_with_block)
+  (VALUE obj, ID method, int argc, VALUE *argv, VALUE udata,
+   VALUE (*block_func)(VALUE block_argv1, VALUE udata, int argc, VALUE *argv));
+  /** Returns the GVL state flag. */
+  uint8_t (*in_GVL)(void);
+  /** Forces the GVL state flag. */
+  void (*set_GVL)(uint8_t state);
+} IodineCaller;
+
+#endif