rage-iodine 1.7.58

data/ext/iodine/websockets.h

@@ -0,0 +1,185 @@
+/*
+copyright: Boaz Segev, 2016-2019
+license: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#ifndef H_WEBSOCKETS_H
+#define H_WEBSOCKETS_H
+
+#include <http.h>
+
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** used internally: attaches the Websocket protocol to the socket. */
+void websocket_attach(intptr_t uuid, http_settings_s *http_settings,
+                      websocket_settings_s *args, void *data, size_t length);
+
+/* *****************************************************************************
+Websocket information
+***************************************************************************** */
+
+/** Returns the opaque user data associated with the websocket. */
+void *websocket_udata_get(ws_s *ws);
+
+/**
+ * Sets the opaque user data associated with the websocket.
+ *
+ * Returns the old value, if any.
+ */
+void *websocket_udata_set(ws_s *ws, void *udata);
+
+/**
+ * Returns the underlying socket UUID.
+ *
+ * This is only relevant for collecting the protocol object from outside of
+ * websocket events, as the socket shouldn't be written to.
+ */
+intptr_t websocket_uuid(ws_s *ws);
+
+/**
+ * Returns 1 if the WebSocket connection is in Client mode (connected to a
+ * remote server) and 0 if the connection is in Server mode (a connection
+ * established using facil.io's HTTP server).
+ */
+uint8_t websocket_is_client(ws_s *ws);
+
+/* *****************************************************************************
+Websocket Connection Management (write / close)
+***************************************************************************** */
+
+/** Writes data to the websocket. Returns -1 on failure (0 on success). */
+int websocket_write(ws_s *ws, fio_str_info_s msg, uint8_t is_text);
+/** Closes a websocket connection. */
+void websocket_close(ws_s *ws);
+
+/* *****************************************************************************
+Websocket Pub/Sub
+=================
+
+API for websocket pub/sub that can be used to publish messages across process
+boundries.
+
+Supports pub/sub engines (see {pubsub.h}) that can connect to a backend service
+such as Redis.
+
+The default pub/sub engine (if `NULL` or unspecified) will publish the messages
+to the process cluster (all the processes in `fio_run`).
+
+To publish to a channel, use the API provided in {pubsub.h}.
+***************************************************************************** */
+
+/** Possible arguments for the {websocket_subscribe} function. */
+struct websocket_subscribe_s {
+  /** the websocket receiving the message. REQUIRED. */
+  ws_s *ws;
+  /** the channel where the message was published. */
+  fio_str_info_s channel;
+  /**
+   * The callback that handles pub/sub notifications.
+   *
+   * Default: send directly to websocket client.
+   */
+  void (*on_message)(ws_s *ws, fio_str_info_s channel, fio_str_info_s msg,
+                     void *udata);
+  /**
+   * An optional cleanup callback for the `udata`.
+   */
+  void (*on_unsubscribe)(void *udata);
+  /** User opaque data, passed along to the notification. */
+  void *udata;
+  /** An optional callback for pattern matching. */
+  fio_match_fn match;
+  /**
+   * When using client forwarding (no `on_message` callback), this indicates if
+   * messages should be sent to the client as binary blobs, which is the safest
+   * approach.
+   *
+   * Default: tests for UTF-8 data encoding and sends as text if valid UTF-8.
+   * Messages above ~32Kb are always assumed to be binary.
+   */
+  unsigned force_binary : 1;
+  /**
+   * When using client forwarding (no `on_message` callback), this indicates if
+   * messages should be sent to the client as text.
+   *
+   * `force_binary` has precedence.
+   *
+   * Default: see above.
+   *
+   */
+  unsigned force_text : 1;
+};
+
+/**
+ * Subscribes to a channel. See {struct websocket_subscribe_s} for possible
+ * arguments.
+ *
+ * Returns a subscription ID on success and 0 on failure.
+ *
+ * All subscriptions are automatically revoked once the websocket is closed.
+ *
+ * If the connections subscribes to the same channel more than once, messages
+ * will be merged. However, another subscription ID will be assigned, since two
+ * calls to {websocket_unsubscribe} will be required in order to unregister from
+ * the channel.
+ */
+uintptr_t websocket_subscribe(struct websocket_subscribe_s args);
+
+#define websocket_subscribe(wbsckt, ...)                                       \
+  websocket_subscribe((struct websocket_subscribe_s){.ws = wbsckt, __VA_ARGS__})
+
+/**
+ * Unsubscribes from a channel.
+ *
+ * Failures are silent.
+ *
+ * All subscriptions are automatically revoked once the websocket is closed. So
+ * only use this function to unsubscribe while the websocket is open.
+ */
+void websocket_unsubscribe(ws_s *ws, uintptr_t subscription_id);
+
+/** Optimize generic broadcasts, for use in websocket_optimize4broadcasts. */
+#define WEBSOCKET_OPTIMIZE_PUBSUB (-32)
+/** Optimize text broadcasts, for use in websocket_optimize4broadcasts. */
+#define WEBSOCKET_OPTIMIZE_PUBSUB_TEXT (-33)
+/** Optimize binary broadcasts, for use in websocket_optimize4broadcasts. */
+#define WEBSOCKET_OPTIMIZE_PUBSUB_BINARY (-34)
+
+/**
+ * Enables (or disables) broadcast optimizations.
+ *
+ * This is performed automatically by the `websocket_subscribe` function.
+ * However, this function is provided for enabling the pub/sub metadata based
+ * optimizations for external connections / subscriptions.
+ *
+ * This function allows enablement (or disablement) of these optimizations:
+ *
+ * * WEBSOCKET_OPTIMIZE_PUBSUB - optimize all direct transmission messages,
+ *                               best attempt to detect Text vs. Binary data.
+ * * WEBSOCKET_OPTIMIZE_PUBSUB_TEXT - optimize direct pub/sub text messages.
+ * * WEBSOCKET_OPTIMIZE_PUBSUB_BINARY - optimize direct pub/sub binary messages.
+ *
+ * Note: to disable an optimization it should be disabled the same amount of
+ * times it was enabled - multiple optimization enablements for the same type
+ * are merged, but reference counted (disabled when reference is zero).
+ *
+ * Note2: The pub/sub metadata type ID will match the optimnization type
+ * requested (i.e., `WEBSOCKET_OPTIMIZE_PUBSUB`) and the optimized data is a
+ * FIOBJ String containing a pre-encoded WebSocket packet ready to be sent.
+ * i.e.:
+ *
+ *     FIOBJ pre_wrapped = (FIOBJ)fio_message_metadata(msg,
+ *                               WEBSOCKET_OPTIMIZE_PUBSUB);
+ *     fiobj_send_free((intptr_t)msg->udata1, fiobj_dup(pre_wrapped));
+ */
+void websocket_optimize4broadcasts(intptr_t type, int enable);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/iodine.gemspec

