itsi 0.1.14 → 0.1.19

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

@@ -5,10 +5,10 @@ module Itsi
         attr_reader :parent, :children, :middleware, :controller_class, :routes, :methods, :protocols,
                     :hosts, :ports, :extensions, :content_types, :accepts, :options
 
-        def self.evaluate(config = Itsi::Server::Config.config_file_path)
-          new do
-            if config.is_a?(Proc)
-              instance_exec(&config)
+        def self.evaluate(config = Itsi::Server::Config.config_file_path, &blk)
+          new(routes: ["/"]) do
+            if blk
+              instance_exec(&blk)
             else
               code = IO.read(config)
               instance_eval(code, config.to_s, 1)
@@ -35,7 +35,6 @@ module Itsi
           @controller_class = nil
 
           @controller = controller
-          # We'll store our array of route specs (strings or a single Regexp).
           @routes = Array(routes).flatten
           @methods = methods.map { |s| s.is_a?(Regexp) ? s : s.to_s }
           @protocols = protocols.map { |s| s.is_a?(Regexp) ? s : s.to_s }
@@ -49,6 +48,8 @@ module Itsi
             middleware_loaders: [],
             middleware_loader: lambda do
               @options[:middleware_loaders].each(&:call)
+              @middleware[:app] ||= {}
+              @middleware[:app][:app_proc] = @middleware[:app]&.[](:preloader)&.call || DEFAULT_APP[]
               flatten_routes
             end
           }
@@ -56,7 +57,6 @@ module Itsi
           instance_exec(&block)
         end
 
-
         def workers(workers)
           raise "Workers must be set at the root" unless @parent.nil?
 
@@ -84,83 +84,118 @@ module Itsi
         def log_format(format)
           raise "Log format must be set at the root" unless @parent.nil?
 
-          case format.to_s
-          when "auto" then nil
-          when "ansi" then ENV["ITSI_LOG_ANSI"] = "true"
-          when "json", "plain" then ENV["ITSI_LOG_PLAIN"] = "true"
-          else raise "Invalid log format '#{format}'"
-          end
+          @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, &blk)
-          endpoint(route, :get, app_proc, &blk)
+        def get(route, app_proc = nil, nonblocking: false, &blk)
+          endpoint(route, [:get], app_proc, nonblocking: nonblocking,  &blk)
         end
 
-        def post(route, app_proc = nil, &blk)
-          endpoint(route, :post, app_proc, &blk)
+        def post(route, app_proc = nil, nonblocking: false, &blk)
+          endpoint(route, [:post], app_proc, nonblocking: nonblocking,  &blk)
         end
 
-        def put(route, app_proc = nil, &blk)
-          endpoint(route, :put, app_proc, &blk)
+        def put(route, app_proc = nil, nonblocking: false, &blk)
+          endpoint(route, [:put], app_proc, nonblocking: nonblocking,  &blk)
         end
 
-        def delete(route, app_proc = nil, &blk)
-          endpoint(route, :delete, app_proc, &blk)
+        def delete(route, app_proc = nil, nonblocking: false, &blk)
+          endpoint(route, [:delete], app_proc, nonblocking: nonblocking,  &blk)
         end
 
-        def patch(route, app_proc = nil, &blk)
-          endpoint(route, :patch, app_proc, &blk)
+        def patch(route, app_proc = nil, nonblocking: false, &blk)
+          endpoint(route, [:patch], app_proc, nonblocking: nonblocking,  &blk)
         end
 
-        def endpoint(route, method, app_proc = nil, &blk)
-          raise "You can't use both a block and an explicit handler in the same endpoint" if blk && app_proc
+        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
 
-          location(route, methods: [method]) do
-            @middleware[:app] = { app_proc: app_proc }
+          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
           end
         end
 
-        def grpc(handler, **)
+        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
 
-          @middleware[:app] ||= {
-            request_type: "grpc",
-            impls: []
-          }
-          @middleware[:app][:impls] << handler
-          @middleware[:app][:app_proc] = Itsi::Server::GrpcInterface.for(@middleware[:app][:impls])
-        end
+          grpc_reflection(handlers) if reflection
 
-        def run(app, sendfile: true)
-          if @options[:app_loader]
-            raise "App has already been set. You can use only one of `run` and `rackup_file` per location"
+          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
 
