itsi 0.1.19 → 0.2.2

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

@@ -0,0 +1,242 @@
+require 'date'
+require 'time'
+
+module Itsi
+  class Server
+    module Config
+      module TypedStruct
+        VALUE = 0
+        VALIDATE = 1
+
+        def self.new(defaults = nil, &defaults_blk)
+          defaults = TypedStruct.module_eval(&defaults_blk) if defaults_blk
+          unless defaults.is_a?(Hash)
+            return defaults
+          end
+          defaults.transform_values! { _1.is_a?(Validation) ? _1.default(nil) : _1 }
+          Struct.new(*defaults.keys, keyword_init: true) do
+            define_method(:initialize) do |*input, validate: true, **raw_input|
+
+              if input.last && !input.last.is_a?(Hash)
+                raise "─ Invalid input to #{self}: #{input.last}"
+              end
+              raw_input.transform_keys!{|k| k.to_s.downcase.to_sym }
+              raw_input.merge!(input.pop.transform_keys!{|k| k.to_s.downcase.to_sym}) if input.last.is_a?(Hash)
+
+              excess_keys = raw_input.keys - defaults.keys
+
+              if excess_keys.any?
+                raise "─ Unsupported keys #{excess_keys}"
+
+              end
+
+              initial_values = defaults.each_with_object({}) do |(k, default_config), inputs|
+                value = raw_input.key?(k) ? raw_input[k] : default_config[VALUE].dup
+                next inputs[k] = value unless validate
+
+                begin
+                  inputs[k] = default_config[VALIDATE].validate!(value)
+                rescue StandardError => e
+                  raise ArgumentError, "─ #{k}: #{e.message}"
+                end
+              end
+
+              super(initial_values)
+              validator = self.class.instance_eval { @validators }
+              instance_eval(&validator) if validator
+            end
+
+            define_singleton_method(:validate) do |&blk|
+              @validators = blk
+            end
+
+            defaults.each do |key, (_, validation)|
+              define_method(:"#{key}?") do
+                !!self[key]
+              end
+              define_method(:"#{key}=") do |value|
+                self[key] = validation.validate!(value)
+              end
+            end
+
+            define_method(:[]=) do |key, value|
+              super(key, defaults[key][VALIDATE].validate!(value))
+            end
+
+            def is_typed_struct?
+              true
+            end
+
+            def merge_config(other)
+              self.class.new(members.map do |key|
+                value = self[key]
+                has_merged_val = (other.is_a?(Hash) ? other.key?(key) : other.member?(key))
+                next [key, value] unless has_merged_val
+
+                [
+                  key,
+                  TypedStruct.typed_struct?(value) ? value.merge_config(other[key]) : other[key]
+                ]
+              end.to_h)
+            end
+
+            def to_h
+              super.transform_values { |v| v.respond_to?(:merge_config) ? v.to_h : v }
+            end
+          end
+        end
+
+        def self.typed_struct?(inst)
+          inst.respond_to?(:is_typed_struct?) && inst.is_typed_struct?
+        end
+
+        class Validation
+          attr_reader :name, :validations
+          attr_accessor :next
+
+          def initialize(name, validations)
+            @name = name.to_s
+            @validations = Array(validations)
+            @next = nil
+          end
+
+          def inspect
+            "#{@name}"
+          end
+
+          def &(other)
+            tail = self
+            while tail.next
+              tail = tail.next
+            end
+            tail.next = other
+            self
+          end
+
+          def default(value)
+            [value, self]
+          end
+
+          def validate!(value)
+            value = value.to_s if value.is_a?(Symbol)
+            @validations.each do |validation|
+              case validation
+              when Proc
+                validation.call(value)
+              when Array
+                unless !value || validation.include?(value)
+                  raise ArgumentError,
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                end
+              when Range
+                unless !value || validation.include?(value)
+                  raise ArgumentError,
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                end
+              when Regexp
+                unless !value || validation.match?(value)
+                  raise ArgumentError,
+                        "─ `#{@name}` validation failed. Invalid #{validation} value: #{value.inspect}"
+                end
+              when Validation
+                validation.validate!(value)
+              when Class
+                if value && !value.is_a?(validation)
+                  begin
+                    value = \
+                      if validation.eql?(Time) then Time.parse(value.to_s)
+                      elsif validation.eql?(::Date) then Date.parse(value.to_s)
+                      elsif validation.eql?(Float) then Float(value)
+                      elsif validation.eql?(Integer) then Integer(value)
+                      elsif validation.eql?(Proc) then
+                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(Proc)
+                      elsif validation.eql?(String) || validation.eql?(Symbol)
+                        raise ArgumentError, "Invalid #{validation} value: #{value.inspect}" unless value.is_a?(String) || value.is_a?(Symbol)
+                        if validation.eql?(String)
+                          value.to_s
+                        elsif validation.eql?(Symbol)
+                          value.to_s.to_sym
+                        end
+                      else
+                        validation.new(value)
+                      end
+                  rescue StandardError => e
+                    raise ArgumentError,
+                          "─ `#{@name}` Validation Failed. Invalid #{validation.to_s.split("::").last} value: #{value.inspect}. Failure reason: \n  └─ #{e.message}"
+                  end
+                end
+              end
+            end
+            if self.next
+              self.next.validate!(value)
+            else
+              value
+            end
+          end
+        end
+
+        {
+          Bool: Validation.new(:Bool, [[true, false]]),
+          Required: Validation.new(:Required, ->(value) { !value.nil? }),
+          Or: ->(*validations){
+            Validation.new(:Or, ->(v){
+
+              return true if v.nil?
+              errs = []
+              validations.each do |validation|
+                begin
+                  v = validation.validate!(v)
+                  return v
+                rescue StandardError => e
+                  errs << e.message
+                end
+              end
+              raise StandardError.new("─ Validation failed (None match:) \n  └#{errs.join("\n  └")}")
+            })
+          },
+          Range: ->(input_range) {
+            Validation.new(:Range, [input_range])
+          },
+          Length: lambda { |input_length|
+            Validation.new(:Length, ->(value) { input_length === value.length })
+          },
+          Hash: ->(key_type, value_type) {
+            Validation.new(:Hash, ->(v){
+              return true if v.nil?
+              raise StandardError.new("Expected hash got #{v.class}") unless v.is_a?(Hash)
+              v.map do |k, v|
+                [
+                  key_type.validate!(k),
+                  value_type.validate!(v)
+                ]
+              end.to_h
+            })
+          },
+          Type: ->(input_type) { Validation.new(:Type, input_type) },
+          Enum: ->(allowed_values) { Validation.new(:Enum, [allowed_values.map{|v| v.kind_of?(Symbol) ? v.to_s : v}]) },
+          Array: lambda { |*value_validations|
+            Validation.new(:Array, [::Array, lambda { |value|
+              return true unless value
+
+              raise StandardError.new("Expected Array got #{value.class}") unless value.is_a?(Array)
+
+              value&.map! do |v|
+                value_validations.all? { v = _1.validate!(v) }
+                v
+              end
+            }])
+          }
+        }.each do |name, factory|
+          if factory.is_a?(Proc)
+            define_singleton_method(name, &factory)
+            define_singleton_method(name.to_s.downcase, &factory)
+          else
+            const_set(name, factory)
+            define_singleton_method(name, -> { factory.dup })
+            define_singleton_method(name.to_s.downcase, -> { factory.dup })
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,9 @@
 module Itsi
   class Server
     module Config
