iodine 0.7.59 → 0.8.0

data/lib/iodine/version.rb

@@ -1,3 +1,19 @@
+# frozen_string_literal: true
+
 module Iodine
-  VERSION = '0.7.59'.freeze
+  # The Iodine gem version number
+  VERSION = "0.8.0"
+  # NeoRack supported extensions.
+  def self.extensions
+    return (@extensions ||= { iodine:   (VERSION.split(?.).map() {|i| i.to_i.to_s == i ? i.to_i : i }),
+                              neo_rack: "0.0.4".split(?.).map(&:to_i),
+                              cookies:  "0.0.2".split(?.).map(&:to_i),
+                              from:     "0.0.2".split(?.).map(&:to_i),
+                              pubsub:   "0.0.2".split(?.).map(&:to_i),
+                              rack:     "1.3.0".split(?.).map(&:to_i),
+                              rest:     "0.0.2".split(?.).map(&:to_i),
+                              sse:      "0.0.2".split(?.).map(&:to_i),
+                              ws:       "0.0.2".split(?.).map(&:to_i)
+                            })
+  end
 end

data/lib/iodine.rb

@@ -1,278 +1,77 @@
+# frozen_string_literal: true
+
 require 'stringio' # Used internally as a default RackIO
 require 'socket'  # TCPSocket is used internally for Hijack support
-# require 'openssl' # For SSL/TLS support using OpenSSL
-
-require_relative './iodine/version'
-require_relative './iodine/iodine_ext' # loading a binary C extension
-
-# Iodine is an HTTP / WebSocket server as well as an Evented Network Tool Library. In essense, Iodine is a Ruby port for the [facil.io](http://facil.io) C library.
-#
-# Here is a simple telnet based echo server using Iodine (see full list at {Iodine::Connection}):
-#
-#
-#       require 'iodine'
-#       # define the protocol for our service
-#       module EchoProtocol
-#         def on_open(client)
-#           # Set a connection timeout
-#           client.timeout = 10
-#           # Write a welcome message
-#           client.write "Echo server running on Iodine #{Iodine::VERSION}.\r\n"
-#         end
-#         # this is called for incoming data - note data might be fragmented.
-#         def on_message(client, data)
-#           # write the data we received
-#           client.write "echo: #{data}"
-#           # close the connection when the time comes
-#           client.close if data =~ /^bye[\n\r]/
-#         end
-#         # called if the connection is still open and the server is shutting down.
-#         def on_shutdown(client)
-#           # write the data we received
-#           client.write "Server going away\r\n"
-#         end
-#         extend self
-#       end
-#       # create the service instance, the block returns a connection handler.
-#       Iodine.listen(port: "3000") { EchoProtocol }
-#       # start the service
-#       Iodine.threads = 1
-#       Iodine.start
-#
-#
-#
-# Methods for setting up and starting {Iodine} include {start}, {threads}, {threads=}, {workers} and {workers=}.
-#
-# Methods for setting startup / operational callbacks include {on_idle}, {on_state}.
-#
-# Methods for asynchronous execution include {run} (same as {defer}), {run_after} and {run_every}.
-#
-# Methods for application wide pub/sub include {subscribe}, {unsubscribe} and {publish}. Connection specific pub/sub methods are documented in the {Iodine::Connection} class).
-#
-# Methods for TCP/IP, Unix Sockets and HTTP connections include {listen} and {connect}.
-#
-# Note that the HTTP server supports both TCP/IP and Unix Sockets as well as SSE / WebSockets extensions.
-#
-# Iodine doesn't call {patch_rack} automatically, but doing so will improve Rack's performace.
-#
-# Please read the {file:README.md} file for an introduction to Iodine.
-#
-module Iodine
 
-    # Will monkey patch some Rack methods to increase their performance.
-    #
-    # This is recommended, see {Iodine::Rack::Utils} for details.
-    def self.patch_rack
-      begin
-        require 'rack'
-      rescue LoadError
-      end
-      ::Rack::Utils.class_eval do
-        Iodine::Base::MonkeyPatch::RackUtils.methods(false).each do |m|
-          ::Rack::Utils.define_singleton_method(m,
-                Iodine::Base::MonkeyPatch::RackUtils.instance_method(m) )
-        end
-      end
-    end
+require_relative 'iodine/version'
 
+require 'iodine/iodine'
 