-          if @parent.nil?
-            @options[:app_loader] = -> { { "app_proc" => Itsi::Server::RackInterface.for(app) } }
-          else
-            @middleware[:app] = { app_proc: Itsi::Server::RackInterface.for(app), sendfile: sendfile }
+        def grpc_reflection(handlers)
+          @grpc_reflected_services ||= []
+          @grpc_reflected_services.concat(handlers)
+
+          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 rackup_file(rackup_file)
-          if @options[:app_loader]
-            raise "App has already been set. You can use only one of `run` and `rackup_file` per location"
+        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)
-
-          if @parent.nil?
-            @options[:app_loader] = -> { { "app_proc" => Itsi::Server::RackInterface.for(rackup_file) } }
-          else
-            @middleware[:app] = { app_proc: Itsi::Server::RackInterface.for(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
 
@@ -209,6 +244,20 @@ module Itsi
           @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?
 
@@ -223,6 +272,18 @@ module Itsi
           @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?
 
@@ -235,11 +296,6 @@ module Itsi
           @options[:shutdown_timeout] = shutdown_timeout.to_f
         end
 
-        def script_name(script_name)
-          raise "Script name must be set at the root" unless @parent.nil?
-
-          @options[:script_name] = script_name.to_s
-        end
 
         def stream_body(stream_body)
           raise "Stream body must be set at the root" unless @parent.nil?
@@ -298,80 +354,85 @@ module Itsi
         end
 
         def controller(controller)
-          raise "`controller` must be set inside a location block" if @parent.nil?
-
           @controller = controller
         end
 
         def auth_basic(**args)
-          raise "`auth_basic` must be set inside a location block" if @parent.nil?
+
+          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)
-          raise "`redirect` must be set inside a location block" if @parent.nil?
-
           @middleware[:redirect] = args
         end
 
         def proxy(**args)
-          raise "`proxy` must be set inside a location block" if @parent.nil?
-
           @middleware[:proxy] = args
         end
 
-        def auth_jwt(**args)
-          raise "`auth_jwt` must be set inside a location block" if @parent.nil?
+        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)
-          raise "`auth_api_key` must be set inside a location block" if @parent.nil?
+          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)
-          raise "`compress` must be set inside a location block" if @parent.nil?
-
           @middleware[:compression] = args
         end
 
         def request_headers(**args)
-          raise "`request_headers` must be set inside a location block" if @parent.nil?
-
           @middleware[:request_headers] = args
         end
 
-        def response_headers(**args)
-          raise "`response_headers` must be set inside a location block" if @parent.nil?
+        def max_body(**args)
+          @middleware[:max_body] = args
+        end
 
+        def response_headers(**args)
           @middleware[:response_headers] = args
         end
 
         def rate_limit(**args)
-          raise "`rate_limit` must be set inside a location block" if @parent.nil?
-
           @middleware[:rate_limit] = args
         end
 
         def cache_control(**args)
-          raise "`cache_control` must be set inside a location block" if @parent.nil?
-
           @middleware[:cache_control] = args
         end
 
         def etag(**args)
-          raise "`etag` must be set inside a location block" if @parent.nil?
-
           @middleware[:etag] = args
         end
 
         def intrusion_protection(**args)
-          raise "`intrusion_protection` must be set inside a location block" if @parent.nil?
-
           args[:banned_url_patterns] = Array(args[:banned_url_patterns]).map do |pattern|
             if pattern.is_a?(Regexp)
               pattern.source
@@ -383,14 +444,10 @@ module Itsi
         end
 
         def cors(**args)
-          raise "`cors` must be set inside a location block" if @parent.nil?
-
           @middleware[:cors] = args
         end
 
         def static_assets(**args)
-          raise "`static_assets` must be set inside a location block" if @parent.nil?
-
           root_dir = args[:root_dir] || "."
 
           if !File.exist?(root_dir)
@@ -401,14 +458,20 @@ module Itsi
 
           args[:relative_path] = true unless args.key?(:relative_path)
 
-          location(/(?<path_suffix>.*)/, extensions: args[:allowed_extensions] || []) do
+          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)
-          raise "`file_server` must be set inside a location block" if @parent.nil?
-
           # Forward to static_assets for implementation
           puts "Note: file_server is an alias for static_assets"
           static_assets(**args)
@@ -421,7 +484,7 @@ module Itsi
           if route_options
             result << deep_stringify_keys(
               {
-                route: Regexp.new("^#{route_options}$"),
+                route: Regexp.new("^#{route_options}/?$"),
                 methods: @methods.any? ? @methods : nil,
                 protocols: @protocols.any? ? @protocols : nil,
                 hosts: @hosts.any? ? @hosts : nil,
@@ -443,22 +506,27 @@ module Itsi
             case seg
             when Regexp
               seg.source
-            when /^:([A-Za-z_]\w*)(?:\(([^)]*)\))?$/
-              param_name = Regexp.last_match(1)
-              custom     = Regexp.last_match(2)
-              if custom && !custom.empty?
-                "(?<#{param_name}>#{custom})"
-              else
-                "(?<#{param_name}>[^/]+)"
-              end
-            when /\*/
-              seg.gsub(/\*/, ".*")
             else
-              Regexp.escape(seg).gsub(%r{/$}, ".*")
+              parts = seg.split('/')
+              parts.map do |part|
+                case part
+                when /^:([A-Za-z_]\w*)(?:\(([^)]*)\))?$/
+                  param_name = Regexp.last_match(1)
+                  custom     = Regexp.last_match(2)
+                  if custom && !custom.empty?
+                    "(?<#{param_name}>#{custom})"
+                  else
+                    "(?<#{param_name}>[^/]+)"
+                  end
+                when /\*/
+                  part.gsub(/\*/, ".*")
+                else
+                  Regexp.escape(part)
+                end
+              end.join("/")
             end
           end.join("|")
