itsi-server 0.1.1 → 0.2.3

data/lib/itsi/server/config/options/workers.rb

@@ -0,0 +1,17 @@
+module Itsi
+  class Server
+    module Config
+      class Workers < Option
+
+        insert_text "workers ${1|1,2,Etc.nprocessors|} # Number of worker processes to run"
+
+        detail "Number of worker processes to run"
+
+        schema do
+          Range(1..255)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+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
+          return defaults unless defaults.is_a?(Hash)
+
+          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|
+              raise "─ Invalid input to #{self}: #{input.last}" if input.last && !input.last.is_a?(Hash)
+
+              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
+
+              raise "─ Unsupported keys #{excess_keys}" if excess_keys.any?
+
+              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
+            tail = tail.next while tail.next
+            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)
+                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(Proc)
+                      elsif validation.eql?(String) || validation.eql?(Symbol)
+                        unless value.is_a?(String) || value.is_a?(Symbol)
+                          raise ArgumentError,
+                                "Invalid #{validation} value: #{value.inspect}"
+                        end
+
+                        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: lambda { |*validations|
+            Validation.new(:Or, lambda { |v|
+              return true if v.nil?
+
+              errs = []
+              validations.each do |validation|
+                v = validation.validate!(v)
+                return v
+              rescue StandardError => e
+                errs << e.message
+              end
+              raise StandardError.new("─ Validation failed (None match:) \n  └#{errs.join("\n  └")}")
+            })
+          },
+          Range: lambda { |input_range|
+            Validation.new(:Range, [input_range])
+          },
+          Length: lambda { |input_length|
+            Validation.new(:Length, ->(value) { input_length === value.length })
+          },
+          Hash: lambda { |key_type, value_type|
+            Validation.new(:Hash, lambda { |hash|
+              return true if hash.nil?
+              raise StandardError.new("Expected hash got #{hash.class}") unless hash.is_a?(Hash)
+
+              hash.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.is_a?(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,304 @@
+# 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 Exception => e # rubocop:disable Lint/RescueException
+            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: if args[:hooks] && itsifile_config[:hooks]
+                   args[:hooks].merge(itsifile_config[:hooks])
+                 else
+                   itsifile_config.fetch(
+                     :hooks, args[:hooks]
+                   )
+                 end,
+          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)
+
+        [srv_config, errors_to_error_lines(errors)]
+      rescue StandardError
+        Itsi.log_error e.message
+        puts e.backtrace
+      end
+
+      def self.test!(cli_params)
+        config, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        unless errors.any?
+          begin
+            config["middleware_loader"][]
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            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
+
+      def self.errors_to_error_lines(errors)
+        return unless errors
+
+        errors.flat_map do |(error, message)|
+          location = message[/(.*?):in/, 1]
+          file, lineno = location.split(":")
+          lineno = lineno.to_i
+          err_message = error.is_a?(NoMethodError) ? error.detailed_message : error.message
+          file_lines = IO.readlines(file)
+          info_lines = \
+            if error.is_a?(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
+      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")
+
+        default_config << \
+          if File.exist?("./config.ru")
+            <<~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
+            <<~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)
+}