itsi 0.1.19 → 0.2.2

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

@@ -1,9 +1,10 @@
 use crate::{
-    default_responses::{INTERNAL_SERVER_ERROR_RESPONSE, NOT_FOUND_RESPONSE},
+    default_responses::NOT_FOUND_RESPONSE,
     prelude::*,
     server::{
         http_message_types::{HttpRequest, HttpResponse, RequestExt, ResponseFormat},
         middleware_stack::ErrorResponse,
+        redirect_type::RedirectType,
     },
 };
 use base64::{engine::general_purpose, Engine};
@@ -46,15 +47,18 @@ pub static ROOT_STATIC_FILE_SERVER: LazyLock<StaticFileServer> = LazyLock::new(|
         recheck_interval: Duration::from_secs(1),
         try_html_extension: true,
         auto_index: true,
+        headers: None,
         not_found_behavior: NotFoundBehavior::Error(ErrorResponse::not_found()),
         serve_hidden_files: false,
         allowed_extensions: vec!["html".to_string(), "css".to_string(), "js".to_string()],
     })
+    .unwrap()
 });
 
 #[derive(Debug, Clone, Deserialize)]
 pub struct Redirect {
     pub to: String,
+    pub r#type: RedirectType,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -67,8 +71,6 @@ pub enum NotFoundBehavior {
     IndexFile(PathBuf),
     #[serde(rename = "redirect")]
     Redirect(Redirect),
-    #[serde(rename = "internal_server_error")]
-    InternalServerError,
 }
 
 #[derive(Debug, Clone)]
@@ -80,6 +82,7 @@ pub struct StaticFileServerConfig {
     pub try_html_extension: bool,
     pub auto_index: bool,
     pub not_found_behavior: NotFoundBehavior,
+    pub headers: Option<HashMap<String, String>>,
     pub serve_hidden_files: bool,
     pub allowed_extensions: Vec<String>,
 }
@@ -112,23 +115,26 @@ struct CacheEntry {
 }
 
 impl CacheEntry {
-    pub fn suggest_content_for(&self, supported_encodings: &[HeaderValue]) -> (Arc<Bytes>, &str) {
+    pub fn suggest_content_for(
+        &self,
+        supported_encodings: &[HeaderValue],
+    ) -> (Arc<Bytes>, Option<&str>) {
         for encoding_header in supported_encodings {
             if let Ok(header_value) = encoding_header.to_str() {
                 for header_value in header_value.split(",").map(|hv| hv.trim()) {
                     for algo in header_value.split(";").map(|hv| hv.trim()) {
                         match algo {
                             "zstd" if self.zstd_encoded.is_some() => {
-                                return (self.zstd_encoded.clone().unwrap(), "zstd")
+                                return (self.zstd_encoded.clone().unwrap(), Some("zstd"))
                             }
                             "gzip" if self.gzip_encoded.is_some() => {
-                                return (self.gzip_encoded.clone().unwrap(), "gzip")
+                                return (self.gzip_encoded.clone().unwrap(), Some("gzip"))
                             }
                             "br" if self.br_encoded.is_some() => {
-                                return (self.br_encoded.clone().unwrap(), "br")
+                                return (self.br_encoded.clone().unwrap(), Some("br"))
                             }
                             "deflate" if self.deflate_encoded.is_some() => {
-                                return (self.deflate_encoded.clone().unwrap(), "deflate")
+                                return (self.deflate_encoded.clone().unwrap(), Some("deflate"))
                             }
                             _ => {}
                         }
@@ -136,7 +142,7 @@ impl CacheEntry {
                 }
             }
         }
-        (self.content.clone(), "identity")
+        (self.content.clone(), None)
     }
 }
 
@@ -209,14 +215,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)]
@@ -290,15 +309,10 @@ impl StaticFileServer {
                         .await
                 }
                 NotFoundBehavior::Redirect(redirect) => Response::builder()
-                    .status(StatusCode::MOVED_PERMANENTLY)
+                    .status(redirect.r#type.status_code())
                     .header(header::LOCATION, redirect.to)
                     .body(BoxBody::new(Full::new(Bytes::new())))
                     .unwrap(),
-                NotFoundBehavior::InternalServerError => {
-                    INTERNAL_SERVER_ERROR_RESPONSE
-                        .to_http_response(request.accept().into())
-                        .await
-                }
             },
         })
     }
