iodine 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ad0af726b17fcc350121f1dbacbe34ae47724b9
-  data.tar.gz: 2d30bc235638f7a2e4aa203fb3f25dfa2d78fafe
+  metadata.gz: 8757fa617add5c9d6d4c8b7feee4c3b97952a7e3
+  data.tar.gz: b66b35b5662458733a47d5358901278e428811b3
 SHA512:
-  metadata.gz: 9f918ab4162ff89e65596bc3154d9bedaad2187a24fa4b2fe0707f06079afddad00e34e8879da340b47f3d5e4a900e83615effe8813db1cc5a99b9c83ff4d635
-  data.tar.gz: cddb06efa79664971a33714811d4c824dd7398d7c1b9573ac0081495b140c7163ebc2b635da466abf7a3465fe3d7c0c73899a855c91c329b923397e662213eb2
+  metadata.gz: 65bc4f93c07a4e81eacdc5ce203bf16516c079a246ca4aee6bec078e3180b0d9aebeb653c711a5519d45f57ab817a188ad1c2509bb87b2587c50ab7763155e4b
+  data.tar.gz: ec57fa3e6674bb4393017f188671bf88ce851b6948b1c3b53917a5b78bef1b6822967e1b525e73250288e4d020a29aaa977f1167201ba22b3b12e300020070c7

data/CHANGELOG.md

@@ -8,6 +8,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+Change log v.0.2.3
+
+**Update** The `write` system call is now deferred when resources allow, meaning that (as long as the `write` buffer isn't full) `write` is not only non-blocking, but it's performed as a separate event, outside of the Ruby GIL.
+
+**Update**: The global socket `write` buffer was increased to ~16Mb (from ~4Mb), allowing for more concurrent `write` operations. However, the `write` buffer is still limited and `write` might block while the buffer is full. Blocking and "hanging" the server until there's enough room in the buffer for the requested `write` will slow the server down while keeping it healthy and more secure. IMHO, it is the lesser of two evils.
+
+***
+
 Change log v.0.2.2
 
 **Update** The static file service now supports `ETag` caching, sending a 304 (not changed) response for valid ETags.

data/README.md

@@ -28,7 +28,7 @@ Iodine is a C extension for Ruby, developed for Ruby MRI 2.2.2 and up... it shou
 
 ## Iodine::Rack - an HTTP and Websockets server
 
-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).
+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.
 
 ### Running the web server
 
@@ -47,7 +47,19 @@ Puma's model of 16 threads and 4 processes is easily adopted and proved to provi
 bundler exec iodine -p $PORT -t 16 -w 4
 ```
 
-It should be noted that Websocket support means that no automatic process scaling is provided... It is important to use `iodine` with the `-w` option and set the number of desired processes (ideally equal to the number of CPU cores).
+It should be noted that Websocket support means that no automatic process scaling is provided (since Websockets don't share data across processes without your help)... It is important to use `iodine` with the `-w` option and set the number of desired processes (ideally equal to the number of CPU cores).
+
+### Writing data to the network layer
+
+Iodine allows Ruby to write strings to the network layer. This includes HTTP and Websocket responses.
+
+Iodine will handle an internal buffer (~4 to ~16 Mb, version depending) so that `write` can return immediately (non-blocking).
+
+However, when the buffer is full, `write` will block until enough space in he buffer becomes available. Sending up to 16Kb of data (a single buffer "packet") is optimal. Sending a larger response might effect concurrency. Best Websocket response length is ~1Kb (1 TCP / IP packet) and allows for faster transmissions.
+
+When using the Iodine's web server (`Iodine::Rack`), the static file service offered by Iodine streams files (instead of using the buffer). Every file response will require up to 2 buffer "packets" (~32Kb), one for the header and the other for file streaming.
+
+This means that even a Gigabyte long response will use ~32Kb of memory, as long as it uses the static file service or the `X-Sendfile` extension (Iodine's static file service can be invoked by the Ruby application using the `X-Sendfile` header).
 
 ### Static file serving support
 
@@ -73,6 +85,32 @@ app = Proc.new { out }
 run app
 ```
 