-    # @deprecated use {Iodine.listen} with `service: :http`.
-    #
-    # Sets a block of code to run once a Worker process shuts down (both in single process mode and cluster mode).
-    def self.listen2http(args, &block)
-      warn "Iodine.listen2http is deprecated, use Iodine.listen(service: :http)."
-      args[:service] = :http;
-      Iodine.listen(args, &block)
-    end
+# Support common ENV options for setting concurrency.
+Iodine.threads = ENV['RAILS_MAX_THREADS'].to_i if ENV['RAILS_MAX_THREADS'] && Iodine.threads.zero?
+Iodine.workers = ENV['WEB_CONCURRENCY'].to_i if ENV['WEB_CONCURRENCY'] && Iodine.workers.zero?
+Iodine.threads = ENV['WEB_THREADS'].to_i if ENV['WEB_THREADS'] && Iodine.threads.zero?
+Iodine.workers = ENV['WEB_WORKERS'].to_i if ENV['WEB_WORKERS'] && Iodine.workers.zero?
+Iodine.threads = ENV['THREADS'].to_i if ENV['THREADS'] && Iodine.threads.zero?
+Iodine.workers = ENV['WORKERS'].to_i if ENV['WORKERS'] && Iodine.workers.zero?
 
-    # @deprecated use {Iodine.on_state}.
-    #
-    # Sets a block of code to run before a new worker process is forked (cluster mode only).
-    def self.before_fork(&block)
-      warn "Iodine.before_fork is deprecated, use Iodine.on_state(:before_fork)."
-      Iodine.on_state(:before_fork, &block)
-    end
-    # @deprecated use {Iodine.on_state}.
-    #
-    # Sets a block of code to run after a new worker process is forked (cluster mode only).
-    #
-    # Code runs in both the parent and the child.
-    def self.after_fork(&block)
-      warn "Iodine.after_fork is deprecated, use Iodine.on_state(:after_fork)."
-      Iodine.on_state(:after_fork, &block)
-    end
-    # @deprecated use {Iodine.on_state}.
-    #
-    # Sets a block of code to run in the worker process, after a new worker process is forked (cluster mode only).
-    def self.after_fork_in_worker(&block)
-      warn "Iodine.after_fork_in_worker is deprecated, use Iodine.on_state(:enter_child)."
-      Iodine.on_state(:enter_child, &block)
-    end
-    # @deprecated use {Iodine.on_state}.
-    #
-    # Sets a block of code to run in the master / root process, after a new worker process is forked (cluster mode only).
-    def self.after_fork_in_master(&block)
-      warn "Iodine.after_fork_in_master is deprecated, use Iodine.on_state(:enter_master)."
-      Iodine.on_state(:enter_master, &block)
-    end
-    # @deprecated use {Iodine.on_state}.
-    #
-    # Sets a block of code to run once a Worker process shuts down (both in single process mode and cluster mode).
-    def self.on_shutdown(&block)
-      warn "Iodine.on_shutdown is deprecated, use Iodine.on_state(:on_finish)."
-      Iodine.on_state(:on_finish, &block)
-    end
-
-    module PubSub
-      # @deprecated use {Iodine::PubSub.detach}.
-      def self.dettach(engine)
-        warn "Iodine::PubSub.dettach is deprecated (was a typo), use Iodine::PubSub.detach(engine)."
-        Iodine::PubSub.detach(engine)
-      end
+module Iodine
+  class Base
+    # Trap SIGINT only if it wasn't trapped beforehand.
+    def self.trap_sigint
+      old_trap = trap('SIGINT') { puts "(#{Process.pid}) Received Ctrl-C and shutting down iodine." }
+      trap('SIGINT', &old_trap) if old_trap && old_trap.respond_to?(:call)
     end
+  end
 
-    ### trap some signals to avoid excessive exception reports
-    begin
-      old_sigint = Signal.trap("SIGINT") { old_sigint.call if old_sigint.respond_to?(:call) }
-    rescue Exception
-    end
-    begin
-      old_sigterm = Signal.trap("SIGTERM") { old_sigterm.call if old_sigterm.respond_to?(:call) }
-    rescue Exception
-    end
-    begin
-      old_sigpipe = Signal.trap("SIGPIPE") { old_sigpipe.call if old_sigpipe.respond_to?(:call) }
-    rescue Exception
-    end
-    begin
-      old_sigusr1 = Signal.trap("SIGUSR1") { old_sigusr1.call if old_sigusr1.respond_to?(:call) }
-    rescue Exception
+  module PubSub
+    class Engine
+      # Base publish method — subclasses override this to route messages to
+      # external brokers. The default implementation is a no-op (the built-in
+      # CLUSTER and LOCAL engines handle delivery in C).
+      #
+      # @param msg [Iodine::PubSub::Message] the message to publish
+      # @return [void]
+      def publish(msg); end
     end
+  end
 end
 
-require 'rack/handler/iodine' unless defined? ::Iodine::Rack::IODINE_RACK_LOADED
+# Trap SIGINT only if it wasn't trapped beforehand
+Iodine::Base.trap_sigint
 