@@ -420,8 +434,8 @@ impl StaticFileServer {
 
         // No valid cached entry, resolve the key to a file path
         let decoded_key = percent_decode_str(key).decode_utf8_lossy();
-        let normalized_path =
-            normalize_path(decoded_key).ok_or(NotFoundBehavior::InternalServerError)?;
+        let normalized_path = normalize_path(decoded_key)
+            .ok_or(NotFoundBehavior::Error(NOT_FOUND_RESPONSE.clone()))?;
 
         if !self.config.serve_hidden_files
             && normalized_path
@@ -435,6 +449,7 @@ impl StaticFileServer {
 
         let mut full_path = self.config.root_dir.clone();
         full_path.push(normalized_path);
+        debug!("Resolving path {:?}", full_path);
         // Check if path exists and is a file
         match tokio::fs::metadata(&full_path).await {
             Ok(metadata) => {
@@ -478,19 +493,26 @@ impl StaticFileServer {
                         // Check for case insensitive index.html
                         let entries = match tokio::fs::read_dir(&full_path).await {
                             Ok(entries) => entries,
-                            Err(_) => return Err(NotFoundBehavior::InternalServerError),
+                            Err(_) => {
+                                return Err(NotFoundBehavior::Error(NOT_FOUND_RESPONSE.clone()))
+                            }
                         };
 
                         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());
                             }
                         }
                     }
@@ -539,6 +561,7 @@ impl StaticFileServer {
             }
             Err(_) => {
                 // Path doesn't exist, try with .html extension if configured
+                debug!("Path doesn't exist");
                 if self.config.try_html_extension {
                     let mut html_path = full_path.clone();
                     html_path.set_extension("html");
@@ -735,6 +758,7 @@ impl StaticFileServer {
                 (end_idx - start) as usize,
                 last_modified,
                 content_range,
+                &self.headers,
                 self.stream_file_range(file, start, end_idx).await.unwrap(),
             )
         } else {
@@ -746,6 +770,7 @@ impl StaticFileServer {
                 content_length as usize,
                 last_modified,
                 content_range,
+                &self.headers,
                 self.stream_file(file).await.unwrap(),
             )
         }
@@ -844,6 +869,7 @@ impl StaticFileServer {
                 range_bytes.len(),
                 cache_entry.last_modified,
                 content_range,
+                &self.headers,
                 BoxBody::new(Full::new(range_bytes)),
             )
         } else {
@@ -852,12 +878,13 @@ impl StaticFileServer {
             let body = build_ok_body(content);
             build_file_response(
                 status,
-                Some(encoding),
+                encoding,
                 Some(&cache_entry.etag),
                 get_mime_type(path),
                 content_length as usize,
                 cache_entry.last_modified,
                 content_range,
+                &self.headers,
                 body,
             )
         }
@@ -928,6 +955,7 @@ fn build_file_response(
     content_length: usize,
     last_modified: SystemTime,
     range_header: Option<String>,
+    headers: &Option<HashMap<String, String>>,
     body: BoxBody<Bytes, Infallible>,
 ) -> http::Response<BoxBody<Bytes, Infallible>> {
     let mut builder = Response::builder()
@@ -947,6 +975,11 @@ fn build_file_response(
     if let Some(range) = range_header {
         builder = builder.header(CONTENT_RANGE, range);
     }
+    if let Some(headers) = headers {
+        for (key, value) in headers {
+            builder = builder.header(key, value);
+        }
+    }
 
     builder.body(body).unwrap()
 }
@@ -999,23 +1032,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/crates/itsi_tracing/src/lib.rs

@@ -3,9 +3,13 @@ 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;
+use tracing_subscriber::fmt::{
+    format::{FmtSpan, JsonFields},
+    writer::BoxMakeWriter,
+};
 use tracing_subscriber::{EnvFilter, fmt, prelude::*, reload};
 use tracing_subscriber::{Layer, Registry, layer::Layered};
 
@@ -61,6 +65,10 @@ pub struct LogConfig {
     pub use_ansi: bool,
 }
 
+fn default_log_file() -> String {
+    env::var("ITSI_LOG_FILE").unwrap_or_else(|_| "itsi-app.log".into())
+}
+
 impl Default for LogConfig {
     fn default() -> Self {
         let level = env::var("ITSI_LOG").unwrap_or_else(|_| "info".into());
@@ -69,14 +77,8 @@ impl Default for LogConfig {
             _ => LogFormat::Plain,
         };
         let target = match env::var("ITSI_LOG_TARGET").as_deref() {
-            Ok("file") => {
-                let file = env::var("ITSI_LOG_FILE").unwrap_or_else(|_| "app.log".into());
-                LogTarget::File(file)
-            }
-            Ok("both") => {
-                let file = env::var("ITSI_LOG_FILE").unwrap_or_else(|_| "app.log".into());
-                LogTarget::Both(file)
-            }
+            Ok("file") => LogTarget::File(default_log_file()),
+            Ok("both") => LogTarget::Both(default_log_file()),
             _ => LogTarget::Stdout,
         };
         // If ITSI_LOG_ANSI is set, use that; otherwise, use ANSI if stdout is a TTY.
@@ -110,21 +112,27 @@ fn build_fmt_layer(
                 .compact()
                 .with_file(false)
                 .with_line_number(false)
-                .with_target(false)
-                .with_thread_ids(false)
-                .with_writer(BoxMakeWriter::new(std::io::stdout))
-                .with_ansi(config.use_ansi)
-                .boxed(),
-            LogFormat::Json => 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)
-                .json()
+                .with_span_events(FmtSpan::NONE)
+                .fmt_fields(JsonFields::new())
                 .boxed(),
+            LogFormat::Json => {
+                fmt::layer()
+                    .compact()
+                    .with_file(false)
+                    .with_line_number(false)
+                    .with_target(true)
+                    .with_thread_ids(false)
+                    .with_writer(BoxMakeWriter::new(std::io::stdout))
+                    .with_ansi(config.use_ansi)
+                    .event_format(fmt::format().json()) // set the JSON event formatter
+                    .with_span_events(FmtSpan::NONE)
+                    .fmt_fields(JsonFields::new())
+                    .boxed()
+            }
         },
         LogTarget::File(file) => {
             let file_clone = file.clone();
@@ -133,12 +141,14 @@ 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())
                     }))
                     .with_ansi(false)
+                    .with_span_events(FmtSpan::NONE)
+                    .fmt_fields(JsonFields::new())
                     .boxed(),
                 LogFormat::Json => {
                     let file_clone = file.clone();
@@ -146,13 +156,15 @@ 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())
                         }))
                         .with_ansi(false)
