itsi 0.1.19 → 0.2.2

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

@@ -2,18 +2,26 @@ 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, :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
+            location("*"){}
+          end
+          [config.options, config.errors]
+        rescue Exception => e
+          [{}, [[e, e.backtrace[0]]]]
         end
 
         def initialize(
@@ -32,11 +40,10 @@ module Itsi
           @parent           = parent
           @children         = []
           @middleware       = {}
-          @controller_class = nil
 
           @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 }
@@ -50,122 +57,40 @@ module Itsi
               @options[:middleware_loaders].each(&:call)
               @middleware[:app] ||= {}
               @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
+              if errors.any?
+                error = errors.first.first
+                error.set_backtrace(error.backtrace.drop_while{|r| r =~ /itsi\/server\/config/ })
+                raise error
+              end
               flatten_routes
             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
-        end
-
-        def threads(threads)
-          raise "Threads must be set at the root" unless @parent.nil?
-
-          @options[:threads] = [threads.to_i, 1].max
-        end
-
-        def oob_gc_responses_threshold(threshold)
-          raise "OOB GC responses threshold must be set at the root" unless @parent.nil?
-
-          @options[:oob_gc_responses_threshold] = threshold.to_i
-        end
-
-        def log_level(level)
-          raise "Log level must be set at the root" unless @parent.nil?
-
-          @options[:log_level] = level.to_s
+        def errors
+          @children.map(&:errors).flatten(1) + @errors
         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 get(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:get], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def post(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:post], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def put(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:put], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def delete(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:delete], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def patch(route, app_proc = nil, nonblocking: false, &blk)
-          endpoint(route, [:patch], app_proc, nonblocking: nonblocking,  &blk)
-        end
-
-        def endpoint(route=nil, methods=[], app_proc = nil, nonblocking: false, &blk)
-          raise "You must provide either a block or an explicit handler for the endpoint" if app_proc.nil? && blk.nil?
-
-          app_proc = @controller.method(app_proc).to_proc if app_proc.is_a?(Symbol)
-
-          app_proc ||= blk
-          num_required, keywords = Itsi::Server::TypedHandlers::SourceParser.extract_expr_from_source_location(app_proc)
-          params_schema = keywords[:params]
-
-          if params_schema && num_required > 1
-            raise "Cannot accept multiple required parameters in a single endpoint. A single typed or untyped params argument is supported"
-          end
-          if num_required > 2
-            raise "Cannot accept more than two required parameters in a single endpoint. An can either accept a single request argument, or a request and a params argument (which may be typed or untyped)"
-          end
-          if num_required == 0
-            raise "Cannot accept zero required parameters in a single endpoint. Endpoint must accept a request parameter"
-          end
-
-          accepts_params = !params_schema.nil? || num_required > 1
-
-          if accepts_params
-            app_proc = Itsi::Server::TypedHandlers.handler_for(app_proc, params_schema)
-          end
-
-
-          if route || 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
-              @middleware[:app] = { preloader: -> { app_proc }, nonblocking: nonblocking }
-            end
-          else
-            app = { preloader: -> { app_proc }, nonblocking: nonblocking }
-            @middleware[:app] = app
-            location("*") do
-              @middleware[:app] = app
-            end
+        Option.subclasses.each do |option|
+          option_name = option.option_name
+          define_method(option_name) do |*args, **kwargs, &blk|
+            option.new(self, *args, **kwargs, &blk).build!
+          rescue => e
+            @errors << [e, caller[1]]
           end
         end
 
-        def grpc(*handlers, reflection: true, nonblocking: false, **, &blk)
-          if @middleware[:app] && @middleware[:app][:request_type].to_s != "grpc"
-            raise "App has already been set. You can use only one of `run` and `rackup_file` or `grpc` per location"
-          end
-
-          grpc_reflection(handlers) if reflection
-
-          handlers.each do |handler|
-            location(Regexp.new("#{Regexp.escape(handler.class.service_name)}/(?:#{handler.class.rpc_descs.keys.map(&:to_s).join("|")})")) do
-              @middleware[:app] = { preloader: -> { Itsi::Server::GrpcInterface.for(handler) }, request_type: "grpc", nonblocking: nonblocking }
-              instance_exec(&blk)
-            end
+        Middleware.subclasses.each do |middleware|
+          middleware_name = middleware.middleware_name
+          define_method(middleware_name) do |*args, **kwargs, &blk|
+            middleware.new(self, *args, **kwargs, &blk).build!
+          rescue Config::Endpoint::InvalidHandlerException => e
+            @errors << [e, "#{e.backtrace[0]}:in #{e.message}"]
+          rescue => e
+            @errors << [e, caller[1]]
           end
         end
 
@@ -173,307 +98,16 @@ module Itsi
           @grpc_reflected_services ||= []
           @grpc_reflected_services.concat(handlers)
 
