itsi-server 0.1.1 → 0.1.11

data/lib/itsi/server/config.rb

@@ -0,0 +1,36 @@
+module Itsi
+  class Server
+    module Config
+      module_function
+
+      ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
+
+      def load(options)
+        options[:config_file] ||= \
+          if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
+            ITSI_DEFAULT_CONFIG_FILE
+          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
+        return options unless options[:config_file]
+
+        require_relative "options_dsl"
+        OptionsDSL.evaluate(options[:config_file]).merge(options)
+      end
+
+      def write_default
+        if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
+          puts "#{ITSI_DEFAULT_CONFIG_FILE} already exists."
+          return
+        end
+
+        puts "Writing default configuration..."
+        File.open(ITSI_DEFAULT_CONFIG_FILE, "w") do |file|
+          file.write(IO.read("#{__dir__}/Itsi.rb"))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+return unless defined?(::Rackup::Handler) || defined?(Rack::Handler)
+
+module Rack
+  module Handler
+    module Itsi
+      def self.run(app, options = {})
+        ::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
+end
+
+if defined?(Rackup)
+  ::Rackup::Handler.register("itsi", Rack::Handler::Itsi)
+  ::Rackup::Handler.register("Itsi", Rack::Handler::Itsi)
+elsif defined?(Rack)
+  ::Rack::Handler.register("itsi", Rack::Handler::Itsi)
+  ::Rack::Handler.register("Itsi", Rack::Handler::Itsi)
+end

data/lib/itsi/server/rack_interface.rb

@@ -0,0 +1,75 @@
+module Itsi
+  class Server
+    module RackInterface
+      # Interface to Rack applications.
+      # Here we build the env, and invoke the Rack app's call method.
+      # We then turn the Rack response into something Itsi server understands.
+      def call(app, request)
+        respond request, app.call(request.to_rack_env)
+      end
+
+      # Itsi responses are asynchronous and can be streamed.
+      # Response chunks are sent using response.send_frame
+      # and the response is finished using response.close_write.
+      # If only a single chunk is written, you can use the #send_and_close method.
+      def respond(request, (status, headers, body))
+        response = request.response
+
+        # Don't try and respond if we've been hijacked.
+        # The hijacker is now responsible for this.
+        return if request.hijacked
+
+        # 1. Set Status
+        response.status = status
+
+        # 2. Set Headers
+        body_streamer = streaming_body?(body) ? body : headers.delete("rack.hijack")
+        headers.each do |key, value|
+          next response.add_header(key, value) unless value.is_a?(Array)
+
+          value.each do |v|
+            response.add_header(key, v)
+          end
+        end
+
+        # 3. Set Body
+        # As soon as we start setting the response
+        # the server will begin to stream it to the client.
+
+        # If we're partially hijacked or returned a streaming body,
+        # stream this response.
+
+        if body_streamer
+          body_streamer.call(StreamIO.new(response))
+
+        # If we're enumerable with more than one chunk
+        # also stream, otherwise write in a single chunk
+        elsif body.respond_to?(:each) || body.respond_to?(:to_ary)
+          unless body.respond_to?(:each)
+            body = body.to_ary
+            raise "Body #to_ary didn't return an array" unless body.is_a?(Array)
+          end
+          # We offset this iteration intentionally,
+          # to optimize for the case where there's only one chunk.
+          buffer = nil
+          body.each do |part|
+            response.send_frame(buffer.to_s) if buffer
+            buffer = part
+          end
+
+          response.send_and_close(buffer.to_s)
+        else
+          response.send_and_close(body.to_s)
+        end
+      ensure
+        response.close_write
+        body.close if body.respond_to?(:close)
+      end
+
+      # A streaming body is one that responds to #call and not #each.
+      def streaming_body?(body)
+        body.respond_to?(:call) && !body.respond_to?(:each)
+      end
+    end
+  end
+end

data/lib/itsi/server/scheduler_interface.rb

@@ -0,0 +1,21 @@
+module Itsi
+  class Server
+    module SchedulerInterface
+      # Simple wrapper to instantiate a scheduler, start it,
+      # and immediate have it invoke a scheduler proc
+      def start_scheduler_loop(scheduler_class, scheduler_task)
+        scheduler = scheduler_class.new
+        Fiber.set_scheduler(scheduler)
+        [scheduler, Fiber.schedule(&scheduler_task)]
+      end
+
+      # When running in scheduler mode,
+      # each request is wrapped in a Fiber.
+      def schedule(app, request)
+        Fiber.schedule do
+          call(app, request)
+        end
+      end
+    end
+  end
+end

data/lib/itsi/server/scheduler_mode.rb

@@ -0,0 +1,6 @@
+if defined?(ActiveSupport::IsolatedExecutionState) && !ENV["ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL"]
+  Itsi.log_info \
+    "ActiveSupport Isolated Execution state detected. Automatically switching to :fiber mode. "\
+    "Set ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL to disable this behavior"
+  ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+end

data/lib/itsi/server/signal_trap.rb

@@ -0,0 +1,23 @@
+module Itsi
+  module SignalTrap
+
+    DEFAULT_SIGNALS = ["DEFAULT", "", nil].freeze
+    INTERCEPTED_SIGNALS = ["INT"].freeze
+
+    def trap(signal, *args, &block)
+      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
+  end
+end
+
+[Kernel, Signal].each do |receiver|
+  receiver.singleton_class.prepend(Itsi::SignalTrap)
+end
+
+[Object].each do |receiver|
+  receiver.include(Itsi::SignalTrap)
+end

data/lib/itsi/server/version.rb

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