+#### X-Sendfile
+
+Sending can be performed by using the `X-Sendfile` header in the Ruby application response.
+
+i.e. (example `config.ru` for Iodine):
+
+```ruby
+app = proc do |env|
+  request = Rack::Request.new(env)
+  if request.path_info == '/source'.freeze
+    [200, { 'X-Sendfile' => File.expand_path(__FILE__) }, []]
+  elsif request.path_info == '/file'.freeze
+    [200, { 'X-Header' => 'This was a Rack::Sendfile response sent as text' }, File.open(__FILE__)]
+  else
+    [200, { 'Content-Type'.freeze => 'text/html'.freeze,
+            'Content-Length'.freeze => request.path_info.length.to_s },
+     [request.path_info]]
+ end
+end
+# # optional:
+# use Rack::Sendfile
+run app
+```
+
+Go to [localhost:3000/source](http://localhost:3000/source) to download the `config.ru` file using the `X-Sendfile` extension.
+
 ### Special HTTP `Upgrade` support
 
 Iodine's HTTP server includes special support for the Upgrade directive using Rack's `env` Hash, allowing the application to focus on services and data while Iodine takes care of the network layer.

data/SPEC-Websocket-Draft.md

@@ -0,0 +1,83 @@
+## Rack Websockets
+
+This is the proposed Websocket support extension for Rack servers.
+
+Servers that publish Websocket support using the `env['upgrade.websocket?']` value are assume by users to follow the requirements set in this document and thus should follow the requirements set in herein.
+
+This document reserves the Rack `env` Hash keys of `upgrade.websocket?` and `upgrade.websocket`.
+
+## The Websocket Callback Object
+
+Websocket connection upgrade and handling is performed using a Websocket Callback Object.
+
+The Websocket Callback Object should be a class (or an instance of such class) who's instances implement any of the following callbacks:
+
+* `on_open()` WILL be called once the upgrade had completed.
+
+* `on_message(data)` WILL be called when incoming Websocket data is received. `data` will be a String with an encoding of UTF-8 for text messages and `binary` encoding for non-text messages (as specified by the Websocket Protocol).
+
+    The *client* **must** assume that the `data` String will be a **recyclable buffer** and that it's content will be corrupted the moment the `on_message` callback returns.
+
+* `on_ready()` MAY be called when the state of the out-going socket buffer changes from full to not full (data can be sent to the socket). **If** `has_pending?` returns `true`, the `on_ready` callback **must** be called once the buffer state changes.
+
+* `on_shutdown()` MAY be called during the server's graceful shutdown process, _before_ the connection is closed and in addition to the `on_close` function (which is called _after_ the connection is closed.
+
+* `on_close()` WILL be called _after_ the connection was closed for whatever reason (socket errors, parsing errors, timeouts, client disconnection, `close` being called, etc').
+
+* `on_open`, `on_ready`, `on_shutdown` and `on_close` shouldn't expect any arguments (`arity == 0`).
+
+The following method names are reserved for the network implementation: `write`, `close` and `has_pending?`.
+
+The server **must** extend the Websocket Callback Object's *class* using `extend`, so that the Websocket Callback Object inherits the following methods:
+
+* `write(data)` will attempt to send the data through the websocket connection. `data` **must** be a String. If `data` is UTF-8 encoded, the data will be sent as text. If `data` is binary encoded it will be sent as non-text (as specified by the Websocket Protocol).
+
+    `write` has the same delivery promise as `Socket#write` (a successful `write` does **not** mean any of the data will reach the other side).
+
+    `write` shall return `true` on success and `false` if the websocket is closed.
+
+    A server **should** document whether `write` will block or return immediately. It is **recommended** that servers implement buffered IO, allowing `write` to return immediately when resources allow and block (or, possibly, disconnect) when the IO buffer is full.
+
+* `close` closes the connection once all the data in the outgoing queue was sent. If `close` is called while there is still data to be sent, `close` will only take effect once the data was sent.
+
+    `close` shall always return `nil`.
+
+* `has_pending?` queries the state of the server's buffer for the specific connection (i.e., if the server has any data it is waiting to send through the socket).
+
+    `has_pending?`, shall return `true` **if** the server has data waiting to be written to the socket **and** the server promises to call the `on_ready` callback once the buffer is empty and the socket is writable. Otherwise (i.e., if the server doesn't support the `on_ready` callback), `has_pending?` shall return `false`.
+
+    To clarify: **implementing `has_pending?` is semi-optional**, meaning that a server may choose to always return `false`, no matter the actual state of the socket's buffer.
+
+The following keywords (both as method names and instance variable names) are reserved for the internal server implementation: `_server_ws` and `conn_id`.
+
+* The `_server_ws` object is private and shouldn't be accessed by the client.
+
+* The `conn_id` object may be used as a connection ID for any functionality not specified herein.
+
+Connection `ping` / `pong`, timeouts and network considerations should be implemented by the server. It is **recommended** (but not required) that the server send `ping`s to prevent connection timeouts and detect network failure.
+
+Server settings **may** (not required) be provided to allow for customization and adaptation for different network environments or websocket extensions. It is **recommended** that any settings be available as command line arguments and **not** incorporated into the application's logic.
+
+## Upgrading
+
+* **Server**: When an upgrade request is received, the server will set the `env['upgrade.websockets?']` flag to `true`, indicating that: 1. this specific request is upgradable; and 2. this server supports specification.
+
+* **Client**: When a client decides to upgrade a request, they will place a Websocket Callback Object (either a class or an instance) in the `env['upgrade.websockets']` Hash key.
+
+* **Server**: The server will review the `env` Hash *before* sending the response. If the `env['upgrade.websockets']` was set, the server will perform the upgrade.
+
+ * **Server**: The server will send the correct response status and headers, as will as any headers present in the response. The server will also perform any required housekeeping, such as closing the response body, if exists.
+
+     The response status provided by the response object shall be ignored and the correct response status shall be set by the server.
+
+* **Server**: Once the upgrade had completed, The server will add the required websocket/network functions to the callback handler or it's class (as aforementioned). If the callback handler is a Class object, the server will create a new instance of that class.
+
+* **Server**: The server will call the `on_open` callback.
+
+    No other callbacks shall be called until the `on_open` callback had returned.
+
+    Websocket messages shall be handled by the `on_message` callback in the same order in which they arrive and the `on_message` will **not** be executed concurrently for the same connection.
+
+    The `on_close` callback will **not** be called while `on_message` or `on_open` callbacks are running.
+
+    The `on_ready` callback might be called concurrently with the `on_message` callback, allowing data to be sent even while other data is being processed. Multi-threading considerations may apply.

data/ext/iodine/http_response.c

@@ -295,8 +295,8 @@ int http_response_sendfile2(http_response_s *response, http_request_s *request,
 
   response->last_modified = file_data.st_mtime;
   http_response_write_header(response, .name = "Cache-Control",
-                             .name_length = 13, .value = "public, max-age=3600",
-                             .value_length = 20);
+                             .name_length = 13, .value = "max-age=3600",
+                             .value_length = 12);
 
   /* check etag */
   if ((ext = http_request_find_header(request, "if-none-match", 13)) &&

data/ext/iodine/iodine_core.c

@@ -558,7 +558,8 @@ static void *srv_start_no_gvl(void *_) {
 // print a warnning if settings are sub optimal
 #ifdef _SC_NPROCESSORS_ONLN
   size_t cpu_count = sysconf(_SC_NPROCESSORS_ONLN);
-  if ((processes << 1) < cpu_count || processes > (cpu_count << 1))
+  if (cpu_count > 0 &&
+      ((processes << 1) < cpu_count || processes > (cpu_count << 1)))
     fprintf(
         stderr, "* Performance warnning:\n"
                 "  - This computer has %lu CPUs available and you'll be "

data/ext/iodine/iodine_websocket.c

@@ -116,14 +116,22 @@ static VALUE iodine_ws_close(VALUE self) {
   return self;
 }
 
-/** Writes data to the websocket. Returns `self` (the websocket object). */
+/**
+ * Writes data to the websocket.
+ *
+ * Returns `true` on success or `false if the websocket was closed or an error
+ * occurred.
+ *
+ * `write` will return immediately UNLESS resources are insufficient. If the
+ * global `write` buffer is full, `write` will block until a buffer "packet"
+ * becomes available and can be assigned to the socket. */
 static VALUE iodine_ws_write(VALUE self, VALUE data) {
   ws_s *ws = get_ws(self);
   if (((protocol_s *)ws)->service != WEBSOCKET_ID_STR)
     return Qfalse;
   websocket_write(ws, RSTRING_PTR(data), RSTRING_LEN(data),
                   rb_enc_get(data) == UTF8Encoding);
-  return self;
+  return Qtrue;
 }
 
 /** Returns the number of active websocket connections (including connections

data/ext/iodine/libserver.c

@@ -80,10 +80,11 @@ These macros help prevent code changes when changing the data struct.
 // run through any open sockets and call the shutdown handler
 static inline void server_on_shutdown(void) {
   if (server_data.fds && server_data.capacity > 0) {
+    intptr_t uuid;
     for (size_t i = 0; i < server_data.capacity; i++) {
       if (server_data.fds[i].protocol == NULL)
         continue;
-      intptr_t uuid = sock_fd2uuid(i);
+      uuid = sock_fd2uuid(i);
       if (uuid != -1) {
         if (server_data.fds[i].protocol->on_shutdown != NULL)
           server_data.fds[i].protocol->on_shutdown(uuid,
@@ -547,12 +548,26 @@ ssize_t server_run(struct ServerSettings settings) {
     async_join();
   else
     async_perform();
+
+  /*
+   * start a single worker thread for shutdown tasks and async close operations
+   */
+  async_start(1);
+
   listener_on_server_shutdown();
   reactor_review();
   server_on_shutdown();
+  /* cycle until no IO events occure. */
+  while (reactor_review() > 0)
+    ;
   if (settings.on_finish)
     settings.on_finish();
 
+  /*
+   * Wait for any unfinished tasks.
+   */
+  async_finish();
+
   if (children) {
     if (rootpid == getpid()) {
       while (waitpid(-1, NULL, 0) >= 0)
@@ -625,6 +640,7 @@ void server_set_timeout(intptr_t fd, uint8_t timeout) {
   if (valid_uuid(fd) == 0)
     return;
   lock_uuid(fd);
+  uuid_data(fd).active = server_data.last_tick;
   uuid_data(fd).timeout = timeout;
   unlock_uuid(fd);
 }

data/ext/iodine/libserver.h

@@ -5,7 +5,10 @@ license: MIT
 Feel free to copy, use and enjoy according to the license provided.
 */
 #ifndef LIB_SERVER
-#define LIB_SERVER "0.4.0"
+#define LIB_SERVER "0.4.1"
+#define LIB_SERVER_VERSION_MAJOR 0
+#define LIB_SERVER_VERSION_MINOR 4
+#define LIB_SERVER_VERSION_PATCH 1
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
@@ -30,7 +33,7 @@ messages regarding the server state (start / finish / listen messages).
 #define SERVER_PRINT_STATE 1
 #endif
 
-#if LIB_ASYNC_VERSION_MINOR != 4 || LIB_REACT_VERSION_MINOR != 3 || \
+#if LIB_ASYNC_VERSION_MINOR != 4 || LIB_REACT_VERSION_MINOR != 3 ||            \
     LIB_SOCK_VERSION_MINOR != 2
 #warning Lib-Server dependency versions are not in sync. Please review API versions.
 #endif
@@ -194,18 +197,18 @@ struct Protocol {
   * The string should be a global constant, only a pointer comparison will be
   * made (not `strcmp`).
   */
-  const char* service;
+  const char *service;
   /** called when a data is available, but will not run concurrently */
-  void (*on_data)(intptr_t fduuid, protocol_s* protocol);
+  void (*on_data)(intptr_t fduuid, protocol_s *protocol);
   /** called when the socket is ready to be written to. */
-  void (*on_ready)(intptr_t fduuid, protocol_s* protocol);
+  void (*on_ready)(intptr_t fduuid, protocol_s *protocol);
   /** called when the server is shutting down,
    * but before closing the connection. */
-  void (*on_shutdown)(intptr_t fduuid, protocol_s* protocol);
+  void (*on_shutdown)(intptr_t fduuid, protocol_s *protocol);
   /** called when the connection was closed, but will not run concurrently */
-  void (*on_close)(protocol_s* protocol);
+  void (*on_close)(protocol_s *protocol);
   /** called when a connection's timeout was reached */
-  void (*ping)(intptr_t fduuid, protocol_s* protocol);
+  void (*ping)(intptr_t fduuid, protocol_s *protocol);
   /** private metadata used for object protection */
   spn_lock_i callback_lock;
 };
@@ -218,21 +221,21 @@ These settings will be used to setup listenning sockets.
 struct ServerServiceSettings {
   /** Called whenever a new connection is accepted. Should return a pointer to
    * the connection's protocol. */
-  protocol_s* (*on_open)(intptr_t fduuid, void* udata);
+  protocol_s *(*on_open)(intptr_t fduuid, void *udata);
   /** The network service / port. Defaults to "3000". */
-  const char* port;
+  const char *port;
   /** The socket binding address. Defaults to the recommended NULL. */
-  const char* address;
+  const char *address;
   /** Opaque user data. */
-  void* udata;
+  void *udata;
   /**
   * Called when the server starts, allowing for further initialization, such as
   * timed event scheduling.
   *
   * This will be called seperately for every process. */
-  void (*on_start)(void* udata);
+  void (*on_start)(void *udata);
   /** called when the server is done, to clean up any leftovers. */
-  void (*on_finish)(void* udata);
+  void (*on_finish)(void *udata);
 };
 
 /**************************************************************************/ /**
@@ -273,7 +276,31 @@ struct ServerSettings {
 */
 
 /**
-Listens to a server with any of the following server settings:
+Listens to a server with any of the available service settings:
+
+* `.on_open` called whenever a new connection is accepted.
+
+    Should return a pointer to the connection's protocol.
+
+* `.port` the network service / port. Defaults to "3000".
+
+* `.address` the socket binding address. Defaults to the recommended NULL.
+
+* `.udata`opaque user data.
+
+*   `.on_start` called when the server starts, allowing for further
+    initialization, such as timed event scheduling.
+
+    This will be called seperately for every process.
+
+* `.on_finish` called when the server is done, to clean up any leftovers.
+
+*/
+int server_listen(struct ServerServiceSettings);
+#define server_listen(...)                                                     \
+  server_listen((struct ServerServiceSettings){__VA_ARGS__})
+/**
+Runs a server with any of the following server settings:
 
 * `.threads` the number of threads to initiate in the server's thread pool.
 
@@ -292,12 +319,11 @@ initiate a `fork`).
 This method blocks the current thread until the server is stopped when a
 SIGINT/SIGTERM is received.
 
-To kill the server use the `kill` function with a SIGINT.
+To shutdown the server use the `kill` function with a SIGINT.
+
+This function only returns after the server had completed it's shutdown process.
+
 */
-int server_listen(struct ServerServiceSettings);
-#define server_listen(...) \
-  server_listen((struct ServerServiceSettings){__VA_ARGS__})
-/** runs the server, hanging the current process and thread. */
 ssize_t server_run(struct ServerSettings);
 #define server_run(...) server_run((struct ServerSettings){__VA_ARGS__})
 /** Stops the server, shouldn't be called unless int's impossible to send an
@@ -317,7 +343,7 @@ Gets the active protocol object for the requested file descriptor.
 Returns NULL on error (i.e. connection closed), otherwise returns a `protocol_s`
 pointer.
 */
-protocol_s* server_get_protocol(intptr_t uuid);
+protocol_s *server_get_protocol(intptr_t uuid);
 /**
 Sets a new active protocol object for the requested file descriptor.
 
@@ -326,7 +352,7 @@ all resources are released.
 
 Returns -1 on error (i.e. connection closed), otherwise returns 0.
 */
-ssize_t server_switch_protocol(intptr_t fd, protocol_s* new_protocol);
+ssize_t server_switch_protocol(intptr_t fd, protocol_s *new_protocol);
 /**
 Sets a connection's timeout.
 
@@ -340,7 +366,7 @@ based resources asynchronously (i.e. database resources etc').
 
 On failure the fduuid_u.data.fd value will be -1.
 */
-intptr_t server_attach(int fd, protocol_s* protocol);
+intptr_t server_attach(int fd, protocol_s *protocol);
 /** Hijack a socket (file descriptor) from the server, clearing up it's
 resources and calling the protocol's `on_close` callback (making sure allocated
 resources are freed).
@@ -355,7 +381,7 @@ The returned value is the fd for the socket, or -1 on error.
 int server_hijack(intptr_t uuid);
 /** Counts the number of connections for the specified protocol (NULL = all
 protocols). */
-long server_count(char* service);
+long server_count(char *service);
 
 /****************************************************************************
 * Read and Write
@@ -390,13 +416,10 @@ callback.
 It is recommended the `on_finish` callback is only used to perform any
 resource cleanup necessary.
 */
-void server_each(intptr_t origin_uuid,
-                 const char* service,
-                 void (*task)(intptr_t uuid, protocol_s* protocol, void* arg),
-                 void* arg,
-                 void (*on_finish)(intptr_t origin_uuid,
-                                   protocol_s* protocol,
-                                   void* arg));
+void server_each(intptr_t origin_uuid, const char *service,
+                 void (*task)(intptr_t uuid, protocol_s *protocol, void *arg),
+                 void *arg, void (*on_finish)(intptr_t origin_uuid,
+                                              protocol_s *protocol, void *arg));
 /** Schedules a specific task to run asyncronously for a specific connection.
 
 returns -1 on failure, 0 on success (success being scheduling the task).
@@ -409,26 +432,22 @@ and call the fallback function from within the main task, but other designes
 are valid as well.
 */
 void server_task(intptr_t uuid,
-                 void (*task)(intptr_t uuid, protocol_s* protocol, void* arg),
-                 void* arg,
-                 void (*fallback)(intptr_t uuid, void* arg));
+                 void (*task)(intptr_t uuid, protocol_s *protocol, void *arg),
+                 void *arg, void (*fallback)(intptr_t uuid, void *arg));
 /** Creates a system timer (at the cost of 1 file descriptor) and pushes the
 timer to the reactor. The task will repeat `repetitions` times. if
 `repetitions` is set to 0, task will repeat forever. Returns -1 on error
 or the new file descriptor on succeess.
 */
-int server_run_every(size_t milliseconds,
-                     size_t repetitions,
-                     void (*task)(void*),
-                     void* arg,
-                     void (*on_finish)(void*));
+int server_run_every(size_t milliseconds, size_t repetitions,
+                     void (*task)(void *), void *arg,
+                     void (*on_finish)(void *));
 
 /** Creates a system timer (at the cost of 1 file descriptor) and pushes the
 timer to the reactor. The task will NOT repeat. Returns -1 on error or the
 new file descriptor on succeess. */
 __unused static inline int server_run_after(size_t milliseconds,
-                                            void task(void*),
-                                            void* arg) {
+                                            void task(void *), void *arg) {
   return server_run_every(milliseconds, 1, task, arg, NULL);
 }
 

data/ext/iodine/libsock.c

@@ -44,6 +44,12 @@ Support timeout setting.
 #pragma weak sock_touch
 void sock_touch(intptr_t uuid) {}
 
+/* *****************************************************************************
+Support event based `write` scheduling.
+*/
+#pragma weak async_run
+int async_run(void (*task)(void *), void *arg) { return -1; }
+
 /* *****************************************************************************
 OS Sendfile settings.
 */
@@ -72,6 +78,19 @@ Buffer and socket map memory allocation. Defaults to mmap.
 #define USE_MALLOC 0
 #endif
 
+/* *****************************************************************************
+The system call to `write` (non-blocking) can be defered when using `libasync`.
+
+However, this will not prevent `sock_write` from cycling through the sockets and
+flushing them (block emulation) when both the system and the user level buffers
+are full.
+
+Defaults to 1 (defered).
+*/
+#ifndef SOCK_DELAY_WRITE
+#define SOCK_DELAY_WRITE 1
+#endif
+
 /* *****************************************************************************
 Library related helper functions
 */
@@ -188,7 +207,8 @@ static inline void set_fd(int fd, unsigned int state) {
   };
   // unlock
   spn_unlock(&fd_info[fd].lock);
-  // should be called within the lock? - no function calling within a spinlock.
+  // should be called within the lock? - no function calling within a
+  // spinlock.
   if (old_data.rw_hooks && old_data.rw_hooks->on_clear)
     old_data.rw_hooks->on_clear(old_data.fduuid.uuid, old_data.rw_hooks);
   // clear old data
@@ -213,6 +233,9 @@ Call this function before calling any `libsock` functions.
 static void destroy_lib_data(void) {
   if (fd_info) {
     while (fd_capacity--) { // include 0 in countdown
+      if (fd_info[fd_capacity].open) {
+        fprintf(stderr, "Socket %lu is marked as open\n", fd_capacity);
+      }
       set_fd(fd_capacity, LIB_SOCK_STATE_CLOSED);
     }
 #if USE_MALLOC == 1
@@ -463,12 +486,30 @@ static void sock_flush_unsafe(int fd) {
   }
 }
 
+#if SOCK_DELAY_WRITE == 1
+
+static inline void sock_flush_schd(intptr_t uuid) {
+  if (async_run((void *)sock_flush, (void *)uuid) == -1)
+    goto fallback;
+  return;
+fallback:
+  sock_flush_unsafe(sock_uuid2fd(uuid));
+}
+
+#define _write_to_sock() sock_flush_schd(sfd->fduuid.uuid)
+
+#else
+
+#define _write_to_sock() sock_flush_unsafe(fd)
+
+#endif
+
 static inline void sock_send_packet_unsafe(int fd, sock_packet_s *packet) {
   fd_info_s *sfd = fd_info + fd;
   if (sfd->packet == NULL) {
     /* no queue, nothing to check */
     sfd->packet = packet;
-    sock_flush_unsafe(fd);
+    _write_to_sock();
     return;
 
   } else if (packet->metadata.urgent == 0) {
@@ -477,7 +518,7 @@ static inline void sock_send_packet_unsafe(int fd, sock_packet_s *packet) {
     while (pos->metadata.next)
       pos = pos->metadata.next;
     pos->metadata.next = packet;
-    sock_flush_unsafe(fd);
+    _write_to_sock();
     return;
 
   } else {
@@ -494,7 +535,7 @@ static inline void sock_send_packet_unsafe(int fd, sock_packet_s *packet) {
       *pos = tail;
     }
   }
-  sock_flush_unsafe(fd);
+  _write_to_sock();
 }
 
 /* *****************************************************************************
@@ -676,7 +717,8 @@ static inline sock_packet_s *sock_try_checkout_packet(void) {
 
 /**
 Checks out a `sock_packet_s` from the packet pool, transfering the
-ownership of the memory to the calling function. The function will hang until a
+ownership of the memory to the calling function. The function will hang until
+a
 packet becomes available, so never check out more then a single packet at a
 time.
 */
@@ -713,7 +755,8 @@ ssize_t sock_send_packet(intptr_t uuid, sock_packet_s *packet) {
 }
 
 /**
-Returns TRUE (non 0) if there is data waiting to be written to the socket in the
+Returns TRUE (non 0) if there is data waiting to be written to the socket in
+the
 user-land buffer.
 */
 _Bool sock_packets_pending(intptr_t uuid) {
@@ -765,7 +808,8 @@ ssize_t sock_read(intptr_t uuid, void *buf, size_t count) {
   }
   if (i_read == -1 && (ERR_OK || ERR_TRY_AGAIN))
     return 0;
-  // fprintf(stderr, "Read Error for %lu bytes from fd %d (closing))\n", count,
+  // fprintf(stderr, "Read Error for %lu bytes from fd %d (closing))\n",
+  // count,
   //         sock_uuid2fd(uuid));
   sock_close(uuid);
   return -1;
@@ -778,9 +822,12 @@ Flushing
 ssize_t sock_flush(intptr_t uuid) {
   if (!fd_info || !is_valid(uuid))
     return -1;
+  if (uuid2info(uuid).packet == NULL)
+    goto no_packet;
   spn_lock(&uuid2info(uuid).lock);
   sock_flush_unsafe(sock_uuid2fd(uuid));
   spn_unlock(&uuid2info(uuid).lock);
+no_packet:
   if (uuid2info(uuid).close) {
     sock_force_close(uuid);
     return -1;

data/ext/iodine/libsock.h

@@ -5,10 +5,10 @@ license: MIT
 Feel free to copy, use and enjoy according to the license provided.
 */
 #ifndef LIB_SOCK
-#define LIB_SOCK "0.2.0"
+#define LIB_SOCK "0.2.2"
 #define LIB_SOCK_VERSION_MAJOR 0
 #define LIB_SOCK_VERSION_MINOR 2
-#define LIB_SOCK_VERSION_PATCH 0
+#define LIB_SOCK_VERSION_PATCH 2
 
 /** \file
 The libsock is a non-blocking socket helper library, using a user level buffer,
@@ -42,7 +42,7 @@ This information is also useful when implementing read / write hooks.
 #define BUFFER_FILE_READ_SIZE BUFFER_PACKET_SIZE
 #endif
 #ifndef BUFFER_PACKET_POOL
-#define BUFFER_PACKET_POOL 248 /* hard limit unless BUFFER_ALLOW_MALLOC */
+#define BUFFER_PACKET_POOL 1024
 #endif
 
 /* *****************************************************************************
@@ -218,12 +218,17 @@ void sock_touch(intptr_t uuid);
 `sock_read` attempts to read up to count bytes from the socket into the buffer
 starting at buf.
 
-It's behavior should conform to the native `read` implementations, except some
-data might be available in the kernel's buffer while it is not available to be
-read using sock_read (i.e., when using a transport layer, such as TLS).
+`sock_read`'s return values are wildly different then the native return values
+and they aim at making far simpler sense.
 
-Also, some internal buffering will might be used in cases where the transport
-layer data available is larger then the data requested.
+`sock_read` returns the number of bytes read (0 is a valid return value which
+simply means that no bytes were read from the buffer).
+
+On a connection error (NOT EAGAIN or EWOULDBLOCK) or signal interrupt,
+`sock_read` returns -1.
+
+Data might be available in the kernel's buffer while it is not available to be
+read using `sock_read` (i.e., when using a transport layer, such as TLS).
 */
 ssize_t sock_read(intptr_t uuid, void *buf, size_t count);
 

data/iodine.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Boaz Segev']
   spec.email         = ['Boaz@2be.co.il']
 
-  spec.summary       = ' Iodine - writing C servers in Ruby.'
-  spec.description   = ' Iodine - writing C servers in Ruby.'
+  spec.summary       = ' Iodine - leveraging C for Ruby servers.'
+  spec.description   = ' Iodine - leveraging C for Ruby servers.'
   spec.homepage      = 'https://github.com/boazsegev/iodine'
   spec.license       = 'MIT'
 
@@ -34,9 +34,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'rack'
   spec.add_dependency 'rake-compiler'
 
-  spec.requirements << 'A Unix based system, i.e.: Linux / OS X / BSD.'
-  spec.requirements << 'An updated C compiler, with support for C11 (i.e. gcc 4.9 or later).'
+  spec.requirements << 'A Unix based system: Linux / macOS / BSD.'
+  spec.requirements << 'An updated C compiler.'
   spec.requirements << 'Ruby >= 2.2.2'
+  spec.requirements << 'Ruby >= 2.0.0 is recommended.'
 
   spec.add_development_dependency 'bundler', '~> 1.10'
   spec.add_development_dependency 'rake', '~> 10.0'

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-13 00:00:00.000000000 Z
+date: 2016-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: " Iodine - writing C servers in Ruby."
+description: " Iodine - leveraging C for Ruby servers."
 email:
 - Boaz@2be.co.il
 executables:
@@ -96,6 +96,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- SPEC-Websocket-Draft.md
 - bin/config.ru
 - bin/console
 - bin/echo
@@ -194,12 +195,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'A Unix based system, i.e.: Linux / OS X / BSD.'
-- An updated C compiler, with support for C11 (i.e. gcc 4.9 or later).
+- 'A Unix based system: Linux / macOS / BSD.'
+- An updated C compiler.
 - Ruby >= 2.2.2
+- Ruby >= 2.0.0 is recommended.
 rubyforge_project: 
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Iodine - writing C servers in Ruby.
+summary: Iodine - leveraging C for Ruby servers.
 test_files: []