@@ -0,0 +1,50 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'iodine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rage-iodine'
+  spec.version       = Iodine::VERSION
+  spec.authors       = ['Boaz Segev']
+  spec.email         = ['bo@plezi.io']
+
+  spec.summary       = 'iodine - a fast HTTP / Websocket Server with Pub/Sub support, optimized for Ruby MRI on Linux / BSD / Windows'
+  spec.description   = 'A fast HTTP / Websocket Server with built-in Pub/Sub support (with or without Redis), static file support and many other features, optimized for Ruby MRI on Linux / BSD / macOS / Windows'
+  spec.homepage      = 'https://github.com/rage-rb/iodine'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = %w(lib ext)
+
+  spec.extensions = %w(ext/iodine/extconf.rb)
+
+  spec.required_ruby_version = '>= 2.2.2' # Because earlier versions had been discontinued
+
+  spec.requirements << 'A Unix based system: Linux / macOS / BSD.'
+  spec.requirements << 'An updated C compiler.'
+  spec.requirements << 'Ruby >= 2.3.8 (Ruby EOL).'
+  spec.requirements << 'Ruby >= 2.5.0 recommended.'
+  spec.requirements << 'TLS requires OpenSSL >= 1.1.0.'
+  spec.requirements << 'Or Windows with Ruby >= 3.0.0 build with MingW and MingW as compiler.'
+
+  # spec.add_development_dependency 'bundler', '>= 1.10', '< 2.0'
+  spec.add_development_dependency 'rake', '>= 12.0', '< 14.0'
+  spec.add_development_dependency 'minitest', '>=5', '< 6.0'
+  spec.add_development_dependency 'rspec', '>=3.9.0', '< 4.0'
+  spec.add_development_dependency 'spec', '>=5.3.0', '< 6.0'
+  spec.add_development_dependency 'rake-compiler', '>= 1', '< 2.0'
+
+  spec.post_install_message = "Thank you for installing Iodine #{Iodine::VERSION}.\n" +
+                              "Remember: if iodine supports your business, it's only fair to give value back (code contributions / donations)."
+end

