itsi 0.1.9 → 0.1.11

data/gems/server/lib/itsi/server/Itsi.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+env = ENV.fetch('APP_ENV') { ENV.fetch('RACK_ENV', 'development') }
+
+# This is the default Itsi configuration file, installed when you run `itsi init`
+# It contains a sane starting point for configuring your Itsi server.
+# You can use this file in both development and production environments.
+# Most of the options in this file can be overridden by command line options.
+# Check out itsi -h to learn more about the command line options available to you.
+
+# Number of worker processes to spawn
+# If more than 1, Itsi will be booted in Cluster mode
+workers ENV.fetch('ITSI_WORKERS') {
+  require 'etc'
+  env == 'development' ? 1 : Etc.nprocessors
+}
+
+# Number of threads to spawn per worker process
+# For pure CPU bound applicationss, you'll get the best results keeping this number low
+# Setting a value of 1 is great for superficial benchmarks, but in reality
+# it's better to set this a bit higher to allow expensive requests to get overtaken and minimize head-of-line blocking
+threads ENV.fetch('ITSI_THREADS', 3)
+
+# If your application is IO bound (e.g. performing a lot of proxied HTTP requests, or heavy queries etc)
+# you can see *substantial* benefits from enabling this option.
+# To set this option, pass a string, not a class (as we will not have loaded the class yet)
+# E.g.
+# `fiber_scheduler "Itsi::Scheduler"` - The default fast and light-weight scheduler that comes with Itsi
+# `fiber_scheduler "Async::Scheduler"` - Bring your own scheduler!
+fiber_scheduler nil
+
+# By default Itsi will run the Rack app from config.ru.
+# You can provide an alternative Rack app file name here
+# Or you can inline the app directly inside Itsi.rb.
+# Only one of `run` and `rackup_file` can be used.
+# E.g.
+# require 'rack'
+# run(Rack::Builder.app do
+#   use Rack::CommonLogger
+#   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+# end)
+rackup_file 'config.ru'
+
+# If you bind to https, without specifying a certificate, Itsi will use a self-signed certificate.
+# The self-signed certificate will use a CA generated for your host and stored inside `ITSI_LOCAL_CA_DIR` (Defaults to ~/.itsi)
+# bind "https://localhost:3000"
+# bind "https://localhost:3000?domains=dev.itsi.fyi"
+#
+# If you want to use let's encrypt to generate you a real certificate you and pass cert=acme and an acme_email address to generate one.
+# bind "https://itsi.fyi?cert=acme&acme_email=admin@itsi.fyi"
+# You can generate certificates for multiple domains at once, by passing a comma-separated list of domains
+# bind "https://0.0.0.0?domains=foo.itsi.fyi,bar.itsi.fyi&cert=acme&acme_email=admin@itsi.fyi"
+#
+# If you already have a certificate you can specify it using the cert and key parameters
+# bind "https://itsi.fyi?cert=/path/to/cert.pem&key=/path/to/key.pem"
+#
+# You can also bind to a unix socket or a tls unix socket. E.g.
+# bind "unix:///tmp/itsi.sock"
+# bind "tls:///tmp/itsi.secure.sock"
+
+if env == 'development'
+  bind 'http://localhost:3000'
+else
+  bind "https://0.0.0.0?domains=#{ENV['PRODUCTION_DOMAINS']}&cert=acme&acme_email=admin@itsi.fyi"
+end
+
+# If you want to preload the application, set preload to true
+# to load the entire rack-app defined in rack_file_name before forking.
+# Alternatively, you can preload just a specific set of gems in a group in your gemfile,
+# by providing the group name here.
+# E.g.
+#
+# preload :preload # Load gems inside the preload group
+# preload false # Don't preload.
+#
+# If you want to be able to perform zero-downtime deploys using a single itsi process,
+# you should disable preloads, so that the application is loaded fresh each time a new worker boots
+preload true
+
+# Set the maximum memory limit for each worker process in bytes
+# When this limit is reached, the worker will be gracefully restarted.
+# Only one worker is restarted at a time to ensure we don't take down
+# all of them at once, if they reach the threshold simultaneously.
+worker_memory_limit 48 * 1024 * 1024
+
+# You can provide an optional block of code to run, when a worker hits its memory threshold (Use this to send yourself an alert,
+# write metrics to disk etc. etc.)
+after_memory_threshold_reached do |pid|
+  puts "Worker #{pid} has reached its memory threshold and will restart"
+end
+
+# Do clean up of any non-threadsafe resources before forking a new worker here.
+before_fork {}
+
+# Reinitialize any non-threadsafe resources after forking a new worker here.
+after_fork {}
+
+# Shutdown timeout
+# Number of seconds to wait for workers to gracefully shutdown before killing them.
+shutdown_timeout 5
+
+# Set this to false for application environments that require rack.input to be a rewindable body
+# (like Rails). For rack applications that can stream inputs, you can set this to true for a more memory-efficient approach.
+stream_body false
+
+# OOB GC responses threshold
+# Specifies how frequently OOB gc should be triggered during periods where there is a gap in queued requests.
+# Setting this too low can substantially worsen performance
+oob_gc_responses_threshold 512
+
+# Set this to false for application environments that require rack.input to be a rewindable body
+# (like Rails). For rack applications that can stream inputs, you can set this to true for a more memory-efficient approach.
+stream_body false
+
+# OOB GC responses threshold
+# Specifies how frequently OOB gc should be triggered during periods where there is a gap in queued requests.
+# Setting this too low can substantially worsen performance
+oob_gc_responses_threshold 512
+
+# Log level
+# Set this to one of the following values: debug, info, warn, error, fatal
+# Can also be set using the ITSI_LOG environment variable
+log_level :info
+
+# Log Format
+# Set this to be either :ansi or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :auto

