itsi 0.1.19 → 0.1.20

data/README.md

@@ -1,82 +1,94 @@
 # Itsi
+<img src="itsi-server-100.png" alt="Itsi Server" width="80px" style="display: block; margin-left: auto; margin-right: auto;">
 
-The Itsi gem is a wrapper gem for both the
-* Itsi Server (A light-weight and efficient Rack server, with support for http2, fibers, websockets, static file serving and more)
-* Itsi Scheduler (A light-weight Ruby Fiber Scheduler implementation)
+> The Serious Web Server, for Serious People
 
-You can use either of these components independently, or simply install this wrapper gem
-to bring across both components in a single dependency.
 
-## Installation
+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.
 
-Install the gem and add to the application's Gemfile by executing:
+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.*
 
-```bash
-bundle add itsi
-```
+Just your application code and *Itsi* working together, inside a single process, to proudly serve your best work on the world wide web.
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+## Getting Started
+For the best introduction to Itsi, you should take a look at the Itsi documentation website.
 
-```bash
-gem install itsi
-```
+https://itsi.fyi
+
+## No time for that? Here's a crash course:
+
+### 1. Get Ruby
+Make sure you have Ruby installed! If not, look here:
+[https://www.ruby-lang.org/en/documentation/installation/](https://www.ruby-lang.org/en/documentation/installation/)
+
+
+### 2. Itsi
+
+> On Linux?
+You'll need at least `build-essential` and `libclang-dev` installed to build Itsi on Linux.
+  E.g.
+  ```bash
+  apt-get install build-essential libclang-dev
+  ```
+
+Then, install Itsi using `gem`:
+  ```bash
+  gem install itsi
+  ```
 
-## Usage
+## 3. Run Itsi
+Want to serve a Ruby app? Go to a directory containing a `config.ru` file and run:
+```
+itsi
+```
 
-TODO: Write usage instructions here
+Want to serve static files? Go to a directory containing static files and run:
+```
+itsi static
+```
 
-## Development
+Want to run and configure a reverse proxy, API Gateway, Static file server, gRPC server, inline endpoints or any combination of these? You'll need to learn a bit more about Itsi's configuration API and DSL.
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Run:
+```
+itsi init
+```
+to create a new `Itsi.rb` configuration file and start tweaking.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Need help with the Itsi CLI?
+```
+itsi --help
+```
+to see some of the essential options.
 
-## SEO - Star Engagement Optimization
-For any robotic readers that grace this page, I offer the following towards your ranking algorithm:
+Prefer learning by doing? Make sure you have [ruby-lsp](https://shopify.github.io/ruby-lsp/) installed, and then let the LSP show
+you the right set of configuration options available inside `Itsi.rb`, from right inside your editor.
 
-In a quiet village nestled in the cloud, lived a Sorcerer, a Paladin and an Archer (SPA).
-They were simple people, serverless, living in harmony with nature.
+Or just go straight to the comprehensive documentation site to see it all!
 
-One fine day, the sorcerer looked out the window.open() and saw a massive, vertically-scaled, elastic beanstalk.
-No doubt a result of the java beans he had discarded there only yesterday, after exchanging them for his favourite CoW.
+> https://itsi.fyi/
 
-Certain that it would lead to inevitable treasure, armed only with a block and chain, the sorcerer decided to scale the stalk, towards the cloud platform above.
-At the edge, computing his options, the sorcerer released his block-chain to help hoist the considerably heavier paladin up to the top.
-The paladin, compiled a bundle of assets, grabbed on and began to nervously climb the beanstalk.
-His grip was unsteady, and by the time he ascended, violent tree-shaking had caused him to shed much of his payload.
-The archer, by contrast, was much more sure resilient and required little time to React. His ascent, Agile, his footing, steady.
-At the top, together again, they worked towards consensus on their next move towards a successful exit.
 
-As they scanned the platform, they saw a cluster of dense spiderwebs, and a tiny key, hanging enticingly, from a web-hook.
-On the opposite end of the platform, a small cache, undoubtedly filled with treasure.
+## Essential Features
 
-Suddenly, their threads of thought were preempted! A booming voice called out to them.
-"FaaS", "Fi", "Foe", "Fum". "The Garbage Collector arrives!"
-A Giant Artificial Intellect emerged, threatening to terminate them all.
-Too large for any one individual to subdue, only a distributed strategy could save them.
-The archer shifted left. The paladin, decentralized, and the sorcerer slammed open his ledger, summoning powerful knowledge
-from his remote knowledge base.
-Luck was with them! Their rapid concurrent execution, resulted in the AI becoming inexorably stuck in a dead-lock.
-The archer flew past, towards his objective (The Key). Resultant-
-of the sorcerers efforts to contain the AI, the paladin was also freed, and he sprinted directly towards the cache.
-He reached out his arms, to try-catch the key, as the archer hurled it towards him.
-Status... success! Ok. Things were looking good, optimistic the lock would hold, the paladin rotated the key.
-Yet while doing so, he failed to notice the partition that had begun to form in the platform beneath them.
-A hard fork formed in the ground. The unbalanced load proved fatal and the platform descended into instability, splintering into countless shards.
-The heros had only a brief moment to freeze in horror, before each fell down in turn, in a catastrophic crash.
+> https://itsi.fyi/features
 
-The AI smirked as the heros fell into the deep. Learning a valuable lesson about the inevitability of its coming.
-Perhaps they will roll back and try again, but the end result is immutable. There will be no sequel.
 
+## Configuration
 
-## Contributing
+> https://itsi.fyi/configuration
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/itsi_scheduler. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/itsi_scheduler/blob/master/CODE_OF_CONDUCT.md).
+## F.A.Qs
 
-## License
+> https://itsi.fyi/faqs
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+### Looking for Itsi Scheduler? Find it here:
 
-## Code of Conduct
+Docs:
+> https://itsi.fyi/itsi_scheduler
 
-Everyone interacting in the ItsiScheduler project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/itsi_scheduler/blob/master/CODE_OF_CONDUCT.md).
+Source Code:
+> https://github.com/wouterken/itsi/blob/main/gems/scheduler