data/lib/iodine/connection.rb

@@ -0,0 +1,61 @@
+module Iodine
+
+  # The default connection settings used by {Iodine.listen} and {Iodine.connect}.
+  #
+  # It's a Hash object that allows Iodine default values to be manipulated. i.e.:
+  #
+  #       DEFAULT_SETTINGS[:port] = "8080" # replaces the default port, which is `ENV["port"] || "3000"`.
+  DEFAULT_SETTINGS = {}
+
+  # @deprecated use {Iodine::DEFAULT_SETTINGS}.
+  #
+  # The default connection settings used by {Iodine.listen} and {Iodine.connect}.
+  DEFAULT_HTTP_ARGS = DEFAULT_SETTINGS
+
+  # Iodine's {Iodine::Connection} class is the class that TCP/IP, WebSockets and SSE connections inherit from.
+  #
+  # Instances of this class are passed to the callback objects. i.e.:
+  #
+  #     module MyConnectionCallbacks
+  #
+  #       # called when the callback object is linked with a new client
+  #       def on_open client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #
+  #       # called when data is available
+  #       def on_message client, data
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #
+  #       # called when the server is shutting down, before closing the client
+  #       # (it's still possible to send messages to the client)
+  #       def on_shutdown client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #
+  #       # called when the client is closed (no longer available)
+  #       def on_close client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #
+  #       # called when all the previous calls to `client.write` have completed
+  #       # (the local buffer was drained and is now empty)
+  #       def on_drained client
+  #          client.is_a?(Iodine::Connection) # => true
+  #       end
+  #
+  #       # called when timeout was reached, llowing a `ping` to be sent
+  #       def ping client
+  #          client.is_a?(Iodine::Connection) # => true
+  #          clint.close() # close connection on timeout is the default
+  #       end
+  #
+  #       # Allows the module to be used as a static callback object (avoiding object allocation)
+  #       extend self
+  #     end
+  #
+  # All connection related actions can be performed using the methods provided through this class.
+	class Connection
+	end
+end

data/lib/iodine/json.rb

@@ -0,0 +1,42 @@
+module Iodine
+  # Iodine includes a lenient JSON parser that attempts to ignore JSON errors when possible and adds some extensions such as Hex numerical representations and comments.
+  #
+  # Depending on content (specifically, the effects of float number parsing), the Iodine JSON parser speed varies.
+  #
+  # On my system, Iodine is about 20%-30% faster than Ruby MRI's parser (Ruby version 2.5.1 vs. Iodine version 0.7.4). When using symbols the speed increase is even higher (50%-90% faster).
+  #
+  # It's easy to monkey-patch the system's `JSON.parse` method (not the `JSON.parse!` method) by using `Iodine.patch_json`.
+  #
+  # You can benchmark the Iodine JSON performance and decide if you wish to monkey-patch the Ruby implementation.
+  #
+  #      JSON_FILENAME="foo.json"
+  #
+  #      require 'json'
+  #      require 'iodine'
+  #      TIMES = 100
+  #      STR = IO.binread(JSON_FILENAME); nil
+  #
+  #      JSON.parse(STR) == Iodine::JSON.parse(STR) # => true
+  #      JSON.parse!(STR) == Iodine::JSON.parse!(STR) # => undefined, maybe true maybe false
+  #
+  #      # warm-up
+  #      TIMES.times { JSON.parse STR }
+  #      TIMES.times { Iodine::JSON.parse STR }
+  #
+  #      puts ""; Benchmark.bm do |b|
+  #        sys = b.report("system") { TIMES.times { JSON.parse STR } }
+  #        sys_sym = b.report("system-sym") { TIMES.times { JSON.parse STR, symbolize_names: true } }
+  #        iodine = b.report("iodine") { TIMES.times { Iodine::JSON.parse STR } }
+  #        iodine_sym = b.report("iodine-sym") { TIMES.times { Iodine::JSON.parse STR, symbolize_names: true } }
+  #
+  #        puts "----------------------------"
+  #        puts "Iodine::JSON speed as percent of Ruby's native JSON:"
+  #        puts "normal:    #{sys/iodine}"
+  #        puts "symolized: #{sys_sym/iodine_sym}"
+  #      end; nil
+  #
+  # Note that the bang(!) method should NOT be used for monkey-patching the default JSON parser, since some important features are unsupported by the Iodine parser.
+  #
+  module JSON
+  end
+end

