itsi 0.1.19 → 0.1.20

data/gems/server/README.md

@@ -1,5 +1,7 @@
 ---
 type: docs
+sidebar:
+  exclude: true
 ---
 
 # ItsiServer

data/gems/server/exe/itsi

@@ -7,9 +7,10 @@ require "optparse"
 
 COMMANDS = {
   "init" => "Initialize a new Itsi.rb server configuration file",
+  "test" => "Test config file validity",
   "status" => "Show the status of the server",
-  "start" => "Start the Isti server",
-  "serve" => "Start the Isti server",
+  "start" => "Start the Itsi server",
+  "serve" => "Start the Itsi server",
   "stop" => "Stop the server",
   "reload" => "Reload the server",
   "restart" => "Restart the server",
@@ -37,7 +38,7 @@ parser = OptionParser.new do |opts|
   end
 
   opts.on("-d", "--daemonize", "Run the process as a daemon") do
-    Process.daemon(true)
+    options[:daemonize] = true
   end
 
   opts.on("-t", "--threads THREADS", Integer, "Number of threads (default: 1)") do |t|
@@ -57,7 +58,7 @@ parser = OptionParser.new do |opts|
     options[:worker_memory_limit] = ml
   end
 
-  opts.on("-f", "--fiber_scheduler [CLASS_NAME]", [String],
+  opts.on("-f", "--fiber_scheduler [CLASS_NAME]", String,
           "Scheduler class to use (default: nil). Provide blank or true to use Itsi::Scheduler, or a classname to use an alternative scheduler") do |scheduler_class|
     if scheduler_class.nil? || scheduler_class == "true"
       options[:scheduler_class] = "Itsi::Scheduler"
@@ -154,7 +155,6 @@ if ENV['COMP_LINE'] || ARGV.include?('--completion')
 end
 
 parser.parse!
-
 case (command = ARGV.shift)
 when *COMMANDS.keys
   required_arity = Itsi::Server.method(command).parameters&.select{|c| c.first == :req }&.length&.succ || 2

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

@@ -0,0 +1,93 @@
+module Itsi
+  class Server
+    module Config
+      module ConfigHelpers
+
+        def self.load_and_register(klass)
+          config_type = klass.name.split("::").last.downcase
+          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
+            require file
+            following = klass.subclasses
+            new_class = (following - current).first
+
+            documentation_file = "#{file[/(.*)\.rb/,1]}.md"
+            if File.exist?(documentation_file) && new_class
+              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
+        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)
+          def cls.inherited(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)
+              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
+        end
+
+        def initialize(location, params)
+          @location = location
+          @params = case self.schema
+          when TypedStruct::Validation
+            self.schema.validate!(params)
+          else
+            self.schema.new(params).to_h
+          end
+        end
+
+        def build!
+          @params
+        end
+      end
+    end
+  end
+end

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

@@ -2,18 +2,25 @@ module Itsi
   class Server
     module Config
       class DSL
-        attr_reader :parent, :children, :middleware, :controller_class, :routes, :methods, :protocols,
+        require_relative "config_helpers"
+        require_relative "option"
+        require_relative "middleware"
+
+        attr_reader :parent, :children, :middleware, :controller_class, :routes, :http_methods, :protocols,
                     :hosts, :ports, :extensions, :content_types, :accepts, :options
 
         def self.evaluate(config = Itsi::Server::Config.config_file_path, &blk)
-          new(routes: ["/"]) do
+          config = new(routes: ["/"]) do
             if blk
               instance_exec(&blk)
             else
               code = IO.read(config)
               instance_eval(code, config.to_s, 1)
             end
-          end.options
+          end
+          [config.options, config.errors]
+        rescue Exception => e
+          [{}, [[e, e.backtrace[0]]]]
         end
 
         def initialize(
@@ -36,7 +43,7 @@ module Itsi
 
           @controller = controller
           @routes = Array(routes).flatten
-          @methods = methods.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @http_methods = methods.map { |s| s.is_a?(Regexp) ? s : s.to_s }
           @protocols = protocols.map { |s| s.is_a?(Regexp) ? s : s.to_s }
           @hosts = hosts.map { |s| s.is_a?(Regexp) ? s : s.to_s }
           @ports = ports.map { |s| s.is_a?(Regexp) ? s : s.to_s }
@@ -54,19 +61,30 @@ module Itsi
             end
           }
 
+          @errors = []
           instance_exec(&block)
         end
 
-        def workers(workers)
-          raise "Workers must be set at the root" unless @parent.nil?
-
-          @options[:workers] = [workers.to_i, 1].max
+        def errors
+          @children.map(&:errors).flatten + @errors
         end
 
-        def threads(threads)
-          raise "Threads must be set at the root" unless @parent.nil?
+        Option.subclasses.each do |option|
+          option_name = option.option_name
+          define_method(option_name) do |*args, **kwargs, &blk|
+            @options[option_name] = option.new(self, *args, **kwargs, &blk).build!
+          rescue => e
+            @errors << [e, caller[1]]
+          end
+        end
 
-          @options[:threads] = [threads.to_i, 1].max
+        Middleware.subclasses.each do |middleware|
+          middleware_name = middleware.middleware_name
+          define_method(middleware_name) do |*args, **kwargs, &blk|
+            @middleware[middleware_name] = middleware.new(@parent, *args, **kwargs, &blk).build!
+          rescue => e
+            @errors << [e, caller[1]]
+          end
         end
 
         def oob_gc_responses_threshold(threshold)
@@ -81,18 +99,24 @@ module Itsi
           @options[:log_level] = level.to_s
         end
 
-        def log_format(format)
-          raise "Log format must be set at the root" unless @parent.nil?
-
-          @options[:log_format] = format.to_s
-        end
-
         def log_target(target)
           raise "Log target must be set at the root" unless @parent.nil?
 
           @options[:log_target] = target.to_s
         end
 
+        def log_target_filters(target_filters)
+          raise "Log target filters must be set at the root" unless @parent.nil?
+
+          @options[:log_target_filters] = target_filters
+        end
+
+        def log_format(target)
+          raise "Log format must be set at the root" unless @parent.nil?
+
+          @options[:log_format] = target.to_s
+        end
+
         def get(route, app_proc = nil, nonblocking: false, &blk)
           endpoint(route, [:get], app_proc, nonblocking: nonblocking,  &blk)
         end
@@ -138,11 +162,10 @@ module Itsi
             app_proc = Itsi::Server::TypedHandlers.handler_for(app_proc, params_schema)
           end
 
-
-          if route || methods.any?
+          if route || http_methods.any?
             # For endpoints, it's usually assumed trailing slash and non-trailing slash behaviour is the same
             routes = route == "/" ? ["", "/"] : [route]
-            location(*routes, methods: methods) do
+            location(*routes, methods: http_methods) do
               @middleware[:app] = { preloader: -> { app_proc }, nonblocking: nonblocking }
             end
           else
@@ -204,6 +227,31 @@ module Itsi
           instance_eval(code, "#{path}.rb", 1)
         end
 
+        def reuse_address(reuse_address)
+          raise "reuse_address must be set at the root" unless @parent.nil?
+          @options[:reuse_address] = reuse_address
+        end
+
+        def reuse_port(reuse_port)
+          raise "reuse_port must be set at the root" unless @parent.nil?
+          @options[:reuse_port] = reuse_port
+        end
+
+        def listen_backlog(listen_backlog)
+          raise "listen_backlog must be set at the root" unless @parent.nil?
+          @options[:listen_backlog] = listen_backlog
+        end
+
+        def nodelay(nodelay)
+          raise "nodelay must be set at the root" unless @parent.nil?
+          @options[:nodelay] = nodelay
+        end
+
+        def recv_buffer_size(recv_buffer_size)
+          raise "recv_buffer_size must be set at the root" unless @parent.nil?
+          @options[:recv_buffer_size] = recv_buffer_size
+        end
+
         def bind(bind_str)
           raise "Bind must be set at the root" unless @parent.nil?
 
@@ -296,6 +344,11 @@ module Itsi
           @options[:shutdown_timeout] = shutdown_timeout.to_f
         end
 
+        def header_read_timeout(header_read_timeout)
+          raise "Header read timeout must be set at the root" unless @parent.nil?
+
+          @options[:header_read_timeout] = header_read_timeout.to_f
+        end
 
         def stream_body(stream_body)
           raise "Stream body must be set at the root" unless @parent.nil?
@@ -309,7 +362,7 @@ module Itsi
             @children << DSL.new(
               self,
               routes: routes,
-              methods: Array(methods) | self.methods,
+              methods: Array(methods) | self.http_methods,
               protocols: Array(protocols) | self.protocols,
               hosts: Array(hosts) | self.hosts,
               ports: Array(ports) | self.ports,
@@ -327,9 +380,6 @@ module Itsi
           end
         end
 
-        def log_requests(**args)
-          @middleware[:log_requests] = args
-        end
 
         def allow_list(**args)
           args[:allowed_patterns] = Array(args[:allowed_patterns]).map do |pattern|
@@ -358,7 +408,6 @@ module Itsi
         end
 
         def auth_basic(**args)
-
           if File.exist?(".itsi-credentials") && !args[:credential_file]
             args[:credential_file] = ".itsi-credentials"
           end
@@ -432,8 +481,12 @@ module Itsi
           @middleware[:etag] = args
         end
 
+        def csp(**args)
+          @middleware[:csp] = args
+        end
+
         def intrusion_protection(**args)
-          args[:banned_url_patterns] = Array(args[:banned_url_patterns]).map do |pattern|
+          args[:banned_url_patterns] = Array(args[:banned_url_patterns]).flatten.map do |pattern|
             if pattern.is_a?(Regexp)
               pattern.source
             else
@@ -485,7 +538,7 @@ module Itsi
             result << deep_stringify_keys(
               {
                 route: Regexp.new("^#{route_options}/?$"),
-                methods: @methods.any? ? @methods : nil,
+                methods: @http_methods.any? ? @http_methods : nil,
                 protocols: @protocols.any? ? @protocols : nil,
                 hosts: @hosts.any? ? @hosts : nil,
                 ports: @ports.any? ? @ports : nil,
@@ -535,11 +588,6 @@ module Itsi
         end
 
         def effective_middleware
-          merged = merge_ancestor_middleware
-          merged.map { |k, v| { type: k.to_s, parameters: v } }
-        end
-
-        def merge_ancestor_middleware
           chain = []
           node = self
           while node
@@ -558,7 +606,7 @@ module Itsi
               merged[k] = v
             end
           end
-          merged
+          deep_stringify_keys(merged)
         end
 
         def deep_stringify_keys(obj)