itsi 0.1.20 → 0.2.2

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

@@ -41,10 +41,9 @@ module Itsi
           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
+                compress min_size: 1024 * 1024, level: 'fastest', algorithms: %w[zstd gzip br 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,
@@ -82,50 +81,63 @@ module Itsi
         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
-          middleware_loader = -> { preloaded_middleware }
+          begin
+            Itsi.log_debug("Preloading middleware and default rack app")
+            preloaded_middleware = middleware_loader.call
+            middleware_loader = -> { preloaded_middleware }
+          rescue StandardError => e
+            errors << [e, e.backtrace[0]]
+          end
         # If we're just preloading a specific gem group, we'll do that here too
         when Symbol
+          Itsi.log_debug("Preloading gem group #{preload}")
           Bundler.require(preload)
         end
 
-        [
-          {
-            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),
-            header_read_timeout: args.fetch(:header_read_timeout) { itsifile_config.fetch(:header_read_timeout, nil) },
-            notify_watchers: itsifile_config.fetch(:notify_watchers, nil),
-            threads: args.fetch(:threads) { itsifile_config.fetch(:threads, 1) },
-            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, 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) },
-            log_target_filters: args.fetch(:log_target_filters) { itsifile_config.fetch(:log_target_filters, nil) },
-            binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
-            middleware_loader: middleware_loader,
-            listeners: args.fetch(:listeners) { nil },
-            reuse_address: itsifile_config.fetch(:reuse_address, true),
-            reuse_port: itsifile_config.fetch(:reuse_port, true),
-            listen_backlog: itsifile_config.fetch(:listen_backlog, 1024 ),
-            nodelay: itsifile_config.fetch(:nodelay, true),
-            recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144)
-          }.transform_keys(&:to_s),
+        if itsifile_config[:daemonize] && !@daemonized
+          @daemonized = true
+          Itsi.log_info("Itsi is running in the background. Writing pid to #{Itsi::Server::Config.pid_file_path}")
+          Itsi.log_info("To stop Itsi, run 'itsi stop' from this directory.")
+          Process.daemon(true, false)
+          Server.write_pid
+        end
+
+        srv_config = {
+          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: args[:hooks] && itsifile_config[:hooks] ? args[:hooks].merge(itsifile_config[:hooks]) : itsifile_config.fetch(:hooks, args[:hooks]),
+          preload: !!preload,
+          request_timeout: itsifile_config.fetch(:request_timeout, nil),
+          header_read_timeout: args.fetch(:header_read_timeout) { itsifile_config.fetch(:header_read_timeout, nil) },
+          notify_watchers: itsifile_config.fetch(:notify_watchers, nil),
+          threads: args.fetch(:threads) { itsifile_config.fetch(:threads, 1) },
+          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, 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) },
+          log_target_filters: args.fetch(:log_target_filters) { itsifile_config.fetch(:log_target_filters, nil) },
+          binds: args.fetch(:binds) { itsifile_config.fetch(:binds, ["http://0.0.0.0:3000"]) },
+          middleware_loader: middleware_loader,
+          listeners: args.fetch(:listeners) { nil },
+          reuse_address: itsifile_config.fetch(:reuse_address, true),
+          reuse_port: itsifile_config.fetch(:reuse_port, true),
+          listen_backlog: itsifile_config.fetch(:listen_backlog, 1024 ),
+          nodelay: itsifile_config.fetch(:nodelay, true),
+          recv_buffer_size: itsifile_config.fetch(:recv_buffer_size, 262_144)
+        }.transform_keys(&:to_s)
 
-          errors.flat_map do |(error, message)|
+        error_lines = errors.flat_map do |(error, message)|
             location =  message[/(.*?)\:in/,1]
             file, lineno = location.split(":")
             lineno = lineno.to_i
@@ -135,12 +147,17 @@ module Itsi
               []
             else
               ([lineno-2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
-                [
-                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline].strip}",
-                  if currline == lineno-1
-                    "     | ^^^ "
-                  end
-                ].compact
+                if currline == lineno-1
+                  line = file_lines[currline][0...-1]
+                  padding = line[/^\s+/]&.length || 0
+
+                  [
+                    " \e[31m#{currline.succ.to_s.rjust(3)} | #{line}\e[0m",
+                    "     | #{' ' * padding}\e[33m^^^\e[0m "
+                  ]
+                else
+                  " #{currline.succ.to_s.rjust(3)} | #{file_lines[currline][0...-1]}"
+                end
               end.flatten
             end
             [
@@ -149,11 +166,23 @@ module Itsi
               *info_lines
             ]
           end
-        ]
+
+        return srv_config, error_lines
+      rescue
+        Itsi.log_error e.message
+        puts e.backtrace
       end
 
       def self.test!(cli_params)
         _, errors = build_config(cli_params, Itsi::Server::Config.config_file_path(cli_params[:config_file]))