-
-          if parent.paths_from_parent && parent.paths_from_parent != "(?:/.*)"
+          if parent && parent.paths_from_parent && parent.paths_from_parent != "(?:/)"
             "#{parent.paths_from_parent}#{route_or_str != "" ? "(?:#{route_or_str})" : ""}"
           else
             route_or_str = "/#{route_or_str}" unless route_or_str.start_with?("/")
@@ -475,12 +543,16 @@ module Itsi
           chain = []
           node = self
           while node
+            if node.middleware[:app]&.[](:preloader)
+              node.middleware[:app][:app_proc] = node.middleware[:app].delete(:preloader).call
+            end
             chain << node
             node = node.parent
           end
           chain.reverse!
 
           merged = {}
+
           chain.each do |n|
             n.middleware.each do |k, v|
               merged[k] = v

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

@@ -5,78 +5,113 @@ module Itsi
     module Config
       require_relative "config/dsl"
       require_relative "default_app/default_app"
-      require "debug"
 
       ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
 
-      def self.save_argv!
+      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)
+      def self.build_config(args, config_file_path, builder_proc = nil)
+        args.transform_keys!(&:to_sym)
         itsifile_config = \
           if builder_proc
-            DSL.evaluate(builder_proc)
+            DSL.evaluate(&builder_proc)
+          elsif args[:static]
+            DSL.evaluate do
+              location "/" do
+                allow_list allowed_patterns: ['127.0.0.1']
+                rate_limit key: 'address', store_config: 'in_memory', requests: 2, seconds: 5
+                etag type: 'strong', algorithm: 'md5', min_body_size: 1024 * 1024
+                compress min_size: 1024 * 1024, level: 'fastest', algorithms: %w[zstd gzip brotli deflate], mime_types: %w[all], compress_streams: true
+                log_requests before: { level: "INFO", format: "[{request_id}] {method} {path_and_query} - {addr} " }, after: { level: "INFO", format: "[{request_id}] └─ {status} in {response_time}" }
+                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
+            end
           elsif File.exist?(config_file_path.to_s)
             DSL.evaluate(config_file_path)
+          elsif File.exist?("./config.ru")
+            DSL.evaluate do
+              preload true
+              rackup_file args.fetch(:rackup_file, "./config.ru")
+            end
           else
-            {}
+            DSL.evaluate{}
           end
-        args.transform_keys!(&:to_sym)
+
         itsifile_config.transform_keys!(&:to_sym)
 
         # We'll preload while we load config, if enabled.
         middleware_loader = itsifile_config.fetch(:middleware_loader, -> {})
-        default_app_loader = itsifile_config.fetch(:app_loader) do
-          rackup_file_path = args.fetch(:rackup_file, "./config.ru")
-          if File.exist?(rackup_file_path)
-            lambda {
-              { "app_proc" => Itsi::Server::RackInterface.for(rackup_file_path) }
-            }
-          else
-            DEFAULT_APP
-          end
-        end
         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
           preloaded_middleware = middleware_loader.call
-          preloaded_app = default_app_loader.call
           middleware_loader = -> { preloaded_middleware }
-          default_app_loader = -> { preloaded_app }
         # If we're just preloading a specific gem group, we'll do that here too
         when Symbol
           Bundler.require(preload)
         end
 
         {
-          workers: args.fetch(:workers) { itsifile_config.fetch(:workers, Etc.nprocessors) },
+          workers: args.fetch(:workers) { itsifile_config.fetch(:workers, 1) },
           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: itsifile_config.fetch(:hooks, nil),
           preload: !!preload,
+          request_timeout: itsifile_config.fetch(:request_timeout, nil),
           notify_watchers: itsifile_config.fetch(:notify_watchers, nil),
           threads: args.fetch(:threads) { itsifile_config.fetch(:threads, 1) },
-          script_name: args.fetch(:script_name) { itsifile_config.fetch(:script_name, "") },
+          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, true)
+            itsifile_config.fetch(:multithreaded_reactor, nil)
           end,
+          pin_worker_cores: args.fetch(:pin_worker_cores) { itsifile_config.fetch(:pin_worker_cores, true) },
           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,
           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) },
           binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
           middleware_loader: middleware_loader,
-          default_app_loader: default_app_loader,
           listeners: args.fetch(:listeners) { nil }
         }.transform_keys(&:to_s)
       end
@@ -123,7 +158,7 @@ module Itsi
 
         puts "Writing default configuration..."
         File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
-          file.write(IO.read("#{__dir__}/Itsi.rb"))
+          file.write(IO.read("#{__dir__}/default_config/Itsi.rb"))
         end
       end
     end

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

@@ -4,35 +4,31 @@ DEFAULT_INDEX = IO.read("#{__dir__}/index.html").freeze
 DEFAULT_BINDS = ["http://0.0.0.0:3000"].freeze
 DEFAULT_APP = lambda {
   require "json"
-  require "itsi/scheduler"
-  Itsi.log_warn "No config.ru or Itsi.rb app detected. Running default app."
-  {
-    "app_proc" => 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
+
+  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" },
           [
-            { "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"]
-              )
-            ]
+            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)
-  }
-
+        ]
+      end
+    [200, headers, body]
+  end)
 }