iodine 0.7.32 → 0.7.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1176ef5b01b31595fe7cccdf6cad949354b5f733ae870a1b56be511d21b0a860
-  data.tar.gz: 15d65ddf131dbb20b40d4aceb6709abff2634b9a68c00e2a2f54480cbca1f9da
+  metadata.gz: 430ea5b683f9561e44a9e1b4f6ab56f1b9c6e58637b3ecaae9f414eed58cc1ba
+  data.tar.gz: 17a876d312611ccb0892a9f41b6ae6ca9fa0257b8c78778a7a8edf545f3dc165
 SHA512:
-  metadata.gz: 12e5c3799f8f85ec60f1e5a2c596e88d5fc4f8dd1704a82a9159c4d3a6894ac48d5adcf7f36c8ab346ad764573f361090790dc96938cf4804cd4369cb2879ce6
-  data.tar.gz: 8fedb5972019f22d202d5bad886c01645caadbe864d9b959d2a11f99c70ca038d4d8042b78751c05151da2a516c02f8aeccb05fb8a283d45e533726166cafd88
+  metadata.gz: 3db4b691bae4fe0745c36b4d29a960bfd712e7cb3a29cc9f4e2f357a680f3c325b808bff8720a9f3835d8b0c86c725a0542c0d1800e2c38fd77198ee8f13399d
+  data.tar.gz: 0404f0211d42ece456f46bfa89b945f3c01d1b87770c612e276743aa3a82519b40e6705854f66a5bceb9d9e3fea27fe86ad9081d3a86271e5cccd07f6c6f0df8

data/CHANGELOG.md

