itsi 0.1.18 → 0.1.20

data/crates/itsi_server/src/server/serve_strategy/cluster_mode.rs

@@ -73,13 +73,18 @@ impl ClusterMode {
                 Ok(())
             }
             LifecycleEvent::Restart => {
-                self.server_config.dup_fds()?;
-                self.shutdown().await.ok();
-                info!("Shutdown complete. Calling reload exec");
-                self.server_config.reload_exec()?;
+                if self.server_config.check_config() {
+                    self.server_config.dup_fds()?;
+                    self.shutdown().await.ok();
+                    info!("Shutdown complete. Calling reload exec");
+                    self.server_config.reload_exec()?;
+                }
                 Ok(())
             }
             LifecycleEvent::Reload => {
+                if !self.server_config.check_config() {
+                    return Ok(());
+                }
                 let should_reexec = self.server_config.clone().reload(true)?;
                 if should_reexec {
                     self.server_config.dup_fds()?;
@@ -286,6 +291,7 @@ impl ClusterMode {
         self.build_runtime().block_on(async {
           let self_ref = self_ref.clone();
           let mut memory_check_interval = time::interval(time::Duration::from_secs(2));
+
           loop {
             tokio::select! {
               _ = receiver.changed() => {

data/crates/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/crates/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/crates/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/crates/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/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,25 @@
 ---
-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 with top-tier performance.
+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,43 @@
+---
+title: Acknowledgements
+type: docs
+sidebar:
+  exclude: true
+---
+
+Itsi is **heavily** is dependent on and/or heavily inspired by a long list of related projects and individuals.
+
+
+## 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.
+
+* 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 heavy-weight 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.

data/docs/content/configuration/_index.md

@@ -0,0 +1,98 @@
+---
+title: Configuration
+type: docs
+weight: 3
+next: /options/
+---
+
+## Itsi.rb
+To realize the full power of all of Itsi's features, you'll typically create a configuration file
+(usually named `Itsi.rb`) at the root of your project.<br/>
+If you're ready to get stuck in and learn all about what Itsi has to offer, use
+`itsi init` to generate a fresh configuration file and read through the following [options](/options/) and [middleware](/middleware/) sections.
+
+
+## Out-of-the-box
+If you prefer a more gradual introduction, Itsi provides several "out-of-the box" capabilities that you can take immediate advantage of *without*, needing to start a dedicated configuration file.
+
+
+
+## Run Rack Applications
+Itsi will automatically host your Rack application if you launch it in a directory with a `config.ru` file.
+This means, it's a drop in server replacement for your favourite `Rails`, `Hanami`, or `Sinatra` applications.
+
+To get started just run
+```ruby
+itsi # or
+bundle exec itsi
+```
+
+There's also a Rails adapter allowing you to add it to your Gemfile and launch it using the `rails server` command.
+
+```ruby
+rails server -U itsi
+```
+{{< callout type="info" >}}
+  Note that `rails server -U itsi` runs Itsi with a intentionally minimal footprint, specifically for development purposes. To take full advantage of Itsi's concurrency features,
+it's advised you tweak these inside a dedicated `Itsi.rb` file.
+  {{< /callout >}}
+
+
+
+## Host static files
+You can run Itsi as a fully fledged, static file server.
+With a single command, Itsi will start an HTTP server to serve files from the current directory.
+To get started just run.
+```ruby
+itsi static # or
+bundle exec itsi static
+```
+
+> This starts a server with a minimal set of defaults. Look at the [`static_assets`](/middleware/static_assets) middleware page to learn more about how to configure Itsi for full control over static file server capabilities.
+
+## Tweak your Itsi server
+Several of the most common features of Itsi are configurable using command line flags.
+Run `itsi --help` to see all available options. If you apply both command line flags and an `Itsi.rb` config file, the command line flags will take precedence.
+
+```bash
+❯ itsi --help
+Usage: itsi [COMMAND] [options]
+    -C, --config CONFIG_FILE         Itsi Configuration file to use (default: Itsi.rb)
+    -w, --workers WORKERS            Number of workers
+    -d, --daemonize                  Run the process as a daemon
+    -t, --threads THREADS            Number of threads (default: 1)
+        --[no-]multithreaded-reactor Use a multithreaded reactor
+    -r, --rackup_file FILE           Rackup file to use (default: config.ru)
+        --worker-memory-limit MEMORY_LIMIT
+                                     Memory limit for each worker (default: None). If this limit is breached the worker is gracefully restarted
+    -f [CLASS_NAME],                 Scheduler class to use (default: nil). Provide blank or true to use Itsi::Scheduler, or a classname to use an alternative scheduler
+        --fiber_scheduler
+        --preload [true, false, :bundle_group_name]
+                                      Toggle preloading the application
+    -b, --bind BIND                  Bind address (default: http://0.0.0.0:3000). You can specify this flag multiple times to bind to multiple addresses.
+    -c, --cert_path CERT_PATH        Path to the SSL certificate file (must follow a --bind option). You can specify this flag multiple times.
+    -k, --key_path KEY_PATH          Path to the SSL key file (must follow a --bind option). You can specify this flag multiple times.
+        --shutdown_timeout SHUTDOWN_TIMEOUT
+                                     Graceful timeout period before forcing workers to shutdown
+        --stream-body                Stream body frames (default: false for best compatibility)
+    -h, --help                       Show this help message
+        --reexec PARAMS              Reexec the server with the given parameters
+        --listeners LISTENERS        Listeners for reexec
+        --passfile PASSFILE          Passfile
+        --algorithm ALGORITHM        Algorithm for password hashing
+COMMAND:
+    init - Initialize a new Itsi.rb server configuration file
+    status - Show the status of the server
+    start - Start the Itsi server
+    serve - Start the Itsi server
+    stop - Stop the server
+    reload - Reload the server
+    restart - Restart the server
+    add_worker - Add a new worker to the server cluster
+    remove_worker - Remove a worker from the server cluster
+    routes - Print the routes of the server
+    passfile - Manage hashed users and passwords in a passfile (like .htpasswd). [add, remove, list]
+    test_route - Test which route a request will be routed to
+    static - Serve static assets in the given directory
+
+```

data/docs/content/contact/_index.md

@@ -0,0 +1,7 @@
+---
+title: Contact
+type: docs
+weight: 3
+sidebar:
+  exclude: true
+---

data/docs/content/faqs/_index.md

@@ -0,0 +1,27 @@
+---
+title: F.A.Qs
+type: docs
+---
+
+{{% details title="Is it just for Ruby applications?" closed="true" %}}
+**No!** While one of Itsi's goals is to be the most frictionless way to get Ruby onto the web, it stands alone as a powerful Reverse Proxy, Static File Server and API Gateway.
+
+You can have Itsi sit in front of *any* application that speaks HTTP and immediately benefit from security middleware, performance enhancements, and more.
+You will need to write a little bit of Ruby, just to configure your Itsi server inside the `Itsi.rb` file. Who knows, maybe you'll learn to love it!
+{{% /details %}}
+
+{{% details title="What's it written in?" closed="true" %}}
+The heart of Itsi is a Rust server, leaning *heavily* on [tokio](https://tokio.rs) and [hyper](https://hyper.rs) and many other fantastic and high performance Rust libraries.
+Take a look at the [Cargo.toml](https://github.com/wouterken/itsi/blob/main/crates/itsi_server/Cargo.toml) to see them all.
+
+This is exposed via a robust and ergonomic Ruby DSL.
+{{% /details %}}
+
+{{% details title="What License is it under?" closed="true" %}}
+Itsi is an open source project licensed under the terms of the [LGPLv3](https://www.gnu.org/licenses/lgpl-3.0.en.html).
+
+You can integrate and use Itsi in your projects—whether they are open source or proprietary—without any licensing fees or obligations, as long as you use Itsi in its unmodified form. However, if you modify Itsi’s source code and distribute the modified version, you are required to release your modifications under the same LGPLv3 license.
+
+If these terms do not meet your project’s needs or if you require bespoke support and legal assurances, Itsi is also available under alternative commercial licensing options.
+Please contact commercial@itsi.fyi for more information.
+{{% /details %}}