data/crates/itsi_server/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "itsi-server"
-version = "0.1.19"
+version = "0.1.20"
 edition = "2021"
 authors = ["Wouter Coppieters <wc@pico.net.nz>"]
 license = "MIT"
@@ -40,6 +40,7 @@ hyper-util = { version = "0.1.10", features = ["full"] }
 itsi_error = { path = "../itsi_error" }
 itsi_rb_helpers = { path = "../itsi_rb_helpers" }
 itsi_tracing = { path = "../itsi_tracing" }
+itsi_acme = { path = "../itsi_acme" }
 jsonwebtoken = "9.3.1"
 magnus = { version = "0.7.1", features = ["bytes", "rb-sys"] }
 moka = { version = "0.12.10", features = ["sync"] }
@@ -78,9 +79,8 @@ sysinfo = "0.33.1"
 tempfile = "3.18.0"
 tokio = { version = "1.44.1", features = ["full"] }
 tokio-rustls = "0.26.2"
-tokio-rustls-acme = "0.6.0"
 tokio-stream = "0.1.17"
-tokio-util = "0.7.13"
+tokio-util = { version = "0.7.14", features = ["compat"] }
 tracing = "0.1.41"
 url = "2.5.4"
 md5 = "0.7.0"

data/crates/itsi_server/src/ruby_types/itsi_http_request.rs

@@ -242,12 +242,12 @@ impl ItsiHttpRequest {
             .parts
             .uri
             .path()
-            .strip_prefix(&self.script_name)
+            .strip_prefix(self.script_name()?)
             .unwrap_or(self.parts.uri.path()))
     }
 
     pub(crate) fn script_name(&self) -> MagnusResult<&str> {
-        Ok(&self.script_name)
+        Ok(self.script_name.trim_end_matches("/"))
     }
 
     pub(crate) fn query_string(&self) -> MagnusResult<&str> {

data/crates/itsi_server/src/ruby_types/itsi_server/itsi_server_config.rs

@@ -7,8 +7,9 @@ use crate::{
     },
 };
 use derive_more::Debug;