-
-### Automatic ActiveRecord and Sequel support for forking (preventing connection sharing)
-Iodine.on_state(:before_fork)  do
-  if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:connection)
-    begin
-      ActiveRecord::Base.connection.disconnect!
-    rescue
-    end
-    begin
-      ActiveRecord::Base.connection_pool.disconnect!
-    rescue
-    end
+# NeoRack Support
+unless defined?(Server)
+  # NeoRack support requires Iodine to set the name Server to the Iodine NeoRack server module.
+  Server = Iodine
+  module Server
+    # NeoRack support requires Server::Event to map to the class implementing the NeoRack events.
+    Event = Iodine::Connection
   end
+end
+
+### Automatic Sequel support for forking (preventing connection sharing)
+Iodine.on_state(:before_fork) do
   if defined?(Sequel)
     begin
-      Sequel::DATABASES.each { |database| database.disconnect }
-    rescue
+      Sequel::DATABASES.each(&:disconnect)
+    rescue StandardError
     end
   end
-end
-Iodine.on_state(:after_fork)  do
-  if defined?(ActiveRecord) && defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:establish_connection)
+  if defined?(ActiveRecord)
     begin
-      ActiveRecord::Base.establish_connection
-    rescue
+      ActiveRecord::Base.connection_handlers.each do |handler|
+        handler.clear_all_connections!
+      end
+    rescue StandardError
     end
   end
 end
 
-### Parse CLI for default HTTP settings
-Iodine::Base::CLI.parse if defined?(IODINE_PARSE_CLI) && IODINE_PARSE_CLI
-
-### Set default port (if missing)
-Iodine::DEFAULT_SETTINGS[:port] ||= (ENV["PORT"] || "3000")
-
-### Set default binding (if missing)
-Iodine::DEFAULT_SETTINGS[:address] ||= nil
-
-### Initialize Redis if set in CLI
-Iodine::PubSub.default = Iodine::PubSub::Redis.new(Iodine::DEFAULT_SETTINGS[:redis_], ping: Iodine::DEFAULT_SETTINGS[:redis_ping_]) if Iodine::DEFAULT_SETTINGS[:redis_]
-
-### PID file generation
-if Iodine::DEFAULT_SETTINGS[:pid_]
-  pid_filename = Iodine::DEFAULT_SETTINGS[:pid_]
-  Iodine::DEFAULT_SETTINGS.delete :pid_
-  pid_filename << "iodine.pid" if(pid_filename[-1] == '/')
-  if File.exist?(pid_filename)
-    raise "pid filename shold point to a valid file name (not a folder)!" if(!File.file?(pid_filename))
-    File.delete(pid_filename)
-  end
-  Iodine.on_state(:pre_start) do
-    IO.binwrite(pid_filename, "#{Process.pid}\r\n")
-  end
-  Iodine.on_state(:on_finish) do
-    File.delete(pid_filename)
-  end
-end
-
-### Puma / Thin DSL compatibility - depracated (DSLs are evil)
-
-if(!defined?(after_fork))
-  # @deprecated use {Iodine.on_state}.
-  #
-  # Performs a block of code whenever a new worker process spins up (performed once per worker).
-  def after_fork(*args, &block)
-    warn "after_fork is deprecated, use Iodine.on_state(:after_fork)."
-    Iodine.on_state(:after_fork, &block)
-  end
-end
-if(!defined?(after_fork_in_worker))
-  # @deprecated use {Iodine.on_state}.
-  #
-  # Performs a block of code whenever a new worker process spins up (performed once per worker).
-  def after_fork_in_worker(*args, &block)
-    warn "after_fork_in_worker is deprecated, use Iodine.on_state(:enter_child)."
-    Iodine.on_state(:enter_child, &block)
-  end
-end
-if(!defined?(after_fork_in_master))
-  # @deprecated use {Iodine.on_state}.
-  #
-  # Performs a block of code whenever a new worker process spins up (performed once per worker).
-  def after_fork_in_master(*args, &block)
-    warn "after_fork_in_master is deprecated, use Iodine.on_state(:enter_master)."
-    Iodine.on_state(:enter_master, &block)
-  end
-end
-if(!defined?(on_worker_boot))
-  # @deprecated use {Iodine.on_state}.
-  #
-  # Performs a block of code before a new worker process spins up (performed once per worker).
-  def on_worker_boot(*args, &block)
-    warn "on_worker_boot is deprecated, use Iodine.on_state(:after_fork)."
-    Iodine.on_state(:after_fork, &block)
-  end
-end
-if(!defined?(on_worker_fork))
-  # @deprecated use {Iodine.on_state}.
-  #
-  # Performs a block of code before a new worker process spins up (performed once per worker).
-  def on_worker_fork(*args, &block)
-    warn "on_worker_fork is deprecated, use Iodine.on_state(:before_fork)."
-    Iodine.on_state(:before_fork, &block)
-  end
-end
-if(!defined?(before_fork))
-  # @deprecated use {Iodine.on_state}.
-  #
-  # Performs a block of code just before a new worker process spins up (performed once per worker, in the master thread).
-  def before_fork(*args, &block)
-    warn "before_fork is deprecated, use Iodine.on_state(:before_fork)."
-    Iodine.on_state(:before_fork, &block)
-  end
-end
-
-
-#############
-## At end of loading
-
-### Load configuration filer
-if Iodine::DEFAULT_SETTINGS[:conf_]
-  require Iodine::DEFAULT_SETTINGS[:conf_]
-  Iodine::DEFAULT_SETTINGS.delete :conf_
+### Initialize RESP3 engine if set in CLI
+if Iodine::Base::CLI['-r']
+  Iodine::PubSub.default = Iodine::PubSub::Engine::RESP3.new(
+    Iodine::Base::CLI['-r'],
+    ping: (Iodine::Base::CLI['-rp'] ? Iodine::Base::CLI['-rp'].to_i : nil)
+  )
 end