+      require_relative "config/typed_struct"
       require_relative "config/dsl"
+      require_relative "config/known_paths"
       require_relative "default_app/default_app"
 
       ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
@@ -33,16 +35,15 @@ module Itsi
       # 3. Default values.
       def self.build_config(args, config_file_path, builder_proc = nil)
         args.transform_keys!(&:to_sym)
-        itsifile_config = \
+        itsifile_config, errors = \
           if 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
+                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,
@@ -80,21 +81,36 @@ 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
 
-        {
+        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: itsifile_config.fetch(:hooks, nil),
+          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) },
@@ -110,10 +126,69 @@ module Itsi
           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 }
+          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)
+
+        error_lines = errors.flat_map do |(error, message)|
+            location =  message[/(.*?)\:in/,1]
+            file, lineno = location.split(":")
+            lineno = lineno.to_i
+            err_message = error.kind_of?(NoMethodError) ? error.detailed_message : error.message
+            file_lines = IO.readlines(file)
+            info_lines = if error.kind_of?(SyntaxError)
+              []
+            else
+              ([lineno-2, 0].max...[file_lines.length, lineno.succ.succ].min).map do |currline|
+                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
+            [
+              err_message,
+              "   --> #{File.expand_path(file)}:#{lineno}",
+              *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
+        else
+          Itsi.log_info("Config file is valid")
+        end
       end
 
       # Reloads the entire process
@@ -135,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
@@ -156,10 +231,58 @@ module Itsi
           return
         end
 
-        puts "Writing default configuration..."
+        default_config = IO.read("#{__dir__}/default_config/Itsi.rb")
+
+        if File.exist?("./config.ru")
+          default_config << <<~RUBY
+          # You can mount several Ruby apps as either
+          # 1. rackup files
+          # 2. inline rack apps
+          # 3. inline Ruby endpoints
+          #
+          # 1. rackup_file
+          rackup_file "./config.ru"
+          #
+          # 2. inline rack app
+          # require 'rack'
+          # run(Rack::Builder.app do
+          #   use Rack::CommonLogger
+          #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+          # end)
+          #
+          # 3. Endpoints
+          # endpoint "/" do |req|
+          #   req.ok "Hello from Itsi"
+          # end
+          RUBY
+        else
+          default_config << <<~RUBY
+            # You can mount several Ruby apps as either
+            # 1. rackup files
+            # 2. inline rack apps
+            # 3. inline Ruby endpoints
+            #
+            # 1. rackup_file
+            # Use `rackup_file` to specify the Rack app file name.
+            #
+            # 2. inline rack app
+            # require 'rack'
+            # run(Rack::Builder.app do
+            #   use Rack::CommonLogger
+            #   run ->(env) { [200, { 'content-type' => 'text/plain' }, ['OK']] }
+            # end)
+            #
+            # 3. Endpoint
+            endpoint "/" do |req|
+              req.ok "Hello from Itsi"
+            end
+          RUBY
+        end
+
         File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
-          file.write(IO.read("#{__dir__}/default_config/Itsi.rb"))
+          file.write(default_config)
         end
+
       end
     end
   end

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

@@ -10,13 +10,17 @@ module Itsi
     INTERCEPTED_SIGNALS = ["INT"].freeze
 
     def trap(signal, *args, &block)
-      unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && Itsi::Server.running?
+      unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && server_running?
         return super(signal, *args, &block)
       end
 
       Itsi::Server.reset_signal_handlers
       nil
     end
+
+    def server_running?
+      Itsi::Server.respond_to?(:running?) && Itsi::Server.running?
+    end
   end
 end