itsi-server 0.1.18 → 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/http_request.rb

@@ -29,6 +29,7 @@ module Itsi
       path = self.path
       host = self.host
       version = self.version
+
       {
         "SERVER_SOFTWARE" => "Itsi",
         "SCRIPT_NAME" => script_name,

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