itsi 0.1.19 → 0.2.2

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

@@ -7,8 +7,9 @@ use crate::{
     },
 };
 use derive_more::Debug;
+use itsi_error::ItsiError;
 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,
@@ -24,9 +25,14 @@ use std::{
     collections::HashMap,
     os::fd::{AsRawFd, OwnedFd, RawFd},
     path::PathBuf,
-    sync::{Arc, OnceLock},
+    str::FromStr,
+    sync::{
+        atomic::{AtomicBool, Ordering::Relaxed},
+        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 +58,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>,
@@ -67,28 +75,66 @@ pub struct ServerParams {
     #[debug(skip)]
     pub(crate) listeners: Mutex<Vec<Listener>>,
     listener_info: Mutex<HashMap<String, i32>>,
+    pub itsi_server_token_preference: ItsiServerTokenPreference,
+    pub preloaded: AtomicBool,
+    socket_opts: SocketOpts,
+    preexisting_listeners: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub enum ItsiServerTokenPreference {
+    Version,
+    Name,
+    None,
+}
+
+impl FromStr for ItsiServerTokenPreference {
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(match s {
+            "version" => ItsiServerTokenPreference::Version,
+            "name" => ItsiServerTokenPreference::Name,
+            "none" => ItsiServerTokenPreference::None,
+            _ => ItsiServerTokenPreference::Version,
+        })
+    }
+
+    type Err = ItsiError;
+}
+
+#[derive(Debug, Clone)]
+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<()> {
+        if self.preloaded.load(Relaxed) {
+            return Ok(());
+        }
         call_with_gvl(|ruby| -> Result<()> {
             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());
+            let middleware = MiddlewareSet::new(routes_raw)?;
             self.middleware.set(middleware).map_err(|_| {
                 magnus::Error::new(
                     magnus::exception::runtime_error(),
@@ -97,6 +143,12 @@ impl ServerParams {
             })?;
             Ok(())
         })?;
+        self.preloaded.store(true, Relaxed);
+        Ok(())
+    }
+
+    pub async fn initialize_middleware(self: &Arc<Self>) -> Result<()> {
+        self.middleware.get().unwrap().initialize_layers().await?;
         Ok(())
     }
 
@@ -132,8 +184,12 @@ impl ServerParams {
             .transpose()?
             .unwrap_or_default();
         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 request_timeout: Option<f64> = rb_param_hash.fetch("request_timeout")?;
+        let request_timeout = request_timeout.map(Duration::from_secs_f64);
+        let header_read_timeout: Duration = rb_param_hash
+            .fetch::<_, Option<f64>>("header_read_timeout")?
+            .map(Duration::from_secs_f64)
+            .unwrap_or(Duration::from_secs(1));
 
         let notify_watchers: Option<Vec<(String, Vec<Vec<String>>)>> =
             rb_param_hash.fetch("notify_watchers")?;
@@ -147,6 +203,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 +233,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,10 +256,55 @@ impl ServerParams {
             .map(|s| s.parse())
             .collect::<itsi_error::Result<Vec<Bind>>>()?;
 
-        let listeners = if let Some(preexisting_listeners) =
-            rb_param_hash.delete::<_, Option<String>>("listeners")?
-        {
-            let bind_to_fd_map: HashMap<String, i32> = serde_json::from_str(&preexisting_listeners)
+        let itsi_server_token_preference: String = rb_param_hash
+            .fetch("itsi_server_token_preference")
+            .unwrap_or_default();
+        let itsi_server_token_preference: ItsiServerTokenPreference =
+            itsi_server_token_preference.parse()?;
+
+        let socket_opts = SocketOpts {
+            reuse_address,
+            reuse_port,
+            listen_backlog,
+            nodelay,
+            recv_buffer_size,
+        };
+        let preexisting_listeners = rb_param_hash.delete::<_, Option<String>>("listeners")?;
+
+        let params = ServerParams {
+            workers,
+            worker_memory_limit,
+            silence,
+            multithreaded_reactor,
+            pin_worker_cores,
+            shutdown_timeout,
+            hooks,
+            preload,
+            request_timeout,
+            header_read_timeout,
+            notify_watchers,
+            threads,
+            scheduler_threads,
+            streamable_body,
+            scheduler_class,
+            oob_gc_responses_threshold,
+            binds,
+            itsi_server_token_preference,
+            socket_opts,
+            preexisting_listeners,
+            listener_info: Mutex::new(HashMap::new()),
+            listeners: Mutex::new(Vec::new()),
+            middleware_loader: middleware_loader.into(),
+            middleware: OnceLock::new(),
+            preloaded: AtomicBool::new(false),
+        };
+
+        Ok(params)
+    }
+
+    pub fn setup_listeners(&self) -> Result<()> {
+        let listeners = if let Some(preexisting_listeners) = self.preexisting_listeners.as_ref() {
+            let bind_to_fd_map: HashMap<String, i32> = serde_json::from_str(preexisting_listeners)
                 .map_err(|e| {
                     magnus::Error::new(
                         magnus::exception::standard_error(),
@@ -178,24 +312,24 @@ impl ServerParams {
                     )
                 })?;
 
-            binds
+            self.binds
                 .iter()
                 .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, &self.socket_opts)
                     } else {
-                        Listener::try_from(bind)
+                        Listener::build(bind, &self.socket_opts)
                     }
                 })
                 .collect::<std::result::Result<Vec<Listener>, _>>()?
                 .into_iter()
                 .collect::<Vec<_>>()
         } else {
-            binds
+            self.binds
                 .iter()
                 .cloned()
-                .map(Listener::try_from)
+                .map(|b| Listener::build(b, &self.socket_opts))
                 .collect::<std::result::Result<Vec<Listener>, _>>()?
                 .into_iter()
                 .collect::<Vec<_>>()
@@ -210,28 +344,9 @@ impl ServerParams {
             })
             .collect::<Result<HashMap<String, i32>>>()?;
 
-        Ok(ServerParams {
-            workers,
-            worker_memory_limit,
-            silence,
-            multithreaded_reactor,
-            pin_worker_cores,
-            shutdown_timeout,
-            hooks,
-            preload,
-            request_timeout,
-            notify_watchers,
-            threads,
-            scheduler_threads,
-            streamable_body,
-            scheduler_class,
-            oob_gc_responses_threshold,
-            binds,
-            listener_info: Mutex::new(listener_info),
-            listeners: Mutex::new(listeners),
-            middleware_loader: middleware_loader.into(),
-            middleware: OnceLock::new(),
-        })
+        *self.listener_info.lock() = listener_info;
+        *self.listeners.lock() = listeners;
+        Ok(())
     }
 }
 
@@ -243,27 +358,34 @@ impl ItsiServerConfig {
         itsi_config_proc: Option<Proc>,
     ) -> Result<Self> {
         let itsi_config_proc = Arc::new(itsi_config_proc.map(HeapValue::from));
-        let server_params = Self::combine_params(
+        match Self::combine_params(
             ruby,
             cli_params,
             itsifile_path.as_ref(),
             itsi_config_proc.clone(),
-        )?;
-        cli_params.delete::<_, Value>(Symbol::new("listeners"))?;
+        ) {
+            Ok(server_params) => {
+                cli_params.delete::<_, Value>(Symbol::new("listeners"))?;
 
-        let watcher_fd = if let Some(watchers) = server_params.notify_watchers.clone() {
-            file_watcher::watch_groups(watchers)?
-        } else {
-            None
-        };
+                let watcher_fd = if let Some(watchers) = server_params.notify_watchers.clone() {
+                    file_watcher::watch_groups(watchers)?
+                } else {
+                    None
+                };
 
-        Ok(ItsiServerConfig {
-            cli_params: Arc::new(cli_params.into()),
-            server_params: RwLock::new(server_params.clone()).into(),
-            itsi_config_proc,
-            itsifile_path,
-            watcher_fd: watcher_fd.into(),
-        })
+                Ok(ItsiServerConfig {
+                    cli_params: Arc::new(cli_params.into()),
+                    server_params: RwLock::new(server_params.clone()).into(),
+                    itsi_config_proc,
+                    itsifile_path,
+                    watcher_fd: watcher_fd.into(),
+                })
+            }
+            Err(err) => Err(magnus::Error::new(
+                magnus::exception::standard_error(),
+                format!("Error loading initial configuration {:?}", err),
+            )),
+        }
     }
 
     /// Reload
@@ -276,7 +398,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 +426,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 +451,52 @@ impl ItsiServerConfig {
         Ok(())
     }
 
+    pub async 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) = params_arc
+                        .middleware
+                        .get()
+                        .unwrap()
+                        .initialize_layers()
+                        .await
+                    {
+                        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 +529,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 async fn check_config(&self) -> bool {
+        if let Some(errors) = self.get_config_errors().await {
+            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

@@ -42,6 +42,7 @@ impl ItsiServer {
 
     #[instrument(skip(self))]
     pub fn start(&self) -> Result<()> {
+        self.config.lock().server_params.read().setup_listeners()?;
         let result = if self.config.lock().server_params.read().silence {
             run_silently(|| self.build_and_run_strategy())
         } else {
@@ -49,6 +50,7 @@ impl ItsiServer {
             self.build_and_run_strategy()
         };
         if let Err(e) = result {
+            error!("Error starting server: {:?}", e);
             if let Some(err_value) = e.value() {
                 print_rb_backtrace(err_value);
             }
@@ -72,6 +74,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/bind.rs

@@ -10,6 +10,7 @@ use std::{
     path::PathBuf,
     str::FromStr,
 };
+use tracing::{instrument, Level};
 
 #[derive(Debug, Clone)]
 pub enum BindAddress {
@@ -86,6 +87,7 @@ impl std::fmt::Debug for Bind {
 impl FromStr for Bind {
     type Err = ItsiError;
 
+    #[instrument(ret(level = Level::DEBUG))]
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
         let (protocol, remainder) = if let Some((proto, rest)) = s.split_once("://") {
             (proto.parse::<BindProtocol>()?, rest)
@@ -180,6 +182,7 @@ fn parse_bind_options(query: &str) -> HashMap<String, String> {
 }
 
 /// Attempts to resolve a hostname into an IP address.
+#[instrument(ret(level = Level::DEBUG))]
 fn resolve_hostname(hostname: &str) -> Option<IpAddr> {
     (hostname, 0)
         .to_socket_addrs()

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,64 +370,75 @@ 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)?;
+    if let Err(e) = socket.bind(&socket_address.into()) {
+        error!("Failed to bind socket: {}", e);
+    };
+    if let Err(e) = socket.listen(socket_opts.listen_backlog as i32) {
+        error!("Failed to listen on socket: {}", e);
+    };
     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();
 
     let socket_address = socket2::SockAddr::unix(path)?;
 
-    socket.bind(&socket_address)?;
-    socket.listen(1024)?;
-
+    if let Err(e) = socket.bind(&socket_address) {
+        error!("Failed to bind socket: {}", e);
+    };
+    if let Err(e) = socket.listen(socket_opts.listen_backlog as i32) {
+        error!("Failed to listen on socket: {}", e);
+    };
     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;