+        unless errors.any?
+          begin
+            _["middleware_loader"][]
+          rescue Exception => e
+            errors = [e]
+          end
+        end
+
         if errors.any?
           Itsi.log_error("Config file is invalid")
           puts errors
@@ -181,7 +210,7 @@ module Itsi
           elsif File.exist?("config/#{ITSI_DEFAULT_CONFIG_FILE}")
             "config/#{ITSI_DEFAULT_CONFIG_FILE}"
           end
-        # Options simply pass through unless we've specified a config file
+        # Options pass through unless we've specified a config file
         return unless File.exist?(config_file_path.to_s)
 
         config_file_path

data/gems/server/lib/itsi/server/default_config/Itsi.rb

@@ -73,7 +73,7 @@ worker_memory_limit 1024 * 1024 * 1024
 
 # You can provide an optional block of code to run, when a worker hits its memory threshold (Use this to send yourself an alert,
 # write metrics to disk etc. etc.)
-after_memory_threshold_reached do |pid|
+after_memory_limit_reached do |pid|
   puts "Worker #{pid} has reached its memory threshold and will restart"
 end
 
@@ -102,6 +102,6 @@ oob_gc_responses_threshold 512
 log_level :info
 
 # Log Format
-# Set this to be either :ansi or :json. If you leave it blank Itsi will try
+# Set this to be either :plain or :json. If you leave it blank Itsi will try
 # and auto-detect the format based on the TTY environment.
-log_format :auto
+log_format :plain

data/gems/server/lib/itsi/server/grpc/grpc_call.rb

@@ -74,7 +74,6 @@ module Itsi
 
           break
         end
-
         # The next non-whitespace, non-comma character should be the start of an object.
         return nil unless char == "{"
 
@@ -90,6 +89,7 @@ module Itsi
 
           buffer << ch
 
+
           if in_string
             if escape
               escape = false

data/gems/server/lib/itsi/server/grpc/grpc_interface.rb

@@ -23,13 +23,14 @@ module Itsi
       def initialize(service)
         @service = service
         @service_class = service.class
-        @service_class.rpc_descs.transform_keys! do |k|
+        @rpc_descs = @service_class.rpc_descs.transform_keys do |k|
           k.to_s.gsub(/([a-z])([A-Z])/, "\\1_\\2").downcase.to_sym
         end
       end
 
       def handle_request(active_call)
-        unless (active_call.rpc_desc = service_class.rpc_descs[active_call.method_name])
+        puts "Handling active call"
+        unless (active_call.rpc_desc = @rpc_descs[active_call.method_name])
           active_call.stream.write("\n")
           active_call.send_status(13, "Method not found")
           active_call.close
@@ -85,15 +86,21 @@ module Itsi
 
       def handle_server_streaming(active_call)
         message = active_call.remote_read
-        service.send(active_call.method_name, message, active_call) do |response|
+        result = service.send(active_call.method_name, message, active_call) do |response|
           active_call.remote_send(response)
         end
+        if result.kind_of?(Enumerator)
+          result.each { |response| active_call.remote_send(response) }
+        end
       end
 
       def handle_bidi_streaming(active_call)
-        service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
+        result = service.send(active_call.method_name, active_call.each_remote_read, active_call) do |response|
           active_call.remote_send(response)
         end
+        if result.kind_of?(Enumerator)
+          result.each { |response| active_call.remote_send(response) }
+        end
       end
     end
   end

data/gems/server/lib/itsi/server/rack/handler/itsi.rb

@@ -1,17 +1,17 @@
 return unless defined?(::Rackup::Handler) || defined?(Rack::Handler)
 
+
 module Rack
   module Handler
     module Itsi
       def self.run(app, options = {})
         host = options.fetch(:host, "127.0.0.1")
         port = options.fetch(:Port, 3001)
-        Itsi::Server.start(
+        ::Itsi::Server.start(
           {
             app: app,
             binds: ["http://#{host}:#{port}"]
-          },
-          Itsi::Server::Config.config_file_path
+          }
         )
       end
     end

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

@@ -4,13 +4,63 @@ module Itsi
 
       require "set"
       require "strscan"
-
+      require "debug"
       def format_mw(mw)
-        case mw["type"]
+        mw_name, mw_args = mw
+        case mw_name
         when "app"
