iodine 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d9f26da78f47f0d2d44534b5a0930862ac5c1092
-  data.tar.gz: 13b1d9adfa9e1df5f4544448ec551f879c6a32ac
+  metadata.gz: 481aeb644c0f6d2b38f2c00bc98412cc867e77d5
+  data.tar.gz: bd3eebc92151a3f2d4f41456c6d9402e7cc005fb
 SHA512:
-  metadata.gz: '0381cd3d98e09b440636e7d4fd53a60139d7673b9595a2b7c9e2c6050d593f4920294496b462cf8661cd7cb3af464077664a78d6ba7afa27143b73bc16087678'
-  data.tar.gz: bb0f81ea6a19da939cf733a3a934c7d2396b9bc980abdff4331fb0c2e03c65a96918341df0ff41fb50e5379de758fa75e4df31e0f8db15b3d3b41bd38e5fcdb6
+  metadata.gz: 4f31a4c09c7cbfe4df0a9f1df10c9c12004c7e92e3a2cbe1b513afff12c4c5670a457e0f4f6e8cf710ae5cb677d6b3c319f30baac802aefac054f8c8ccda058b
+  data.tar.gz: 9332123f1197af323c1b1af3a5fb1c5bbce7619b6586c1fb6ca049d220d9ebe6780637f5212588b55552e1bf17a07823cf5aedd1062dbf072095b1418df71cd5

data/CHANGELOG.md

@@ -6,6 +6,18 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.4.7
+
+**Update**: Now using `facil.io` edge (stripped down v.0.5.3).
+
+**Fix**: (`websocket`) fix #21, where a client's first message could have been lost due to long `on_open` processing times. This was fixed by fragmenting the `upgrade` event into two events, adding the `facil_attach_locked` feature and attaching the new protocol before sending the response. Credit to @madsheep and @nilclass for exposing the issue and tracking it down to the `on_open` callbacks.
+
+**Fix**: (`sock`) sockets created using the TCP/IP `sock` library now use `TCP_NODELAY` as the new default. This shouldn't be considered a breaking change as much as it should be considered a fix.
+
+**Fix**: (`http1`) HTTP/1.x now correctly initializes the `udata` pointer to NULL fore each new request.
+
+**Fix**: (`defer`) a shutdown issue in `defer_perform_in_fork` was detected by @cdkrot and his fix was implemented.
+
 #### Change log v.0.4.6
 
 **Update**: Now using `facil.io` v.0.5.2.

data/README.md

