itsi-server 0.2.22-aarch64-linux

data/lib/itsi/server/config.rb

@@ -0,0 +1,321 @@
+# 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"
+      ITSI_SERVER_PID_DIR = ENV.fetch("ITSI_SERVER_PID_DIR", "tmp")
+
+      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
+              rate_limit key: "address", store_config: "in_memory", requests: 5, seconds: 10
+              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: "DEBUG", format: "[{request_id}] {method} {path_and_query} - {addr} " },
+                           after: { level: "DEBUG",
+                                    format: "[{request_id}] └─ {status} in {response_time}" }
+              nodelay false
+              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
+          elsif File.exist?(config_file_path.to_s)
+            DSL.evaluate do
+              include config_file_path.gsub(".rb", "")
+              rackup_file args[:rackup_file], script_name: "/" if args.key?(:rackup_file)
+            end
+          elsif File.exist?("./config.ru")
+            DSL.evaluate do
+              preload true
+              rackup_file args.fetch(:rackup_file, "./config.ru"), script_name: "/"
+            end
+          else
+            DSL.evaluate do
+              rackup_file args[:rackup_file], script_name: "/" if args.key?(:rackup_file)
+            end
+          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, String
+          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, nil) },
+          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, false) },
+          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,
+          ruby_thread_request_backlog_size: args.fetch(:ruby_thread_request_backlog_size) do
+            itsifile_config.fetch(:ruby_thread_request_backlog_size, 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) },
+          pipeline_flush: itsifile_config.fetch(:pipeline_flush, true),
+          writev: itsifile_config.fetch(:writev, false),
+          max_concurrent_streams: itsifile_config.fetch(:max_concurrent_streams, nil),
+          max_local_error_reset_streams: itsifile_config.fetch(:max_local_error_reset_streams, nil),
+          max_header_list_size: itsifile_config.fetch(:max_header_list_size, 2 * 1024 * 1024),
+          max_send_buf_size: itsifile_config.fetch(:max_send_buf_size, 64 * 1024),
+          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),
+          send_buffer_size: itsifile_config.fetch(:send_buffer_size, 262_144)
+        }.transform_keys(&:to_s)
+
+        [srv_config, errors_to_error_lines(errors)]
+      rescue StandardError => e
+        [{}, errors_to_error_lines([[e, e.backtrace[0]]])]
+      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.respond_to?(:detailed_message) ? 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)
+        raise "Config file #{config_file_path} does not exist" if config_file_path && !File.exist?(config_file_path)
+
+        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?(ITSI_SERVER_PID_DIR)
+          File.join(ITSI_SERVER_PID_DIR, "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)
+}

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>

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# 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.
+
+env = ENV.fetch("APP_ENV") { ENV.fetch("RACK_ENV", "development") }
+
+# Number of worker processes to spawn
+# If more than 1, Itsi will be booted in Cluster mode
+workers ENV["ITSI_WORKERS"]&.to_i || (env == "development" ? 1 : nil)
+
+# 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
+
+# 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://0.0.0.0:3000"
+# bind "https://0.0.0.0: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 1024 * 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_limit_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
+
+# 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 :plain or :json. If you leave it blank Itsi will try
+# and auto-detect the format based on the TTY environment.
+log_format :plain