-          "app #{mw["parameters"]["app_proc"].inspect.split(" ")[1]}"
+          "\e[33mapp\e[0m(#{mw_args['app_proc'].inspect.split(' ')[1][0...-1]})"
+        when "log_requests"
+          if mw_args['before'] && mw_args['after']
+            "\e[33mlog_requests\e[0m(before: #{mw_args['before']['format'][0..6]}..., after: #{mw_args['after']['format'][0..6]}...)"
+          elsif mw_args['before']
+            "\e[33mlog_requests\e[0m(before: #{mw_args['before']['format'][0..6]}...)"
+          elsif mw_args['after']
+            "\e[33mlog_requests\e[0m(before: nil, after: #{mw_args['after']['format'][0..6]}...)"
+          end
+        when "compress"
+          "\e[33mcompress\e[0m(#{mw_args['algorithms'].join(' ')}, #{mw_args['mime_types']})"
+        when "cors"
+          "\e[33mcors\e[0m(#{mw_args['allow_origins'].join(' ')}, #{mw_args['allow_methods'].join(' ')})"
+        when "etag"
+          "\e[33metag\e[0m(#{mw_args['type']}/#{mw_args['algorithm']}, #{mw_args['handle_if_none_match'] ? 'if_none_match' : ''})"
+        when "cache_control"
+          "\e[33mcache_control\e[0m(max_age: #{mw_args['max_age']}, #{mw_args.select{|_,v| v == true }.keys.join(", ")})"
+        when "redirect"
+          "\e[33mredirect\e[0m(to: #{mw_args['to']}, type: #{mw_args['type']})"
+        when "static_assets"
+          "\e[33mstatic_assets\e[0m(path: #{mw_args['root_dir']})"
+        when "auth_api_key"
+          "\e[33mauth_api_key\e[0m(keys: #{mw_args['valid_keys'].keys}#{mw_args['credentials_file'] ? ", credentials_file: #{mw_args['credentials_file']}" : ""})"
+        when "auth_basic"
+          "\e[33mbasic_auth\e[0m(keys: #{mw_args['realm']}#{mw_args['credentials_file'] ? ", credentials_file: #{mw_args['credentials_file']}" : ""})"
+        when "auth_jwt"
+          "\e[33mjwt_auth\e[0m(#{mw_args['verifiers'].keys.join(",")})"
+        when "rate_limit"
+          key = mw_args['key'].kind_of?(Hash) ? mw_args['key']["parameter"] : mw_args['key']
+          "\e[33mrate_limit\e[0m(rps: #{mw_args['requests']}/#{mw_args['seconds']}, key: #{key})"
+        when "allow_list"
+          "\e[33mallow_list\e[0m(patterns: #{mw_args['allowed_patterns'].join(", ")})"
+        when "deny_list"
+          "\e[33mdeny_list\e[0m(patterns: #{mw_args['denied_patterns'].join(", ")})"
+        when "csp"
+          "\e[33mcsp\e[0m(#{mw_args['policy'].map{|k,v| "#{k}: #{v.join(",")}"}.join(", ")})"
+        when "intrusion_protection"
+          [mw_args].flatten.map do |mw_args|
+            "\e[33mintrusion_protection\e[0m(banned_url_patterns: #{mw_args['banned_url_patterns']&.length}, banned_header_patterns: #{mw_args['banned_header_patterns']&.keys&.join(", ")}, #{mw_args['banned_time_seconds']}s)"
+          end.join("\n")
+        when "request_headers"
+          [mw_args].flatten.map do |mw_args|
+            "\e[33mrequest_headers\e[0m(added: #{mw_args["additions"].keys}, removed: #{mw_args["removals"]})"
+          end.join("\n")
+        when "response_headers"
+          [mw_args].flatten.map do |mw_args|
+            "\e[33mresponse_headers\e[0m(added: #{mw_args["additions"].keys}, removed: #{mw_args["removals"]})"
+          end.join("\n")
+        when "static_response"
+          "\e[response_headers\e[0m(#{mw_args["code"]} body: #{mw_args["body"][0..10]})"
         else
-          mw["type"]
+          "\e[33m#{mw.first}\e[0m"
         end
       end
 
@@ -21,12 +71,12 @@ module Itsi
         end.compact
         filter_str = filters.any? ? filters.join(", ") : "(none)"
 
-        middlewares = stack["middleware"]
+        middlewares = stack["middleware"].to_a
 
         puts "─" * 76
-        puts "Route:      #{route_str}"
-        puts "Conditions: #{filter_str}"
-        puts "Middleware: • #{format_mw(middlewares.first)}"
+        puts "\e[32mRoute:\e[0m      \e[33m#{route_str}\e[0m"
+        puts "\e[32mConditions:\e[0m \e[34m#{filter_str}\e[0m"
+        puts "\e[32mMiddleware:\e[0m • #{format_mw(middlewares.first)}"
         middlewares[1..].each do |mw|
           puts "            • #{format_mw(mw)}"
         end

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

@@ -19,7 +19,7 @@ module Itsi
     end
 
     def server_running?
