itsi-server 0.2.22-aarch64-linux

data/lib/itsi/http_request/response_status_shortcodes.rb

@@ -0,0 +1,76 @@
+module Itsi
+  class HttpRequest
+    module ResponseStatusShortcodes
+
+      HTTP_STATUS_CODES = {
+        100 => :continue,
+        101 => :switching_protocols,
+        102 => :processing,
+        200 => :ok,
+        201 => :created,
+        202 => :accepted,
+        203 => :non_authoritative_information,
+        204 => :no_content,
+        205 => :reset_content,
+        206 => :partial_content,
+        207 => :multi_status,
+        208 => :already_reported,
+        226 => :im_used,
+        300 => :multiple_choices,
+        301 => :moved_permanently,
+        302 => :found,
+        303 => :see_other,
+        304 => :not_modified,
+        305 => :use_proxy,
+        307 => :temporary_redirect,
+        308 => :permanent_redirect,
+        400 => :bad_request,
+        401 => :unauthorized,
+        402 => :payment_required,
+        403 => :forbidden,
+        404 => :not_found,
+        405 => :method_not_allowed,
+        406 => :not_acceptable,
+        407 => :proxy_authentication_required,
+        408 => :request_timeout,
+        409 => :conflict,
+        410 => :gone,
+        411 => :length_required,
+        412 => :precondition_failed,
+        413 => :payload_too_large,
+        414 => :uri_too_long,
+        415 => :unsupported_media_type,
+        416 => :range_not_satisfiable,
+        417 => :expectation_failed,
+        418 => :im_a_teapot,
+        421 => :misdirected_request,
+        422 => :unprocessable_entity,
+        423 => :locked,
+        424 => :failed_dependency,
+        425 => :too_early,
+        426 => :upgrade_required,
+        428 => :precondition_required,
+        429 => :too_many_requests,
+        431 => :request_header_fields_too_large,
+        451 => :unavailable_for_legal_reasons,
+        500 => :internal_server_error,
+        501 => :not_implemented,
+        502 => :bad_gateway,
+        503 => :service_unavailable,
+        504 => :gateway_timeout,
+        505 => :http_version_not_supported,
+        506 => :variant_also_negotiates,
+        507 => :insufficient_storage,
+        508 => :loop_detected,
+        510 => :not_extended,
+        511 => :network_authentication_required
+      }.freeze
+
+      HTTP_STATUS_NAME_TO_CODE_MAP = HTTP_STATUS_CODES.invert.freeze
+
+      HTTP_STATUS_CODES.each do |code, name|
+        define_method(name) {|*args, **kwargs| respond(*args, **kwargs, status: code) }
+      end
+    end
+  end
+end