@@ -397,7 +397,9 @@ Yes, please, here are some thoughts:
 
 * I'm really not good at writing automated tests and benchmarks, any help would be appreciated. I keep testing manually and that's less then ideal (and it's mistake prone).
 
-* If we can write a Java wrapper for [the C libraries](https://github.com/boazsegev/facil.io), it would be nice... but it could be as big a project as the whole gem, as a lot of minor details are implemented within the bridge between these two languages.
+* If we can write a Java wrapper for [the `facil.io` C framework](https://github.com/boazsegev/facil.io), it would be nice... but it could be as big a project as the whole gem, as a lot of minor details are implemented within the bridge between these two languages.
+
+* PRs or issues related to [the `facil.io` C framework](https://github.com/boazsegev/facil.io) would be better placed in [the `facil.io` repository](https://github.com/boazsegev/facil.io).
 
 * Bug reports and pull requests are welcome on GitHub at https://github.com/boazsegev/iodine.
 

data/examples/config.ru

@@ -0,0 +1,56 @@
+# This is a Websocket echo application.
+#
+# Running this application from the command line is eacy with:
+#
+#      iodine hello.ru
+#
+# Or, in single thread and single process:
+#
+#      iodine -t 1 -w 1 hello.ru
+#
+# Benchmark with `ab` or `wrk` (a 5 seconds benchmark with 2000 concurrent clients):
+#
+#      ab -c 2000 -t 5 -n 1000000 -k http://127.0.0.1:3000/
+#      wrk -c2000 -d5 -t12 http://localhost:3000/
+
+
+# A simple router - Checks for Websocket Upgrade and answers HTTP.
+module MyHTTPRouter
+  # This is the HTTP response object according to the Rack specification.
+  HTTP_RESPONSE = [200, { 'Content-Type' => 'text/html',
+          'Content-Length' => '32' },
+   ['Please connect using websockets.']]
+
+   WS_RESPONSE = [0, {}, []].freeze
+
+   # this is function will be called by the Rack server (iodine) for every request.
+   def self.call env
+     # check if this is an upgrade request.
+     if(env['upgrade.websocket?'.freeze])
+       env['upgrade.websocket'.freeze] = WebsocketEcho
+       return [0, {}, []]
+       return WS_RESPONSE
+     end
+     # simply return the RESPONSE object, no matter what request was received.
+     HTTP_RESPONSE
+   end
+end
+
+# A simple Websocket Callback Object.
+class WebsocketEcho
+  # seng a message to new clients.
+  def on_open
+    write "Echo service initiated."
+  end
+  # send a message, letting the client know the server is suggunt down.
+  def on_shutdown
+    write "Server shutting down. Goodbye."
+  end
+  # perform the echo
+  def on_message data
+    write data
+  end
+end
+
+# this function call links our HelloWorld application with Rack
+run MyHTTPRouter

data/ext/iodine/defer.c

@@ -379,7 +379,6 @@ int defer_perform_in_fork(unsigned int process_count,
     }
   }
 
-  pids_count++;
   forked_pool = &pool_placeholder;
   forked_pool = defer_pool_start(thread_count);
 

data/ext/iodine/defer.h

@@ -17,7 +17,7 @@ forked process.
 #define H_DEFER_H
 #define LIB_DEFER_VERSION_MAJOR 0
 #define LIB_DEFER_VERSION_MINOR 1
-#define LIB_DEFER_VERSION_PATCH 0
+#define LIB_DEFER_VERSION_PATCH 2
 
 #ifdef __cplusplus
 extern "C" {

data/ext/iodine/evio.h

@@ -24,7 +24,7 @@ The callbacks supported by thils library:
 #define H_FACIL_EVIO_H
 #define LIB_EVIO_VERSION_MAJOR 0
 #define LIB_EVIO_VERSION_MINOR 1
-#define LIB_EVIO_VERSION_PATCH 0
+#define LIB_EVIO_VERSION_PATCH 2
 
 #ifdef __cplusplus
 extern "C" {

data/ext/iodine/facil.c

@@ -505,6 +505,7 @@ static void connector_on_close(intptr_t uuid, protocol_s *pconnector) {
 
 #undef facil_connect
 intptr_t facil_connect(struct facil_connect_args opt) {
+  intptr_t uuid = -1;
   if (!opt.address || !opt.port || !opt.on_connect)
     goto error;
   if (!opt.set_rw_hooks)
@@ -524,7 +525,7 @@ intptr_t facil_connect(struct facil_connect_args opt) {
       .rw_udata = opt.rw_udata,
       .opened = 0,
   };
-  intptr_t uuid = connector->uuid = sock_connect(opt.address, opt.port);
+  uuid = connector->uuid = sock_connect(opt.address, opt.port);
   /* check for errors, always invoke the on_fail if required */
   if (uuid == -1)
     goto error;
@@ -1080,10 +1081,8 @@ void facil_run(struct facil_run_args args) {
 Setting the protocol
 ***************************************************************************** */
 
-/** Attaches (or updates) a protocol object to a socket UUID.
- * Returns -1 on error and 0 on success.
- */
-int facil_attach(intptr_t uuid, protocol_s *protocol) {
+static int facil_attach_state(intptr_t uuid, protocol_s *protocol,
+                              protocol_metadata_s state) {
   if (!facil_data)
     facil_lib_init();
   if (protocol) {
@@ -1097,7 +1096,7 @@ int facil_attach(intptr_t uuid, protocol_s *protocol) {
       protocol->ping = mock_ping;
     if (!protocol->on_shutdown)
       protocol->on_shutdown = mock_on_ev;
-    protocol->rsv = 0;
+    prt_meta(protocol) = state;
   }
   spn_lock(&uuid_data(uuid).lock);
   if (!sock_isvalid(uuid)) {
@@ -1117,6 +1116,24 @@ int facil_attach(intptr_t uuid, protocol_s *protocol) {
   return 0;
 }
 
+/** Attaches (or updates) a protocol object to a socket UUID.
+ * Returns -1 on error and 0 on success.
+ */
+int facil_attach(intptr_t uuid, protocol_s *protocol) {
+  return facil_attach_state(uuid, protocol, (protocol_metadata_s){.rsv = 0});
+}
+
+/**
+ * Attaches (or updates) a LOCKED protocol object to a socket UUID.
+ */
+int facil_attach_locked(intptr_t uuid, protocol_s *protocol) {
+  {
+    protocol_metadata_s state = {.rsv = 0};
+    spn_lock(state.locks + FIO_PR_LOCK_TASK);
+    return facil_attach_state(uuid, protocol, state);
+  }
+}
+
 /** Sets a timeout for a specific connection (if active). */
 void facil_set_timeout(intptr_t uuid, uint8_t timeout) {
   if (sock_isvalid(uuid)) {

data/ext/iodine/facil.h

@@ -284,6 +284,7 @@ struct facil_run_args {
  */
 void facil_run(struct facil_run_args args);
 #define facil_run(...) facil_run((struct facil_run_args){__VA_ARGS__})
+
 /**
  * Attaches (or updates) a protocol object to a socket UUID.
  *
@@ -298,6 +299,23 @@ void facil_run(struct facil_run_args args);
  */
 int facil_attach(intptr_t uuid, protocol_s *protocol);
 
+/**
+ * Attaches (or updates) a LOCKED protocol object to a socket UUID.
+ *
+ * The protocol will be attached in the FIO_PR_LOCK_TASK state, requiring a
+ * furthur call to `facil_protocol_unlock`.
+ *
+ * The new protocol object can be NULL, which will practically "hijack" the
+ * socket away from facil.
+ *
+ * The old protocol's `on_close` will be scheduled, if they both exist.
+ *
+ * Returns -1 on error and 0 on success.
+ *
+ * On error, the new protocol's `on_close` callback will be called.
+ */
+int facil_attach_locked(intptr_t uuid, protocol_s *protocol);
+
 /** Sets a timeout for a specific connection (if active). */
 void facil_set_timeout(intptr_t uuid, uint8_t timeout);
 

data/ext/iodine/http.h

@@ -6,9 +6,7 @@ Feel free to copy, use and enjoy according to the license provided.
 */
 #ifndef HTTP_H
 #define HTTP_H
-#define LIB_FACIL_HTTP_VERSION_MAJOR 0
-#define LIB_FACIL_HTTP_VERSION_MINOR 4
-#define LIB_FACIL_HTTP_VERSION_PATCH 0
+
 #include "facil.h"
 
 /** an HTTP/1.1 vs. HTTP/2 identifier. */

data/ext/iodine/http1.c

@@ -117,121 +117,115 @@ static void http1_on_data(intptr_t uuid, http1_protocol_s *pr) {
   char buff[HTTP_BODY_CHUNK_SIZE];
   http1_request_s *request = &pr->request;
   char *buffer = request->buffer;
-  for (;;) {
-    // handle requests with no file data
-    if (request->request.body_file <= 0) {
-      // request headers parsing
-      if (pr->len == 0) {
-        buffer = request->buffer;
-        // make sure headers don't overflow
-        pr->len = sock_read(uuid, buffer + request->buffer_pos,
-                            HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
-        // update buffer read position.
-        request->buffer_pos += pr->len;
-        // if (len > 0) {
-        //   fprintf(stderr, "\n----\nRead from socket, %lu bytes, total
-        //   %lu:\n",
-        //           len, request->buffer_pos);
-        //   for (size_t i = 0; i < request->buffer_pos; i++) {
-        //     fprintf(stderr, "%c", buffer[i] ? buffer[i] : '-');
-        //   }
-        //   fprintf(stderr, "\n");
-        // }
-      }
-      if (pr->len <= 0)
-        goto finished_reading;
-
-      // parse headers
-      result =
-          http1_parse_request_headers(buffer, request->buffer_pos,
-                                      &request->request, http1_on_header_found);
-      // review result
-      if (result >= 0) { // headers comeplete
-        // are we done?
-        if (request->request.content_length == 0 || request->request.body_str) {
-          goto handle_request;
-        }
-        if (request->request.content_length > pr->settings->max_body_size) {
-          goto body_to_big;
-        }
-        // initialize or submit body data
-        result = http1_parse_request_body(buffer + result, pr->len - result,
-                                          (http_request_s *)request);
-        if (result >= 0) {
-          request->buffer_pos += result;
-          goto handle_request;
-        } else if (result == -1) // parser error
-          goto parser_error;
-        goto parse_body;
-      } else if (result == -1) // parser error
-        goto parser_error;
-      // assume incomplete (result == -2), even if wrong, we're right.
-      pr->len = 0;
-      continue;
+  // handle requests with no file data
+  if (request->request.body_file <= 0) {
+    // request headers parsing
+    if (pr->len == 0) {
+      buffer = request->buffer;
+      // make sure headers don't overflow
+      pr->len = sock_read(uuid, buffer + request->buffer_pos,
+                          HTTP1_MAX_HEADER_SIZE - request->buffer_pos);
+      // update buffer read position.
+      request->buffer_pos += pr->len;
+      // if (len > 0) {
+      //   fprintf(stderr, "\n----\nRead from socket, %lu bytes, total
+      //   %lu:\n",
+      //           len, request->buffer_pos);
+      //   for (size_t i = 0; i < request->buffer_pos; i++) {
+      //     fprintf(stderr, "%c", buffer[i] ? buffer[i] : '-');
+      //   }
+      //   fprintf(stderr, "\n");
+      // }
     }
-    if (request->request.body_file > 0) {
-    // fprintf(stderr, "Body File\n");
-    parse_body:
-      buffer = buff;
-      // request body parsing
-      pr->len = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
-      if (pr->len <= 0)
-        goto finished_reading;
-      result = http1_parse_request_body(buffer, pr->len, &request->request);
+    if (pr->len <= 0)
+      goto finished_reading;
+
+    // parse headers
+    result = http1_parse_request_headers(
+        buffer, request->buffer_pos, &request->request, http1_on_header_found);
+    // review result
+    if (result >= 0) { // headers comeplete
+      // are we done?
+      if (request->request.content_length == 0 || request->request.body_str) {
+        goto handle_request;
+      }
+      if (request->request.content_length > pr->settings->max_body_size) {
+        goto body_to_big;
+      }
+      // initialize or submit body data
+      result = http1_parse_request_body(buffer + result, pr->len - result,
+                                        (http_request_s *)request);
       if (result >= 0) {
+        request->buffer_pos += result;
         goto handle_request;
       } else if (result == -1) // parser error
         goto parser_error;
-      if (pr->len < HTTP_BODY_CHUNK_SIZE) // pause parser for more data
-        goto finished_reading;
       goto parse_body;
-    }
-    continue;
-  handle_request:
-    // review required headers / data
-    if (request->request.host == NULL)
-      goto bad_request;
-    http_settings_s *settings = pr->settings;
-    request->request.settings = settings;
-    // call request callback
-    if (pr && settings &&
-        (request->request.upgrade || settings->public_folder == NULL ||
-         http_response_sendfile2(
-             NULL, &request->request, settings->public_folder,
-             settings->public_folder_length, request->request.path,
-             request->request.path_len, settings->log_static))) {
-      pr->on_request(&request->request);
-      // fprintf(stderr, "Called on_request\n");
-    }
-    // rotate buffer for HTTP pipelining
-    if ((ssize_t)request->buffer_pos <= result) {
-      pr->len = 0;
-      // fprintf(stderr, "\n----\nAll data consumed.\n");
-    } else {
-      memmove(request->buffer, buffer + result, request->buffer_pos - result);
-      pr->len = request->buffer_pos - result;
-      // fprintf(stderr, "\n----\ndata after move, %lu long:\n%.*s\n", len,
-      //         (int)len, request->buffer);
-    }
-    // fprintf(stderr, "data in buffer, %lu long:\n%.*s\n", len, (int)len,
-    //         request->buffer);
-    // clear request state
-    http1_request_clear(&request->request);
-    request->buffer_pos = pr->len;
-    // make sure to use the correct buffer.
-    buffer = request->buffer;
-    if (pr->len) {
-      /* prevent this connection from hogging the thread by pipelining endless
-       * requests.
-       */
-      facil_force_event(uuid, FIO_EVENT_ON_DATA);
-      return;
-    }
+    } else if (result == -1) // parser error
+      goto parser_error;
+    // assume incomplete (result == -2), even if wrong, we're right.
+    pr->len = 0;
+    goto postpone;
+  }
+  if (request->request.body_file > 0) {
+  // fprintf(stderr, "Body File\n");
+  parse_body:
+    buffer = buff;
+    // request body parsing
+    pr->len = sock_read(uuid, buffer, HTTP_BODY_CHUNK_SIZE);
+    if (pr->len <= 0)
+      goto finished_reading;
+    result = http1_parse_request_body(buffer, pr->len, &request->request);
+    if (result >= 0) {
+      goto handle_request;
+    } else if (result == -1) // parser error
+      goto parser_error;
+    if (pr->len < HTTP_BODY_CHUNK_SIZE) // pause parser for more data
+      goto finished_reading;
+    goto parse_body;
+  }
+  goto postpone;
+handle_request:
+  // review required headers / data
+  if (request->request.host == NULL)
+    goto bad_request;
+  http_settings_s *settings = pr->settings;
+  request->request.settings = settings;
+  // make sure udata to NULL, making it available for the user
+  request->request.udata = NULL;
+  // call request callback
+  if (pr && settings &&
+      (request->request.upgrade || settings->public_folder == NULL ||
+       http_response_sendfile2(NULL, &request->request, settings->public_folder,
+                               settings->public_folder_length,
+                               request->request.path, request->request.path_len,
+                               settings->log_static))) {
+    pr->on_request(&request->request);
+    // fprintf(stderr, "Called on_request\n");
   }
-  // no routes lead here.
-  fprintf(stderr,
-          "I am lost on a deserted island, no code can reach me here :-)\n");
-  goto finished_reading; // How did we get here?
+  // rotate buffer for HTTP pipelining
+  if ((ssize_t)request->buffer_pos <= result) {
+    pr->len = 0;
+    // fprintf(stderr, "\n----\nAll data consumed.\n");
+  } else {
+    memmove(request->buffer, buffer + result, request->buffer_pos - result);
+    pr->len = request->buffer_pos - result;
+    // fprintf(stderr, "\n----\ndata after move, %lu long:\n%.*s\n", len,
+    //         (int)len, request->buffer);
+  }
+  // fprintf(stderr, "data in buffer, %lu long:\n%.*s\n", len, (int)len,
+  //         request->buffer);
+  // clear request state
+  http1_request_clear(&request->request);
+  request->buffer_pos = pr->len;
+  // make sure to use the correct buffer.
+  buffer = request->buffer;
+/* prevent this connection from hogging the thread by pipelining endless
+ * requests.
+ */
+postpone:
+  facil_force_event(uuid, FIO_EVENT_ON_DATA);
+  return;
 parser_error:
   if (request->request.headers_count >= HTTP1_MAX_HEADER_COUNT)
     goto too_big;

data/ext/iodine/http1_simple_parser.c

@@ -358,7 +358,7 @@ ssize_t http1_parse_request_body(void *buffer, size_t len,
     request->body_file = mkstemp(template);
     if (request->body_file == -1)
       return -1;
-    // use the `next` field to store parser state.
+    // use the `udata` field to store parser state.
     uintptr_t *tmp = (uintptr_t *)(&request->udata);
     *tmp = 0;
   }
@@ -373,9 +373,9 @@ ssize_t http1_parse_request_body(void *buffer, size_t len,
   // write the data to the temporary file.
   if (write(request->body_file, buffer, to_read) < to_read)
     return -1;
-  // update the `next` field data with the received content length
+  // update the `udata` field data with the received content length
   uintptr_t *tmp = (uintptr_t *)(&request->udata);
-  *tmp += to_read; // request->metadata.next += to_read;
+  *tmp += to_read; // (uintptr_t)(request->metadata.udata) += to_read;
 
   // check the state and return.
   if (((uintptr_t)request->udata) >= request->content_length) {

data/ext/iodine/http_request.h

@@ -22,7 +22,7 @@ struct http_request_s {
   const http_settings_s *settings;
   /** the HTTP connection identifier. */
   intptr_t fd;
-  /** this is an opaque pointer, intended for request pooling / chaining */
+  /** this is an opaque pointer, doubles for request pooling / chaining */
   void *udata;
   /** points to the HTTP method name. */
   const char *method;

data/ext/iodine/http_response.c

@@ -475,9 +475,8 @@ void http_response_log_start(http_response_s *response) {
 prints out the log to stderr.
 */
 static void http_response_log_finish(http_response_s *response) {
-#define HTTP_REQUEST_LOG_LIMIT 128
+#define HTTP_REQUEST_LOG_LIMIT 128 /* Log message length limit */
   char buffer[HTTP_REQUEST_LOG_LIMIT];
-
   http_request_s *request = response->request;
   intptr_t bytes_sent = response->content_length;
 
@@ -485,9 +484,20 @@ static void http_response_log_finish(http_response_s *response) {
       response->logged
           ? ((get_clock_mili() - response->clock_start) / CLOCK_RESOLUTION)
           : 0;
-  struct tm tm;
+
+  /* pre-print log message every 1 or 2 seconds or so. */
+  static __thread time_t cached_tick;
+  static __thread char cached_httpdate[48];
+  static __thread size_t chached_len;
   time_t last_tick = facil_last_tick();
-  http_gmtime(&last_tick, &tm);
+  if (last_tick > cached_tick) {
+    struct tm tm;
+    cached_tick = last_tick | 1;
+    http_gmtime(&last_tick, &tm);
+    chached_len = http_date2str(cached_httpdate, &tm);
+    fprintf(stderr, "Updated date cache to (%lu) %s\n", chached_len,
+            cached_httpdate);
+  }
 
   // TODO Guess IP address from headers (forwarded) where possible
   sock_peer_addr_s addrinfo = sock_peer_addr(response->fd);
@@ -509,7 +519,8 @@ static void http_response_log_finish(http_response_s *response) {
   }
   memcpy(buffer + pos, " - - [", 6);
   pos += 6;
-  pos += http_date2str(buffer + pos, &tm);
+  memcpy(buffer + pos, cached_httpdate, chached_len);
+  pos += chached_len;
   buffer[pos++] = ']';
   buffer[pos++] = ' ';
   buffer[pos++] = '"';

data/ext/iodine/misc.c

@@ -54,16 +54,17 @@ fdump_s *bscrypt_fdump(const char *file_path, size_t size_limit) {
     goto error;
   if (size_limit == 0 || (size_t)f_data.st_size < size_limit)
     size_limit = f_data.st_size;
-  container = malloc(size_limit + sizeof(fdump_s));
+  container = malloc(size_limit + sizeof(fdump_s) + 1);
   if (!container)
     goto error;
-  container->length = size_limit;
   file = open(file_path, O_RDONLY);
   if (file < 0)
     goto error;
   if (read(file, container->data, size_limit) != (ssize_t)size_limit)
     goto error;
   close(file);
+  container->length = size_limit;
+  container->data[size_limit] = 0;
   return container;
 error:
   if (container)

data/ext/iodine/pubsub.c

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz segev, 2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.

data/ext/iodine/pubsub.h

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz segev, 2017
 License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.

data/ext/iodine/resp.h

@@ -126,7 +126,7 @@ void resp_free_object(resp_object_s *obj);
  * to the size of the buffer.
  *
  * Once the function returns, `size` will be updated to include the number of
- * bytes required for the string. If the function returned a failuer, this value
+ * bytes required for the string. If the function returned a failure, this value
  * can be used to allocate enough memory to contain the string.
  *
  * The string is Binary safe and it ISN'T always NUL terminated.
@@ -134,8 +134,7 @@ void resp_free_object(resp_object_s *obj);
  * The optional `parser` argument allows experimental extensions to be used when
  * formatting the object. It can be ignored when formatting without extensions.
  *
- * **If implementing a server**: DON'T use this to format outgoing pub/sub
- * notifications.
+ * **If implementing a server**:
  *
  * When implementing a server, Pub/Sub should avoid multiple copies by using a
  * dedicated buffer with a reference count. By decreasing the reference count

data/ext/iodine/sock.c

@@ -18,6 +18,8 @@ Includes and state
 #include <fcntl.h>
 #include <limits.h>
 #include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
@@ -688,6 +690,7 @@ intptr_t sock_accept(intptr_t srv_uuid) {
   struct sockaddr_in6 addrinfo;
   socklen_t addrlen = sizeof(addrinfo);
   int client;
+  int one = 1;
 #ifdef SOCK_NONBLOCK
   client = accept4(sock_uuid2fd(srv_uuid), (struct sockaddr *)&addrinfo,
                    &addrlen, SOCK_NONBLOCK);
@@ -700,10 +703,10 @@ intptr_t sock_accept(intptr_t srv_uuid) {
     return -1;
   sock_set_non_block(client);
 #endif
+  setsockopt(client, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
   clear_fd(client, 1);
   fdinfo(client).addrinfo = addrinfo;
   fdinfo(client).addrlen = addrlen;
-  // sock_touch(srv_uuid);
   return fd2uuid(client);
 }
 
@@ -733,6 +736,7 @@ before attempting to write to the socket.
 */
 intptr_t sock_connect(char *address, char *port) {
   int fd;
+  int one = 1;
   // setup the address
   struct addrinfo hints;
   struct addrinfo *addrinfo;       // will point to the results
@@ -763,6 +767,7 @@ intptr_t sock_connect(char *address, char *port) {
     freeaddrinfo(addrinfo);
     return -1;
   }
+  setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
   clear_fd(fd, 1);
   fdinfo(fd).addrinfo = *((struct sockaddr_in6 *)addrinfo->ai_addr);
   fdinfo(fd).addrlen = addrinfo->ai_addrlen;

data/ext/iodine/sock.h

@@ -8,7 +8,7 @@ Feel free to copy, use and enjoy according to the license provided.
 */
 #define LIB_SOCK_VERSION_MAJOR 0
 #define LIB_SOCK_VERSION_MINOR 3
-#define LIB_SOCK_VERSION_PATCH 0
+#define LIB_SOCK_VERSION_PATCH 2
 
 /** \file
 The `sock.h` is a non-blocking socket helper library, using a user level buffer,
@@ -16,8 +16,16 @@ non-blocking sockets and some helper functions.
 
 This library is great when using it alongside `evio.h`.
 
-The library is designed to be thread safe, but not fork safe (mostly since
-sockets, except listenning sockets, shouldn't be shared among processes).
+The library is designed to be thread safe, but not fork safe - mostly since
+sockets, except listenning sockets, shouldn't be shared among processes.
+
+Socket connections accepted or created using this library will use the
+TCP_NODELAY option by default.
+
+Non TCP/IP stream sockets and file descriptors (i.e., unix sockets) can be
+safely used with this library. However, file descriptors that can't use the
+`read` or `write` system calls MUST set correct Read / Write hooks or they will
+fail.
 */
 
 #include <stdint.h>

data/ext/iodine/websockets.c

@@ -881,6 +881,11 @@ void websocket_unsubscribe(ws_s *ws, uintptr_t subscription_id) {
 The API implementation
 */
 
+static void deferred_on_open(void *func, void *pr) {
+  ((void (*)(ws_s *))func)(pr);
+  facil_protocol_unlock(pr, FIO_PR_LOCK_TASK);
+}
+
 /** The upgrade */
 #undef websocket_upgrade
 ssize_t websocket_upgrade(websocket_settings_s settings) {
@@ -973,6 +978,8 @@ refuse:
   response->status = 400;
 cleanup:
   if (response->status == 101) {
+    // update the protocol object, cleanning up the old one
+    facil_attach_locked(ws->fd, (protocol_s *)ws);
     // send the response
     http_response_finish(response);
     // we have an active websocket connection - prep the connection buffer
@@ -980,10 +987,9 @@ cleanup:
     // update the timeout
     facil_set_timeout(ws->fd, settings.timeout);
     // call the on_open callback
-    if (settings.on_open)
-      settings.on_open(ws);
-    // update the protocol object, cleanning up the old one
-    facil_attach(ws->fd, (protocol_s *)ws);
+    if (settings.on_open) {
+      defer(deferred_on_open, (void *)settings.on_open, ws);
+    }
     return 0;
   }
   http_response_finish(response);

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.6'.freeze
+  VERSION = '0.4.7'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-07-05 00:00:00.000000000 Z
+date: 2017-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -120,6 +120,7 @@ files:
 - bin/ws-echo
 - bin/ws-shootout
 - examples/broadcast.ru
+- examples/config.ru
 - examples/echo.ru
 - examples/hello.ru
 - examples/redis.ru