-      Itsi::Server.respond_to?(:running) && Itsi::Server.running?
+      Itsi::Server.respond_to?(:running?) && Itsi::Server.running?
     end
   end
 end

data/gems/server/lib/itsi/server/typed_handlers/param_parser.rb

@@ -23,21 +23,21 @@ module Itsi
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           FalseClass => ->(v){
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           :Boolean  => ->(v){
             case v
             when true, 'true', '1', 1 then true
             when false, 'false', '0', 0 then false
-            else raise "Cannot cast #{v.inspect} to Boolean"
+            else raise ValidationError.new("Cannot cast #{v.inspect} to Boolean")
             end
           },
           Date      => ->(v){ Date.parse(v.to_s) },
@@ -45,17 +45,6 @@ module Itsi
           DateTime  => ->(v){ DateTime.parse(v.to_s) }
         }.compare_by_identity
 
-        # Extracts the expected type and required flag from a schema definition.
-        def extract_schema(schema_def)
-          if schema_def.is_a?(Hash) && schema_def.key?(:_type)
-            expected_type = schema_def[:_type]
-            required = schema_def.fetch(:required, true)
-            [expected_type, required]
-          else
-            [schema_def, true]
-          end
-        end
-
         # Preprocess the schema into fixed keys (as symbols) and regex keys.
         # Memoizes the result based on the schema.
         def processed_schema(schema)
@@ -63,8 +52,9 @@ module Itsi
           @@schema_cache[schema] ||= begin
             fixed = {}
             regex = []
+            required_params = schema[:_required] || []
             schema.each do |k, schema_def|
-              expected_type, required = extract_schema(schema_def)
+              expected_type, required = schema_def, required_params.include?(k)
               if k.is_a?(Regexp)
                 regex << [k, [expected_type, required]]
               else
@@ -179,16 +169,22 @@ module Itsi
           end
 
           # Process regex keys (only string keys not already handled as fixed keys).
-          params.keys.select { |k| k.is_a?(String) }.each do |key|
+          params.keys.each do |key|
+            if key == :_required
+              params.delete(key)
+              next
+            end
             next if fixed_schema.has_key?(key.to_sym) || fixed_schema.has_key?(key)
-            regex_schema.each do |regex, (expected_type, _required)|
+            unless regex_schema.find do |regex, (expected_type, _required)|
               if regex.match(key)
                 new_path = path + [key]
                 err = cast_value!(params, key, expected_type, new_path)
                 errors << err if err
-                break  # only use the first matching regex
+                true  # only use the first matching regex
               end
             end
+              params.delete(key)
+            end
           end
 
           raise ValidationError.new(errors) unless errors.empty?

data/gems/server/lib/itsi/server/typed_handlers/source_parser.rb

@@ -6,17 +6,18 @@ module Itsi
 
 
         def self.extract_expr_from_source_location(proc)
-          source_lines = IO.readlines(proc.source_location.first)
+          source_location = proc.source_location
+          source_lines = IO.readlines(source_location.first)
 
           proc_line = source_location.last - 1
           first_line = source_lines[proc_line]
 
-          until first_line =~ /(?:lambda|proc|->|def|.*?do\s*\|)/ || proc_line.zero?
+          until first_line =~ /(?:lambda|proc|->|def|.*?do\s*|.*?\{.*?\|)/ || proc_line.zero?
             proc_line -= 1
             first_line = source_lines[proc_line]
           end
           lines = source_lines[proc_line..]
-          lines[0] = lines[0][/(?:lambda|proc|->|def|.*?do\s*\|).*/]
+          lines[0] = lines[0][/(?:lambda|proc|->|def|.*?do\s+|.*?\{.*?\|).*/]
           src_str = lines.first << "\n"
           intermediate = Prism.parse(src_str)
 
@@ -47,7 +48,7 @@ module Itsi
 
           [requireds.length, keywords]
         rescue
-          [ proc.parameters.first&.length || 0, {}]
+          [ proc.parameters.select{|p| p == :req }&.length || 0, {}]
         end
       end
     end

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

@@ -5,10 +5,18 @@ module Itsi
   class Server
     module TypedHandlers
       def self.handler_for(proc, input_schema)
-        input_schema = proc.binding.eval(input_schema) if input_schema
-        lambda do |req|
-          req.params(input_schema) do |params|
-            proc.call(req, params: params)
+        if input_schema
+          input_schema = proc.binding.eval(input_schema)
+          lambda do |req|
+            req.params(input_schema) do |params|
+              proc.call(req, params: params)
+            end
+          end
+        else
+          lambda do |req|
+            req.params do |params|
+              proc.call(req, params)
+            end
           end
         end
       end

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

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.20"
+    VERSION = "0.2.2"
   end
 end