iodine 0.7.40 → 0.7.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e0b09518eec222b16c1740793a825c123672f3f027c7182c7fc021c9894136d
-  data.tar.gz: 0cf02ed5b0a11526dadf984f7d58accc434c896aa011ed3f3319f418df80c73b
+  metadata.gz: 03af29c680fee3cd7b70b4a9fbc0f370b42a763f83f4422cc0f1cae296b95f1c
+  data.tar.gz: b6e25d8cc33dd955989ae6c8f6bf18d45f84dad42887eff22f39c68aada56f02
 SHA512:
-  metadata.gz: 6bbcc4ffb71aaed9efef0549b91b4da786672b000ec3b14e87106ad65421a28fe36b415ef0a0f02b9da1620c7ef057abba50e93e88bea37bc82c26a2728fd793
-  data.tar.gz: bfcd03eda1096833ab4315935f435f9891349830db493a74d570c7830505a4e43d5b6c6f0d143273ddb83a076174183888b4f8173dc421c23e12a645edf2006b
+  metadata.gz: b4eab8d5f7309dd8845d4f6c8052935dbd8145201c4820786ae000e895277883765c1dd628c1e053816b50a1d7c002180f6b4e0a5833e60d76277dab8ecf81b1
+  data.tar.gz: f90eb620cf2a9aaf7c943fe981e829f698cb1e8fc176ad8ad778df2c36c5eb026314522d428bee8058915e95f9ed3750ed078931193b81b0dec062e27eb569c2

data/.travis.yml

@@ -1,4 +1,7 @@
 language: ruby
+arch:
+  - amd64
+  - arm64
 os:
   - linux
   # - osx
@@ -6,6 +9,7 @@ before_install:
   - gem install bundler -v 1.10.6
   - bundle install
 rvm:
+  - 2.7.1
   - 2.6.5
   - 2.5.7
   - 2.4.9
@@ -14,7 +18,7 @@ rvm:
 notifications:
   email: false
 sudo: required
-dist: trusty
+dist: xenial
 addons:
   apt:
     sources:
@@ -24,8 +28,5 @@ addons:
 script:
   - echo CFLAGS = $CFLAGS
   - echo cflags = $cflags
-  - bundle exec rake compile
+  - bundle exec rake install
   - env VERBOSE=1 bundle exec rspec --format documentation
-  - gem uninstall -x iodine
-  - rake build
-  - find pkg/iodine-*.gem -exec gem install -V {} +

data/CHANGELOG.md

@@ -6,6 +6,12 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.41 (2020-07-24)
+
+**Fix**: Hot Restart failed because listening sockets were cleared away. Credit to Néstor Coppi (@Shelvak) for exposing issue #97.
+
+**Fix**: CLI argument parsing is now only active when using the iodine CLI (or if defining `IODINE_PARSE_CLI` before requiring `iodine`). Credit to Aldis Berjoza (@graudeejs) for exposing issue #96.
+
 #### Change log v.0.7.40 (2020-05-23)
 
 **Fix**: fixed TLS logging and performance issues exposed by Franck Gille (@fgi) in issue #93.

data/README.md

@@ -19,14 +19,15 @@ Iodine includes native support for:
 * Pub/Sub (with optional Redis Pub/Sub scaling);
 * Fast(!) builtin Mustache template engine.
 * Static file service (with automatic `gzip` support for pre-compressed assets);
+* Optimized Logging to `stderr`.
 * Asynchronous event scheduling and timers;
 * HTTP/1.1 keep-alive and pipelining;
+* Heap Fragmentation Protection.
 * TLS 1.2 and above (Requires OpenSSL >= 1.1.0);
 * TCP/IP server and client connectivity;
 * Unix Socket server and client connectivity;
-* Hot Restart (using the USR1 signal);
+* Hot Restart (using the USR1 signal and without hot deployment);
 * Custom protocol authoring;