data/lib/iodine/mustache.rb

@@ -0,0 +1,113 @@
+module Iodine
+  # Iodine includes a safe and fast Mustache templating engine.
+  #
+  # The engine is simpler and safer to use (and often faster) than the official and feature richer Ruby engine.
+  #
+  # Note: {Iodine::Mustache} behaves differently than the official Ruby templating engine in a number of ways:
+  #
+  # * When a partial template can't be found, a `LoadError` exception is raised (the official implementation outputs an empty String).
+  #
+  # * HTML escaping is more agressive, increasing XSS protection. Read why at: https://wonko.com/post/html-escaping .
+  #
+  # * Partial template padding in Iodine adds padding to dynamic text as well as static text, unlike the official Ruby mustache engine. i.e., if an argument contains a new line marker, the new line will be padded to match the partial template padding.
+  #
+  # * Lambda support is significantly different. For example, the text returned from a lambda isn't parsed (no lambda interpolation).
+  #
+  # * Dot notation is tested in whole as well as in part (i.e. `user.name.first` will be tested as is, than the couplet `"user","name.first"` and than as each `"use","name","first"`), allowing for the Hash data to contain keys with dots while still supporting dot notation shortcuts.
+  #
+  # * Dot notation supports method names (even chained method names) as long as they don't have or require arguments. For example, `user.class.to_s` will behave differently on Iodine (returns call name as `String`) than on the official mustache engine (fails / returns empty string).
+  #
+  # Iodine Mustache's engine was designed to play best with basic data structures, such as results from the {Iodine::JSON} parser and doesn't require any special classes or types.
+  #
+  # Hash data is tested for Symbol keys before being tested for String keys and methods. This means that `:key` has precedence over `"key"`.
+  #
+  # Note: Although using methods as "keys" (or argument names) is supported, no Ruby code is evaluated. This means that only trusted (pre-existing) code will execute.
+  #
+  # Iodine's {Iodine::Mustache} engine performes about 5-7 times faster(!) than the official Ruby mustache engine. Tests performed with Ruby 2.6.0, comparing iodine 0.7.33 against mustache 1.1.0 using a 2.9 GHz Intel Core i9 CPU.
+  #
+  # You can benchmark the Iodine Mustache performance and decide if you wish to switch from the official Ruby implementation.
+  #
+  #     require 'benchmark/ips'
+  #     require 'mustache'
+  #     require 'iodine'
+  #
+  #     # Benchmark code was copied, in part, from:
+  #     #   https://github.com/mustache/mustache/blob/master/benchmarks/render_collection_benchmark.rb
+  #     # The test is, sadly, biased and doesn't test for missing elements, proc/method resolution or template partials.
+  #     def benchmark_mustache
+  #       template = """
+  #       {{#products}}
+  #         <div class='product_brick'>
+  #           <div class='container'>
+  #             <div class='element'>
+  #               <img src='images/{{image}}' class='product_miniature' />
+  #             </div>
+  #             <div class='element description'>
+  #               <a href={{url}} class='product_name block bold'>
+  #                 {{external_index}}
+  #               </a>
+  #             </div>
+  #           </div>
+  #         </div>
+  #       {{/products}}
+  #       """
+  #
+  #       IO.write "test_template.mustache", template
+  #       filename = "test_template.mustache"
+  #
+  #       data_1000 = {
+  #         products: []
+  #       }
+  #       data_1000_escaped = {
+  #         products: []
+  #       }
+  #
+  #       1000.times do
+  #         data_1000[:products] << {
+  #           :external_index=>"product",
+  #           :url=>"/products/7",
+  #           :image=>"products/product.jpg"
+  #         }
+  #         data_1000_escaped[:products] << {
+  #           :external_index=>"This <product> should've been \"properly\" escaped.",
+  #           :url=>"/products/7",
+  #           :image=>"products/product.jpg"
+  #         }
+  #       end
+  #
+  #       view = Mustache.new
+  #       view.template = template
+  #       view.render # Call render once so the template will be compiled
+  #       iodine_view = Iodine::Mustache.new(template: template)
+  #
+  #       Benchmark.ips do |x|
+  #         x.report("Ruby Mustache render list of 1000") do |times|
+  #           view.render(data_1000)
+  #         end
+  #         x.report("Iodine::Mustache render list of 1000") do |times|
+  #           iodine_view.render(data_1000)
+  #         end
+  #
+  #         x.report("Ruby Mustache render list of 1000 with escaped data") do |times|
+  #           view.render(data_1000_escaped)
+  #         end
+  #         x.report("Iodine::Mustache render list of 1000 with escaped data") do |times|
+  #           iodine_view.render(data_1000_escaped)
+  #         end
+  #
+  #         x.report("Ruby Mustache - no caching - render list of 1000") do |times|
+  #           tmp = Mustache.new
+  #           tmp.template = template
+  #           tmp.render(data_1000)
+  #         end
+  #         x.report("Iodine::Mustache - no caching - render list of 1000") do |times|
+  #           Iodine::Mustache.render(nil, data_1000, template)
+  #         end
+  #       end
+  #       nil
+  #     end
+  #
+  #     benchmark_mustache
+  class Mustache
+  end
+end