data/lib/itsi/http_request.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "socket"
+require "uri"
+require_relative "http_request/response_status_shortcodes"
+
+module Itsi
+  class HttpRequest
+    include Server::TypedHandlers::ParamParser
+    include ResponseStatusShortcodes
+    attr_accessor :hijacked
+
+    EMPTY_IO = StringIO.new("").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
+
+    RACK_HEADER_MAP = StandardHeaders::ALL.map do |header|
+      rack_form = \
+        if header == "content-type"
+          "CONTENT_TYPE"
+        elsif header == "content-length"
+          "CONTENT_LENGTH"
+        else
+          "HTTP_#{header.upcase.gsub(/-/, "_")}"
+        end
+      [header, rack_form]
+    end.to_h
+
+    RACK_HEADER_MAP.default_proc = proc { |_, key| "HTTP_#{key.upcase.gsub(/-/, "_")}" }
+
+    SPECIAL_RACK_HEADER_MAP = {
+      "content-type" => "CONTENT_TYPE",
+      "content-length" => "CONTENT_LENGTH",
+      "accept" => "HTTP_ACCEPT",
+      "accept-encoding" => "HTTP_ACCEPT_ENCODING",
+      "accept-language" => "HTTP_ACCEPT_LANGUAGE",
+      "user-agent" => "HTTP_USER_AGENT",
+      "referer" => "HTTP_REFERER",
+      "origin" => "HTTP_ORIGIN",
+      "cookie" => "HTTP_COOKIE",
+      "authorization" => "HTTP_AUTHORIZATION",
+      "x-forwarded-for" => "HTTP_X_FORWARDED_FOR",
+      "x-forwarded-proto" => "HTTP_X_FORWARDED_PROTO"
+    }.freeze
+
+    HTTP_09 = "HTTP/0.9"
+    HTTP_09_ARR = ["HTTP/0.9"].freeze
+    HTTP_10 = "HTTP/1.0"
+    HTTP_10_ARR = ["HTTP/1.0"].freeze
+    HTTP_11 = "HTTP/1.1"
+    HTTP_11_ARR = ["HTTP/1.1"].freeze
+    HTTP_20 = "HTTP/2.0"
+    HTTP_20_ARR = ["HTTP/2.0"].freeze
+    HTTP_30 = "HTTP/3.0"
+    HTTP_30_ARR = ["HTTP/3.0"].freeze
+
+    def to_rack_env
+      path = self.path
+      host = self.host
+      version = self.version
+      env = RackEnvPool.checkout
+      env["SCRIPT_NAME"] = script_name
+      env["REQUEST_METHOD"] = request_method
+      env["REQUEST_PATH"] = env["PATH_INFO"] = path
+      env["QUERY_STRING"] = query_string
+      env["REMOTE_ADDR"] = remote_addr
+      env["SERVER_PORT"] = port.to_s
+      env["HTTP_HOST"] = env["SERVER_NAME"] = host
+      env["HTTP_VERSION"] = env["SERVER_PROTOCOL"] = version
+      env["itsi.request"] = self
+      env["itsi.response"] = response
+      env["rack.version"] = \
+        case version
+        when HTTP_09 then HTTP_09_ARR
+        when HTTP_10 then HTTP_10_ARR
+        when HTTP_11 then HTTP_11_ARR
+        when HTTP_20 then HTTP_20_ARR
+        when HTTP_30 then HTTP_30_ARR
+        end
+      env["rack.url_scheme"] = scheme
+      env["rack.input"] = build_input_io
+      env["rack.hijack"] = self
+      each_header do |k, v|
+        env[SPECIAL_RACK_HEADER_MAP[k] || RACK_HEADER_MAP[k]] = v
+      end
+      env
+    end
+
+    def respond(
+      _body = nil, _status = 200, _headers = nil, # rubocop:disable Lint/UnderscorePrefixedVariableName
+      json: nil,
+      html: nil,
+      text: nil,
+      xml: nil,
+      hijack: false,
+      as: nil,
+      status: _status,
+      headers: _headers,
+      body: _body,
+      &blk
+    )
+      if json
+        if as
+          begin
+            validate!(json, as: as)
+          rescue ValidationError => e
+            json = { type: "error", message: "Validation Error: #{e.message}" }
+            status = 400
+          end
+        end
+        body = json.to_json
+        headers ||= {}
+        headers["Content-Type"] ||= "application/json"
+      elsif html
+        body = html
+        headers ||= {}
+        headers["Content-Type"] ||= "text/html"
+      elsif xml
+        body = xml
+        headers ||= {}
+        headers["Content-Type"] ||= "application/xml"
+      elsif text
+        body = text
+        headers ||= {}
+        headers["Content-Type"] ||= "text/plain"
+      end
+
+      response.respond(status: status, headers: headers, body: body, hijack: hijack, &blk)
+    end
+
+    def hijack
+      self.hijacked = true
+      UNIXSocket.pair.yield_self do |(server_sock, app_sock)|
+        server_sock.autoclose = false
+        response.hijack(server_sock.fileno)
+        server_sock.sync = true
+        app_sock.sync = true
+        app_sock
+      end
+    end
+
+    # Rack expects env["rack.hijack"] to respond to #call.
+    def call
+      hijack
+    end
+
+    def body
+      @body ||= build_input_io
+    end
+
+    def build_input_io
+      case body_parts
+      when nil then EMPTY_IO
+      when String then StringIO.new(body_parts).tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
+      when Array then File.open(body_parts.first, "rb").tap { |io| io.set_encoding(Encoding::ASCII_8BIT) }
+      else body_parts
+      end
+    end
+
+    def validate!(params, as: nil)
+      as ? apply_schema!(params, as) : params
+    end
+
+    def params(schema = nil)
+      params = if url_encoded?
+                 URI.decode_www_form(build_input_io.read).to_h
+               elsif json?
+                 JSON.parse(build_input_io.read)
+               elsif multipart?
+                 Rack::Multipart::Parser.parse(
+                   build_input_io,
+                   content_length,
+                   content_type,
+                   Rack::Multipart::Parser::TEMPFILE_FACTORY,
+                   Rack::Multipart::Parser::BUFSIZE,
+                   Rack::Utils.default_query_parser
+                 ).params
+               else
+                 {}
+               end
+
+      params.merge!(query_params).merge!(url_params)
+      validated = schema ? apply_schema!(params, schema) : params
+      if block_given?
+        yield validated
+      else
+        raise "#params must take a block for multipart requests" if multipart?
+
+        validated
+
+      end
+    rescue ValidationError => e
+      if response.json?
+        respond(json: { error: e.message }, status: 400)
+      else
+        respond(e.message, 400)
+      end
+    rescue StandardError => e
+      Itsi.log_error e.message
+      puts e.backtrace
+
+      # Unexpected error.
+      # Don't reveal potential sensitive information to client.
+      if response.json?
+        respond(json: { error: "Internal Server Error" }, status: 500)
+      else
+        respond("Internal Server Error", 500)
+      end
+    ensure
+      clean_temp_files(params)
+    end
+
+    def clean_temp_files(params)
+      case params
+      when Hash
+        if params.key?(:tempfile)
+          params[:tempfile].unlink
+        else
+          params.each_value { |v| clean_temp_files(v) }
+        end
+      when Array then params.each { |v| clean_temp_files(v) }
+      end
+    end
+
+    def query_params
+      URI.decode_www_form(query_string).to_h
+    end
+  end
+end

