iodine 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0801b0def77514bb565e4330fba285d1a35fc84fb039e8931791f3f49af164f7'
-  data.tar.gz: 2f17d26fbae2495c70f1b4d9f822641ad8501940c872a4cd3e1d7636bbfdb1a9
+  metadata.gz: 360dcbeabc106918078a92d3902fc8ef1a94323c933e028c99224a2ef3b5409a
+  data.tar.gz: 75425229c8fefd9429d0f8d0936186d13668eb7b3f7c8905e16e3d617cdd3390
 SHA512:
-  metadata.gz: abbb75f0b612e43054d2c1e0725a8bcb7c70815be580fe1b62d6f64ae203a30ac41508f8652b9a005b8d65de17bf0e9f404b9b73a5b6899e2115dfca51bc9d1a
-  data.tar.gz: a1cc7e4f532b93c33e3cdb29040eef2ce02b2c3d6b03d13fb3daa96bbce3bc986dae0132694feb41cbc7b0c5c8d689cfe393b0b44cbce1a93ede3745f6d87219
+  metadata.gz: 1f437aad47df8fc727bf360692597e31ad41e297d1ff7dfe46786b9d3d7a9c40ff334e3eeca8cec1927b2143d4509b2ce509eaf192d9d521f4113b0b68a1cec8
+  data.tar.gz: ca852958d4f264f907911f95fbd44288b8e6b525afdfc5708b51d2ea13b3d8e236c166544b19686151fdf2c73741b7353e2c2a90b28702275158f16bdf311eeb

data/CHANGELOG.md

@@ -6,7 +6,11 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
-#### Change log v.0.5.1 (next release)
+#### Change log v.0.5.2
+
+**Fix**: fixed compilation issues on FreeBSD. Credit to @adam12 (Adam Daniels) for opening issue #35 and offering a patch.
+
+#### Change log v.0.5.1
 
 **Fix**: fixed compilation issues on OS X version < 10.12 and Alpine Linux. Credit to @jdickey (Jeff Dickey) for opening issue #32.
 

data/README.md

@@ -27,6 +27,22 @@ Iodine is an **evented** framework with a simple API that builds off the low lev
 
 Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but Rack requires Ruby 2.2.2, and so iodine matches this requirement.
 
+---
+
+## Important Note about API Changes and Standardization 
+
+I am very thankful to the many early adopters of iodine using the WebSocket and Pub/Sub API.
+
+Please note that Iodine 0.5.0's API is a temporary API that was part of an attempt to come up with a de facto Rack standard for WebSocket / SSE connectivity.
+
+Sadly, this standard isn't progressing as well as I had hoped. More API changes were requested and it seems that the PR with the finalized API is still being considered ([please vote for the PR!](https://github.com/rack/rack/pull/1272)).
+
+I'm working on Iodine 0.6.0 with the requested updates to the API, along with an updated Pub/Sub API that should fit better with existing pub/sub approaches such ActionCable.
+
+It's my sincere hope that the upcoming API changes in 0.6.0 will be the last and that this will signal the API's maturity as well as general acceptance.
+
+---
+
 ## Iodine::Rack == fast & powerful HTTP + Websockets server with native Pub/Sub
 
 Iodine includes a light and fast HTTP and Websocket server written in C that was written according to the [Rack interface specifications](http://www.rubydoc.info/github/rack/rack/master/file/SPEC) and the [Websocket draft extension](./SPEC-Websocket-Draft.md).

data/ext/iodine/evio_kqueue.c

@@ -12,6 +12,8 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #ifdef EVIO_ENGINE_KQUEUE
 
+#include <sys/types.h>
+
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -20,13 +22,12 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/event.h>
 #include <sys/socket.h>
-#include <sys/time.h>
-#include <sys/types.h>
 #include <time.h>
 #include <unistd.h>
 
+#include <sys/event.h>
+#include <sys/time.h>
 /* *****************************************************************************
 Global data and system independant code
 ***************************************************************************** */

data/ext/iodine/facil.c

@@ -1697,7 +1697,9 @@ static void facil_worker_cleanup(void) {
     }
   }
   defer_perform();