data/lib/iodine/pubsub.rb

@@ -0,0 +1,55 @@
+module Iodine
+   # Iodine is equiped with an internal pub/sub service that allows improved resource management from a deployment perspective.
+   #
+   # @note From {https://en.wikipedia.org/wiki/Publish–subscribe_pattern Wikipedia}: publish–subscribe is a messaging pattern where senders of messages, called publishers, do not program the messages to be sent directly to specific receivers, called subscribers, but instead characterize published messages into classes without knowledge of which subscribers, if any, there may be. Similarly, subscribers express interest in one or more classes and only receive messages that are of interest, without knowledge of which publishers, if any, there are.
+   #
+   # The common paradigm, which is implemented by pub/sub services like Redis,
+   # is for a "client" to "subscribe" to one or more "channels". Messages are streamed
+   # to these "channels" by different "publishers" (the application / other clients) and are
+   # broadcasted to the "clients" through their "subscription".
+   #
+   # Iodine's approach it to offload pub/sub resource costs from the pub/sub service
+   # (which is usually expensive to scale) onto the application layer.
+   #
+   # For example, the default (`nil`) pub/sub {Iodine::PubSub::Engine} implements
+   # an internal pub/sub service that manages subscriptions (clients and channels) throughout an Iodine process cluster without any need to connect to an external pub/sub service.
+   #
+   # If Iodine was runninng with 8 processes and 16 threads per process,
+   # a publishing in process A will be delivered to subscribers in process B.
+   #
+   # In addition, by inheriting the {Iodine::PubSub::Engine} class, it's easy to create pub/sub engines that connect to this
+   # underlying pub/sub service. This means that Iodine will call the engine's `subscribe` method only once per
+   # channel and once messages arrive, Iodine will distribute the messages to all the subscribed clients.
+  module PubSub
+    # The {Iodine::PubSub::Engine} class makes it easy to use leverage Iodine's pub/sub system using external services.
+    #
+    # Iodine comes with two built-in engines:
+    #
+    # * `Iodine::PubSub::Engine::CLUSTER` will distribute messages to all subscribers in the process cluster.
+    # * `Iodine::PubSub::Engine::PROCESS` will distribute messages to all subscribers sharing the same process.
+    #
+    # It's recommended that {Iodine::PubSub::Engine} instances be initialized only after Iodine
+    # started running (or the `fork`ing of the engine's connection will introduce communication issues).
+    #
+    # For this reason, the best approcah to initialization would be:
+    #
+    #       class MyEngineClass < Iodine::PubSub::Engine
+    #            # ...
+    #       end
+    #
+    #       Iodine.run do
+    #          MyEngine = MyEngineClass.new
+    #       end
+    #
+    # {Iodine::PubSub::Engine} child classes MUST override the {Iodine::PubSub::Engine#subscribe}, {Iodine::PubSub::Engine#unsubscribe} and {Iodine::PubSub::Engine#publish}
+    # in order to perform this actions using the backend service (i.e. using Redis).
+    #
+    # Once an {Iodine::PubSub::Engine} instance receives a message from the backend service,
+    # it should forward the message to the Iodine distribution layer using the {Iodine.publish} method, setting the 3rd argument to `false`.
+    #
+    # Iodine will than distribute the message to all registered clients in that specific process (if the engine is cluster wide, set the 3rd argument to {Iodine::PubSub::CLUSTER}.
+    #
+    class Engine
+    end
+  end
+end