data/lib/itsi/http_response.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "forwardable"
+require "stringio"
+require "socket"
+
+module Itsi
+  class HttpResponse
+    def respond(
+      _body = nil, _status = 200, _header = nil, # rubocop:disable Lint/UnderscorePrefixedVariableName
+      status: _status, headers: _header, body: _body,
+      hijack: false
+    )
+      self.status = status.is_a?(Symbol) ? HTTP_STATUS_NAME_TO_CODE_MAP.fetch(status) : status.to_i
+
+      body = body.to_s unless body.is_a?(String)
+
+      if headers
+        reserve_headers(headers.size)
+        headers.each do |key, value|
+          if value.is_a?(Array)
+            value.each { |v| add_header(key, v) }
+          else
+            add_header(key, value)
+          end
+        end
+      end
+
+      if body
+        # Common case. Write a single string body.
+        send_and_close(body)
+      elsif block_given?
+
+        # If you call respond with a block, you get a handle to a stream that you can write to.
+        yield self
+
+        # If you hijack the connection, you are responsible for closing it.
+        # Otherwise, the response will be closed automatically.
+        close unless hijack
+      else
+        close
+      end
+    end
+
+    def flush
+      # No-op. Our Rust server performs stream coalescing and automatically flushes on a tight interval.
+    end
+  end
+end

data/lib/itsi/passfile.rb

@@ -0,0 +1,108 @@
+module Itsi
+  class Server
+    module Passfile
+      require "io/console"
+
+      module_function
+
+      def load(filename)
+        if filename.nil? || filename.strip.empty?
+          puts "Error: a valid filename is required."
+          return nil
+        end
+
+        creds = {}
+        if File.exist?(filename)
+          File.foreach(filename) do |line|
+            line.chomp!
+            next if line.empty?
+
+            user, pass = line.split(":", 2)
+            creds[user] = pass
+          end
+        end
+        creds
+      end
+
+      def save(creds, filename)
+        File.open(filename, "w", 0o600) do |f|
+          creds.each do |u, p|
+            f.puts "#{u}:#{p}"
+          end
+        end
+      end
+
+      def echo(_, algorithm)
+        print "Enter username: "
+        username = $stdin.gets.chomp
+
+        print "Enter password: "
+
+        password = $stdin.noecho(&:gets).chomp
+        puts
+
+        print "Confirm password: "
+        password_confirm = $stdin.noecho(&:gets).chomp
+        puts
+
+        if password != password_confirm
+          puts "Error: Passwords do not match!"
+          exit(1)
+        end
+
+        puts "#{username}:#{Itsi.create_password_hash(password, algorithm)}"
+      end
+
+      def add(filename, algorithm)
+        return unless (creds = load(filename))
+
+        print "Enter username: "
+        username = $stdin.gets.chomp
+
+        print "Enter password: "
+
+        password = $stdin.noecho(&:gets).chomp
+        puts
+
+        print "Confirm password: "
+        password_confirm = $stdin.noecho(&:gets).chomp
+        puts
+
+        if password != password_confirm
+          puts "Error: Passwords do not match!"
+          exit(1)
+        end
+
+        creds[username] = Itsi.create_password_hash(password, algorithm)
+
+        save(creds, filename)
+
+        puts "User '#{username}' added."
+      end
+
+      def remove(filename)
+        return unless (creds = load(filename))
+
+        print "Enter username to remove: "
+        username = $stdin.gets.chomp
+
+        if creds.key?(username)
+          creds.delete(username)
+          save(creds, filename)
+          puts "User '#{username}' removed."
+        else
+          puts "Warning: User '#{username}' not found."
+        end
+      end
+
+      def list(filename)
+        puts "Current credentials in '#{filename}':"
+        return unless (creds = load(filename))
+
+        creds.each do |u, p|
+          puts "#{u}:#{p}"
+        end
+      end
+    end
+  end
+end

