iodine 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8757fa617add5c9d6d4c8b7feee4c3b97952a7e3
-  data.tar.gz: b66b35b5662458733a47d5358901278e428811b3
+  metadata.gz: c5dd781b994de37f715d28a0bb3d2116d0130ec7
+  data.tar.gz: ef6e1fb31118a909c479c5b3a5eca55984794cfa
 SHA512:
-  metadata.gz: 65bc4f93c07a4e81eacdc5ce203bf16516c079a246ca4aee6bec078e3180b0d9aebeb653c711a5519d45f57ab817a188ad1c2509bb87b2587c50ab7763155e4b
-  data.tar.gz: ec57fa3e6674bb4393017f188671bf88ce851b6948b1c3b53917a5b78bef1b6822967e1b525e73250288e4d020a29aaa977f1167201ba22b3b12e300020070c7
+  metadata.gz: dcc16cec26d57a181e7883fef1772abff857f07c5d20ef7900f3ea1c63e953061567185d0456be14b6dfa8e827f7637720555455e38b5146ddcba26ca2d41eee
+  data.tar.gz: 1ca3bb3ccd3d45ad069e9093af6cecdd73c08ccb9b6018394f4ca1467cc7ae157cdcee248da32c5f5e82e91f5042a98d6173f10eeecf073225415c67bf9c7d97

data/CHANGELOG.md

@@ -8,9 +8,21 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+Change log v.0.2.4
+
+**Minor Fix**: Patched Iodine against Apple's broken `getrlimit` on macOS. This allows correct auto-setting of open file limits for the socket layer.
+
+**Minor Fix**: Fixed the processor under-utilization warning, where "0" might be shown for the number processes instead of "1".
+
+**Update**: Added support for the `env` keys `HTTP_VERSION` and `SERVER_PROTOCOL` to indicate the HTTP protocol version. Iodine implements an HTTP/1.1 server, so versions aren't expected to be higher than 1.x.
+
+**Update**: Iodine::Rack startup messages now include details regarding open file limits imposed by the OS (open file limits control the maximum allowed concurrent connections and other resource limits).
+
+***
+
 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 `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.
 

data/README.md

@@ -8,7 +8,7 @@
 
 Iodine makes writing Object Oriented **Network Services** easy to write.
 
-Iodine is an **evented** framework with a simple API that builds off a low level [C code library](https://github.com/boazsegev/c-server-tools) with support for **epoll** and **kqueue** - this means that:
+Iodine is an **evented** framework with a simple API that builds off the low level [C code library facil.io](https://github.com/boazsegev/facil.io) with support for **epoll** and **kqueue** - this means that:
 
 * Iodine can handle **thousands of concurrent connections** (tested with 20K connections).
 
@@ -352,7 +352,7 @@ 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/c-server-tools), 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 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.
 
 * Bug reports and pull requests are welcome on GitHub at https://github.com/boazsegev/iodine.
 
@@ -380,7 +380,7 @@ Here's a few things you can use from this project and they seem to be handy to h
 
     I'm attaching it to one of Iodine's library classes, just in-case someone adopts my code and decides the registry should be owned by the global Object class.
 
-* I was using a POSIX thread pool library ([`libasync.h`](https://github.com/boazsegev/c-server-tools/blob/master/lib/libasync.c)) until I realized how many issues Ruby has with non-Ruby threads... So now there's a Ruby-thread port for this library at ([`rb-libasync.h`](https://github.com/boazsegev/iodine/blob/master/ext/iodine/rb-libasync.h)).
+* I was using a POSIX thread pool library ([`libasync.h`](https://github.com/boazsegev/facil.io/blob/master/lib/libasync.c)) until I realized how many issues Ruby has with non-Ruby threads... So now there's a Ruby-thread port for this library at ([`rb-libasync.h`](https://github.com/boazsegev/iodine/blob/master/ext/iodine/rb-libasync.h)).
 
     Notice that all the new threads are free from the GVL - this allows true concurrency... but, you can't make Ruby API calls in that state.
 

data/SPEC-Websocket-Draft.md

@@ -16,9 +16,9 @@ The Websocket Callback Object should be a class (or an instance of such class) w
 
 * `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.
+    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_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.
 
@@ -28,15 +28,15 @@ The Websocket Callback Object should be a class (or an instance of such class) w
 
 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:
