itsi-server 0.1.19 → 0.1.20

data/ext/itsi_server/src/server/serve_strategy/single_mode.rs

@@ -90,6 +90,7 @@ impl SingleMode {
     }
 
     pub fn stop(&self) -> Result<()> {
+        SHUTDOWN_REQUESTED.store(true, std::sync::atomic::Ordering::SeqCst);
         self.lifecycle_channel.send(LifecycleEvent::Shutdown).ok();
         Ok(())
     }
@@ -231,14 +232,17 @@ impl SingleMode {
         );
 
         let (shutdown_sender, _) = watch::channel(RunningPhase::Running);
-        let thread = self.clone().start_monitors(thread_workers.clone());
+        let monitor_thread = self.clone().start_monitors(thread_workers.clone());
         if SHUTDOWN_REQUESTED.load(Ordering::SeqCst) {
             return Ok(());
         }
-        runtime.block_on(
+        let result = runtime.block_on(
           async  {
               let server_params = self.server_config.server_params.read().clone();
-              server_params.middleware.get().unwrap().initialize_layers().await?;
+              if let Err(err) = server_params.initialize_middleware().await {
+                  error!("Failed to initialize middleware: {}", err);
+                  return Err(ItsiError::new("Failed to initialize middleware"))
+              }
               let tokio_listeners = server_params.listeners.lock()
                   .drain(..)
                   .map(|list| {
@@ -310,7 +314,19 @@ impl SingleMode {
               drop(tokio_listeners);
 
               Ok::<(), ItsiError>(())
-          })?;
+          });
+
+        debug!("Single mode runtime exited.");
+
+        if result.is_err() {
+            for _i in 0..thread_workers.len() {
+                job_sender.send_blocking(RequestJob::Shutdown).unwrap();
+                nonblocking_sender
+                    .send_blocking(RequestJob::Shutdown)
+                    .unwrap();
+            }
+            self.lifecycle_channel.send(LifecycleEvent::Shutdown).ok();
+        }
 
         shutdown_sender.send(RunningPhase::Shutdown).ok();
         let deadline = Instant::now()
@@ -318,12 +334,13 @@ impl SingleMode {
 
         runtime.shutdown_timeout(Duration::from_millis(100));
 
+        debug!("Shutdown timeout finished.");
         loop {
             if thread_workers
                 .iter()
                 .all(|worker| call_with_gvl(move |_| !worker.poll_shutdown(deadline)))
             {
-                funcall_no_ret(thread, "join", ()).ok();
+                funcall_no_ret(monitor_thread, "join", ()).ok();
                 break;
             }
             sleep(Duration::from_millis(50));
@@ -335,7 +352,7 @@ impl SingleMode {
             self.run()?;
         }
         debug!("Runtime has shut down");
-        Ok(())
+        result
     }
 
     pub(crate) async fn serve_connection(
@@ -367,7 +384,7 @@ impl SingleMode {
         let mut serve = Box::pin(
             binding
                 .timer(TokioTimer::new())
-                .header_read_timeout(Duration::from_secs(1))
+                .header_read_timeout(self.server_config.server_params.read().header_read_timeout)
                 .serve_connection_with_upgrades(io, service),
         );
 
@@ -401,6 +418,9 @@ impl SingleMode {
     /// Not that when running in single mode this will not unload
     /// old code. If you need a clean restart, use the `restart` (SIGHUP) method instead
     pub fn reload(&self) -> Result<()> {
+        if !self.server_config.check_config() {
+            return Ok(());
+        }
         let should_reexec = self.server_config.clone().reload(false)?;
         if should_reexec {
             self.server_config.dup_fds()?;
@@ -414,6 +434,9 @@ impl SingleMode {
 
     /// Restart the server while keeping connections open.
     pub fn restart(&self) -> Result<()> {
+        if !self.server_config.check_config() {
+            return Ok(());
+        }
         self.server_config.dup_fds()?;
         self.server_config.reload_exec()?;
         Ok(())

data/ext/itsi_server/src/server/thread_worker.rs

@@ -159,11 +159,10 @@ impl ThreadWorker {
     pub fn poll_shutdown(&self, deadline: Instant) -> bool {
         if let Some(thread) = self.thread.read().deref() {
             if Instant::now() > deadline {
-                warn!("Worker shutdown timed out. Killing thread");
+                warn!("Worker shutdown timed out. Killing thread {:?}", thread);
                 self.terminated.store(true, Ordering::SeqCst);
                 kill_threads(vec![thread.as_value()]);
             }
-            debug!("Checking thread status");
             if thread.funcall::<_, _, bool>(*ID_ALIVE, ()).unwrap_or(false) {
                 return true;
             }
@@ -184,6 +183,7 @@ impl ThreadWorker {
         call_with_gvl(|_| {
             *self.thread.write() = Some(
                 create_ruby_thread(move || {
+                    debug!("Ruby thread worker started");
                     if let Some(scheduler_class) = scheduler_class {
                         if let Err(err) = self_ref.fiber_accept_loop(
                             params,

data/ext/itsi_server/src/services/static_file_server.rs

@@ -50,6 +50,7 @@ pub static ROOT_STATIC_FILE_SERVER: LazyLock<StaticFileServer> = LazyLock::new(|
         serve_hidden_files: false,
         allowed_extensions: vec!["html".to_string(), "css".to_string(), "js".to_string()],
     })
+    .unwrap()
 });
 
 #[derive(Debug, Clone, Deserialize)]
@@ -209,14 +210,27 @@ struct ServeCacheArgs<'a>(
 );
 
 impl StaticFileServer {
-    pub fn new(config: StaticFileServerConfig) -> Self {
+    pub fn new(config: StaticFileServerConfig) -> Result<Self> {
         let cache = Cache::builder().max_capacity(config.max_entries).build();
+        if !config.root_dir.exists() {
+            return Err(ItsiError::InternalError(format!(
+                "Root directory {} for static file server doesn't exist",
+                config.root_dir.display()
+            )));
+        }
+
+        if std::fs::read_dir(&config.root_dir).is_err() {
+            return Err(ItsiError::InternalError(format!(
+                "Root directory {} for static file server is not readable",
+                config.root_dir.display()
+            )));
+        }
 
-        StaticFileServer {
+        Ok(StaticFileServer {
             config: Arc::new(config),
             cache,
             key_to_path: Arc::new(Mutex::new(HashMap::new())),
-        }
+        })
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -483,14 +497,19 @@ impl StaticFileServer {
 
                         tokio::pin!(entries);
                         while let Some(entry) = entries.next_entry().await.unwrap_or(None) {
-                            if entry
-                                .file_name()
-                                .to_str()
-                                .is_some_and(|name| name.eq_ignore_ascii_case("index.html"))
-                                && entry.metadata().await.unwrap().is_file()
-                            {
-                                index_file = Some(entry.path());
-                                break;
+                            if let Ok(metadata) = entry.metadata().await {
+                                if entry
+                                    .file_name()
+                                    .to_str()
+                                    .is_some_and(|name| name.eq_ignore_ascii_case("index.html"))
+                                    && metadata.is_file()
+                                {
+                                    index_file = Some(entry.path());
+                                    break;
+                                }
+                            } else {
+                                error!("Failed to retrieve metadata for entry: {:?}", entry.path());
+                                return Err(self.config.not_found_behavior.clone());
                             }
                         }
                     }
@@ -999,23 +1018,6 @@ impl std::fmt::Display for StaticFileServer {
     }
 }
 
-impl Default for StaticFileServer {
-    fn default() -> Self {
-        let config = StaticFileServerConfig {
-            root_dir: "public".into(),
-            max_file_size: 10 * 1024 * 1024,
-            max_entries: 100,
-            recheck_interval: Duration::from_secs(60),
-            try_html_extension: true,
-            auto_index: true,
-            not_found_behavior: NotFoundBehavior::Error(ErrorResponse::not_found()),
-            serve_hidden_files: false,
-            allowed_extensions: vec!["html".to_string(), "css".to_string(), "js".to_string()],
-        };
-        Self::new(config)
-    }
-}
-
 async fn generate_directory_listing(
     dir_path: &Path,
     config: &StaticFileServerConfig,

data/ext/itsi_tracing/src/lib.rs

@@ -3,6 +3,7 @@ use std::{
     env,
     sync::{Mutex, OnceLock},
 };
+use tracing::Level;
 pub use tracing::{debug, error, info, trace, warn};
 use tracing_appender::rolling;
 use tracing_subscriber::fmt::writer::BoxMakeWriter;
@@ -110,7 +111,7 @@ fn build_fmt_layer(
                 .compact()
                 .with_file(false)
                 .with_line_number(false)
-                .with_target(false)
+                .with_target(true)
                 .with_thread_ids(false)
                 .with_writer(BoxMakeWriter::new(std::io::stdout))
                 .with_ansi(config.use_ansi)
@@ -119,7 +120,7 @@ fn build_fmt_layer(
                 .compact()
                 .with_file(false)
                 .with_line_number(false)
-                .with_target(false)
+                .with_target(true)
                 .with_thread_ids(false)
                 .with_writer(BoxMakeWriter::new(std::io::stdout))
                 .with_ansi(config.use_ansi)
@@ -133,7 +134,7 @@ fn build_fmt_layer(
                     .compact()
                     .with_file(false)
                     .with_line_number(false)
-                    .with_target(false)
+                    .with_target(true)
                     .with_thread_ids(false)
                     .with_writer(BoxMakeWriter::new(move || {
                         rolling::daily(".", file_clone.clone())
@@ -146,7 +147,7 @@ fn build_fmt_layer(
                         .compact()
                         .with_file(false)
                         .with_line_number(false)
-                        .with_target(false)
+                        .with_target(true)
                         .with_thread_ids(false)
                         .with_writer(BoxMakeWriter::new(move || {
                             rolling::daily(".", file_clone.clone())
@@ -165,7 +166,7 @@ fn build_fmt_layer(
                         .compact()
                         .with_file(false)
                         .with_line_number(false)
-                        .with_target(false)
+                        .with_target(true)
                         .with_thread_ids(false)
                         .with_writer(BoxMakeWriter::new(std::io::stdout))
                         .with_ansi(config.use_ansi);
@@ -173,7 +174,7 @@ fn build_fmt_layer(
                         .compact()
                         .with_file(false)
                         .with_line_number(false)
-                        .with_target(false)
+                        .with_target(true)
                         .with_thread_ids(false)
                         .with_writer(BoxMakeWriter::new(move || {
                             rolling::daily(".", file_clone.clone())
@@ -186,7 +187,7 @@ fn build_fmt_layer(
                         .compact()
                         .with_file(false)
                         .with_line_number(false)
-                        .with_target(false)
+                        .with_target(true)
                         .with_thread_ids(false)
                         .with_writer(BoxMakeWriter::new(std::io::stdout))
                         .with_ansi(config.use_ansi)
@@ -195,7 +196,7 @@ fn build_fmt_layer(
                         .compact()
                         .with_file(false)
                         .with_line_number(false)
-                        .with_target(false)
+                        .with_target(true)
                         .with_thread_ids(false)
                         .with_writer(BoxMakeWriter::new(move || {
                             rolling::daily(".", file_clone.clone())
@@ -304,6 +305,36 @@ pub fn set_format(new_format: &str) {
         eprintln!("Current configuration not initialized; call init() first.");
     }
 }
+pub fn set_target_filters(targets: Vec<(&str, Level)>) {
+    if let Some(reload_handle_mutex) = RELOAD_HANDLE.get() {
+        if let Ok(handle_guard) = reload_handle_mutex.lock() {
+            if let Some(handle) = handle_guard.as_ref() {
+                let mut new_filter = EnvFilter::new("");
+
+                if let Some(config_mutex) = CURRENT_CONFIG.get() {
+                    if let Ok(config) = config_mutex.lock() {
+                        if let Ok(directive) = config.level.parse() {
+                            new_filter = new_filter.add_directive(directive);
+                        }
+                    }
+                }
+
+                for (target, level) in targets {
+                    let directive_str = format!("{}={}", target, level);
+                    if let Ok(directive) = directive_str.parse() {
+                        new_filter = new_filter.add_directive(directive);
+                    }
+                }
+
+                if let Err(e) = handle.modify(|filter| *filter = new_filter) {
+                    eprintln!("Failed to update filter with target directives: {}", e);
+                }
+            }
+        }
+    } else {
+        eprintln!("Reload handle for filter not initialized; call init() first.");
+    }
+}
 
 /// Run a function silently by temporarily setting a no-op subscriber.
 pub fn run_silently<F, R>(f: F) -> R

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

@@ -0,0 +1,93 @@
+module Itsi
+  class Server
+    module Config
+      module ConfigHelpers
+
+        def self.load_and_register(klass)
+          config_type = klass.name.split("::").last.downcase
+          listing = [
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}/**.rb")],
+            Dir[File.expand_path(File.dirname(__FILE__) + "/#{config_type}s/**.rb")]
+          ].flatten
+
+          listing.each do |file|
+            current = klass.subclasses
+            require file
+            following = klass.subclasses
+            new_class = (following - current).first
+
+            documentation_file = "#{file[/(.*)\.rb/,1]}.md"
+            if File.exist?(documentation_file) && new_class
+              new_class.documentation IO.read(documentation_file)
+                .gsub(/^---.*?\n.*?-+/m,'') # Strip frontmatter
+                .gsub(/^(```.*?)\{.*?\}.*$/, "\\1") # Strip filename from code blocks
+                .gsub(/^\{\{[^\}]+\}\}/, "") # Strip Hugo blocks
+            end
+          end
+        end
+
+        def normalize_keys!(hash, expected=[])
+          hash.keys.each do |key|
+            value = hash.delete(key)
+            key = key.to_s.downcase.to_sym
+            hash[key] = value
+            raise "Unexpected key: #{key}" unless expected.include?(key)
+            expected -= [key]
+          end
+          raise "Missing required keys: #{expected.join(', ')}" unless expected.empty?
+          hash
+        end
+
+        def self.included(cls)
+          def cls.inherited(base)
+            %i[detail documentation insert_text schema].each do |attr|
+              base.define_singleton_method(attr) do |value=nil|
+                @middleware_class_attrs ||= {}
+                if value
+                  @middleware_class_attrs[attr] = value
+                else
+                  @middleware_class_attrs[attr]
+                end
+              end
+
+              base.define_method(attr) do |value=nil|
+                self.class.send(attr)
+              end
+            end
+
+            def base.schema(value=nil, &blk)
+              @middleware_class_attrs ||= {}
+              if blk
+                @middleware_class_attrs[:schema] = TypedStruct.new(&blk)
+              else
+                @middleware_class_attrs[:schema]
+              end
+            end
+          end
+
+          load_and_register(cls)
+
+          config_type = cls.name.split("::").last.downcase
+
+          cls.define_singleton_method("#{config_type}_name") do |name=self.name|
+            @config_name ||= name.split("::").last.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+          end
+        end
+
+        def initialize(location, params)
+          @location = location
+          @params = case self.schema
+          when TypedStruct::Validation
+            self.schema.validate!(params)
+          else
+            self.schema.new(params).to_h
+          end
+        end
+
+        def build!
+          @params
+        end
+      end
+    end
+  end
+end

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

@@ -2,18 +2,25 @@ module Itsi
   class Server
     module Config
       class DSL
-        attr_reader :parent, :children, :middleware, :controller_class, :routes, :methods, :protocols,
+        require_relative "config_helpers"
+        require_relative "option"
+        require_relative "middleware"
+
+        attr_reader :parent, :children, :middleware, :controller_class, :routes, :http_methods, :protocols,
                     :hosts, :ports, :extensions, :content_types, :accepts, :options
 
         def self.evaluate(config = Itsi::Server::Config.config_file_path, &blk)
-          new(routes: ["/"]) do
+          config = new(routes: ["/"]) do
             if blk
               instance_exec(&blk)
             else
               code = IO.read(config)
               instance_eval(code, config.to_s, 1)
             end
-          end.options
+          end
+          [config.options, config.errors]
+        rescue Exception => e
+          [{}, [[e, e.backtrace[0]]]]
         end
 
         def initialize(
@@ -36,7 +43,7 @@ module Itsi
 
           @controller = controller
           @routes = Array(routes).flatten
-          @methods = methods.map { |s| s.is_a?(Regexp) ? s : s.to_s }
+          @http_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 }
@@ -54,19 +61,30 @@ module Itsi
             end
           }
 
+          @errors = []
           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
+        def errors
+          @children.map(&:errors).flatten + @errors
         end
 
-        def threads(threads)
-          raise "Threads must be set at the root" unless @parent.nil?
+        Option.subclasses.each do |option|
+          option_name = option.option_name
+          define_method(option_name) do |*args, **kwargs, &blk|
+            @options[option_name] = option.new(self, *args, **kwargs, &blk).build!
+          rescue => e
+            @errors << [e, caller[1]]
+          end
+        end
 
-          @options[:threads] = [threads.to_i, 1].max
+        Middleware.subclasses.each do |middleware|
+          middleware_name = middleware.middleware_name
+          define_method(middleware_name) do |*args, **kwargs, &blk|
+            @middleware[middleware_name] = middleware.new(@parent, *args, **kwargs, &blk).build!
+          rescue => e
+            @errors << [e, caller[1]]
+          end
         end
 
         def oob_gc_responses_threshold(threshold)
@@ -81,18 +99,24 @@ module Itsi
           @options[:log_level] = level.to_s
         end
 
-        def log_format(format)
-          raise "Log format must be set at the root" unless @parent.nil?
-
-          @options[:log_format] = format.to_s
-        end
-
         def log_target(target)
           raise "Log target must be set at the root" unless @parent.nil?
 
           @options[:log_target] = target.to_s
         end
 
+        def log_target_filters(target_filters)
+          raise "Log target filters must be set at the root" unless @parent.nil?
+
+          @options[:log_target_filters] = target_filters
+        end
+
+        def log_format(target)
+          raise "Log format must be set at the root" unless @parent.nil?
+
+          @options[:log_format] = target.to_s
+        end
+
         def get(route, app_proc = nil, nonblocking: false, &blk)
           endpoint(route, [:get], app_proc, nonblocking: nonblocking,  &blk)
         end
@@ -138,11 +162,10 @@ module Itsi
             app_proc = Itsi::Server::TypedHandlers.handler_for(app_proc, params_schema)
           end
 
-
-          if route || methods.any?
+          if route || http_methods.any?
             # For endpoints, it's usually assumed trailing slash and non-trailing slash behaviour is the same
             routes = route == "/" ? ["", "/"] : [route]
-            location(*routes, methods: methods) do
+            location(*routes, methods: http_methods) do
               @middleware[:app] = { preloader: -> { app_proc }, nonblocking: nonblocking }
             end
           else
@@ -204,6 +227,31 @@ module Itsi
           instance_eval(code, "#{path}.rb", 1)
         end
 
+        def reuse_address(reuse_address)
+          raise "reuse_address must be set at the root" unless @parent.nil?
+          @options[:reuse_address] = reuse_address
+        end
+
+        def reuse_port(reuse_port)
+          raise "reuse_port must be set at the root" unless @parent.nil?
+          @options[:reuse_port] = reuse_port
+        end
+
+        def listen_backlog(listen_backlog)
+          raise "listen_backlog must be set at the root" unless @parent.nil?
+          @options[:listen_backlog] = listen_backlog
+        end
+
+        def nodelay(nodelay)
+          raise "nodelay must be set at the root" unless @parent.nil?
+          @options[:nodelay] = nodelay
+        end
+
+        def recv_buffer_size(recv_buffer_size)
+          raise "recv_buffer_size must be set at the root" unless @parent.nil?
+          @options[:recv_buffer_size] = recv_buffer_size
+        end
+
         def bind(bind_str)
           raise "Bind must be set at the root" unless @parent.nil?
 
@@ -296,6 +344,11 @@ module Itsi
           @options[:shutdown_timeout] = shutdown_timeout.to_f
         end
 
+        def header_read_timeout(header_read_timeout)
+          raise "Header read timeout must be set at the root" unless @parent.nil?
+
+          @options[:header_read_timeout] = header_read_timeout.to_f
+        end
 
         def stream_body(stream_body)
           raise "Stream body must be set at the root" unless @parent.nil?
@@ -309,7 +362,7 @@ module Itsi
             @children << DSL.new(
               self,
               routes: routes,
-              methods: Array(methods) | self.methods,
+              methods: Array(methods) | self.http_methods,
               protocols: Array(protocols) | self.protocols,
               hosts: Array(hosts) | self.hosts,
               ports: Array(ports) | self.ports,
@@ -327,9 +380,6 @@ module Itsi
           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|
@@ -358,7 +408,6 @@ module Itsi
         end
 
         def auth_basic(**args)
-
           if File.exist?(".itsi-credentials") && !args[:credential_file]
             args[:credential_file] = ".itsi-credentials"
           end
@@ -432,8 +481,12 @@ module Itsi
           @middleware[:etag] = args
         end
 
+        def csp(**args)
+          @middleware[:csp] = args
+        end
+
         def intrusion_protection(**args)
-          args[:banned_url_patterns] = Array(args[:banned_url_patterns]).map do |pattern|
+          args[:banned_url_patterns] = Array(args[:banned_url_patterns]).flatten.map do |pattern|
             if pattern.is_a?(Regexp)
               pattern.source
             else
@@ -485,7 +538,7 @@ module Itsi
             result << deep_stringify_keys(
               {
                 route: Regexp.new("^#{route_options}/?$"),
-                methods: @methods.any? ? @methods : nil,
+                methods: @http_methods.any? ? @http_methods : nil,
                 protocols: @protocols.any? ? @protocols : nil,
                 hosts: @hosts.any? ? @hosts : nil,
                 ports: @ports.any? ? @ports : nil,
@@ -535,11 +588,6 @@ module Itsi
         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
@@ -558,7 +606,7 @@ module Itsi
               merged[k] = v
             end
           end
-          merged
+          deep_stringify_keys(merged)
         end
 
         def deep_stringify_keys(obj)