-                        .json()
+                        .event_format(fmt::format().json()) // set the JSON event formatter
+                        .with_span_events(FmtSpan::NONE)
+                        .fmt_fields(JsonFields::new())
                         .boxed()
                 }
             }
@@ -165,19 +177,23 @@ 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_span_events(FmtSpan::NONE)
+                        .fmt_fields(JsonFields::new())
                         .with_ansi(config.use_ansi);
                     let file_layer = 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())
                         }))
+                        .with_span_events(FmtSpan::NONE)
+                        .fmt_fields(JsonFields::new())
                         .with_ansi(false);
                     stdout_layer.and_then(file_layer).boxed()
                 }
@@ -186,22 +202,26 @@ 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)
-                        .json();
+                        .event_format(fmt::format().json()) // set the JSON event formatter
+                        .with_span_events(FmtSpan::NONE)
+                        .fmt_fields(JsonFields::new());
                     let file_layer = 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())
                         }))
                         .with_ansi(false)
-                        .json();
+                        .event_format(fmt::format().json()) // set the JSON event formatter
+                        .with_span_events(FmtSpan::NONE)
+                        .fmt_fields(JsonFields::new());
                     stdout_layer.and_then(file_layer).boxed()
                 }
             }
@@ -278,6 +298,7 @@ pub fn set_level(new_level: &str) {
 pub fn set_target(new_target: &str) {
     let target: LogTarget = match new_target {
         "stdout" => LogTarget::Stdout,
+        "both" => LogTarget::Both(default_log_file()),
         path => LogTarget::File(path.to_string()),
     };
     if let Some(config_mutex) = CURRENT_CONFIG.get() {
@@ -304,6 +325,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/docker/Dockerfile

@@ -0,0 +1,12 @@
+FROM ruby:3.4.2-slim
+
+WORKDIR /app
+
+# Install only what's needed to install the gem, then clean up in the same layer
+RUN apt-get update && \
+  apt-get install -y --no-install-recommends libclang-dev build-essential curl && \
+  gem install itsi --no-document && \
+  apt-get purge -y --auto-remove build-essential && \
+  rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+ENTRYPOINT ["itsi"]

data/docs/content/_index.md

@@ -1,17 +1,24 @@
 ---
-title: My Site
-toc: false
+type: docs
 ---
+# Itsi
+<img src="itsi-server-100.png" alt="asd" width="80px" style="display: block; margin-left: auto; margin-right: auto;">
 
-This is the landing page.
+> The Serious Web Server, for Serious People
 
-## Explore
 
-{{< cards >}}
-  {{< card link="docs" title="Docs" icon="book-open" >}}
-  {{< card link="about" title="About" icon="user" >}}
-{{< /cards >}}
+Itsi is a feature-packed, high performance web and application server, with first-class support for Ruby applications.
+It's a compliant Rack server. It’s also a well-equipped reverse-proxy, API gateway, and static file server, controlled by an intuitive and elegant configuration API and DSL.
+
 
-## Documentation
+Itsi is motivated by the belief that:
+>*It should be **easy** to share your application on the internet with confidence, without a need for complex configuration or multiple layers of tools.*
 
-For more information, visit [Hextra](https://imfing.github.io/hextra).
+With *just* your application code and *Itsi* working within a single process, you can proudly serve your best work, directly to the world wide web.
+
+{{< cards >}}
+  {{< card link="../features" title="Features" icon="star" >}}
+  {{< card link="../getting_started" title="Getting Started" icon="academic-cap" >}}
+  {{< card link="../configuration" title="Configuration" icon="adjustments" >}}
+  {{< card link="https://github.com/wouterken/itsi" title="Source Code" icon="github" >}}
+{{< /cards >}}

data/docs/content/acknowledgements/_index.md

@@ -0,0 +1,46 @@
+---
+title: Acknowledgements
+type: docs
+prev: itsi_scheduler/
+sidebar:
+  exclude: true
+---
+
+Itsi has a long list of **critical** dependencies and **strong** influences.
+
+
+## Key Dependencies
+* [hyper](https://hyper.rs/)
+Hyper is a fast, correct and memory-safe HTTP1 & 2 Implementation in Rust.
+It is an absolutely essential component of Itsi.
+
+* [tokio](https://tokio.rs/)
+Tokio is a fast and featureful asynchronous runtime for Rust.
+It is the backbone of *all* asynchronous IO in Itsi.
+
+* [rb-sys](https://github.com/oxidize-rb/rb-sys) and [magnus](https://github.com/matsadler/magnus), two essential libraries for building Ruby extensions in Rust.
+
+* and many more [essential](https://github.com/wouterken/itsi/blob/main/crates/itsi_server/Cargo.toml) Rust crates!
+
+* [hugo](https://gohugo.io/) and [hextra](https://imfing.github.io/hextra/) - generating *this very page* and allowing me to put together
+this website with minimal effort.
+
+
+## Inspiration
+* [Puma](https://puma.io/) is a long-standing industry heavyweight and the current leading choice of web server in the Ruby ecosystem.
+It's mature, stable and rock solid. Many features and interfaces of Itsi have been inspired by Puma.
+
+* [NGINX](https://nginx.org/) is a popular open-source web server and reverse proxy server.
+It's highly scalable and a great choice for high-traffic websites.
+Many of Itsi's proxy and static file server design decisions and features have been inspired by their NGINX equivalents.
+
+* The [Async](https://github.com/socketry/async) ecosystem and [Falcon](https://github.com/socketry/falcon), championed by [@ioaquatix](https://github.com/ioquatix) - a fellow Kiwi.
+These tools and efforts in driving forward Ruby's cooperative multitasking have been a great inspiration and source of learning for Itsi's async IO design.
+
+* [Iodine](https://github.com/boazsegev/iodine), [Agoo](https://github.com/ohler55/agoo). Two class-leading options when it comes to blazing fast Ruby servers written in native code.
+
+* [Caddy](https://caddyserver.com/)
+An open-source web server and reverse proxy server, with a huge feature set, great performance, and arguably the first tool to popularize automated ACME certificate management.
+
+* [RubyLSP](https://shopify.github.io/ruby-lsp/)
+An open-source language server for Ruby, built by engineers at Shopify making it *easy* to significantly enhance the Itsi developer experience.