-  facil_data->on_finish();
+  if (facil_data->on_finish) {
+    facil_data->on_finish();
+  }
   defer_perform();
   evio_close();
   facil_external_cleanup();
@@ -1901,56 +1903,77 @@ static inline size_t facil_detect_cpu_cores(void) {
   return cpu_count;
 }
 
-#undef facil_run
-void facil_run(struct facil_run_args args) {
-  signal(SIGPIPE, SIG_IGN);
-  if (!facil_data)
-    facil_lib_init();
-  if (!args.on_idle)
-    args.on_idle = mock_idle;
-  if (!args.on_finish)
-    args.on_finish = mock_idle;
-  if (!args.threads && !args.processes) {
+/**
+ * Returns the number of expected threads / processes to be used by facil.io.
+ *
+ * The pointers should start with valid values that match the expected threads /
+ * processes values passed to `facil_run`.
+ *
+ * The data in the pointers will be overwritten with the result.
+ */
+void facil_expected_concurrency(int16_t *threads, int16_t *processes) {
+  if (!threads || !processes)
+    return;
+  if (!*threads && !*processes) {
     /* both options set to 0 - default to cores*cores matrix */
     ssize_t cpu_count = facil_detect_cpu_cores();
 #if FACIL_CPU_CORES_LIMIT
     if (cpu_count > FACIL_CPU_CORES_LIMIT) {
-      fprintf(
-          stderr,
-          "INFO: Detected %zu cores. Capping auto-detection of cores "
-          "to %zu.\n"
-          "      Avoid this message by setting threads / workers manually.\n"
-          "      To increase auto-detection limit, recompile with:\n"
-          "             -DFACIL_CPU_CORES_LIMIT=%zu \n",
-          (size_t)cpu_count, (size_t)FACIL_CPU_CORES_LIMIT, (size_t)cpu_count);
+      static int print_cores_warning = 1;
+      if (print_cores_warning) {
+        fprintf(
+            stderr,
+            "INFO: Detected %zu cores. Capping auto-detection of cores "
+            "to %zu.\n"
+            "      Avoid this message by setting threads / workers manually.\n"
+            "      To increase auto-detection limit, recompile with:\n"
+            "             -DFACIL_CPU_CORES_LIMIT=%zu \n",
+            (size_t)cpu_count, (size_t)FACIL_CPU_CORES_LIMIT,
+            (size_t)cpu_count);
+        print_cores_warning = 0;
+      }
       cpu_count = FACIL_CPU_CORES_LIMIT;
     }
 #endif
-    args.threads = args.processes = (int16_t)cpu_count;
-  } else if (args.threads < 0 || args.processes < 0) {
+    *threads = *processes = (int16_t)cpu_count;
+  } else if (*threads < 0 || *processes < 0) {
     /* Set any option that is less than 0 be equal to cores/value */
     /* Set any option equal to 0 be equal to the other option in value */
     ssize_t cpu_count = facil_detect_cpu_cores();
 
     if (cpu_count > 0) {
-      int16_t threads = 0;
-      if (args.threads < 0)
-        threads = (int16_t)(cpu_count / (args.threads * -1));
-      else if (args.threads == 0)
-        threads = -1 * args.processes;
-      if (args.processes < 0)
-        args.processes = (int16_t)(cpu_count / (args.processes * -1));
-      else if (args.processes == 0)
-        args.processes = -1 * args.threads;
-      args.threads = threads;
+      int16_t tmp_threads = 0;
+      if (*threads < 0)
+        tmp_threads = (int16_t)(cpu_count / (*threads * -1));
+      else if (*threads == 0)
+        tmp_threads = -1 * *processes;
+      if (*processes < 0)
+        *processes = (int16_t)(cpu_count / (*processes * -1));
+      else if (*processes == 0)
+        *processes = -1 * *threads;
+      *threads = tmp_threads;
     }
   }
 
   /* make sure we have at least one process and at least one thread */
-  if (args.processes <= 0)
-    args.processes = 1;
-  if (args.threads <= 0)
-    args.threads = 1;
+  if (*processes <= 0)
+    *processes = 1;
+  if (*threads <= 0)
+    *threads = 1;
+}
+
+#undef facil_run
+void facil_run(struct facil_run_args args) {
+  signal(SIGPIPE, SIG_IGN);
+  if (!facil_data)
+    facil_lib_init();
+  if (!args.on_idle)
+    args.on_idle = mock_idle;
+  if (!args.on_finish)
+    args.on_finish = mock_idle;
+
+  /* compute actual concurrency */
+  facil_expected_concurrency(&args.threads, &args.processes);
 
   /* listen to SIGINT / SIGTERM */
   facil_setup_signal_handler();

data/ext/iodine/facil.h

@@ -121,7 +121,7 @@ struct FacilIOProtocol {
    * Called when the server is shutting down, immediately before closing the
    * connection.
    *
-   * The callback runs within a {FIO_PR_LOCK_TACK} lock, so it will never run
+   * The callback runs within a {FIO_PR_LOCK_TASK} lock, so it will never run
    * concurrently wil {on_data} or other connection specific tasks.
    */
   void (*on_shutdown)(intptr_t uuid, protocol_s *protocol);
@@ -336,6 +336,7 @@ struct facil_run_args {
   /** called when the server is done, to clean up any leftovers. */
   void (*on_finish)(void);
 };
+
 /**
  * Starts the facil.io event loop. This function will return after facil.io is
  * done (after shutdown).
@@ -345,6 +346,16 @@ struct facil_run_args {
 void facil_run(struct facil_run_args args);
 #define facil_run(...) facil_run((struct facil_run_args){__VA_ARGS__})
 
+/**
+ * Returns the number of expected threads / processes to be used by facil.io.
+ *
+ * The pointers should start with valid values that match the expected threads /
+ * processes values passed to `facil_run`.
+ *
+ * The data in the pointers will be overwritten with the result.
+ */
+void facil_expected_concurrency(int16_t *threads, int16_t *processes);
+
 /**
  * returns true (1) if the facil.io engine is already running.
  */

data/ext/iodine/fio_mem.c

@@ -140,9 +140,10 @@ static inline void *sys_alloc(size_t len, uint8_t is_indi) {
   static void *next_alloc = NULL;
 /* hope for the best? */
 #ifdef MAP_ALIGNED
-  result = mmap(
-      next_alloc, len, PROT_READ | PROT_WRITE,
-      MAP_PRIVATE | MAP_ANONYMOUS | MAP_ALIGNED(FIO_MEMORY_BLOCK_SIZE), -1, 0);
+  result =
+      mmap(next_alloc, len, PROT_READ | PROT_WRITE,
+           MAP_PRIVATE | MAP_ANONYMOUS | MAP_ALIGNED(FIO_MEMORY_BLOCK_SIZE_LOG),
+           -1, 0);
 #else
   result = mmap(next_alloc, len, PROT_READ | PROT_WRITE,
                 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

data/ext/iodine/fio_mem.h

@@ -122,8 +122,11 @@ void fio_malloc_test(void);
 #endif
 
 /** Allocator default settings. */
+#ifndef FIO_MEMORY_BLOCK_SIZE_LOG
+#define FIO_MEMORY_BLOCK_SIZE_LOG (17) /* 17 == 128Kb */
+#endif
 #ifndef FIO_MEMORY_BLOCK_SIZE
-#define FIO_MEMORY_BLOCK_SIZE ((uintptr_t)1 << 17) /* 17 == 128Kb */
+#define FIO_MEMORY_BLOCK_SIZE ((uintptr_t)1 << FIO_MEMORY_BLOCK_SIZE_LOG)
 #endif
 #ifndef FIO_MEMORY_BLOCK_MASK
 #define FIO_MEMORY_BLOCK_MASK (FIO_MEMORY_BLOCK_SIZE - 1) /* 0b111... */

data/ext/iodine/http.c

@@ -2289,6 +2289,7 @@ size_t http_date2rfc2109(char *target, struct tm *tmbuf) {
   pos[0] = MONTH_NAMES[tmbuf->tm_mon][0];
   pos[1] = MONTH_NAMES[tmbuf->tm_mon][1];
   pos[2] = MONTH_NAMES[tmbuf->tm_mon][2];
+  pos[3] = ' ';
   pos += 4;
   // write year.
   pos += fio_ltoa(pos, tmbuf->tm_year + 1900, 10);

data/ext/iodine/http.h

@@ -449,14 +449,17 @@ sock_peer_addr_s http_peer_addr(http_s *h);
  * It's possible to hijack the socket and than reconnect it to a new protocol
  * object.
  *
- * If any HTTP functions are called after the hijacking, the protocol object
- * might attempt to continue reading data from the buffer.
+ * It's possible to call `http_finish` immediately after calling `http_hijack`
+ * in order to send the outgoing headers.
+ *
+ * If any aditional HTTP functions are called after the hijacking, the protocol
+ * object might attempt to continue reading data from the buffer.
  *
  * Returns the underlining socket connection's uuid. If `leftover` isn't NULL,
  * it will be populated with any remaining data in the HTTP buffer (the data
- * will be automatically deallocated, so copy the data if it's required).
+ * will be automatically deallocated, so copy the data when in need).
  *
- * WARNING: this isn't a good was to handle HTTP connections, especially as
+ * WARNING: this isn't a good way to handle HTTP connections, especially as
  * HTTP/2 enters the picture.
  */
 intptr_t http_hijack(http_s *h, fio_cstr_s *leftover);

data/ext/iodine/http1.c

@@ -509,7 +509,7 @@ static int http1_upgrade2sse(http_s *h, http_sse_s *sse) {
 
   if (facil_attach(uuid, &sse_pr->p))
     return -1;
-
+  facil_set_timeout(uuid, handle2pr(h)->p.settings->ws_timeout);
   if (sse->on_open)
     sse->on_open(&sse_pr->sse->sse);
 

data/ext/iodine/pubsub.c

@@ -332,6 +332,15 @@ pubsub_sub_pt pubsub_find_sub(struct pubsub_subscribe_args args) {
 #define pubsub_find_sub(...)                                                   \
   pubsub_find_sub((struct pubsub_subscribe_args){__VA_ARGS__})
 
+/**
+ * This helper returns a temporary handle to an existing subscription's channel.
+ *
+ * To keep the handle beyond the lifetime of the subscription, use `fiobj_dup`.
+ */
+FIOBJ pubsub_sub_channel(pubsub_sub_pt sub) {
+  return (((channel_s *)((client_s *)sub)->parent))->name;
+}
+
 /**
  * Unsubscribes from a specific subscription.
  *
@@ -406,11 +415,24 @@ static void pubsub_on_channel_destroy(channel_s *ch) {
 
 /** Registers an engine, so it's callback can be called. */
 void pubsub_engine_register(pubsub_engine_s *engine) {
+  if (!engine) {
+    return;
+  }
   spn_lock(&engn_lock);
   fio_hash_insert(
       &engines,
       (fio_hash_key_s){.hash = (uintptr_t)engine, .obj = FIOBJ_INVALID},
       engine);
+  if (engine->subscribe) {
+    FIO_HASH_FOR_LOOP(&channels, i) {
+      channel_s *ch = i->obj;
+      engine->subscribe(engine, ch->name, 0);
+    }
+    FIO_HASH_FOR_LOOP(&patterns, i) {
+      channel_s *ch = i->obj;
+      engine->subscribe(engine, ch->name, 1);
+    }
+  }
   spn_unlock(&engn_lock);
 }
 

data/ext/iodine/pubsub.h

@@ -108,6 +108,13 @@ pubsub_sub_pt pubsub_find_sub(struct pubsub_subscribe_args);
 #define pubsub_find_sub(...)                                                   \
   pubsub_find_sub((struct pubsub_subscribe_args){__VA_ARGS__})
 
+/**
+ * This helper returns a temporary handle to an existing subscription's channel.
+ *
+ * To keep the handle beyond the lifetime of the subscription, use `fiobj_dup`.
+ */
+FIOBJ pubsub_sub_channel(pubsub_sub_pt);
+
 /**
  * Unsubscribes from a specific subscription.
  *

data/ext/iodine/sock.c

@@ -1090,7 +1090,7 @@ ssize_t sock_write2_fn(sock_write_info_s options) {
   if (validate_uuid(options.uuid) || !options.buffer)
     goto error;
   lock_fd(fd);
-  if (!fdinfo(fd).open) {
+  if (!fdinfo(fd).open || fdinfo(fd).close) {
     unlock_fd(fd);
     goto error;
   }

data/ext/iodine/sock.h

@@ -39,6 +39,11 @@ Feel free to copy, use and enjoy according to the license provided.
 #include <sys/types.h>
 #include <unistd.h>
 
+#if defined(__FreeBSD__)
+#include <netinet/in.h>
+#include <sys/socket.h>
+#endif
+
 // clang-format off
 #if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
 #   if defined(__has_include)

data/ext/iodine/spnlock.inc

@@ -81,10 +81,10 @@ static inline int spn_trylock(spn_lock_i *lock) {
 }
 
 /** Releases a lock. */
-static inline __attribute__((unused)) void spn_unlock(spn_lock_i *lock) {
-  __asm__ volatile("" ::: "memory");
-  *lock = 0;
+static inline __attribute__((unused)) int spn_unlock(spn_lock_i *lock) {
+  return SPN_LOCK_BUILTIN(lock, 0);
 }
+
 /** returns a lock's state (non 0 == Busy). */
 static inline __attribute__((unused)) int spn_is_locked(spn_lock_i *lock) {
   __asm__ volatile("" ::: "memory");

data/ext/iodine/websockets.c

@@ -9,6 +9,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #include "fio_llist.h"
 #include "fiobj.h"
 
+#include "evio.h"
 #include "fio_base64.h"
 #include "fio_sha1.h"
 #include "http.h"
@@ -286,10 +287,13 @@ static void on_data_first(intptr_t sockfd, protocol_s *ws_) {
   if (ws->on_open)
     ws->on_open(ws);
   ws->protocol.on_data = on_data;
+  ws->protocol.on_ready = on_ready;
 
-  if (ws->length)
+  if (ws->length) {
     ws->length = websocket_consume(ws->buffer.data, ws->length, ws,
                                    (~(ws->is_client) & 1));
+  }
+  evio_add_write(sock_uuid2fd(sockfd), (void *)sockfd);
 
   facil_force_event(sockfd, FIO_EVENT_ON_DATA);
 }
@@ -310,7 +314,7 @@ static ws_s *new_websocket(intptr_t uuid) {
       .protocol.ping = ws_ping,
       .protocol.on_data = on_data_first,
       .protocol.on_close = on_close,
-      .protocol.on_ready = on_ready,
+      .protocol.on_ready = NULL /* filled in after `on_open` */,
       .protocol.on_shutdown = on_shutdown,
       .subscriptions = FIO_LS_INIT(ws->subscriptions),
       .is_client = 0,

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.5.1'.freeze
+  VERSION = '0.5.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-02 00:00:00.000000000 Z
+date: 2018-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack