itsi 0.1.11 → 0.1.12

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

@@ -0,0 +1,506 @@
+module Itsi
+  class Server
+    module Config
+      class DSL
+        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)
+            else
+              code = IO.read(config)
+              instance_eval(code, config.to_s, 1)
+            end
+          end.options
+        end
+
+        def initialize(
+          parent = nil,
+          routes: [],
+          methods: [],
+          protocols: [],
+          hosts: [],
+          ports: [],
+          extensions: [],
+          content_types: [],
+          accepts: [],
+          controller: self,
+          &block
+        )
+          @parent           = parent
+          @children         = []
+          @middleware       = {}
+          @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 }
+          @hosts = hosts.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @ports = ports.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @extensions = extensions.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @content_types = content_types.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @accepts = accepts.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+
+          @options = {
+            middleware_loaders: [],
+            middleware_loader: lambda do
+              @options[:middleware_loaders].each(&:call)
+              flatten_routes
+            end
+          }
+
+          instance_exec(&block)
+        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 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?
+
+          @options[:log_level] = 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" 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
+        end
+
+        def get(route, app_proc = nil, &blk)
+          endpoint(route, :get, app_proc, &blk)
+        end
+
+        def post(route, app_proc = nil, &blk)
+          endpoint(route, :post, app_proc, &blk)
+        end
+
+        def put(route, app_proc = nil, &blk)
+          endpoint(route, :put, app_proc, &blk)
+        end
+
+        def delete(route, app_proc = nil, &blk)
+          endpoint(route, :delete, app_proc, &blk)
+        end
+
+        def patch(route, app_proc = nil, &blk)
+          endpoint(route, :patch, app_proc, &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
+          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
+
+          location(route, methods: [method]) do
+            @middleware[:app] = { app_proc: app_proc }
+          end
+        end
+
+        def grpc(handler, **)
+          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
+
+        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"
+          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 }
+          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"
+          end
+
+          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) }
+          end
+        end
+
+        def include(path)
+          code = IO.read("#{path}.rb")
+          instance_eval(code, "#{path}.rb", 1)
+        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 multithreaded_reactor(multithreaded)
+          raise "Multithreaded reactor must be set at the root" unless @parent.nil?
+
+          @options[:multithreaded_reactor] = !!multithreaded
+        end
+
+        def watch(path, commands)
+          raise "Watch be set at the root" unless @parent.nil?
+
+          @options[:notify_watchers] ||= []
+          @options[:notify_watchers] << [path, commands]
+        end
+
+        def fiber_scheduler(klass_name = true)
+          raise "Fiber scheduler must be set at the root" unless @parent.nil?
+
+          klass_name = "Itsi::Scheduler" if klass_name == true
+          @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(*routes, methods: [], protocols: [], hosts: [], ports: [], extensions: [], content_types: [],
+                     accepts: [], &block)
+          build_child = lambda {
+            @children << DSL.new(
+              self,
+              routes: routes,
+              methods: Array(methods) | self.methods,
+              protocols: Array(protocols) | self.protocols,
+              hosts: Array(hosts) | self.hosts,
+              ports: Array(ports) | self.ports,
+              extensions: Array(extensions) | self.extensions,
+              content_types: Array(content_types) | self.content_types,
+              accepts: Array(accepts) | self.accepts,
+              controller: @controller,
+              &block
+            )
+          }
+          if @parent.nil?
+            @options[:middleware_loaders] << build_child
+          else
+            build_child[]
+          end
+        end
+
+        def log_requests(**args)
+          @middleware[:log_requests] = args
+        end
+
+        def allow_list(**args)
+          args[:allowed_patterns] = Array(args[:allowed_patterns]).map do |pattern|
+            if pattern.is_a?(Regexp)
+              pattern.source
+            else
+              pattern
+            end
+          end
+          @middleware[:allow_list] = args
+        end
+
+        def deny_list(**args)
+          args[:denied_patterns] = Array(args[:denied_patterns]).map do |pattern|
+            if pattern.is_a?(Regexp)
+              pattern.source
+            else
+              pattern
+            end
+          end
+          @middleware[:deny_list] = args
+        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?
+
+          @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?
+
+          @middleware[:auth_jwt] = args
+        end
+
+        def auth_api_key(**args)
+          raise "`auth_api_key` must be set inside a location block" if @parent.nil?
+
+          @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?
+
+          @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
+            else
+              pattern
+            end
+          end
+          @middleware[:intrusion_protection] = args
+        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)
+            warn "Warning: static_assets root_dir '#{root_dir}' does not exist!"
+          elsif !File.directory?(root_dir)
+            warn "Warning: static_assets root_dir '#{root_dir}' is not a directory!"
+          end
+
+          args[:relative_path] = true unless args.key?(:relative_path)
+
+          location(/(?<path_suffix>.*)/, 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)
+        end
+
+        def flatten_routes
+          result = []
+          result.concat(@children.flat_map(&:flatten_routes))
+          route_options = paths_from_parent
+          if route_options
+            result << deep_stringify_keys(
+              {
+                route: Regexp.new("^#{route_options}$"),
+                methods: @methods.any? ? @methods : nil,
+                protocols: @protocols.any? ? @protocols : nil,
+                hosts: @hosts.any? ? @hosts : nil,
+                ports: @ports.any? ? @ports : nil,
+                extensions: @extensions.any? ? @extensions : nil,
+                content_types: @content_types.any? ? @content_types : nil,
+                accepts: @accepts.any? ? @accepts : nil,
+                middleware: effective_middleware
+              }
+            )
+          end
+          result
+        end
+
+        def paths_from_parent
+          return nil unless @routes.any?
+
+          route_or_str = @routes.map do |seg|
+            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{/$}, ".*")
+            end
+          end.join("|")
+
+          if 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?("/")
+            "(?:#{route_or_str})"
+          end
+        end
+
+        def effective_middleware
+          merged = merge_ancestor_middleware
+          merged.map { |k, v| { type: k.to_s, parameters: v } }
+        end
+
+        def merge_ancestor_middleware
+          chain = []
+          node = self
+          while node
+            chain << node
+            node = node.parent
+          end
+          chain.reverse!
+
+          merged = {}
+          chain.each do |n|
+            n.middleware.each do |k, v|
+              merged[k] = v
+            end
+          end
+          merged
+        end
+
+        def deep_stringify_keys(obj)
+          case obj
+          when Hash
+            obj.transform_keys!(&:to_s)
+            obj.transform_values! { |v| deep_stringify_keys(v) }
+          when Array
+            obj.map { |v| deep_stringify_keys(v) }
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,26 +1,121 @@
+# frozen_string_literal: true
+
 module Itsi
   class Server
     module Config
-      module_function
+      require_relative "config/dsl"
+      require_relative "default_app/default_app"
+      require "debug"
 
       ITSI_DEFAULT_CONFIG_FILE = "Itsi.rb"
 
-      def load(options)
-        options[:config_file] ||= \
+      def self.save_argv!
+        @argv ||= ARGV[0...ARGV.index("--listeners")]
+      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)
+        itsifile_config = \
+          if builder_proc
+            DSL.evaluate(builder_proc)
+          elsif File.exist?(config_file_path.to_s)
+            DSL.evaluate(config_file_path)
+          else
+            {}
+          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) },
+          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,
+          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, "") },
+          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)
+          end,
+          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) },
+          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
+
+      # Reloads the entire process
+      # using exec, passing in any active file descriptors
+      # and previous invocation arguments
+      def self.reload_exec(listener_info)
+        if ENV["BUNDLE_BIN_PATH"]
+          exec "bundle", "exec", $PROGRAM_NAME, *@argv, "--listeners", listener_info
+        else
+          exec $PROGRAM_NAME, *@argv, "--listeners", listener_info
+        end
+      end
+
+      # Find config file path, if it exists.
+      def self.config_file_path(config_file_path = nil)
+        config_file_path ||= \
           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]
+        return unless File.exist?(config_file_path.to_s)
+
+        config_file_path
+      end
 
-        require_relative "options_dsl"
-        OptionsDSL.evaluate(options[:config_file]).merge(options)
+      def self.pid_file_path
+        if Dir.exist?("tmp")
+          File.join("tmp", "itsi.pid")
+        else
+          ".itsi.pid"
+        end
       end
 
-      def write_default
+      # Write a default config file, if one doesn't exist.
+      def self.write_default
         if File.exist?(ITSI_DEFAULT_CONFIG_FILE)
           puts "#{ITSI_DEFAULT_CONFIG_FILE} already exists."
           return

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

@@ -0,0 +1,38 @@
+# When you Run Itsi without a Rack app,
+# 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."
+  {
+    "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
+          [
+            { "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"]
+              )
+            ]
+          ]
+        end
+      [200, headers, body]
+    end)
+  }
+
+}