data/gems/server/lib/itsi/server/config.rb

@@ -0,0 +1,36 @@
+module Itsi
+  class Server
+    module Config
+      module_function
+
+      ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
+
+      def load(options)
+        options[:config_file] ||= \
+          if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
+            ITSI_DEFAULT_CONFIG_FILE
+          elsif File.exist?("config/#{ITSI_DEFAULT_CONFIG_FILE}")
+            "config/#{ITSI_DEFAULT_CONFIG_FILE}"
+          end
+
+        # Options simply pass through unless we've specified a config file
+        return options unless options[:config_file]
+
+        require_relative "options_dsl"
+        OptionsDSL.evaluate(options[:config_file]).merge(options)
+      end
+
+      def write_default
+        if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
+          puts "#{ITSI_DEFAULT_CONFIG_FILE} already exists."
+          return
+        end
+
+        puts "Writing default configuration..."
+        File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
+          file.write(IO.read("#{__dir__}/Itsi.rb"))
+        end
+      end
+    end
+  end
+end

data/gems/server/lib/itsi/server/options_dsl.rb

@@ -0,0 +1,401 @@
+module Itsi
+  class Server
+    class OptionsDSL
+      attr_reader :parent, :children, :filters, :endpoint_defs, :controller_class
+
+      def self.evaluate(filename)
+        new do
+          instance_eval(IO.read(filename))
+        end.to_options
+      end
+
+      def initialize(parent = nil, route_specs = [], &block)
+        @parent           = parent
+        @children         = []
+        @filters          = {}
+        @endpoint_defs    = [] # Each is [subpath, *endpoint_args]
+        @controller_class = nil
+        @options          = {}
+
+        # We'll store our array of route specs (strings or a single Regexp).
+        @route_specs = Array(route_specs).flatten
+
+        validate_path_specs!(@route_specs)
+        instance_exec(&block)
+      end
+
+      def to_options
+        @options.merge(
+          {
+            routes: flatten_routes
+          }
+        )
+      end
+
+      def workers(workers)
+        raise "Workers must be set at the root" unless @parent.nil?
+
+        @options[:workers] = [workers.to_i, 1].max
+      end
+
+      def threads(threads)
+        raise "Threads must be set at the root" unless @parent.nil?
+
+        @options[:threads] = [threads.to_i, 1].max
+      end
+
+      def rackup_file(rackup_file)
+        raise "Rackup file must be set at the root" unless @parent.nil?
+        raise "rackup_file already set" if @options[:rackup_file]
+        raise "Cannot provide a rackup_file if app is defined" if @options[:app]
+
+        if rackup_file.is_a?(File) && rackup_file.exist?
+          @options[:rackup_file] = file_path
+        else
+          file_path = rackup_file
+          @options[:rackup_file] = file_path if File.exist?(file_path)
+        end
+      end
+
+      def oob_gc_responses_threshold(threshold)
+        raise "OOB GC responses threshold must be set at the root" unless @parent.nil?
+
+        @options[:oob_gc_responses_threshold] = threshold.to_i
+      end
+
+      def log_level(level)
+        raise "Log level must be set at the root" unless @parent.nil?
+
+        ENV["ITSI_LOG"] = level.to_s
+      end
+
+      def log_format(format)
+        raise "Log format must be set at the root" unless @parent.nil?
+
+        case format.to_s
+        when "auto"
+        when "ansi" then ENV['ITSI_LOG_ANSI'] = "true"
+        when "json", "plain" then ENV['ITSI_LOG_PLAIN'] = "true"
+        else raise "Invalid log format '#{format}'"
+        end
+      end
+
+      def run(app)
+        raise "App must be set at the root" unless @parent.nil?
+        raise "App already set" if @options[:app]
+        raise "Cannot provide an app if rackup_file is defined" if @options[:rackup_file]
+
+        @options[:app] = app
+      end
+
+      def bind(bind_str)
+        raise "Bind must be set at the root" unless @parent.nil?
+
+        @options[:binds] ||= []
+        @options[:binds] << bind_str.to_s
+      end
+
+      def after_fork(&block)
+        raise "After fork must be set at the root" unless @parent.nil?
+
+        @options[:hooks] ||= {}
+        @options[:hooks][:after_fork] = block
+      end
+
+      def before_fork(&block)
+        raise "Before fork must be set at the root" unless @parent.nil?
+
+        @options[:hooks] ||= {}
+        @options[:hooks][:before_fork] = block
+      end
+
+      def after_memory_threshold_reached(&block)
+        raise "Before fork must be set at the root" unless @parent.nil?
+
+        @options[:hooks] ||= {}
+        @options[:hooks][:after_memory_threshold_reached] = block
+      end
+
+      def worker_memory_limit(memory_limit)
+        raise "Worker memory limit must be set at the root" unless @parent.nil?
+
+        @options[:worker_memory_limit] = memory_limit
+      end
+
+      def fiber_scheduler(klass_name)
+        raise "Fiber scheduler must be set at the root" unless @parent.nil?
+
+        @options[:scheduler_class] = klass_name if klass_name
+      end
+
+      def preload(preload)
+        raise "Preload must be set at the root" unless @parent.nil?
+
+        @options[:preload] = preload
+      end
+
+      def shutdown_timeout(shutdown_timeout)
+        raise "Shutdown timeout must be set at the root" unless @parent.nil?
+
+        @options[:shutdown_timeout] = shutdown_timeout.to_f
+      end
+
+      def script_name(script_name)
+        raise "Script name must be set at the root" unless @parent.nil?
+
+        @options[:script_name] = script_name.to_s
+      end
+
+      def stream_body(stream_body)
+        raise "Stream body must be set at the root" unless @parent.nil?
+
+        @options[:stream_body] = !!stream_body
+      end
+
+      def location(*route_specs, &block)
+        route_specs = route_specs.flatten
+        child = OptionsDSL.new(self, route_specs, &block)
+        @children << child
+      end
+
+      # define endpoints
+      def endpoint(subpath, *args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @endpoint_defs << [subpath, *args]
+      end
+
+      def controller(klass)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @controller_class = klass
+      end
+
+      # define some filters
+      def basic_auth(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:basic_auth] = args
+      end
+
+      # define some filters
+      def redirect(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:redirect] = args
+      end
+
+      def jwt_auth(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:jwt_auth] = args
+      end
+
+      def api_key_auth(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:api_key_auth] = args
+      end
+
+      def compress(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:compress] = args
+      end
+
+      def rate_limit(name, **args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:rate_limit] = { name: name }.merge(args)
+      end
+
+      def cors(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:cors] = args
+      end
+
+      def file_server(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:file_server] = args
+      end
+
+      def flatten_routes
+        child_routes = @children.flat_map(&:flatten_routes)
+        base_expansions = combined_paths_from_parent
+        endpoint_routes = @endpoint_defs.map do |(endpoint_subpath, *endpoint_args)|
+          ep_expansions = expand_single_subpath(endpoint_subpath)
+          final_regex_str = or_pattern_for(cartesian_combine(base_expansions, ep_expansions))
+
+          {
+            route: Regexp.new("^#{final_regex_str}$"),
+            filters: effective_filters_with_endpoint(endpoint_args)
+          }
+        end
+
+        location_route = unless @route_specs.empty?
+                           pattern_str = or_pattern_for(base_expansions) # the expansions themselves
+                           {
+                             route: Regexp.new("^#{pattern_str}$"),
+                             filters: effective_filters
+                           }
+                         end
+
+        result = []
+        result.concat(child_routes)
+        result.concat(endpoint_routes)
+        result << location_route if location_route
+        result
+      end
+
+      def validate_path_specs!(specs)
+        regexes = specs.select { |s| s.is_a?(Regexp) }
+        return unless regexes.size > 1
+
+        raise ArgumentError, "Cannot have multiple raw Regex route specs in a single location."
+      end
+
+      # Called by flatten_routes to get expansions from the parent's expansions combined with mine
+      def combined_paths_from_parent
+        if parent
+          pex = parent.combined_paths_from_parent_for_children
+          cartesian_combine(pex, expansions_for(@route_specs))
+        else
+          expansions_for(@route_specs)
+        end
+      end
+
+      def combined_paths_from_parent_for_children
+        if parent
+          pex = parent.combined_paths_from_parent_for_children
+          cartesian_combine(pex, expansions_for(@route_specs))
+        else
+          expansions_for(@route_specs)
+        end
+      end
+
+      def expand_single_subpath(subpath)
+        expansions_for([subpath]) # just treat it as a mini specs array
+      end
+
+      def expansions_for(specs)
+        return [] if specs.empty?
+
+        if specs.any? { |s| s.is_a? Regexp }
+          raise "Cannot combine a raw Regexp with other strings in the same location." if specs.size > 1
+
+          [[:raw_regex, specs.first]]
+        else
+          specs.map do |string_spec|
+            string_spec = string_spec.sub(%r{^/}, "")
+            string_spec
+          end
+        end
+      end
+
+      def cartesian_combine(parent_exps, child_exps)
+        return child_exps if parent_exps.empty?
+        return parent_exps if child_exps.empty?
+
+        if parent_exps.size == 1 && parent_exps.first.is_a?(Array) && parent_exps.first.first == :raw_regex
+          raise "Cannot nest under a raw Regexp route."
+        end
+
+        if child_exps.size == 1 && child_exps.first.is_a?(Array) && child_exps.first.first == :raw_regex
+          raise "Cannot nest a raw Regexp route under a parent string route."
+        end
+
+        results = []
+        parent_exps.each do |p|
+          child_exps.each do |c|
+            joined = [p, c].reject(&:empty?).join("/")
+            results << joined
+          end
+        end
+        results
+      end
+
+      def or_pattern_for(expansions)
+        return "" if expansions.empty?
+
+        if expansions.size == 1 && expansions.first.is_a?(Array) && expansions.first.first == :raw_regex
+          raw = expansions.first.last
+          return raw.source # Use the raw Regexp's source
+        end
+
+        pattern_pieces = expansions.map do |exp|
+          if exp.empty?
+            "" # => means top-level "/"
+          else
+            segment_to_regex_with_slash(exp)
+          end
+        end
+
+        joined = pattern_pieces.join("|")
+
+        "(?:#{joined})"
+      end
+
+      def segment_to_regex_with_slash(path_str)
+        return "" if path_str == ""
+
+        segments = path_str.split("/")
+
+        converted = segments.map do |seg|
+          # wildcard?
+          next ".*" if seg == "*"
+
+          # :param(...)?
+          if seg =~ /^:([A-Za-z_]\w*)(?:\(([^)]*)\))?$/
+            param_name = Regexp.last_match(1)
+            custom     = Regexp.last_match(2)
+            if custom && !custom.empty?
+              "(?<#{param_name}>#{custom})"
+            else
+              "(?<#{param_name}>[^/]+)"
+            end
+          else
+            Regexp.escape(seg)
+          end
+        end
+
+        converted.join("/")
+      end
+
+      def effective_filters
+        # gather from root -> self, overriding duplicates
+        merged = merge_ancestor_filters
+        # turn into array
+        merged.map { |k, v| { type: k, params: v } }
+      end
+
+      def effective_filters_with_endpoint(endpoint_args)
+        arr = effective_filters
+        # endpoint filter last
+        ep_filter_params = endpoint_args.dup
+        ep_filter_params << @controller_class if @controller_class
+        arr << { type: :endpoint, params: ep_filter_params }
+        arr
+      end
+
+      def merge_ancestor_filters
+        chain = []
+        node = self
+        while node
+          chain << node
+          node = node.parent
+        end
+        chain.reverse!
+
+        merged = {}
+        chain.each do |n|
+          n.filters.each do |k, v|
+            merged[k] = v
+          end
+        end
+        merged
+      end
+    end
+  end
+end

data/gems/server/lib/itsi/server/rack/handler/itsi.rb

@@ -4,12 +4,24 @@ module Rack
   module Handler
     module Itsi
       def self.run(app, options = {})
-        ::Itsi::Server.new(
-          app: -> { app },
-          binds: ["http://#{options.fetch(:host, "127.0.0.1")}:#{options.fetch(:Port, 3001)}"],
-          workers: options.fetch(:workers, 1),
-          threads: options.fetch(:threads, 1)
-        ).start
+        ::Itsi::Server.start(
+          **Itsi::Server::Config.load(
+            {
+              app: app,
+              binds: [
+                "http://#{
+                options.fetch(
+                  :host,
+                  "127.0.0.1"
+                )}:#{
+                options.fetch(
+                  :Port,
+                  3001
+                )}"
+              ]
+            }
+          )
+        )
       end
     end
   end

data/gems/server/lib/itsi/server/rack_interface.rb

@@ -57,11 +57,7 @@ module Itsi
             buffer = part
           end
 
-          begin
-            response.send_and_close(buffer.to_s)
-          rescue StandardError
-            binding.b
-          end
+          response.send_and_close(buffer.to_s)
         else
           response.send_and_close(body.to_s)
         end

data/gems/server/lib/itsi/server/signal_trap.rb

@@ -8,7 +8,6 @@ module Itsi
       unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && Itsi::Server.running?
         return super(signal, *args, &block)
       end
-
       Itsi::Server.reset_signal_handlers
       nil
     end

data/gems/server/lib/itsi/server/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.9"
+    VERSION = "0.1.11"
   end
 end

data/gems/server/lib/itsi/server.rb

@@ -6,15 +6,18 @@ require_relative "server/rack_interface"
 require_relative "server/signal_trap"
 require_relative "server/scheduler_interface"
 require_relative "server/rack/handler/itsi"
+require_relative "server/config"
 require_relative "request"
 require_relative "stream_io"
 
 # When you Run Itsi without a Rack app,
-# we start a tiny
+# we start a tiny little echo server, just so you can see it in action.
 DEFAULT_INDEX = IO.read("#{__dir__}/index.html").freeze
 DEFAULT_BINDS = ["http://0.0.0.0:3000"].freeze
 DEFAULT_APP = lambda {
   require "json"
+  require "itsi/scheduler"
+  Itsi.log_warn "No config.ru or Itsi.rb app detected. Running default app."
   lambda do |env|
     headers, body = \
       if env["itsi.response"].json?
@@ -55,17 +58,18 @@ module Itsi
 
       def build(
         app: DEFAULT_APP[],
+        loader: nil,
         binds: DEFAULT_BINDS,
         **opts
       )
-        new(app: -> { app }, binds: binds, **opts)
+        new(app: loader || -> { app }, binds: binds, **opts)
       end
 
       def start_in_background_thread(silence: true, **opts)
         start(background: true, silence: silence, **opts)
       end
 
-      def start(background: false, **opts)
+      def start(background: false, silence: false, **opts)
         build(**opts).tap do |server|
           previous_handler = Signal.trap("INT", "DEFAULT")
           @running = true