itsi-server 0.1.1 → 0.2.2

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

@@ -0,0 +1,242 @@
+require 'date'
+require 'time'
+
+module Itsi
+  class Server
+    module Config
+      module TypedStruct
+        VALUE = 0
+        VALIDATE = 1
+
+        def self.new(defaults = nil, &defaults_blk)
+          defaults = TypedStruct.module_eval(&defaults_blk) if defaults_blk
+          unless defaults.is_a?(Hash)
+            return defaults
+          end
+          defaults.transform_values! { _1.is_a?(Validation) ? _1.default(nil) : _1 }
+          Struct.new(*defaults.keys, keyword_init: true) do
+            define_method(:initialize) do |*input, validate: true, **raw_input|
+
+              if input.last && !input.last.is_a?(Hash)
+                raise "─ Invalid input to #{self}: #{input.last}"
+              end
+              raw_input.transform_keys!{|k| k.to_s.downcase.to_sym }
+              raw_input.merge!(input.pop.transform_keys!{|k| k.to_s.downcase.to_sym}) if input.last.is_a?(Hash)
+
+              excess_keys = raw_input.keys - defaults.keys
+
+              if excess_keys.any?
+                raise "─ Unsupported keys #{excess_keys}"
+
+              end
+
+              initial_values = defaults.each_with_object({}) do |(k, default_config), inputs|
+                value = raw_input.key?(k) ? raw_input[k] : default_config[VALUE].dup
+                next inputs[k] = value unless validate
+
+                begin
+                  inputs[k] = default_config[VALIDATE].validate!(value)
+                rescue StandardError => e
+                  raise ArgumentError, "─ #{k}: #{e.message}"
+                end
+              end
+
+              super(initial_values)
+              validator = self.class.instance_eval { @validators }
+              instance_eval(&validator) if validator
+            end
+
+            define_singleton_method(:validate) do |&blk|
+              @validators = blk
+            end
+
+            defaults.each do |key, (_, validation)|
+              define_method(:"#{key}?") do
+                !!self[key]
+              end
+              define_method(:"#{key}=") do |value|
+                self[key] = validation.validate!(value)
+              end
+            end
+
+            define_method(:[]=) do |key, value|
+              super(key, defaults[key][VALIDATE].validate!(value))
+            end
+
+            def is_typed_struct?
+              true
+            end
+
+            def merge_config(other)
+              self.class.new(members.map do |key|
+                value = self[key]
+                has_merged_val = (other.is_a?(Hash) ? other.key?(key) : other.member?(key))
+                next [key, value] unless has_merged_val
+
+                [
+                  key,
+                  TypedStruct.typed_struct?(value) ? value.merge_config(other[key]) : other[key]
+                ]
+              end.to_h)
+            end
+
+            def to_h
+              super.transform_values { |v| v.respond_to?(:merge_config) ? v.to_h : v }
+            end
+          end
+        end
+
+        def self.typed_struct?(inst)
+          inst.respond_to?(:is_typed_struct?) && inst.is_typed_struct?
+        end
+
+        class Validation
+          attr_reader :name, :validations
+          attr_accessor :next
+
+          def initialize(name, validations)
+            @name = name.to_s
+            @validations = Array(validations)
+            @next = nil
+          end
+
+          def inspect
+            "#{@name}"
+          end
+
+          def &(other)
+            tail = self
+            while tail.next
+              tail = tail.next
+            end
+            tail.next = other
+            self
+          end
+
+          def default(value)
+            [value, self]
+          end
+
+          def validate!(value)
+            value = value.to_s if value.is_a?(Symbol)
+            @validations.each do |validation|
+              case validation
+              when Proc
+                validation.call(value)
+              when Array
+                unless !value || validation.include?(value)
+                  raise ArgumentError,
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                end
+              when Range
+                unless !value || validation.include?(value)
+                  raise ArgumentError,
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                end
+              when Regexp
+                unless !value || validation.match?(value)
+                  raise ArgumentError,
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                end
+              when Validation
+                validation.validate!(value)
+              when Class
+                if value && !value.is_a?(validation)
+                  begin
+                    value = \
+                      if validation.eql?(Time) then Time.parse(value.to_s)
+                      elsif validation.eql?(::Date) then Date.parse(value.to_s)
+                      elsif validation.eql?(Float) then Float(value)
+                      elsif validation.eql?(Integer) then Integer(value)
+                      elsif validation.eql?(Proc) then
+                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(Proc)
+                      elsif validation.eql?(String) || validation.eql?(Symbol)
+                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(String) || value.is_a?(Symbol)
+                        if validation.eql?(String)
+                          value.to_s
+                        elsif validation.eql?(Symbol)
+                          value.to_s.to_sym
+                        end
+                      else
+                        validation.new(value)
+                      end
+                  rescue StandardError => e
+                    raise ArgumentError,
+                          "─ `#{@name}` Validation Failed. Invalid #{validation.to_s.split("::").last} value: #{value.inspect}. Failure reason: \n  └─ #{e.message}"
+                  end
+                end
+              end
+            end
+            if self.next
+              self.next.validate!(value)
+            else
+              value
+            end
+          end
+        end
+
+        {
+          Bool: Validation.new(:Bool, [[true, false]]),
+          Required: Validation.new(:Required, ->(value) { !value.nil? }),
+          Or: ->(*validations){
+            Validation.new(:Or, ->(v){
+
+              return true if v.nil?
+              errs = []
+              validations.each do |validation|
+                begin
+                  v = validation.validate!(v)
+                  return v
+                rescue StandardError => e
+                  errs << e.message
+                end
+              end
+              raise StandardError.new("─ Validation failed (None match:) \n  └#{errs.join("\n  └")}")
+            })
+          },
+          Range: ->(input_range) {
+            Validation.new(:Range, [input_range])
+          },
+          Length: lambda { |input_length|
+            Validation.new(:Length, ->(value) { input_length === value.length })
+          },
+          Hash: ->(key_type, value_type) {
+            Validation.new(:Hash, ->(v){
+              return true if v.nil?
+              raise StandardError.new("Expected hash got #{v.class}") unless v.is_a?(Hash)
+              v.map do |k, v|
+                [
+                  key_type.validate!(k),
+                  value_type.validate!(v)
+                ]
+              end.to_h
+            })
+          },
+          Type: ->(input_type) { Validation.new(:Type, input_type) },
+          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map{|v| v.kind_of?(Symbol) ? v.to_s : v}]) },
+          Array: lambda { |*value_validations|
+            Validation.new(:Array, [::Array, lambda { |value|
+              return true unless value
+
+              raise StandardError.new("Expected Array got #{value.class}") unless value.is_a?(Array)
+
+              value&.map! do |v|
+                value_validations.all? { v = _1.validate!(v) }
+                v
+              end
+            }])
+          }
+        }.each do |name, factory|
+          if factory.is_a?(Proc)
+            define_singleton_method(name, &factory)
+            define_singleton_method(name.to_s.downcase, &factory)
+          else
+            const_set(name, factory)
+            define_singleton_method(name, -> { factory.dup })
+            define_singleton_method(name.to_s.downcase, -> { factory.dup })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/itsi/server/config.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+module Itsi
+  class Server
+    module Config
+      require_relative "config/typed_struct"
+      require_relative "config/dsl"
+      require_relative "config/known_paths"
+      require_relative "default_app/default_app"
+
+      ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
+
+      def self.prep_reexec!
+        @argv ||= ARGV[0...ARGV.index("--listeners")]
+
+        auto_suppress_fork_darwin_fork_safety_warnings = [
+          ENV["OBJC_DISABLE_INITIALIZE_FORK_SAFETY"].nil? || ENV["PGGSSENCMODE"].nil?,
+          RUBY_PLATFORM =~ /darwin/,
+          !ENV.key?("ITSI_DISABLE_AUTO_DISABLE_DARWIN_FORK_SAFETY_WARNINGS"),
+          $PROGRAM_NAME =~ /itsi$/
+        ].all?
+        return unless auto_suppress_fork_darwin_fork_safety_warnings
+
+        env = ENV.to_h.merge("OBJC_DISABLE_INITIALIZE_FORK_SAFETY" => "YES", "PGGSSENCMODE" => "disable")
+        if ENV["BUNDLE_BIN_PATH"]
+          exec env, "bundle", "exec", $PROGRAM_NAME, *@argv
+        else
+          exec env, $PROGRAM_NAME, *@argv
+        end
+      end
+
+      # The configuration used when launching the Itsi server are evaluated in the following precedence:
+      # 1. CLI Args.
+      # 2. Itsi.rb file.
+      # 3. Default values.
+      def self.build_config(args, config_file_path, builder_proc = nil)
+        args.transform_keys!(&:to_sym)
+        itsifile_config, errors = \
+          if builder_proc
+            DSL.evaluate(&builder_proc)
+          elsif args[:static]
+            DSL.evaluate do
+              location "/" do
+                rate_limit key: 'address', store_config: 'in_memory', requests: 2, seconds: 5
+                etag type: 'strong', algorithm: 'md5', min_body_size: 1024 * 1024
+                compress min_size: 1024 * 1024, level: 'fastest', algorithms: %w[zstd gzip br deflate], mime_types: %w[all], compress_streams: true
+                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " }, after: { level: "INFO", format: "[{request_id}] └─ {status} in {response_time}" }
+                static_assets \
+                  relative_path: true,
+                  allowed_extensions: [],
+                  root_dir: '.',
+                  not_found_behavior: {error: 'not_found'},
+                  auto_index: true,
+                  try_html_extension: true,
+                  max_file_size_in_memory: 1024 * 1024, # 1MB
+                  max_files_in_memory: 1000,
+                  file_check_interval: 1,
+                  serve_hidden_files: false,
+                  headers: {
+                    'X-Content-Type-Options' => 'nosniff'
+                  }
+              end
+            end
+          elsif File.exist?(config_file_path.to_s)
+            DSL.evaluate(config_file_path)
+          elsif File.exist?("./config.ru")
+            DSL.evaluate do
+              preload true
+              rackup_file args.fetch(:rackup_file, "./config.ru")
+            end
+          else
+            DSL.evaluate{}
+          end
+
+        itsifile_config.transform_keys!(&:to_sym)
+
+        # We'll preload while we load config, if enabled.
+        middleware_loader = itsifile_config.fetch(:middleware_loader, -> {})
+        preload = args.fetch(:preload) { itsifile_config.fetch(:preload, false) }
+
+        case preload
+        # If we preload everything, then we'll load middleware and default rack app ahead of time
+        when true
+          begin
+            Itsi.log_debug("Preloading middleware and default rack app")
+            preloaded_middleware = middleware_loader.call
+            middleware_loader = -> { preloaded_middleware }
+          rescue StandardError => e
+            errors << [e, e.backtrace[0]]
+          end
+        # If we're just preloading a specific gem group, we'll do that here too
+        when Symbol
+          Itsi.log_debug("Preloading gem group #{preload}")
+          Bundler.require(preload)
+        end
+
+        if itsifile_config[:daemonize] && !@daemonized
+          @daemonized = true
+          Itsi.log_info("Itsi is running in the background. Writing pid to #{Itsi::Server::Config.pid_file_path}")
+          Itsi.log_info("To stop Itsi, run 'itsi stop' from this directory.")
+          Process.daemon(true, false)
+          Server.write_pid
+        end
+
+        srv_config = {
+          workers: args.fetch(:workers) { itsifile_config.fetch(:workers, 1) },
+          worker_memory_limit: args.fetch(:worker_memory_limit) { itsifile_config.fetch(:worker_memory_limit, nil) },
+          silence: args.fetch(:silence) { itsifile_config.fetch(:silence, false) },
+          shutdown_timeout: args.fetch(:shutdown_timeout) { itsifile_config.fetch(:shutdown_timeout, 5) },
+          hooks: args[:hooks] && itsifile_config[:hooks] ? args[:hooks].merge(itsifile_config[:hooks]) : itsifile_config.fetch(:hooks, args[:hooks]),
+          preload: !!preload,
+          request_timeout: itsifile_config.fetch(:request_timeout, nil),
+          header_read_timeout: args.fetch(:header_read_timeout) { itsifile_config.fetch(:header_read_timeout, nil) },
+          notify_watchers: itsifile_config.fetch(:notify_watchers, nil),
+          threads: args.fetch(:threads) { itsifile_config.fetch(:threads, 1) },
+          scheduler_threads: args.fetch(:scheduler_threads) { itsifile_config.fetch(:scheduler_threads, nil) },
+          streamable_body: args.fetch(:streamable_body) { itsifile_config.fetch(:streamable_body, false) },
+          multithreaded_reactor: args.fetch(:multithreaded_reactor) do
+            itsifile_config.fetch(:multithreaded_reactor, nil)
+          end,
+          pin_worker_cores: args.fetch(:pin_worker_cores) { itsifile_config.fetch(:pin_worker_cores, true) },
+          scheduler_class: args.fetch(:scheduler_class) { itsifile_config.fetch(:scheduler_class, nil) },
+          oob_gc_responses_threshold: args.fetch(:oob_gc_responses_threshold) do
+            itsifile_config.fetch(:oob_gc_responses_threshold, nil)
+          end,
+          log_level: args.fetch(:log_level) { itsifile_config.fetch(:log_level, nil) },
+          log_format: args.fetch(:log_format) { itsifile_config.fetch(:log_format, nil) },
+          log_target: args.fetch(:log_target) { itsifile_config.fetch(:log_target, nil) },
+          log_target_filters: args.fetch(:log_target_filters) { itsifile_config.fetch(:log_target_filters, nil) },
+          binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
+          middleware_loader: middleware_loader,
+          listeners: args.fetch(:listeners) { nil },
+          reuse_address: itsifile_config.fetch(:reuse_address, true),
+          reuse_port: itsifile_config.fetch(:reuse_port, true),
+          listen_backlog: itsifile_config.fetch(:listen_backlog, 1024 ),
+          nodelay: itsifile_config.fetch(:nodelay, true),
+          recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144)
+        }.transform_keys(&:to_s)
+
+        error_lines = errors.flat_map do |(error, message)|
+            location =  message[/(.*?)\:in/,1]
+            file, lineno = location.split(":")
+            lineno = lineno.to_i
+            err_message = error.kind_of?(NoMethodError) ? error.detailed_message : error.message
+            file_lines = IO.readlines(file)
+            info_lines = if error.kind_of?(SyntaxError)
+              []
+            else
+              ([lineno-2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
+                if currline == lineno-1
+                  line = file_lines[currline][0...-1]
+                  padding = line[/^\s+/]&.length || 0
+
+                  [
+                    " \e[31m#{currline.succ.to_s.rjust(3)} | #{line}\e[0m",
+                    "     | #{' ' * padding}\e[33m^^^\e[0m "
+                  ]
+                else
+                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline][0...-1]}"
+                end
+              end.flatten
+            end
+            [
+              err_message,
+              "   --> #{File.expand_path(file)}:#{lineno}",
+              *info_lines
+            ]
+          end
+
+        return srv_config, error_lines
+      rescue
+        Itsi.log_error e.message
+        puts e.backtrace
+      end
+
+      def self.test!(cli_params)
+        _, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        unless errors.any?
+          begin
+            _["middleware_loader"][]
+          rescue Exception => e
+            errors = [e]
+          end
+        end
+
+        if errors.any?
+          Itsi.log_error("Config file is invalid")
+          puts errors
+        else
+          Itsi.log_info("Config file is valid")
+        end
+      end
+
+      # Reloads the entire process
+      # using exec, passing in any active file descriptors
+      # and previous invocation arguments
+      def self.reload_exec(listener_info)
+        if ENV["BUNDLE_BIN_PATH"]
+          exec "bundle", "exec", $PROGRAM_NAME, *@argv, "--listeners", listener_info
+        else
+          exec $PROGRAM_NAME, *@argv, "--listeners", listener_info
+        end
+      end
+
+      # Find config file path, if it exists.
+      def self.config_file_path(config_file_path = nil)
+        config_file_path ||= \
+          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 pass through unless we've specified a config file
+        return unless File.exist?(config_file_path.to_s)
+
+        config_file_path
+      end
+
+      def self.pid_file_path
+        if Dir.exist?("tmp")
+          File.join("tmp", "itsi.pid")
+        else
+          ".itsi.pid"
+        end
+      end
+
+      # Write a default config file, if one doesn't exist.
+      def self.write_default
+        if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
+          puts "#{ITSI_DEFAULT_CONFIG_FILE} already exists."
+          return
+        end
+
+        default_config = IO.read("#{__dir__}/default_config/Itsi.rb")
+
+        if File.exist?("./config.ru")
+          default_config << <<~RUBY
+          # You can mount several Ruby apps as either
+          # 1. rackup files
+          # 2. inline rack apps
+          # 3. inline Ruby endpoints
+          #
+          # 1. rackup_file
+          rackup_file "./config.ru"
+          #
+          # 2. inline rack app
+          # require 'rack'
+          # run(Rack::Builder.app do
+          #   use Rack::CommonLogger
+          #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+          # end)
+          #
+          # 3. Endpoints
+          # endpoint "/" do |req|
+          #   req.ok "Hello from Itsi"
+          # end
+          RUBY
+        else
+          default_config << <<~RUBY
+            # You can mount several Ruby apps as either
+            # 1. rackup files
+            # 2. inline rack apps
+            # 3. inline Ruby endpoints
+            #
+            # 1. rackup_file
+            # Use `rackup_file` to specify the Rack app file name.
+            #
+            # 2. inline rack app
+            # require 'rack'
+            # run(Rack::Builder.app do
+            #   use Rack::CommonLogger
+            #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+            # end)
+            #
+            # 3. Endpoint
+            endpoint "/" do |req|
+              req.ok "Hello from Itsi"
+            end
+          RUBY
+        end
+
+        File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
+          file.write(default_config)
+        end
+
+      end
+    end
+  end
+end

