itsi 0.1.20 → 0.2.2

data/gems/server/lib/itsi/http_request.rb

@@ -92,7 +92,14 @@ module Itsi
     )
 
       if json
-        validate!(json, as: as) if as
+        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"
@@ -111,6 +118,8 @@ module Itsi
       end
 
       response.respond(status: status, headers: headers, body: body, hijack: hijack, &blk)
+
+
     end
 
     def hijack
@@ -124,12 +133,16 @@ module Itsi
       end
     end
 
+    def body
+      @body ||= build_input_io
+    end
+
     def build_input_io
-      case body
+      case body_parts
       when nil then EMPTY_IO
-      when String then StringIO.new(body)
-      when Array then File.open(body.first, "rb")
-      else body
+      when String then StringIO.new(body_parts)
+      when Array then File.open(body_parts.first, "rb")
+      else body_parts
       end
     end
 
@@ -155,15 +168,33 @@ module Itsi
       end
 
       params.merge!(query_params).merge!(url_params)
-
-      yield schema ? apply_schema!(params, schema) : params
-
-    rescue StandardError => e
+      validated = schema ? apply_schema!(params, schema) : params
+      unless block_given?
+        if multipart?
+          raise "#params must take a block for multipart requests"
+        else
+          return validated
+        end
+      else
+        yield 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

data/gems/server/lib/itsi/http_response.rb

@@ -8,7 +8,8 @@ module Itsi
   class HttpResponse
 
     def respond _body=nil, _status=200, _header=nil, status: _status, headers: _header, body: _body, hijack: false, &blk
-      self.status = status
+
+      self.status = status.kind_of?(Symbol) ? HTTP_STATUS_NAME_TO_CODE_MAP.fetch(status) : status.to_i
 
       body = body.to_s unless body.is_a?(String)
 

data/gems/server/lib/itsi/passfile.rb

@@ -34,7 +34,6 @@ module Itsi
       end
 
       def echo(filename, algorithm)
-        return unless (creds = load(filename))
         print "Enter username: "
         username = $stdin.gets.chomp
 

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

@@ -4,10 +4,11 @@ module Itsi
       module ConfigHelpers
 
         def self.load_and_register(klass)
-          config_type = klass.name.split("::").last.downcase
+          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")]
+            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|
@@ -17,6 +18,9 @@ module Itsi
             new_class = (following - current).first
 
             documentation_file = "#{file[/(.*)\.rb/,1]}.md"
+            if ! File.exist?(documentation_file)
+              documentation_file =  "#{file[/(.*)\/[^\/]+\.rb/,1]}/_index.md"
+            end
             if File.exist?(documentation_file) && new_class
               new_class.documentation IO.read(documentation_file)
                 .gsub(/^---.*?\n.*?-+/m,'') # Strip frontmatter
@@ -59,6 +63,8 @@ module Itsi
               @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
@@ -72,21 +78,27 @@ module Itsi
           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)
+        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 self.schema
           when TypedStruct::Validation
             self.schema.validate!(params)
+          when Array
+            default, validation = self.schema
+            params ? validation.validate!(params) : default
+          when nil
+            nil
           else
             self.schema.new(params).to_h
           end
         end
-
-        def build!
-          @params
-        end
       end
     end
   end

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

@@ -6,7 +6,7 @@ module Itsi
         require_relative "option"
         require_relative "middleware"
 
-        attr_reader :parent, :children, :middleware, :controller_class, :routes, :http_methods, :protocols,
+        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)
@@ -17,6 +17,7 @@ module Itsi
               code = IO.read(config)
               instance_eval(code, config.to_s, 1)
             end
+            location("*"){}
           end
           [config.options, config.errors]
         rescue Exception => e
@@ -39,7 +40,6 @@ module Itsi
           @parent           = parent
           @children         = []
           @middleware       = {}
-          @controller_class = nil
 
           @controller = controller
           @routes = Array(routes).flatten
@@ -57,6 +57,11 @@ 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
           }
@@ -66,13 +71,13 @@ module Itsi
         end
 
         def errors
-          @children.map(&:errors).flatten + @errors
+          @children.map(&:errors).flatten(1) + @errors
         end
 
         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!
+            option.new(self, *args, **kwargs, &blk).build!
           rescue => e
             @errors << [e, caller[1]]
           end
@@ -81,452 +86,28 @@ module Itsi
         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!
+            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
 
-        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
-        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
-
-        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 || 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: http_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
-          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
-          end
-        end
-
         def grpc_reflection(handlers)
           @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 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?
-
-          @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 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?
-
-          @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.http_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 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 csp(**args)
-          @middleware[:csp] = args
-        end
-
-        def intrusion_protection(**args)
-          args[:banned_url_patterns] = Array(args[:banned_url_patterns]).flatten.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
 
@@ -603,7 +184,11 @@ 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
           deep_stringify_keys(merged)