-* Optimized Logging to `stderr`.
 * [Sequel](https://github.com/jeremyevans/sequel) and ActiveRecord forking protection.
 * and more!
 
@@ -48,6 +49,10 @@ With `Iodine.listen service: :http` it's possible to run multiple HTTP applicati
 
 Iodine also supports native process cluster Pub/Sub and a native RedisEngine to easily scale iodine's Pub/Sub horizontally.
 
+### Known Issues and Reporting Issues
+
+See the [GitHub Open Issues](https://github.com/boazsegev/iodine/issues) list for known issues and to report new issues.
+
 ### Installing and Running Iodine
 
 Install iodine on any Linux / BSD / macOS system using:
@@ -70,6 +75,8 @@ bundler exec iodine
 
 #### Installing with SSL/TLS
 
+**Note**: iodine has known issues with the TLS/SSL support. TLS/SSL should **NOT** be used in production (see issues #95 and #94).
+
 Make sure to update OpenSSL to the latest version **before installing Ruby** (`rbenv` should do this automatically).
 
 To avoid name resolution conflicts, iodine will bind to the same OpenSSL version Ruby is bound to. To use SSL/TLS this should be OpenSSL >= 1.1.0 or LibreSSL >= 2.7.4.
@@ -87,9 +94,7 @@ Confirmed OpenSSL to be version 1.1.0 or above (OpenSSL 1.1.0j  20 Nov 2018)...
 ...
 ```
 
-**KNOWN ISSUE:**
-
-The installation script tests for OpenSSL 1.1.0 and above. However, this testing approach sometimes provides false positives. If TLS isn't required, install with `NO_SSL=1`. i.e.:
+The installation script tests for OpenSSL 1.1.0 and above. However, this testing approach sometimes provides false positives. **If TLS isn't required, install with `NO_SSL=1`**. i.e.:
 
 ```bash
 NO_SSL=1 bundler exec iodine
@@ -110,17 +115,19 @@ On Rails:
     if(defined?(Iodine))
       Iodine.threads = ENV.fetch("RAILS_MAX_THREADS", 5).to_i if Iodine.threads.zero?
       Iodine.workers = ENV.fetch("WEB_CONCURRENCY", 2).to_i if Iodine.workers.zero?
-      Iodine::DEFAULT_SETTINGS[:port] = ENV.fetch("PORT") if ENV.fetch("PORT")
+      Iodine::DEFAULT_SETTINGS[:port] ||= ENV.fetch("PORT") if ENV.fetch("PORT")
     end
     ```
 
 When using native WebSockets with Rails, middle-ware is probably the best approach. A guide for this approach will, hopefully, get published in the future.
 
+**Note**: command-line instructions (CLI) should be the preferred way for configuring iodine, allowing for code-less configuration updates.
+
 ### Optimizing Iodine's Concurrency
 
 To get the most out of iodine, consider the amount of CPU cores available and the concurrency level the application requires.
 
-Iodine will calculate, when possible, a good enough default concurrency model. See if this works for your application or customize according to the application's needs.
+Iodine will calculate, when possible, a good enough default concurrency model for fast applications. See if this works for your application or customize according to the application's needs.
 
 Command line arguments allow easy access to different options, including concurrency levels. i.e., to set up 16 threads and 4 processes:
 
@@ -136,13 +143,19 @@ export WORKERS=-1 # negative values are fractions of CPU cores.
 bundler exec iodine -p $PORT
 ```
 
+Negative values are evaluated as "CPU Cores / abs(Value)". i.e., on an 8 core CPU machine, this will produce 4 worker processes with 2 threads per worker:
+
+```bash
+bundler exec iodine -p $PORT -t 2 -w -2
+```
+
 ### Heap Fragmentation Protection
 
 Iodine includes a fast, network oriented, custom memory allocator, optimizing away some of the work usually placed on the Ruby Garbage Collector (GC).
 
 This approach helps to minimize heap fragmentation for long running processes, by grouping many short-lived objects into a common memory space.
 
-It's still recommended to consider [jemalloc](http://jemalloc.net) or other allocators that also help mitigate heap fragmentation issues.
+It is still recommended to consider [jemalloc](http://jemalloc.net) or other allocators that also help mitigate heap fragmentation issues.
 
 ### Static file serving support
 
@@ -435,11 +448,11 @@ Iodine.connect url: "wss://echo.websocket.org", handler: EchoClient.new, ping: 4
 Iodine.start
 ```
 
-### TLS 1.2 support
+### TLS >= 1.2 support
 
 >  Requires OpenSSL >= `1.1.0`. On Heroku, requires `heroku-18`.
 
-Iodine supports secure connections fore TLS version 1.2 and up (depending on the OpenSSL version).
+Iodine supports secure connections fore TLS version 1.2 **and up** (depending on the OpenSSL version).
 
 A self signed certificate is available using the `-tls` flag from the command-line.
 
@@ -480,31 +493,11 @@ run APP
 
 ### How does it compare to other servers?
 
-The honest answer is "I don't know". I recommend that you perform your own tests.
-
-In my tests, pitching Iodine against Puma, Iodine was anywhere between x1.5 and x7 faster than Puma (depending on use-case). such a big difference is suspect and I recommend that you test it yourself.
+In my tests, pitching Iodine against Puma, Iodine was anywhere between x1.5 and more than x10 faster than Puma (depending on use-case and settings).
 
-Also, performing benchmarks on a single machine isn't very reliable... but it's all I've got.
+Such a big difference is suspect and I recommend that you test it yourself - even better if you test performance using your own application and a number of possible different settings (how many threads per CPU core? how many worker processes? middleware vs. server request logging, etc').
 
-When benchmarking with `wrk`, on the same local machine with similar settings for both Puma and Iodine (4 workers, 16 threads each, 200 concurrent connections), I calculated Iodine to be x1.52 faster::
-
-* Iodine performed at 74,786.27 req/sec, consuming ~68.4Mb of memory.
-
-* Puma performed at 48,994.59 req/sec, consuming ~79.6Mb of memory.
-
-When benchmarking using a VM (crossing machine boundaries, 16 threads, 4 workers, 200 concurrent connections), I calculated Iodine to be x2.3 faster:
-
-* Iodine performed at 23,559.56 req/sec, consuming ~88.8Mb of memory.
-
-* Puma performed at 9,935.31 req/sec, consuming ~84.0Mb of memory.
-
-When benchmarking using a VM (crossing machine boundaries, single thread, single worker, 200 concurrent connections), I calculated Iodine to be x7.3 faster:
-
-* Iodine performed at 18,444.31 req/sec, consuming ~25.6Mb of memory.
-
-* Puma performed at 2,521.56 req/sec, consuming ~27.5Mb of memory.
-
-I have doubts about my own benchmarks and I recommend benchmarking the performance for yourself using `wrk` or `ab`:
+I recommend benchmarking the performance for yourself using `wrk` or `ab`:
 
 ```bash
 $ wrk -c200 -d4 -t2 http://localhost:3000/
@@ -512,7 +505,7 @@ $ wrk -c200 -d4 -t2 http://localhost:3000/
 $ ab -n 100000 -c 200 -k http://127.0.0.1:3000/
 ```
 
-Create a simple `config.ru` file with a hello world app:
+The best application to use for benchmarking is your actual application. Or, you could create a simple `config.ru` file with a __hello world__ app:
 
 ```ruby
 App = Proc.new do |env|
@@ -525,17 +518,21 @@ end
 run App
 ```
 
-Then start comparing servers. Here are the settings I used to compare iodine and Puma (4 processes, 16 threads):
+Then start comparing servers. Here are the settings I used to compare iodine and Puma (4 processes, 4 threads):
 
 ```bash
-$ RACK_ENV=production iodine -p 3000 -t 16 -w 4
+$ RACK_ENV=production iodine -p 3000 -t 4 -w 4
 # vs.
-$ RACK_ENV=production puma -p 3000 -t 16 -w 4
+$ RACK_ENV=production puma -p 3000 -t 4 -w 4
 # Review the `iodine -?` help for more command line options.
 ```
 
 It's recommended that the servers (Iodine/Puma) and the client (`wrk`/`ab`) run on separate machines.
 
+It is worth noting that iodine can also speed up logging by replacing the logging middleware with `iodine -v`. This approach uses less memory and improves performance at the expense of fuzzy timing and some string caching.
+
+On my machine, testing with the logging functionality enabled, iodine was more then 10 times faster than puma (60.9K req/sec vs. 5.3K req/sec)
+
 ### A few notes
 
 Iodine's upgrade / callback design has a number of benefits, some of them related to better IO handling, resource optimization (no need for two IO polling systems), etc. This also allows us to use middleware without interfering with connection upgrades and provides backwards compatibility.

data/exe/iodine

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
+IODINE_PARSE_CLI = true
 require 'iodine'
 
 # Load Rack if available (assume it will be used).

data/ext/iodine/fio.c

@@ -36,6 +36,12 @@ Feel free to copy, use and enjoy according to the license provided.
 
 #include <arpa/inet.h>
 
+#if HAVE_OPENSSL
+#include <openssl/bio.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#endif
+
 /* force poll for testing? */
 #ifndef FIO_ENGINE_POLL
 #define FIO_ENGINE_POLL 0
@@ -3492,11 +3498,13 @@ static void fio_on_fork(void) {
   fio_poll_init();
   fio_state_callback_on_fork();
 
+  /* don't pass open connections belonging to the parent onto the child. */
   const size_t limit = fio_data->capa;
   for (size_t i = 0; i < limit; ++i) {
     fd_data(i).sock_lock = FIO_LOCK_INIT;
     fd_data(i).protocol_lock = FIO_LOCK_INIT;
-    if (fd_data(i).protocol) {
+    if (fd_data(i).protocol && fd_data(i).open) {
+      /* open without protocol might be waiting for the child (listening) */
       fd_data(i).protocol->rsv = 0;
       fio_force_close(fd2uuid(i));
     }
@@ -3678,8 +3686,9 @@ static void fio_review_timeout(void *arg, void *ignr) {
   unlock:
     protocol_unlock(tmp, FIO_PR_LOCK_STATE);
   } else {
-    /* open FD but no protocol? */
-    fio_close(fd2uuid(fd));
+    /* open FD but no protocol? RW hook thing or listening sockets? */
+    if (fd_data(fd).rw_hooks != &FIO_DEFAULT_RW_HOOKS)
+      fio_close(fd2uuid(fd));
   }
 finish:
   do {
@@ -3908,16 +3917,22 @@ void fio_start FIO_IGNORE_MACRO(struct fio_start_args args) {
   fio_data->is_worker = 0;
 
   fio_state_callback_force(FIO_CALL_PRE_START);
-
   FIO_LOG_INFO(
       "Server is running %u %s X %u %s with facil.io " FIO_VERSION_STRING
       " (%s)\n"
+#if HAVE_OPENSSL
+      "* Linked to %s\n"
+#endif
       "* Detected capacity: %d open file limit\n"
       "* Root pid: %d\n"
       "* Press ^C to stop\n",
       fio_data->workers, fio_data->workers > 1 ? "workers" : "worker",
       fio_data->threads, fio_data->threads > 1 ? "threads" : "thread",
-      fio_engine(), fio_data->capa, (int)fio_data->parent);
+      fio_engine(),
+#if HAVE_OPENSSL
+      OpenSSL_version(0),
+#endif
+      fio_data->capa, (int)fio_data->parent);
 
   if (args.workers > 1) {
     for (int i = 0; i < args.workers && fio_data->active; ++i) {

data/lib/iodine.rb

@@ -178,7 +178,7 @@ Iodine.on_state(:after_fork)  do
 end
 
 ### Parse CLI for default HTTP settings
-Iodine::Base::CLI.parse
+Iodine::Base::CLI.parse if defined?(IODINE_PARSE_CLI) && IODINE_PARSE_CLI
 
 ### Set default port (if missing)
 Iodine::DEFAULT_SETTINGS[:port] ||= (ENV["PORT"] || "3000")

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.40'.freeze
+  VERSION = '0.7.41'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.40
+  version: 0.7.41
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-23 00:00:00.000000000 Z
+date: 2020-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -243,7 +243,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
 post_install_message: |-
-  Thank you for installing Iodine 0.7.40.
+  Thank you for installing Iodine 0.7.41.
   Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations).
 rdoc_options: []
 require_paths: