itsi-server 0.1.9 → 0.1.11

data/lib/itsi/server/options_dsl.rb

@@ -0,0 +1,401 @@
+module Itsi
+  class Server
+    class OptionsDSL
+      attr_reader :parent, :children, :filters, :endpoint_defs, :controller_class
+
+      def self.evaluate(filename)
+        new do
+          instance_eval(IO.read(filename))
+        end.to_options
+      end
+
+      def initialize(parent = nil, route_specs = [], &block)
+        @parent           = parent
+        @children         = []
+        @filters          = {}
+        @endpoint_defs    = [] # Each is [subpath, *endpoint_args]
+        @controller_class = nil
+        @options          = {}
+
+        # We'll store our array of route specs (strings or a single Regexp).
+        @route_specs = Array(route_specs).flatten
+
+        validate_path_specs!(@route_specs)
+        instance_exec(&block)
+      end
+
+      def to_options
+        @options.merge(
+          {
+            routes: flatten_routes
+          }
+        )
+      end
+
+      def workers(workers)
+        raise "Workers must be set at the root" unless @parent.nil?
+
+        @options[:workers] = [workers.to_i, 1].max
+      end
+
+      def threads(threads)
+        raise "Threads must be set at the root" unless @parent.nil?
+
+        @options[:threads] = [threads.to_i, 1].max
+      end
+
+      def rackup_file(rackup_file)
+        raise "Rackup file must be set at the root" unless @parent.nil?
+        raise "rackup_file already set" if @options[:rackup_file]
+        raise "Cannot provide a rackup_file if app is defined" if @options[:app]
+
+        if rackup_file.is_a?(File) && rackup_file.exist?
+          @options[:rackup_file] = file_path
+        else
+          file_path = rackup_file
+          @options[:rackup_file] = file_path if File.exist?(file_path)
+        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?
+
+        ENV["ITSI_LOG"] = level.to_s
+      end
+
+      def log_format(format)
+        raise "Log format must be set at the root" unless @parent.nil?
+
+        case format.to_s
+        when "auto"
+        when "ansi" then ENV['ITSI_LOG_ANSI'] = "true"
+        when "json", "plain" then ENV['ITSI_LOG_PLAIN'] = "true"
+        else raise "Invalid log format '#{format}'"
+        end
+      end
+
+      def run(app)
+        raise "App must be set at the root" unless @parent.nil?
+        raise "App already set" if @options[:app]
+        raise "Cannot provide an app if rackup_file is defined" if @options[:rackup_file]
+
+        @options[:app] = app
+      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 fiber_scheduler(klass_name)
+        raise "Fiber scheduler must be set at the root" unless @parent.nil?
+
+        @options[:scheduler_class] = klass_name if klass_name
+      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 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?
+
+        @options[:stream_body] = !!stream_body
+      end
+
+      def location(*route_specs, &block)
+        route_specs = route_specs.flatten
+        child = OptionsDSL.new(self, route_specs, &block)
+        @children << child
+      end
+
+      # define endpoints
+      def endpoint(subpath, *args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @endpoint_defs << [subpath, *args]
+      end
+
+      def controller(klass)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @controller_class = klass
+      end
+
+      # define some filters
+      def basic_auth(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:basic_auth] = args
+      end
+
+      # define some filters
+      def redirect(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:redirect] = args
+      end
+
+      def jwt_auth(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:jwt_auth] = args
+      end
+
+      def api_key_auth(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:api_key_auth] = args
+      end
+
+      def compress(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:compress] = args
+      end
+
+      def rate_limit(name, **args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:rate_limit] = { name: name }.merge(args)
+      end
+
+      def cors(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:cors] = args
+      end
+
+      def file_server(**args)
+        raise "Endpoint must be set inside a location block" if @parent.is_nil?
+
+        @filters[:file_server] = args
+      end
+
+      def flatten_routes
+        child_routes = @children.flat_map(&:flatten_routes)
+        base_expansions = combined_paths_from_parent
+        endpoint_routes = @endpoint_defs.map do |(endpoint_subpath, *endpoint_args)|
+          ep_expansions = expand_single_subpath(endpoint_subpath)
+          final_regex_str = or_pattern_for(cartesian_combine(base_expansions, ep_expansions))
+
+          {
+            route: Regexp.new("^#{final_regex_str}$"),
+            filters: effective_filters_with_endpoint(endpoint_args)
+          }
+        end
+
+        location_route = unless @route_specs.empty?
+                           pattern_str = or_pattern_for(base_expansions) # the expansions themselves
+                           {
+                             route: Regexp.new("^#{pattern_str}$"),
+                             filters: effective_filters
+                           }
+                         end
+
+        result = []
+        result.concat(child_routes)
+        result.concat(endpoint_routes)
+        result << location_route if location_route
+        result
+      end
+
+      def validate_path_specs!(specs)
+        regexes = specs.select { |s| s.is_a?(Regexp) }
+        return unless regexes.size > 1
+
+        raise ArgumentError, "Cannot have multiple raw Regex route specs in a single location."
+      end
+
+      # Called by flatten_routes to get expansions from the parent's expansions combined with mine
+      def combined_paths_from_parent
+        if parent
+          pex = parent.combined_paths_from_parent_for_children
+          cartesian_combine(pex, expansions_for(@route_specs))
+        else
+          expansions_for(@route_specs)
+        end
+      end
+
+      def combined_paths_from_parent_for_children
+        if parent
+          pex = parent.combined_paths_from_parent_for_children
+          cartesian_combine(pex, expansions_for(@route_specs))
+        else
+          expansions_for(@route_specs)
+        end
+      end
+
+      def expand_single_subpath(subpath)
+        expansions_for([subpath]) # just treat it as a mini specs array
+      end
+
+      def expansions_for(specs)
+        return [] if specs.empty?
+
+        if specs.any? { |s| s.is_a? Regexp }
+          raise "Cannot combine a raw Regexp with other strings in the same location." if specs.size > 1
+
+          [[:raw_regex, specs.first]]
+        else
+          specs.map do |string_spec|
+            string_spec = string_spec.sub(%r{^/}, "")
+            string_spec
+          end
+        end
+      end
+
+      def cartesian_combine(parent_exps, child_exps)
+        return child_exps if parent_exps.empty?
+        return parent_exps if child_exps.empty?
+
+        if parent_exps.size == 1 && parent_exps.first.is_a?(Array) && parent_exps.first.first == :raw_regex
+          raise "Cannot nest under a raw Regexp route."
+        end
+
+        if child_exps.size == 1 && child_exps.first.is_a?(Array) && child_exps.first.first == :raw_regex
+          raise "Cannot nest a raw Regexp route under a parent string route."
+        end
+
+        results = []
+        parent_exps.each do |p|
+          child_exps.each do |c|
+            joined = [p, c].reject(&:empty?).join("/")
+            results << joined
+          end
+        end
+        results
+      end
+
+      def or_pattern_for(expansions)
+        return "" if expansions.empty?
+
+        if expansions.size == 1 && expansions.first.is_a?(Array) && expansions.first.first == :raw_regex
+          raw = expansions.first.last
+          return raw.source # Use the raw Regexp's source
+        end
+
+        pattern_pieces = expansions.map do |exp|
+          if exp.empty?
+            "" # => means top-level "/"
+          else
+            segment_to_regex_with_slash(exp)
+          end
+        end
+
+        joined = pattern_pieces.join("|")
+
+        "(?:#{joined})"
+      end
+
+      def segment_to_regex_with_slash(path_str)
+        return "" if path_str == ""
+
+        segments = path_str.split("/")
+
+        converted = segments.map do |seg|
+          # wildcard?
+          next ".*" if seg == "*"
+
+          # :param(...)?
+          if seg =~ /^:([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
+          else
+            Regexp.escape(seg)
+          end
+        end
+
+        converted.join("/")
+      end
+
+      def effective_filters
+        # gather from root -> self, overriding duplicates
+        merged = merge_ancestor_filters
+        # turn into array
+        merged.map { |k, v| { type: k, params: v } }
+      end
+
+      def effective_filters_with_endpoint(endpoint_args)
+        arr = effective_filters
+        # endpoint filter last
+        ep_filter_params = endpoint_args.dup
+        ep_filter_params << @controller_class if @controller_class
+        arr << { type: :endpoint, params: ep_filter_params }
+        arr
+      end
+
+      def merge_ancestor_filters
+        chain = []
+        node = self
+        while node
+          chain << node
+          node = node.parent
+        end
+        chain.reverse!
+
+        merged = {}
+        chain.each do |n|
+          n.filters.each do |k, v|
+            merged[k] = v
+          end
+        end
+        merged
+      end
+    end
+  end
+end

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

@@ -4,12 +4,24 @@ module Rack
   module Handler
     module Itsi
       def self.run(app, options = {})
-        ::Itsi::Server.new(
-          app: -> { app },
-          binds: ["http://#{options.fetch(:host, "127.0.0.1")}:#{options.fetch(:Port, 3001)}"],
-          workers: options.fetch(:workers, 1),
-          threads: options.fetch(:threads, 1)
-        ).start
+        ::Itsi::Server.start(
+          **Itsi::Server::Config.load(
+            {
+              app: app,
+              binds: [
+                "http://#{
+                options.fetch(
+                  :host,
+                  "127.0.0.1"
+                )}:#{
+                options.fetch(
+                  :Port,
+                  3001
+                )}"
+              ]
+            }
+          )
+        )
       end
     end
   end

data/lib/itsi/server/rack_interface.rb

@@ -57,11 +57,7 @@ module Itsi
             buffer = part
           end
 
-          begin
-            response.send_and_close(buffer.to_s)
-          rescue StandardError
-            binding.b
-          end
+          response.send_and_close(buffer.to_s)
         else
           response.send_and_close(body.to_s)
         end

data/lib/itsi/server/signal_trap.rb

@@ -8,7 +8,6 @@ module Itsi
       unless INTERCEPTED_SIGNALS.include?(signal.to_s) && block.nil? && Itsi::Server.running?
         return super(signal, *args, &block)
       end
-
       Itsi::Server.reset_signal_handlers
       nil
     end

data/lib/itsi/server/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.9"
+    VERSION = "0.1.11"
   end
 end

data/lib/itsi/server.rb

@@ -6,15 +6,18 @@ require_relative "server/rack_interface"
 require_relative "server/signal_trap"
 require_relative "server/scheduler_interface"
 require_relative "server/rack/handler/itsi"
+require_relative "server/config"
 require_relative "request"
 require_relative "stream_io"
 
 # When you Run Itsi without a Rack app,
-# we start a tiny
+# we start a tiny little echo server, just so you can see it in action.
 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."
   lambda do |env|
     headers, body = \
       if env["itsi.response"].json?
@@ -55,17 +58,18 @@ module Itsi
 
       def build(
         app: DEFAULT_APP[],
+        loader: nil,
         binds: DEFAULT_BINDS,
         **opts
       )
-        new(app: -> { app }, binds: binds, **opts)
+        new(app: loader || -> { app }, binds: binds, **opts)
       end
 
       def start_in_background_thread(silence: true, **opts)
         start(background: true, silence: silence, **opts)
       end
 
-      def start(background: false, **opts)
+      def start(background: false, silence: false, **opts)
         build(**opts).tap do |server|
           previous_handler = Signal.trap("INT", "DEFAULT")
           @running = true

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: itsi-server
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - Wouter Coppieters
 bindir: exe
 cert_chain: []
-date: 2025-03-16 00:00:00.000000000 Z
+date: 2025-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -105,6 +105,9 @@ files:
 - lib/itsi/index.html
 - lib/itsi/request.rb
 - lib/itsi/server.rb
+- lib/itsi/server/Itsi.rb
+- lib/itsi/server/config.rb
+- lib/itsi/server/options_dsl.rb
 - lib/itsi/server/rack/handler/itsi.rb
 - lib/itsi/server/rack_interface.rb
 - lib/itsi/server/scheduler_interface.rb