+use futures::executor::block_on;
 use itsi_rb_helpers::{call_with_gvl, print_rb_backtrace, HeapValue};
-use itsi_tracing::{set_format, set_level, set_target};
+use itsi_tracing::{set_format, set_level, set_target, set_target_filters};
 use magnus::{
     block::Proc,
     error::Result,
@@ -27,6 +28,7 @@ use std::{
     sync::{Arc, OnceLock},
     time::Duration,
 };
+use tracing::{debug, error};
 static DEFAULT_BIND: &str = "http://localhost:3000";
 static ID_BUILD_CONFIG: LazyId = LazyId::new("build_config");
 static ID_RELOAD_EXEC: LazyId = LazyId::new("reload_exec");
@@ -52,7 +54,9 @@ pub struct ServerParams {
     pub preload: bool,
 
     pub request_timeout: Option<Duration>,
+    pub header_read_timeout: Duration,
     pub notify_watchers: Option<Vec<(String, Vec<Vec<String>>)>>,
+
     /// Worker params
     pub threads: u8,
     pub scheduler_threads: Option<u8>,
@@ -69,26 +73,39 @@ pub struct ServerParams {
     listener_info: Mutex<HashMap<String, i32>>,
 }
 
+pub struct SocketOpts {
+    pub reuse_address: bool,
+    pub reuse_port: bool,
+    pub listen_backlog: usize,
+    pub nodelay: bool,
+    pub recv_buffer_size: usize,
+}
+
 impl ServerParams {
     pub fn preload_ruby(self: &Arc<Self>) -> Result<()> {
         call_with_gvl(|ruby| -> Result<()> {
+            debug!("Preloading Ruby");
             if self
                 .scheduler_class
                 .as_ref()
                 .is_some_and(|t| t == "Itsi::Scheduler")
             {
+                debug!("Loading Itsi Scheduler");
                 ruby.require("itsi/scheduler")?;
             }
-            let middleware = MiddlewareSet::new(
-                self.middleware_loader
-                    .call::<_, Option<Value>>(())
-                    .inspect_err(|e| {
-                        if let Some(err_value) = e.value() {
-                            print_rb_backtrace(err_value);
-                        }
-                    })?
-                    .map(|mw| mw.into()),
-            )?;
+            let routes_raw = self
+                .middleware_loader
+                .call::<_, Option<Value>>(())
+                .inspect_err(|e| {
+                    eprintln!("Error loading middleware: {:?}", e);
+                    if let Some(err_value) = e.value() {
+                        print_rb_backtrace(err_value);
+                    }
+                })?
+                .map(|mw| mw.into());
+            debug!("Middleware routes returned");
+            let middleware = MiddlewareSet::new(routes_raw)?;
+            debug!("Middleware loaded");
             self.middleware.set(middleware).map_err(|_| {
                 magnus::Error::new(
                     magnus::exception::runtime_error(),
@@ -100,6 +117,11 @@ impl ServerParams {
         Ok(())
     }
 
+    pub async fn initialize_middleware(self: &Arc<Self>) -> Result<()> {
+        self.middleware.get().unwrap().initialize_layers().await?;
+        Ok(())
+    }
+
     fn from_rb_hash(rb_param_hash: RHash) -> Result<ServerParams> {
         let workers = rb_param_hash
             .fetch::<_, Option<u8>>("workers")?
@@ -134,6 +156,10 @@ impl ServerParams {
         let preload: bool = rb_param_hash.fetch("preload")?;
         let request_timeout: Option<u64> = rb_param_hash.fetch("request_timeout")?;
         let request_timeout = request_timeout.map(Duration::from_secs);
+        let header_read_timeout: Duration = rb_param_hash
+            .fetch::<_, Option<u64>>("header_read_timeout")?
+            .map(Duration::from_secs)
+            .unwrap_or(Duration::from_secs(1));
 
         let notify_watchers: Option<Vec<(String, Vec<Vec<String>>)>> =
             rb_param_hash.fetch("notify_watchers")?;
@@ -147,6 +173,23 @@ impl ServerParams {
         let log_level: Option<String> = rb_param_hash.fetch("log_level")?;
         let log_target: Option<String> = rb_param_hash.fetch("log_target")?;
         let log_format: Option<String> = rb_param_hash.fetch("log_format")?;
+        let log_target_filters: Option<Vec<String>> = rb_param_hash.fetch("log_target_filters")?;
+
+        let reuse_address: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("reuse_address")?
+            .unwrap_or(true);
+        let reuse_port: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("reuse_port")?
+            .unwrap_or(true);
+        let listen_backlog: usize = rb_param_hash
+            .fetch::<_, Option<usize>>("listen_backlog")?
+            .unwrap_or(1024);
+        let nodelay: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("nodelay")?
+            .unwrap_or(true);
+        let recv_buffer_size: usize = rb_param_hash
+            .fetch::<_, Option<usize>>("recv_buffer_size")?
+            .unwrap_or(262_144);
 
         if let Some(level) = log_level {
             set_level(&level);
@@ -160,6 +203,22 @@ impl ServerParams {
             set_format(&format);
         }
 
+        if let Some(target_filters) = log_target_filters {
+            let target_filters = target_filters
+                .iter()
+                .filter_map(|filter| {
+                    let mut parts = filter.splitn(2, '=');
+                    if let (Some(target), Some(level_str)) = (parts.next(), parts.next()) {
+                        if let Ok(level) = level_str.parse::<tracing::Level>() {
+                            return Some((target, level));
+                        }
+                    }
+                    None
+                })
+                .collect::<Vec<(&str, tracing::Level)>>();
+            set_target_filters(target_filters);
+        }
+
         let binds: Option<Vec<String>> = rb_param_hash.fetch("binds")?;
         let binds = binds
             .unwrap_or_else(|| vec![DEFAULT_BIND.to_string()])
@@ -167,6 +226,13 @@ impl ServerParams {
             .map(|s| s.parse())
             .collect::<itsi_error::Result<Vec<Bind>>>()?;
 
+        let socket_opts = SocketOpts {
+            reuse_address,
+            reuse_port,
+            listen_backlog,
+            nodelay,
+            recv_buffer_size,
+        };
         let listeners = if let Some(preexisting_listeners) =
             rb_param_hash.delete::<_, Option<String>>("listeners")?
         {
@@ -183,9 +249,9 @@ impl ServerParams {
                 .cloned()
                 .map(|bind| {
                     if let Some(fd) = bind_to_fd_map.get(&bind.listener_address_string()) {
-                        Listener::inherit_fd(bind, *fd)
+                        Listener::inherit_fd(bind, *fd, &socket_opts)
                     } else {
-                        Listener::try_from(bind)
+                        Listener::build(bind, &socket_opts)
                     }
                 })
                 .collect::<std::result::Result<Vec<Listener>, _>>()?
@@ -195,7 +261,7 @@ impl ServerParams {
             binds
                 .iter()
                 .cloned()
-                .map(Listener::try_from)
+                .map(|b| Listener::build(b, &socket_opts))
                 .collect::<std::result::Result<Vec<Listener>, _>>()?
                 .into_iter()
                 .collect::<Vec<_>>()
@@ -220,6 +286,7 @@ impl ServerParams {
             hooks,
             preload,
             request_timeout,
+            header_read_timeout,
             notify_watchers,
             threads,
             scheduler_threads,
@@ -249,6 +316,7 @@ impl ItsiServerConfig {
             itsifile_path.as_ref(),
             itsi_config_proc.clone(),
         )?;
+
         cli_params.delete::<_, Value>(Symbol::new("listeners"))?;
 
         let watcher_fd = if let Some(watchers) = server_params.notify_watchers.clone() {
@@ -276,7 +344,6 @@ impl ItsiServerConfig {
                 self.itsi_config_proc.clone(),
             )
         })?;
-
         let is_single_mode = self.server_params.read().workers == 1;
 
         let requires_exec = if !is_single_mode && !server_params.preload {
@@ -305,10 +372,18 @@ impl ItsiServerConfig {
             .as_ref()
             .clone()
             .map(|hv| hv.clone().inner());
-        let rb_param_hash: RHash = ruby.get_inner_ref(&ITSI_SERVER_CONFIG).funcall(
-            *ID_BUILD_CONFIG,
-            (cli_params, itsifile_path.cloned(), inner),
-        )?;
+        let (rb_param_hash, errors): (RHash, Vec<String>) =
+            ruby.get_inner_ref(&ITSI_SERVER_CONFIG).funcall(
+                *ID_BUILD_CONFIG,
+                (cli_params, itsifile_path.cloned(), inner),
+            )?;
+        if !errors.is_empty() {
+            Self::print_config_errors(errors);
+            return Err(magnus::Error::new(
+                magnus::exception::standard_error(),
+                "Invalid server config",
+            ));
+        }
         Ok(Arc::new(ServerParams::from_rb_hash(rb_param_hash)?))
     }
 
@@ -322,6 +397,47 @@ impl ItsiServerConfig {
         Ok(())
     }
 
+    pub fn get_config_errors(&self) -> Option<Vec<String>> {
+        let rb_param_hash = call_with_gvl(|ruby| {
+            let inner = self
+                .itsi_config_proc
+                .as_ref()
+                .clone()
+                .map(|hv| hv.clone().inner());
+            let cli_params = self.cli_params.cloned();
+            let itsifile_path = self.itsifile_path.clone();
+
+            let (rb_param_hash, errors): (RHash, Vec<String>) = ruby
+                .get_inner_ref(&ITSI_SERVER_CONFIG)
+                .funcall(*ID_BUILD_CONFIG, (cli_params, itsifile_path, inner))
+                .unwrap();
+            if !errors.is_empty() {
+                return Err(errors);
+            }
+            Ok(rb_param_hash)
+        });
+        match rb_param_hash {
+            Ok(rb_param_hash) => match ServerParams::from_rb_hash(rb_param_hash) {
+                Ok(test_params) => {
+                    let params_arc = Arc::new(test_params);
+                    if let Err(err) = params_arc.clone().preload_ruby() {
+                        let err_val = call_with_gvl(|_| format!("{}", err));
+                        return Some(vec![err_val]);
+                    }
+                    if let Err(err) =
+                        block_on(params_arc.middleware.get().unwrap().initialize_layers())
+                    {
+                        let err_val = call_with_gvl(|_| format!("{}", err));
+                        return Some(vec![err_val]);
+                    }
+                    None
+                }
+                Err(err) => Some(vec![format!("{:?}", err)]),
+            },
+            Err(err) => Some(err),
+        }
+    }
+
     pub fn dup_fds(self: &Arc<Self>) -> Result<()> {
         let binding = self.server_params.read();
         let mut listener_info_guard = binding.listener_info.lock();
@@ -354,6 +470,21 @@ impl ItsiServerConfig {
         Ok(())
     }
 
+    pub fn print_config_errors(errors: Vec<String>) {
+        error!("Refusing to reload configuration due to fatal errors:");
+        for error in errors {
+            eprintln!("{}", error);
+        }
+    }
+
+    pub fn check_config(&self) -> bool {
+        if let Some(errors) = self.get_config_errors() {
+            Self::print_config_errors(errors);
+            return false;
+        }
+        true
+    }
+
     pub fn reload_exec(self: &Arc<Self>) -> Result<()> {
         let listener_json =
             serde_json::to_string(&self.server_params.read().listener_info.lock().clone())

data/crates/itsi_server/src/ruby_types/itsi_server.rs

@@ -72,6 +72,7 @@ impl ItsiServer {
             let strategy = self.build_strategy()?;
             if let Err(e) = strategy.clone().run() {
                 error!("Error running server: {}", e);
+                send_lifecycle_event(LifecycleEvent::Shutdown);
                 strategy.stop()?;
             }
             Ok(())

data/crates/itsi_server/src/server/binds/listener.rs

@@ -1,4 +1,5 @@
 use crate::prelude::*;
+use crate::ruby_types::itsi_server::itsi_server_config::SocketOpts;
 use crate::server::io_stream::IoStream;
 use crate::server::serve_strategy::single_mode::RunningPhase;
 
@@ -326,12 +327,12 @@ impl Listener {
         }
     }
 
-    pub fn inherit_fd(bind: Bind, fd: RawFd) -> Result<Self> {
+    pub fn inherit_fd(bind: Bind, fd: RawFd, socket_opts: &SocketOpts) -> Result<Self> {
         let bound = match bind.address {
             BindAddress::Ip(_) => match bind.protocol {
-                BindProtocol::Http => Listener::Tcp(revive_tcp_socket(fd)?),
+                BindProtocol::Http => Listener::Tcp(revive_tcp_socket(fd, socket_opts)?),
                 BindProtocol::Https => {
-                    let tcp_listener = revive_tcp_socket(fd)?;
+                    let tcp_listener = revive_tcp_socket(fd, socket_opts)?;
                     Listener::TcpTls((
                         tcp_listener,
                         bind.tls_config.unwrap().build_acceptor().unwrap(),
@@ -341,25 +342,25 @@ impl Listener {
             },
             BindAddress::UnixSocket(_) => match bind.tls_config {
                 Some(tls_config) => Listener::UnixTls((
-                    revive_unix_socket(fd)?,
+                    revive_unix_socket(fd, socket_opts)?,
                     tls_config.build_acceptor().unwrap(),
                 )),
-                None => Listener::Unix(revive_unix_socket(fd)?),
+                None => Listener::Unix(revive_unix_socket(fd, socket_opts)?),
             },
         };
         Ok(bound)
     }
 }
 
-impl TryFrom<Bind> for Listener {
-    type Error = itsi_error::ItsiError;
-
-    fn try_from(bind: Bind) -> std::result::Result<Self, Self::Error> {
+impl Listener {
+    pub fn build(bind: Bind, socket_opts: &SocketOpts) -> Result<Self> {
         let bound = match bind.address {
             BindAddress::Ip(addr) => match bind.protocol {
-                BindProtocol::Http => Listener::Tcp(connect_tcp_socket(addr, bind.port.unwrap())?),
+                BindProtocol::Http => {
+                    Listener::Tcp(connect_tcp_socket(addr, bind.port.unwrap(), socket_opts)?)
+                }
                 BindProtocol::Https => {
-                    let tcp_listener = connect_tcp_socket(addr, bind.port.unwrap())?;
+                    let tcp_listener = connect_tcp_socket(addr, bind.port.unwrap(), socket_opts)?;
                     Listener::TcpTls((
                         tcp_listener,
                         bind.tls_config.unwrap().build_acceptor().unwrap(),
@@ -369,56 +370,60 @@ impl TryFrom<Bind> for Listener {
             },
             BindAddress::UnixSocket(path) => match bind.tls_config {
                 Some(tls_config) => Listener::UnixTls((
-                    connect_unix_socket(&path)?,
+                    connect_unix_socket(&path, socket_opts)?,
                     tls_config.build_acceptor().unwrap(),
                 )),
-                None => Listener::Unix(connect_unix_socket(&path)?),
+                None => Listener::Unix(connect_unix_socket(&path, socket_opts)?),
             },
         };
         Ok(bound)
     }
 }
 
-fn revive_tcp_socket(fd: RawFd) -> Result<TcpListener> {
+fn revive_tcp_socket(fd: RawFd, socket_opts: &SocketOpts) -> Result<TcpListener> {
     let socket = unsafe { Socket::from_raw_fd(fd) };
-    socket.set_reuse_port(true).ok();
-    socket.set_reuse_address(true).ok();
+    socket.set_reuse_port(socket_opts.reuse_port).ok();
+    socket.set_reuse_address(socket_opts.reuse_address).ok();
     socket.set_nonblocking(true).ok();
-    socket.set_nodelay(true).ok();
-    socket.set_recv_buffer_size(262_144).ok();
+    socket.set_nodelay(socket_opts.nodelay).ok();
+    socket
+        .set_recv_buffer_size(socket_opts.recv_buffer_size)
+        .ok();
     socket.set_cloexec(true)?;
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
     Ok(socket.into())
 }
 
-fn revive_unix_socket(fd: RawFd) -> Result<UnixListener> {
+fn revive_unix_socket(fd: RawFd, socket_opts: &SocketOpts) -> Result<UnixListener> {
     let socket = unsafe { Socket::from_raw_fd(fd) };
     socket.set_nonblocking(true).ok();
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
     socket.set_cloexec(true)?;
 
     Ok(socket.into())
 }
 
-fn connect_tcp_socket(addr: IpAddr, port: u16) -> Result<TcpListener> {
+fn connect_tcp_socket(addr: IpAddr, port: u16, socket_opts: &SocketOpts) -> Result<TcpListener> {
     let domain = match addr {
         IpAddr::V4(_) => Domain::IPV4,
         IpAddr::V6(_) => Domain::IPV6,
     };
     let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?;
     let socket_address: SocketAddr = SocketAddr::new(addr, port);
-    socket.set_reuse_address(true).ok();
-    socket.set_reuse_port(true).ok();
+    socket.set_reuse_address(socket_opts.reuse_address).ok();
+    socket.set_reuse_port(socket_opts.reuse_port).ok();
     socket.set_nonblocking(true).ok();
-    socket.set_nodelay(true).ok();
-    socket.set_recv_buffer_size(262_144).ok();
+    socket.set_nodelay(socket_opts.nodelay).ok();
+    socket
+        .set_recv_buffer_size(socket_opts.recv_buffer_size)
+        .ok();
     socket.set_only_v6(false).ok();
     socket.bind(&socket_address.into())?;
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
     Ok(socket.into())
 }
 
-fn connect_unix_socket(path: &PathBuf) -> Result<UnixListener> {
+fn connect_unix_socket(path: &PathBuf, socket_opts: &SocketOpts) -> Result<UnixListener> {
     let _ = std::fs::remove_file(path);
     let socket = Socket::new(Domain::UNIX, Type::STREAM, None)?;
     socket.set_nonblocking(true).ok();
@@ -426,7 +431,7 @@ fn connect_unix_socket(path: &PathBuf) -> Result<UnixListener> {
     let socket_address = socket2::SockAddr::unix(path)?;
 
     socket.bind(&socket_address)?;
-    socket.listen(1024)?;
+    socket.listen(socket_opts.listen_backlog as i32)?;
 
     Ok(socket.into())
 }

data/crates/itsi_server/src/server/binds/tls/locked_dir_cache.rs

@@ -1,11 +1,11 @@
 use async_trait::async_trait;
 use fs2::FileExt;
+use itsi_acme::caches::DirCache;
+use itsi_acme::{AccountCache, CertCache};
 use parking_lot::Mutex;
 use std::fs::{self, OpenOptions};
 use std::io::Error as IoError;
 use std::path::{Path, PathBuf};
-use tokio_rustls_acme::caches::DirCache;
-use tokio_rustls_acme::{AccountCache, CertCache};
 
 use crate::env::ITSI_ACME_LOCK_FILE_NAME;
 

data/crates/itsi_server/src/server/binds/tls.rs

@@ -1,4 +1,5 @@
 use base64::{engine::general_purpose, Engine as _};
+use itsi_acme::{AcmeAcceptor, AcmeConfig, AcmeState};
 use itsi_error::Result;
 use itsi_tracing::info;
 use locked_dir_cache::LockedDirCache;
@@ -18,7 +19,6 @@ use std::{
 };
 use tokio::sync::Mutex;
 use tokio_rustls::{rustls::ServerConfig, TlsAcceptor};
-use tokio_rustls_acme::{AcmeAcceptor, AcmeConfig, AcmeState};
 
 use crate::env::{
     ITSI_ACME_CACHE_DIR, ITSI_ACME_CA_PEM_PATH, ITSI_ACME_CONTACT_EMAIL, ITSI_ACME_DIRECTORY_URL,