data/lib/itsi/rack_env_pool.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Itsi
+  module RackEnvPool
+
+    RACK_ENV_TEMPLATE = {
+      "SERVER_SOFTWARE" => "Itsi",
+      "rack.errors" => $stderr,
+      "rack.multithread" => true,
+      "rack.multiprocess" => true,
+      "rack.run_once" => false,
+      "rack.hijack?" => true,
+      "rack.multipart.buffer_size" => 16_384,
+      "SCRIPT_NAME" => "",
+      "REQUEST_METHOD" => "",
+      "PATH_INFO" => "",
+      "REQUEST_PATH" => "",
+      "QUERY_STRING" => "",
+      "REMOTE_ADDR" => "",
+      "SERVER_PORT" => "",
+      "SERVER_NAME" => "",
+      "SERVER_PROTOCOL" => "",
+      "HTTP_HOST" => "",
+      "HTTP_VERSION" => "",
+      "itsi.request" => "",
+      "itsi.response" => "",
+      "rack.version" => nil,
+      "rack.url_scheme" => "",
+      "rack.input" => "",
+      "rack.hijack" => ""
+    }.freeze
+
+    POOL = []
+
+    def self.checkout
+      recycled = POOL.pop
+      return RACK_ENV_TEMPLATE.dup unless recycled
+
+      # Reset in C rather than iterating key-by-key in Ruby for every request.
+      recycled.replace(RACK_ENV_TEMPLATE)
+      recycled
+    end
+
+    def self.checkin(env)
+      POOL << env
+    end
+  end
+
+end

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

@@ -0,0 +1,116 @@
+module Itsi
+  class Server
+    module Config
+      module ConfigHelpers
+        def self.load_and_register(klass)
+          config_type = klass.name.split("::").last.downcase.gsub(/([a-z]()[A-Z])/, '\1_\2')
+
+          listing = [
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}/**/*.rb")],
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}s/**/*.rb")]
+          ].flatten
+
+          listing.each do |file|
+            current = klass.subclasses.dup
+            require file
+            following = klass.subclasses
+            new_class = (following - current).first
+
+            documentation_file = "#{file[/(.*)\.rb/, 1]}.md"
+            documentation_file = "#{file[%r{(.*)/[^/]+\.rb}, 1]}/_index.md" unless File.exist?(documentation_file)
+            unless File.exist?(documentation_file) && new_class
+              new_class&.documentation "Documentation not found"
+              next
+            end
+
+            new_class.documentation IO.read(documentation_file)
+                                      .gsub(/^---.*?\n.*?-+/m, "") # Strip frontmatter
+                                      .gsub(/^(```.*?)\{.*?\}.*$/, "\\1") # Strip filename from code blocks
+                                      .gsub(/^\{\{[^}]+\}\}/, "") # Strip Hugo blocks
+          end
+        end
+
+        def normalize_keys!(hash, expected = [])
+          hash.keys.each do |key|
+            value = hash.delete(key)
+            key = key.to_s.downcase.to_sym
+            hash[key] = value
+            raise "Unexpected key: #{key}" unless expected.include?(key)
+
+            expected -= [key]
+          end
+          raise "Missing required keys: #{expected.join(", ")}" unless expected.empty?
+
+          hash
+        end
+
+        def self.included(cls) # rubocop:disable Metrics/PerceivedComplexity,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+
+          class << cls
+            def subclasses
+              @subclasses ||= []
+            end
+          end
+
+          def cls.inherited(base) # rubocop:disable Metrics/MethodLength,Lint/MissingSuper,Metrics/PerceivedComplexity
+            self.subclasses << base
+
+            %i[detail documentation insert_text schema].each do |attr|
+              base.define_singleton_method(attr) do |value = nil|
+                @middleware_class_attrs ||= {}
+                if value
+                  @middleware_class_attrs[attr] = value
+                else
+                  @middleware_class_attrs[attr]
+                end
+              end
+
+              base.define_method(attr) do |_value = nil|
+                self.class.send(attr)
+              end
+            end
+
+            def base.schema(value = nil, &blk)
+              @middleware_class_attrs ||= {}
+              if blk
+                @middleware_class_attrs[:schema] = TypedStruct.new(&blk)
+              elsif value
+                @middleware_class_attrs[:schema] = value
+              else
+                @middleware_class_attrs[:schema]
+              end
+            end
+          end
+
+          load_and_register(cls)
+
+          config_type = cls.name.split("::").last.downcase
+
+          cls.define_singleton_method("#{config_type}_name") do |name = self.name|
+            @config_name ||= name.split("::").last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+          end
+          cls.define_method(:opt_name) { self.class.send("#{config_type}_name") }
+          cls.define_method(:location) { @location }
+        end
+
+        def initialize(location, params = {})
+          if !self.class.ancestors.include?(Middleware) && !location.parent.nil?
+            raise "#{opt_name} must be set at the top level"
+          end
+          @location = location
+          @params = case schema
+                    when TypedStruct::Validation
+                      schema.validate!(params)
+                    when Array
+                      default, validation = schema
+                      !params.nil? ? validation.validate!(params) : default
+                    when nil
+                      nil
+                    else
+                      schema.new(params).to_h
+                    end
+        end
+      end
+    end
+  end
+end