data/logo.svg

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="100%" height="100%" viewBox="0 0 100 100" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:20;">
+
+<!-- Main Diamond Paths -->
+<path d="M50,80 L10,40 L25,10 L75,10 L90,40Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M50,80 L20,40 L35,20 L65,20 L80,40Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<!-- Diamond Connector Lines -->
+<path d="M35,20 L25,10Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M65,20 L75,10Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M10,40 L20,40" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M90,40, L80,40Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<path d="M28,30 L72,30Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M30,53 L70,53Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<!-- Circles + Connectors -->
+<circle cx="5" cy="20" r="2" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M28,30 L7,21Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<circle cx="95" cy="20" r="2" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M72,30 L93,21Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<circle cx="95" cy="70" r="2" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M70,53 L93,69Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<circle cx="5" cy="70" r="2" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M30,53 L7,69Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<circle cx="50" cy="95" r="2" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+<path d="M50,53 L50,93Z" style="fill:none;stroke:#A24;stroke-width:1px;"/>
+
+<!-- Iodine Name -->
+<text x="50" y="42" font-family="Arial, sans-serif" font-size="17" fill="#A24" text-anchor="middle" alignment-baseline="middle" font-weight="bold">iodine</text>
+</svg>

data/mustache.md

@@ -0,0 +1,55 @@
+# Iodine::Mustashe
+
+Iodine::Mustache is a lighter implementation of the mustache template rendering gem, with a focus on a few minor security details:
+
+1. HTML escaping is more aggressive, increasing XSS protection. Read why at: [wonko.com/post/html-escaping](https://wonko.com/post/html-escaping).
+
+2. 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 `user`, `name` , `first`), allowing for the Hash data to contain keys with dots while still supporting dot notation shortcuts.
+
+3. Less logic: i.e., lambdas / procs do not automatically invoke a re-rendering... I'd remove them completely as unsafe, but for now there's that.
+
+4. Improved Protection against Endless Recursion: i.e., Partial templates reference themselves when recursively nested (instead of being recursively re-loaded); and Partial's context is limited to their starting point's context (cannot access parent context).
+
+It wasn't designed specifically for speed or performance... but it ended up being significantly faster.
+
+## Usage
+
+This approach to Mustache templates may require more forethought when designing either the template or the context's data format, however it should force implementations to be more secure and performance aware.
+
+Approach:
+
+```ruby
+require 'iodine'
+# One-off rendering of (possibly dynamic) template:
+result = Iodine::Mustache.render(template: "{{foo}}", ctx: {foo: "bar"}) # => "bar"
+# caching of parsed template data for multiple render operations:
+view = Iodine::Mustache.new(file: "./views/foo.mustache", template: "{{foo}}")
+results = Array.new(100) {|i| view.render(foo: "bar#{i}") } # => ["bar0", "bar1", ...]
+```
+
+## Performance
+
+Performance testing requires the main Ruby `mustache` gem as well as the `benchmark-ips` gem.
+
+Test using:
+
+```ruby
+require 'iodine/benchmark'
+Iodine::Benchmark.mustache
+```
+
+On my machine this benchmark indicates about an x10 performance boost.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/boazsegev/iodine.
+
+This gem is a C extension, so you will need to know C to use it.
+
+The gem also leverages the facil.io C STL library under the hood, so things related to the facil.io library will have to go in the facil.io repo.
+
+Good luck!
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/sig/iodine.rbs

@@ -0,0 +1,4 @@
+module Iodine
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end