data/lib/itsi/server/default_app/default_app.rb

@@ -0,0 +1,34 @@
+# When you Run Itsi without a Rack app,
+# 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"
+
+  Itsi::Server::RackInterface.for(lambda do |env|
+    headers, body = \
+      if env["itsi.response"].json?
+        [
+          { "Content-Type" => "application/json" },
+          [{ "message" => "You're running on Itsi!", "rack_env" => env,
+              "version" => Itsi::Server::VERSION }.to_json]
+        ]
+      else
+        [
+          { "Content-Type" => "text/html" },
+          [
+            format(
+              DEFAULT_INDEX,
+              REQUEST_METHOD: env["REQUEST_METHOD"],
+              PATH_INFO: env["PATH_INFO"],
+              SERVER_NAME: env["SERVER_NAME"],
+              SERVER_PORT: env["SERVER_PORT"],
+              REMOTE_ADDR: env["REMOTE_ADDR"],
+              HTTP_USER_AGENT: env["HTTP_USER_AGENT"]
+            )
+          ]
+        ]
+      end
+    [200, headers, body]
+  end)
+}

data/lib/itsi/server/default_app/index.html

@@ -0,0 +1,115 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Itsi - Default</title>
+    <style>
+      :root {
+        --bg-color: #f0f2f5;
+        --text-color: #333;
+        --link-color: #0052cc;
+      }
+      *,
+      *::before,
+      *::after {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        font-family: "Helvetica Neue", Arial, sans-serif;
+        background: var(--bg-color);
+        color: var(--text-color);
+        line-height: 1.6;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        padding: 3rem 1rem;
+      }
+      header {
+        text-align: center;
+        margin-bottom: 2rem;
+      }
+      h1 {
+        font-size: 2.5rem;
+        margin-bottom: 0.5rem;
+      }
+      p {
+        font-size: 1.5rem;
+        margin-bottom: 2rem;
+        color: #555;
+      }
+      ul.fields {
+        list-style: none;
+        padding: 0;
+        margin: 0;
+        max-width: 100%%;
+        width: 100%%;
+      }
+      ul.fields li {
+        display: flex;
+        justify-content: space-between;
+        padding: 1rem;
+        border-bottom: 1px solid #ddd;
+      }
+      ul.fields li:last-child {
+        border-bottom: none;
+      }
+      .label {
+        font-weight: bold;
+        margin-right: 1rem;
+      }
+      /* Make it expansive: let content use more horizontal space on larger screens */
+      main {
+        max-width: 1200px;
+        width: 100%%;
+      }
+      /* Responsive adjustments for small devices */
+      @media (max-width: 480px) {
+        h1 {
+          font-size: 2.5rem;
+        }
+        p {
+          font-size: 1.2rem;
+        }
+        ul.fields li {
+          padding: 0.75rem;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <header>
+        <h1>You're running on Itsi!</h1>
+        <p>RACK environment:</p>
+      </header>
+      <ul class="fields">
+        <li>
+          <span class="label">REQUEST_METHOD:</span>
+          <span>%{REQUEST_METHOD}</span>
+        </li>
+        <li>
+          <span class="label">PATH_INFO:</span>
+          <span>%{PATH_INFO}</span>
+        </li>
+        <li>
+          <span class="label">SERVER_NAME:</span>
+          <span>%{SERVER_NAME}</span>
+        </li>
+        <li>
+          <span class="label">SERVER_PORT:</span>
+          <span>%{SERVER_PORT}</span>
+        </li>
+        <li>
+          <span class="label">REMOTE_ADDR:</span>
+          <span>%{REMOTE_ADDR}</span>
+        </li>
+        <li>
+          <span class="label">HTTP_USER_AGENT:</span>
+          <span>%{HTTP_USER_AGENT}</span>
+        </li>
+      </ul>
+    </main>
+  </body>
+</html>