-          location(["grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
-                    "grpc.reflection.v1.ServerReflection/ServerReflectionInfo"]) do
+          location("grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo",
+                    "grpc.reflection.v1.ServerReflection/ServerReflectionInfo") do
             @middleware[:app] = { preloader: lambda {
               Itsi::Server::GrpcInterface.reflection_for(handlers)
             }, request_type: "grpc" }
           end
         end
 
-        def run(app, sendfile: true, nonblocking: false, path_info: "/")
-          app_args = { preloader: -> { Itsi::Server::RackInterface.for(app) }, sendfile: sendfile, base_path: "^(?<base_path>#{paths_from_parent.gsub(/\.\*\)$/, ')')}).*$", path_info: path_info, nonblocking: nonblocking }
-          base_path =  "^(?<base_path>#{paths_from_parent.gsub(/\.\*\)$/, ')')}).*$"
-          @middleware[:app] = app_args
-          location("*") do
-            @middleware[:app] = app_args
-          end
-        end
-
-        def rackup_file(rackup_file, nonblocking: false, sendfile: true, path_info: "/")
-          raise "Rackup file #{rackup_file} doesn't exist" unless File.exist?(rackup_file)
-          app_args = { preloader: -> { Itsi::Server::RackInterface.for(rackup_file) }, sendfile: sendfile, base_path: "^(?<base_path>#{paths_from_parent.gsub(/\.\*\)$/, ')')}).*$", path_info: path_info, nonblocking: nonblocking }
-          @middleware[:app] = app_args
-          location("*") do
-            @middleware[:app] = app_args
-          end
-        end
-
-        def include(path)
-          code = IO.read("#{path}.rb")
-          instance_eval(code, "#{path}.rb", 1)
-        end
-
-        def bind(bind_str)
-          raise "Bind must be set at the root" unless @parent.nil?
-
-          @options[:binds] ||= []
-          @options[:binds] << bind_str.to_s
-        end
-
-        def after_fork(&block)
-          raise "After fork must be set at the root" unless @parent.nil?
-
-          @options[:hooks] ||= {}
-          @options[:hooks][:after_fork] = block
-        end
-
-        def before_fork(&block)
-          raise "Before fork must be set at the root" unless @parent.nil?
-
-          @options[:hooks] ||= {}
-          @options[:hooks][:before_fork] = block
-        end
-
-        def after_memory_threshold_reached(&block)
-          raise "Before fork must be set at the root" unless @parent.nil?
-
-          @options[:hooks] ||= {}
-          @options[:hooks][:after_memory_threshold_reached] = block
-        end
-
-        def worker_memory_limit(memory_limit)
-          raise "Worker memory limit must be set at the root" unless @parent.nil?
-
-          @options[:worker_memory_limit] = memory_limit
-        end
-
-        def multithreaded_reactor(multithreaded)
-          raise "Multithreaded reactor must be set at the root" unless @parent.nil?
-
-          @options[:multithreaded_reactor] = !!multithreaded
-        end
-
-        def pin_worker_cores(pin_worker_cores)
-          raise "Pin worker cores must be set at the root" unless @parent.nil?
-
-          @options[:pin_worker_cores] = !!pin_worker_cores
-        end
-
-        def auto_reload_config!
-          if ENV["BUNDLE_BIN_PATH"]
-            watch "Itsi.rb", [%w[bundle exec itsi restart]]
-          else
-            watch "Itsi.rb", [%w[itsi restart]]
-          end
-        end
-
-        def watch(path, commands)
-          raise "Watch be set at the root" unless @parent.nil?
-
-          @options[:notify_watchers] ||= []
-          @options[:notify_watchers] << [path, commands]
-        end
-
-        def fiber_scheduler(klass_name = true)
-          raise "Fiber scheduler must be set at the root" unless @parent.nil?
-
-          klass_name = "Itsi::Scheduler" if klass_name == true
-          @options[:scheduler_class] = klass_name if klass_name
-        end
-
-        def scheduler_threads(threads = 1)
-          raise "Scheduler threads must be set at the root" unless @parent.nil?
-
-          @options[:scheduler_threads] = threads
-        end
-
-        def request_timeout(request_timeout)
-          raise "Request timeout must be set at the root" unless @parent.nil?
-
-          @options[:request_timeout] = request_timeout
-        end
-
-        def preload(preload)
-          raise "Preload must be set at the root" unless @parent.nil?
-
-          @options[:preload] = preload
-        end
-
-        def shutdown_timeout(shutdown_timeout)
-          raise "Shutdown timeout must be set at the root" unless @parent.nil?
-
-          @options[:shutdown_timeout] = shutdown_timeout.to_f
-        end
-
-
-        def stream_body(stream_body)
-          raise "Stream body must be set at the root" unless @parent.nil?
-
-          @options[:stream_body] = !!stream_body
-        end
-
-        def location(*routes, methods: [], protocols: [], hosts: [], ports: [], extensions: [], content_types: [],
-                     accepts: [], &block)
-          build_child = lambda {
-            @children << DSL.new(
-              self,
-              routes: routes,
-              methods: Array(methods) | self.methods,
-              protocols: Array(protocols) | self.protocols,
-              hosts: Array(hosts) | self.hosts,
-              ports: Array(ports) | self.ports,
-              extensions: Array(extensions) | self.extensions,
-              content_types: Array(content_types) | self.content_types,
-              accepts: Array(accepts) | self.accepts,
-              controller: @controller,
-              &block
-            )
-          }
-          if @parent.nil?
-            @options[:middleware_loaders] << build_child
-          else
-            build_child[]
-          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|
-            if pattern.is_a?(Regexp)
-              pattern.source
-            else
-              pattern
-            end
-          end
-          @middleware[:allow_list] = args
-        end
-
-        def deny_list(**args)
-          args[:denied_patterns] = Array(args[:denied_patterns]).map do |pattern|
-            if pattern.is_a?(Regexp)
-              pattern.source
-            else
-              pattern
-            end
-          end
-          @middleware[:deny_list] = args
-        end
-
-        def controller(controller)
-          @controller = controller
-        end
-
-        def auth_basic(**args)
-
-          if File.exist?(".itsi-credentials") && !args[:credential_file]
-            args[:credential_file] = ".itsi-credentials"
-          end
-
-          if args[:credential_file] && File.exist?(args[:credential_file])
-            args[:credential_pairs] = Passfile.load(args[:credential_file])
-          end
-
-          @middleware[:auth_basic] = args
-        end
-
-        def redirect(**args)
-          @middleware[:redirect] = args
-        end
-
-        def proxy(**args)
-          @middleware[:proxy] = args
-        end
-
-        def static_response(**args)
-          args[:body] = args[:body].bytes
-          @middleware[:static_response] = args
-        end
-
-        def auth_jwt(**args)
-          @middleware[:auth_jwt] = args
-        end
-
-        def auth_api_key(**args)
-          if args[:valid_keys] && args[:valid_keys].is_a?(Array)
-            args[:valid_keys] = args[:valid_keys].each_with_index.map { |key, index| [index, key] }.to_h
-            args[:key_id_source] = nil
-          end
-
-          if File.exist?(".itsi-credentials") && !args[:credential_file]
-            args[:credential_file] = ".itsi-credentials"
-          end
-
-          if args[:credential_file] && File.exist?(args[:credential_file])
-            args[:valid_keys] = Passfile.load(args[:credential_file])
-          end
-
-          @middleware[:auth_api_key] = args
-        end
-
-        def compress(**args)
-          @middleware[:compression] = args
-        end
-
-        def request_headers(**args)
-          @middleware[:request_headers] = args
-        end
-
-        def max_body(**args)
-          @middleware[:max_body] = args
-        end
-
-        def response_headers(**args)
-          @middleware[:response_headers] = args
-        end
-
-        def rate_limit(**args)
-          @middleware[:rate_limit] = args
-        end
-
-        def cache_control(**args)
-          @middleware[:cache_control] = args
-        end
-
-        def etag(**args)
-          @middleware[:etag] = args
-        end
-
-        def intrusion_protection(**args)
-          args[:banned_url_patterns] = Array(args[:banned_url_patterns]).map do |pattern|
-            if pattern.is_a?(Regexp)
-              pattern.source
-            else
-              pattern
-            end
-          end
-          @middleware[:intrusion_protection] = args
-        end
-
-        def cors(**args)
-          @middleware[:cors] = args
-        end
-
-        def static_assets(**args)
-          root_dir = args[:root_dir] || "."
-
-          if !File.exist?(root_dir)
-            warn "Warning: static_assets root_dir '#{root_dir}' does not exist!"
-          elsif !File.directory?(root_dir)
-            warn "Warning: static_assets root_dir '#{root_dir}' is not a directory!"
-          end
-
-          args[:relative_path] = true unless args.key?(:relative_path)
-
-          args[:allowed_extensions] ||= []
-
-          if (args[:allowed_extensions].include?("html") || args[:allowed_extensions].include?(:html)) && args[:try_html_extension]
-            args[:allowed_extensions] << ""
-          end
-
-          args[:base_path] = "^(?<base_path>#{paths_from_parent}).*$"
-
-          location("*", extensions: args[:allowed_extensions]) do
-            @middleware[:static_assets] = args
-          end
-        end
-
         def file_server(**args)
-          # Forward to static_assets for implementation
-          puts "Note: file_server is an alias for static_assets"
+          Itsi.log_info "Note: file_server is an alias for static_assets"
           static_assets(**args)
         end
 
@@ -485,7 +119,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 +169,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
@@ -555,10 +184,14 @@ module Itsi
 
           chain.each do |n|
             n.middleware.each do |k, v|
-              merged[k] = v
+              if v[:combine]
+                merged[k] = ([merged[k] || []] + [v]).flatten
+              else
+                merged[k] = v
+              end
             end
           end
-          merged
+          deep_stringify_keys(merged)
         end
 
         def deep_stringify_keys(obj)