+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(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.
+    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.
 
@@ -54,9 +54,9 @@ The following keywords (both as method names and instance variable names) are re
 
 * 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.
+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.
+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
 

data/ext/iodine/iodine_core.c

@@ -566,7 +566,7 @@ static void *srv_start_no_gvl(void *_) {
                 "utilizing %lu processes.\n  - %s\n"
                 "  - Use the command line option: `-w %lu`\n"
                 "  - Or, within Ruby: `Iodine.processes = %lu`\n",
-        cpu_count, processes,
+        cpu_count, (processes ? processes : 1),
         (processes < cpu_count
              ? "Some CPUs won't be utilized, inhibiting performance."
              : "This causes excessive context switches, wasting resources."),

data/ext/iodine/iodine_http.c

@@ -43,6 +43,9 @@ rack_declare(QUERY_STRING);
 rack_declare(QUERY_ESTRING);
 rack_declare(SERVER_NAME);
 rack_declare(SERVER_PORT);
+rack_declare(SERVER_PROTOCOL);
+rack_declare(HTTP_VERSION);
+rack_declare(REMOTE_ADDR);
 rack_declare(CONTENT_LENGTH);
 rack_declare(CONTENT_TYPE);
 rack_declare(R_URL_SCHEME);          // rack.url_scheme
@@ -78,6 +81,18 @@ static inline VALUE copy2env(http_request_s *request) {
       (request->query
            ? rb_enc_str_new(request->query, request->query_len, BinaryEncoding)
            : QUERY_ESTRING));
+  rb_hash_aset(
+      env, QUERY_STRING,
+      (request->query
+           ? rb_enc_str_new(request->query, request->query_len, BinaryEncoding)
+           : QUERY_ESTRING));
+
+  hname =
+      rb_enc_str_new(request->version, request->version_len, BinaryEncoding);
+  rb_hash_aset(env, SERVER_PROTOCOL, hname);
+  rb_hash_aset(env, HTTP_VERSION, hname);
+
+  // rack_declare(REMOTE_ADDR);
 
   /* setup input IO + hijack support */
   rb_hash_aset(env, R_INPUT, (hname = RackIO.new(request, env)));
@@ -539,16 +554,21 @@ int iodine_http_review(void) {
       fprintf(stderr, "Starting up Iodine Http Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
                       " * %d processes X %d thread%s\n"
+                      " * %d max concurrent connections / open files\n"
                       " * Serving static files from:\n"
                       "           %s\n\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
-              processes, threads, (threads > 1 ? "s" : ""), public_folder);
+              processes, threads, (threads > 1 ? "s" : ""), sock_max_capacity(),
+              public_folder);
     else
       fprintf(stderr, "Starting up Iodine Http Server:\n"
                       " * Ruby v.%s\n * Iodine v.%s \n"
-                      " * %d processes X %d thread%s\n\n",
+                      " * %d processes X %d thread%s\n"
+                      " * %d max concurrent connections / open files\n"
+                      "\n",
               StringValueCStr(ruby_version), StringValueCStr(iodine_version),
-              processes, threads, (threads > 1 ? "s" : ""));
+              processes, threads, (threads > 1 ? "s" : ""),
+              sock_max_capacity());
 
     // listen
     return http1_listen(port, address, .on_request = on_rack_request,
@@ -571,6 +591,9 @@ void Init_iodine_http(void) {
   rack_autoset(SERVER_PORT);
   rack_autoset(CONTENT_LENGTH);
   rack_autoset(CONTENT_TYPE);
+  rack_autoset(SERVER_PROTOCOL);
+  rack_autoset(HTTP_VERSION);
+  rack_autoset(REMOTE_ADDR);
   rack_set(HTTP_SCHEME, "http");
   rack_set(HTTPS_SCHEME, "https");
   rack_set(QUERY_ESTRING, "");

data/ext/iodine/libsock.c

@@ -10,17 +10,18 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include "libsock.h"
 
-#include <string.h>
-#include <stdio.h>
-#include <time.h>
-#include <fcntl.h>
 #include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
 #include <netdb.h>
-#include <sys/types.h>
-#include <sys/socket.h>
+#include <stdio.h>
+#include <string.h>
 #include <sys/mman.h>
-#include <sys/time.h>
 #include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
 
 /* *****************************************************************************
 Use spinlocks "spnlock.h".
@@ -62,7 +63,7 @@ OS Sendfile settings.
 #elif defined(__unix__) /* BSD sendfile should work, but isn't tested */
 #include <sys/uio.h>
 #define USE_SENDFILE 0
-#elif defined(__APPLE__) /* AIs the pple sendfile still broken? */
+#elif defined(__APPLE__) /* Is the apple sendfile still broken? */
 #include <sys/uio.h>
 #define USE_SENDFILE 1
 #else /* sendfile might not be available - always set to 0 */
@@ -130,11 +131,16 @@ ssize_t sock_max_capacity(void) {
   flim = OPEN_MAX;
 #endif
   // try to maximize limits - collect max and set to max
-  struct rlimit rlim;
+  struct rlimit rlim = {0};
   getrlimit(RLIMIT_NOFILE, &rlim);
-  // printf("Meximum open files are %llu out of %llu\n", rlim.rlim_cur,
-  //        rlim.rlim_max);
+// printf("Meximum open files are %llu out of %llu\n", rlim.rlim_cur,
+//        rlim.rlim_max);
+#if defined(__APPLE__) /* Apple's getrlimit is broken. */
+  rlim.rlim_cur = rlim.rlim_max >= OPEN_MAX ? OPEN_MAX : rlim.rlim_max;
+#else
   rlim.rlim_cur = rlim.rlim_max;
+#endif
+
   setrlimit(RLIMIT_NOFILE, &rlim);
   getrlimit(RLIMIT_NOFILE, &rlim);
   // printf("Meximum open files are %llu out of %llu\n", rlim.rlim_cur,
@@ -233,9 +239,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);
-      }
+      // 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

data/lib/iodine/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-07 00:00:00.000000000 Z
+date: 2016-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -200,7 +200,7 @@ requirements:
 - Ruby >= 2.2.2
 - Ruby >= 2.0.0 is recommended.
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Iodine - leveraging C for Ruby servers.