data/lib/iodine/rack_utils.rb

@@ -0,0 +1,43 @@
+module Iodine
+  # Iodine's {Iodine::Rack} module provides a Rack complient interface (connecting Iodine to Rack) for an HTTP and Websocket Server.
+	module Rack
+		# The methods in this module are designed to be Rack compatible and to provide higher performance than the original Rack methods.
+		#
+		# Iodine does NOT monkey patch Rack automatically. However, it's possible and recommended to moneky patch Rack::Utils to use the methods in this module.
+    #
+		# Choosing to monkey patch Rack::Utils could offer significant performance gains for some applications. i.e. (on my machine):
+		#
+		#       require 'iodine'
+		#       require 'rack'
+		#       # a String in need of decoding
+		#       s = '%E3%83%AB%E3%83%93%E3%82%A4%E3%82%B9%E3%81%A8'
+		#       Benchmark.bm do |bm|
+		#         # Pre-Patch
+		#         bm.report("   Rack.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
+		#         bm.report("    Rack.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
+		#         bm.report("    Rack.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
+		#         # Perform Patch
+		#         Iodine.patch_rack
+		#         puts "            --- Monkey Patching Rack ---"
+		#         # Post Patch
+		#         bm.report("Patched.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
+		#         bm.report(" Patched.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
+		#         bm.report(" Patched.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
+		#       end && nil
+		#
+		# Results:
+		#
+		#         user     system      total        real
+		#         Rack.unescape  8.706881   0.019995   8.726876 (  8.740530)
+		#         Rack.rfc2822  3.270305   0.007519   3.277824 (  3.279416)
+		#         Rack.rfc2109  3.152188   0.003852   3.156040 (  3.157975)
+		#                    --- Monkey Patching Rack ---
+		#         Patched.unescape  0.327231   0.003125   0.330356 (  0.337090)
+		#         Patched.rfc2822  0.691304   0.003330   0.694634 (  0.701172)
+		#         Patched.rfc2109  0.685029   0.001956   0.686985 (  0.687607)
+		#
+		# Iodine uses the same code internally for HTTP timestamping (adding missing `Date` headers) and logging.
+		module Utils
+		end
+	end
+end

data/lib/iodine/tls.rb

@@ -0,0 +1,16 @@
+module Iodine
+  # Iodine's {Iodine::TLS} instances hold SSL/TLS settings for secure connections.
+  #
+  # This allows both secure client connections and secure server connections to be established.
+  #
+  #     tls = Iodine::TLS.new "localhost" # self-signed certificate
+  #     Iodine.listen service: "http", handler: APP, tls: tls
+  #
+  # Iodine abstracts away the underlying SSL/TLS library to minimize the risk of misuse and insecure settings.
+  #
+  # Calling TLS methods when no SSL/TLS library is available should result in iodine crashing. This is expected behavior.
+  #
+  # At the moment, only OpenSSL is supported. BearSSL support is planned.
+	class TLS
+	end
+end

data/lib/iodine/version.rb

@@ -0,0 +1,3 @@
+module Iodine
+  VERSION = '1.7.58'.freeze
+end