@@ -6,6 +6,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.0.7.33
+
+**Fix**: (`iodine`) exception protection would fail and crash if the exception throws wasn't of type `Exception`. I'm not sure how this would happen, but on some Ruby versions it appeared to have occur, maybe where a custom `raise` would be called with a non-exception type. The issue was fixed by testing for the availability of the `message` and `backtrace` functions. Credit to Jan Biedermann (@janbiedermann) for exposing this issue (#76).
+
+**Fix**: (`cli`) the CLI interface no longer requires Rack to be installed. If Rack is installed, it will be used. Otherwise, a copy of the Rack::Builder code will execute, licensed under the MIT license from the Rack source code (Copyright (C) 2007-2019 [Leah Neukirchen](http://leahneukirchen.org/infopage.html)).
+
+**Compatibility**: (`facil`) iodine would raise the signal `SIGINT` when shutting down in cluster mode, even if shutdown was initiated using `Iodine.stop`. Although this was designed to ensure worker processes would stop, this approach caused RSpec to stop testing and report an error. A temporary fix was applied and might be upstreamed to the facil.io repo. Credit to Jan Biedermann (@janbiedermann) for exposing this issue (#76).
+
 #### Change log v.0.7.32
 
 **Fix**: (`http1`) fixes a race-condition between the `on_ready` and `on_data` events, that could result in the `on_data` event being called twice instead of once (only possible with some clients). On multi-threaded workers, this could result in the CPU spinning while the task lock remains busy. Credit to Néstor Coppi (@Shelvak) for exposing the issue and providing an example application with detailed reports. Issue #75.

data/SPEC-WebSocket-Draft.md

@@ -25,6 +25,10 @@ Servers that publish WebSocket and/or EventSource (SSE) support using the `env['
 
 This document reserves the Rack `env` Hash keys of `rack.upgrade?` and `rack.upgrade`.
 
+A conforming server MUST set `env['rack.upgrade?']` to `:websocket` for incoming WebSocket connections and `:sse` for incoming EventSource (SSE) connections.
+
+If a connection is not "upgradable", a conforming server SHOULD set `env['rack.upgrade?']` to either `nil` or `false`. 
+
 The historical use of `upgrade.websocket?` and `upgrade.websocket` (iodine 0.4.x) will be gradually deprecated.
 
 ### The WebSocket / EventSource Callback Object
@@ -82,7 +86,7 @@ The server **MUST** provide the Callback Object with a `client` object, that sup
 
     \*Servers that divide large messages into a number of smaller messages (implement message fragmentation) MAY count each fragment separately, as if the fragmentation was performed by the user and `write` was called more than once per message.
 
-* `env` (iodine specific for now) returns the Rack `env` hash related to the originating HTTP request. Some changes to the `env` hash (such as removal of the IO hijacking support) might be required by the implementation.
+* `env` returns the Rack `env` hash related to the originating HTTP request. Some changes to the `env` hash (such as removal of the IO hijacking support) MAY be implemented by the server.
 
 WebSocket `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.
 

data/examples/shootout.ru

@@ -1,5 +1,6 @@
 require 'iodine'
 require 'json'
+require 'rack'
 
 module ShootoutApp
   # the default HTTP response

data/exe/iodine

@@ -1,11 +1,209 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+require 'iodine'
+
+# Load Rack if available (assume it will be used).
+#
+# Remember, code costs memory. Duplicating the Rack::Builder module and functions can be avoided.
 begin
   require 'rack'
+  module Iodine
+    module Base
+      module Rack
+        Builder = ::Rack::Builder
+      end
+    end
+  end
 rescue LoadError
-  puts "ERROR: the iodine command-line utility requires the gem: rack."
-  exit(0)
+  module Iodine
+    module Base
+      module Rack
+        # The Rack::Builder code is used when Rack isn't available.
+        #
+        # The code was copied (with minor adjustments) from the Rack source code and is licensed under the MIT license.
+        # Copyright (C) 2007-2019 Leah Neukirchen <http://leahneukirchen.org/infopage.html>
+        #
+        # ====
+        #
+        # Rack::Builder implements a small DSL to iteratively construct Rack
+        # applications.
+        #
+        # Example:
+        #
+        #  require 'rack/lobster'
+        #  app = Rack::Builder.new do
+        #    use Rack::CommonLogger
+        #    use Rack::ShowExceptions
+        #    map "/lobster" do
+        #      use Rack::Lint
+        #      run Rack::Lobster.new
+        #    end
+        #  end
+        #
+        #  run app
+        #
+        # Or
+        #
+        #  app = Rack::Builder.app do
+        #    use Rack::CommonLogger
+        #    run lambda { |env| [200, {'Content-Type' => 'text/plain'}, ['OK']] }
+        #  end
+        #
+        #  run app
+        #
+        # +use+ adds middleware to the stack, +run+ dispatches to an application.
+        # You can use +map+ to construct a Rack::URLMap in a convenient way.
+        class Builder
+          # https://stackoverflow.com/questions/2223882/whats-the-difference-between-utf-8-and-utf-8-without-bom
+          UTF_8_BOM = '\xef\xbb\xbf'
+
+          def self.parse_file(config, opts = Hash.new)
+            if config =~ /\.ru$/
+              return self.load_file(config, opts)
+            else
+              require config
+              app = Object.const_get(::File.basename(config, '.rb').split('_').map(&:capitalize).join(''))
+              return app, {}
+            end
+          end
+
+          def self.load_file(path, options = Hash.new)
+            cfgfile = ::File.read(path)
+            cfgfile.slice!(/\A#{UTF_8_BOM}/) if cfgfile.encoding == Encoding::UTF_8
+
+            cfgfile.sub!(/^__END__\n.*\Z/m, '')
+            app = new_from_string cfgfile, path
+
+            return app, options
+          end
+
+          def self.new_from_string(builder_script, file = "(rackup)")
+            eval "Iodine::Base::Rack::Builder.new {\n" + builder_script + "\n}.to_app",
+              TOPLEVEL_BINDING, file, 0
+          end
+
+          def initialize(default_app = nil, &block)
+            @use, @map, @run, @warmup, @freeze_app = [], nil, default_app, nil, false
+            instance_eval(&block) if block_given?
+          end
+
+          def self.app(default_app = nil, &block)
+            self.new(default_app, &block).to_app
+          end
+
+          # Specifies middleware to use in a stack.
+          #
+          #   class Middleware
+          #     def initialize(app)
+          #       @app = app
+          #     end
+          #
+          #     def call(env)
+          #       env["rack.some_header"] = "setting an example"
+          #       @app.call(env)
+          #     end
+          #   end
+          #
+          #   use Middleware
+          #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
+          #
+          # All requests through to this application will first be processed by the middleware class.
+          # The +call+ method in this example sets an additional environment key which then can be
+          # referenced in the application if required.
+          def use(middleware, *args, &block)
+            if @map
+              mapping, @map = @map, nil
+              @use << proc { |app| generate_map(app, mapping) }
+            end
+            @use << proc { |app| middleware.new(app, *args, &block) }
+          end
+
+          # Takes an argument that is an object that responds to #call and returns a Rack response.
+          # The simplest form of this is a lambda object:
+          #
+          #   run lambda { |env| [200, { "Content-Type" => "text/plain" }, ["OK"]] }
+          #
+          # However this could also be a class:
+          #
+          #   class Heartbeat
+          #     def self.call(env)
+          #      [200, { "Content-Type" => "text/plain" }, ["OK"]]
+          #     end
+          #   end
+          #
+          #   run Heartbeat
+          def run(app)
+            @run = app
+          end
+
+          # Takes a lambda or block that is used to warm-up the application.
+          #
+          #   warmup do |app|
+          #     client = Rack::MockRequest.new(app)
+          #     client.get('/')
+          #   end
+          #
+          #   use SomeMiddleware
+          #   run MyApp
+          def warmup(prc = nil, &block)
+            @warmup = prc || block
+          end
+
+          # Creates a route within the application.
+          #
+          #   Rack::Builder.app do
+          #     map '/' do
+          #       run Heartbeat
+          #     end
+          #   end
+          #
+          # The +use+ method can also be used here to specify middleware to run under a specific path:
+          #
+          #   Rack::Builder.app do
+          #     map '/' do
+          #       use Middleware
+          #       run Heartbeat
+          #     end
+          #   end
+          #
+          # This example includes a piece of middleware which will run before requests hit +Heartbeat+.
+          #
+          def map(path, &block)
+            @map ||= {}
+            @map[path] = block
+          end
+
+          # Freeze the app (set using run) and all middleware instances when building the application
+          # in to_app.
+          def freeze_app
+            @freeze_app = true
+          end
+
+          def to_app
+            app = @map ? generate_map(@run, @map) : @run
+            fail "missing run or map statement" unless app
+            app.freeze if @freeze_app
+            app = @use.reverse.inject(app) { |a, e| e[a].tap { |x| x.freeze if @freeze_app } }
+            @warmup.call(app) if @warmup
+            app
+          end
+
+          def call(env)
+            to_app.call(env)
+          end
+
+          private
+
+          def generate_map(default_app, mapping)
+            mapped = default_app ? { '/' => default_app } : {}
+            mapping.each { |r, b| mapped[r] = self.class.new(default_app, &b).to_app }
+            URLMap.new(mapped)
+          end
+        end
+      end
+    end
+  end
 end
-require 'iodine'
 
 module Iodine
   # The Iodine::Base namespace is reserved for internal use and is NOT part of the public API.
@@ -15,7 +213,7 @@ module Iodine
 
       def self.try_file filename
         return nil unless File.exist? filename
-        return ::Rack::Builder.parse_file filename
+        return Iodine::Base::Rack::Builder.parse_file filename
       end
 
       def self.get_app_opts
@@ -36,7 +234,7 @@ module Iodine
           puts "WARNING: Ruby application not found#{ filename ? " - missing both #{filename} and config.ru" : " - missing config.ru"}."
           if Iodine::DEFAULT_SETTINGS[:public]
             puts "         Running only static file service."
-            opt = ::Rack::Server::Options.new.parse!([])
+            opt = Hash.new
             app = Proc.new { [404, {}, "Not Found!"] }
           else
             puts "\nERROR: Couldn't run Ruby application, check command line arguments."
@@ -49,7 +247,7 @@ module Iodine
       end
 
       def self.perform_warmup(app)
-        # load anything marked with `autoload`, since autoload isn't thread safe nor fork friendly.
+        # load anything marked with `autoload`, since autoload is niether thread safe nor fork friendly.
         Iodine.on_state(:on_start) do
           Module.constants.each do |n|
             begin
@@ -57,7 +255,7 @@ module Iodine
             rescue StandardError => _e
             end
           end
-          ::Rack::Builder.new(app) do |r|
+          Iodine::Base::Rack::Builder.new(app) do |r|
             r.warmup do |a|
               client = ::Rack::MockRequest.new(a)
               client.get('/')

data/ext/iodine/fio.c

@@ -3815,7 +3815,7 @@ static void fio_worker_cleanup(void) {
   fio_state_callback_force(FIO_CALL_ON_FINISH);
   fio_defer_perform();
   if (!fio_data->is_worker) {
-    kill(0, SIGINT);
+    fio_cluster_signal_children();
     while (wait(NULL) != -1)
       ;
   }
@@ -6202,7 +6202,7 @@ static void fio_cluster_listen_on_close(intptr_t uuid,
                   (int)getpid());
 #endif
     if (fio_data->active)
-      kill(0, SIGINT);
+      fio_stop();
   }
   (void)uuid;
 }
@@ -6244,7 +6244,6 @@ static void fio_cluster_client_handler(struct cluster_pr_s *pr) {
     break;
   case FIO_CLUSTER_MSG_SHUTDOWN:
     fio_stop();
-    kill(getpid(), SIGINT);
   case FIO_CLUSTER_MSG_ERROR:         /* fallthrough */
   case FIO_CLUSTER_MSG_PING:          /* fallthrough */
   case FIO_CLUSTER_MSG_ROOT:          /* fallthrough */
@@ -6499,7 +6498,7 @@ static void fio_pubsub_on_fork(void) {
 /** Signals children (or self) to shutdown) - NOT signal safe. */
 static void fio_cluster_signal_children(void) {
   if (fio_parent_pid() != getpid()) {
-    kill(getpid(), SIGINT);
+    fio_stop();
     return;
   }
   fio_cluster_server_sender(fio_msg_internal_create(0, FIO_CLUSTER_MSG_SHUTDOWN,

data/ext/iodine/iodine_caller.c

@@ -27,7 +27,8 @@ typedef struct {
 static void *iodine_handle_exception(void *ignr) {
   (void)ignr;
   VALUE exc = rb_errinfo();
-  if (exc != Qnil) {
+  if (exc != Qnil && rb_respond_to(exc, rb_intern("message")) &&
+      rb_respond_to(exc, rb_intern("backtrace"))) {
     VALUE msg = rb_funcall2(exc, rb_intern("message"), 0, NULL);
     VALUE exc_class = rb_class_name(CLASS_OF(exc));
     VALUE bt = rb_funcall2(exc, rb_intern("backtrace"), 0, NULL);
@@ -46,6 +47,9 @@ static void *iodine_handle_exception(void *ignr) {
     rb_backtrace();
     FIO_LOG_ERROR("\n");
     rb_set_errinfo(Qnil);
+  } else if (exc != Qnil) {
+    FIO_LOG_ERROR(
+        "Iodine caught an unprotected exception - NO MESSAGE / DATA AVAILABLE");
   }
   return (void *)Qnil;
 }

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.7.32'.freeze
+  VERSION = '0.7.33'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.7.32
+  version: 0.7.33
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-01 00:00:00.000000000 Z
+date: 2019-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -202,7 +202,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 'Thank you for installing Iodine 0.7.32.
+post_install_message: 'Thank you for installing Iodine 0.7.33.
 
 '
 rdoc_options: []