itsi 0.1.14 → 0.1.19

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

@@ -1,14 +1,14 @@
 use derive_more::Debug;
 use futures::StreamExt;
-use http::{request::Parts, Response, StatusCode, Version};
+use http::{header::CONTENT_LENGTH, request::Parts, Response, StatusCode, Version};
 use http_body_util::{combinators::BoxBody, BodyExt, Empty};
-use itsi_error::from::CLIENT_CONNECTION_CLOSED;
+use itsi_error::CLIENT_CONNECTION_CLOSED;
 use itsi_rb_helpers::{print_rb_backtrace, HeapValue};
 use itsi_tracing::{debug, error};
 use magnus::{
     block::Proc,
     error::{ErrorType, Result as MagnusResult},
-    Error,
+    Error, RHash, Symbol,
 };
 use magnus::{
     value::{LazyId, ReprValue},
@@ -21,11 +21,14 @@ use super::{
     itsi_body_proxy::{big_bytes::BigBytes, ItsiBody, ItsiBodyProxy},
     itsi_http_response::ItsiHttpResponse,
 };
-use crate::server::{
-    byte_frame::ByteFrame,
-    itsi_service::RequestContext,
-    request_job::RequestJob,
-    types::{HttpRequest, HttpResponse},
+use crate::{
+    server::{
+        byte_frame::ByteFrame,
+        http_message_types::{HttpRequest, HttpResponse},
+        request_job::RequestJob,
+        size_limited_incoming::MaxBodySizeReached,
+    },
+    services::itsi_http_service::HttpRequestContext,
 };
 
 static ID_MESSAGE: LazyId = LazyId::new("message");
@@ -40,7 +43,8 @@ pub struct ItsiHttpRequest {
     pub response: ItsiHttpResponse,
     pub start: Instant,
     #[debug(skip)]
-    pub context: RequestContext,
+    pub context: HttpRequestContext,
+    pub script_name: String,
 }
 
 impl fmt::Display for ItsiHttpRequest {
@@ -73,7 +77,7 @@ impl ItsiHttpRequest {
             }
         }
     }
-    fn content_type_str(&self) -> &str {
+    pub fn content_type_str(&self) -> &str {
         self.parts
             .headers
             .get("Content-Type")
@@ -85,10 +89,49 @@ impl ItsiHttpRequest {
         self.content_type_str() == "application/json"
     }
 
+    pub fn url_params(&self) -> magnus::error::Result<RHash> {
+        let captures = self
+            .context
+            .matching_pattern
+            .as_ref()
+            .and_then(|re| re.captures(self.parts.uri.path()));
+        if let Some(caps) = &captures {
+            let re = self.context.matching_pattern.as_ref().unwrap();
+            let params = RHash::with_capacity(caps.len());
+            for (i, group_name) in re.capture_names().enumerate().skip(1) {
+                if let Some(name) = group_name {
+                    if let Some(m) = caps.get(i) {
+                        // Insert into the hash: key is the group name, value is the match.
+                        params.aset(Symbol::new(name), m.as_str())?;
+                    }
+                }
+            }
+            Ok(params)
+        } else {
+            Ok(RHash::new())
+        }
+    }
+
     pub fn is_html(&self) -> bool {
         self.content_type_str() == "text/html"
     }
 
+    pub fn is_url_encoded(&self) -> bool {
+        self.content_type_str() == "application/x-www-form-urlencoded"
+    }
+
+    pub fn is_multipart(&self) -> bool {
+        self.content_type_str().starts_with("multipart/form-data")
+    }
+
+    pub fn content_length(&self) -> Option<u64> {
+        self.parts
+            .headers
+            .get(CONTENT_LENGTH)
+            .and_then(|hv| hv.to_str().ok())
+            .and_then(|s| s.parse().ok())
+    }
+
     pub fn process(self, ruby: &Ruby, app_proc: Arc<HeapValue<Proc>>) -> magnus::error::Result<()> {
         let response = self.response.clone();
         let result = app_proc.call::<_, Value>((self,));
@@ -117,37 +160,48 @@ impl ItsiHttpRequest {
     pub(crate) async fn process_request(
         app: Arc<HeapValue<Proc>>,
         hyper_request: HttpRequest,
-        context: &RequestContext,
+        context: &HttpRequestContext,
+        script_name: String,
+        nonblocking: bool,
     ) -> itsi_error::Result<HttpResponse> {
-        let (request, mut receiver) = ItsiHttpRequest::new(hyper_request, context).await;
-        let shutdown_channel = context.service.shutdown_channel.clone();
-        let response = request.response.clone();
-        match context
-            .sender
-            .send(RequestJob::ProcessHttpRequest(request, app))
-            .await
-        {
-            Err(err) => {
-                error!("Error occurred: {}", err);
-                let mut response = Response::new(BoxBody::new(Empty::new()));
-                *response.status_mut() = StatusCode::BAD_REQUEST;
-                Ok(response)
+        match ItsiHttpRequest::new(hyper_request, context, script_name).await {
+            Ok((request, mut receiver)) => {
+                let shutdown_channel = context.service.shutdown_channel.clone();
+                let response = request.response.clone();
+                let sender = if nonblocking {
+                    &context.nonblocking_sender
+                } else {
+                    &context.sender
+                };
+                match sender
+                    .send(RequestJob::ProcessHttpRequest(request, app))
+                    .await
+                {
+                    Err(err) => {
+                        error!("Error occurred: {}", err);
+                        let mut response = Response::new(BoxBody::new(Empty::new()));
+                        *response.status_mut() = StatusCode::BAD_REQUEST;
+                        Ok(response)
+                    }
+                    _ => match receiver.recv().await {
+                        Some(first_frame) => Ok(response
+                            .build(first_frame, receiver, shutdown_channel)
+                            .await),
+                        None => Ok(response
+                            .build(ByteFrame::Empty, receiver, shutdown_channel)
+                            .await),
+                    },
+                }
             }
-            _ => match receiver.recv().await {
-                Some(first_frame) => Ok(response
-                    .build(first_frame, receiver, shutdown_channel)
-                    .await),
-                None => Ok(response
-                    .build(ByteFrame::Empty, receiver, shutdown_channel)
-                    .await),
-            },
+            Err(err_resp) => Ok(err_resp),
         }
     }
 
     pub(crate) async fn new(
         request: HttpRequest,
-        context: &RequestContext,
-    ) -> (ItsiHttpRequest, mpsc::Receiver<ByteFrame>) {
+        context: &HttpRequestContext,
+        script_name: String,
+    ) -> Result<(ItsiHttpRequest, mpsc::Receiver<ByteFrame>), HttpResponse> {
         let (parts, body) = request.into_parts();
         let body = if context.server_params.streamable_body {
             ItsiBody::Stream(ItsiBodyProxy::new(body))
@@ -155,23 +209,32 @@ impl ItsiHttpRequest {
             let mut body_bytes = BigBytes::new();
             let mut stream = body.into_data_stream();
             while let Some(chunk) = stream.next().await {
-                let byte_array = chunk.unwrap().to_vec();
-                body_bytes.write_all(&byte_array).unwrap();
+                match chunk {
+                    Ok(byte_array) => body_bytes.write_all(&byte_array).unwrap(),
+                    Err(e) => {
+                        let mut err_resp = Response::new(BoxBody::new(Empty::new()));
+                        if e.downcast_ref::<MaxBodySizeReached>().is_some() {
+                            *err_resp.status_mut() = StatusCode::PAYLOAD_TOO_LARGE;
+                        }
+                        return Err(err_resp);
+                    }
+                }
             }
             ItsiBody::Buffered(body_bytes)
         };
         let response_channel = mpsc::channel::<ByteFrame>(100);
-        (
+        Ok((
             Self {
                 context: context.clone(),
                 version: parts.version,
                 response: ItsiHttpResponse::new(parts.clone(), response_channel.0),
                 start: Instant::now(),
+                script_name,
                 body,
                 parts,
             },
             response_channel.1,
-        )
+        ))
     }
 
     pub(crate) fn path(&self) -> MagnusResult<&str> {
@@ -179,12 +242,12 @@ impl ItsiHttpRequest {
             .parts
             .uri
             .path()
-            .strip_prefix(&self.context.server_params.script_name)
+            .strip_prefix(&self.script_name)
             .unwrap_or(self.parts.uri.path()))
     }
 
     pub(crate) fn script_name(&self) -> MagnusResult<&str> {
-        Ok(&self.context.server_params.script_name)
+        Ok(&self.script_name)
     }
 
     pub(crate) fn query_string(&self) -> MagnusResult<&str> {

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

@@ -2,8 +2,9 @@ use bytes::{Bytes, BytesMut};
 use derive_more::Debug;
 use futures::stream::{unfold, StreamExt};
 use http::{
-    header::TRANSFER_ENCODING, request::Parts, HeaderMap, HeaderName, HeaderValue, Request,
-    Response, StatusCode,
+    header::{ACCEPT, TRANSFER_ENCODING},
+    request::Parts,
+    HeaderMap, HeaderName, HeaderValue, Request, Response, StatusCode,
 };
 use http_body_util::{combinators::BoxBody, Empty, Full, StreamBody};
 use hyper::{body::Frame, upgrade::Upgraded};
@@ -32,7 +33,8 @@ use tokio_util::io::ReaderStream;
 use tracing::warn;
 
 use crate::server::{
-    byte_frame::ByteFrame, serve_strategy::single_mode::RunningPhase, types::HttpResponse,
+    byte_frame::ByteFrame, http_message_types::HttpResponse,
+    serve_strategy::single_mode::RunningPhase,
 };
 
 #[magnus::wrap(class = "Itsi::HttpResponse", free_immediately, size)]
@@ -297,11 +299,12 @@ impl ItsiHttpResponse {
         self.data.response_writer.write().take();
         Ok(true)
     }
-    fn accept_str(&self) -> &str {
+
+    pub fn accept_str(&self) -> &str {
         self.data
             .parts
             .headers
-            .get("Content-Type")
+            .get(ACCEPT)
             .and_then(|hv| hv.to_str().ok()) // handle invalid utf-8
             .unwrap_or("application/x-www-form-urlencoded")
     }

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

@@ -71,7 +71,7 @@ const DEBOUNCE_DURATION: Duration = Duration::from_millis(500);
 pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<Option<OwnedFd>> {
     let (r_fd, w_fd): (OwnedFd, OwnedFd) = pipe().map_err(|e| {
         magnus::Error::new(
-            magnus::exception::exception(),
+            magnus::exception::standard_error(),
             format!("Failed to create watcher pipe: {}", e),
         )
     })?;
@@ -79,7 +79,7 @@ pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<O
     let fork_result = unsafe {
         fork().map_err(|e| {
             magnus::Error::new(
-                magnus::exception::exception(),
+                magnus::exception::standard_error(),
                 format!("Failed to fork file watcher: {}", e),
             )
         })
@@ -107,13 +107,13 @@ pub fn watch_groups(pattern_groups: Vec<(String, Vec<Vec<String>>)>) -> Result<O
             let base_dir = extract_and_canonicalize_base_dir(&pattern);
             let glob = Glob::new(&pattern).map_err(|e| {
                 magnus::Error::new(
-                    magnus::exception::exception(),
+                    magnus::exception::standard_error(),
                     format!("Failed to create watch glob: {}", e),
                 )
             })?;
             let glob_set = GlobSetBuilder::new().add(glob).build().map_err(|e| {
                 magnus::Error::new(
-                    magnus::exception::exception(),
+                    magnus::exception::standard_error(),
                     format!("Failed to create watch glob set: {}", e),
                 )
             })?;

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

@@ -1,11 +1,14 @@
 use super::file_watcher::{self};
 use crate::{
     ruby_types::ITSI_SERVER_CONFIG,
-    server::{bind::Bind, listener::Listener, middleware_stack::MiddlewareSet},
+    server::{
+        binds::{bind::Bind, listener::Listener},
+        middleware_stack::MiddlewareSet,
+    },
 };
 use derive_more::Debug;
-use itsi_rb_helpers::{call_with_gvl, print_rb_backtrace, HeapVal, HeapValue};
-use itsi_tracing::set_level;
+use itsi_rb_helpers::{call_with_gvl, print_rb_backtrace, HeapValue};
+use itsi_tracing::{set_format, set_level, set_target};
 use magnus::{
     block::Proc,
     error::Result,
@@ -22,8 +25,8 @@ use std::{
     os::fd::{AsRawFd, OwnedFd, RawFd},
     path::PathBuf,
     sync::{Arc, OnceLock},
+    time::Duration,
 };
-
 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");
@@ -48,16 +51,17 @@ pub struct ServerParams {
     pub hooks: HashMap<String, HeapValue<Proc>>,
     pub preload: bool,
 
+    pub request_timeout: Option<Duration>,
     pub notify_watchers: Option<Vec<(String, Vec<Vec<String>>)>>,
     /// Worker params
     pub threads: u8,
-    pub script_name: String,
+    pub scheduler_threads: Option<u8>,
     pub streamable_body: bool,
     pub multithreaded_reactor: bool,
+    pub pin_worker_cores: bool,
     pub scheduler_class: Option<String>,
     pub oob_gc_responses_threshold: Option<u64>,
     pub middleware_loader: HeapValue<Proc>,
-    pub default_app_loader: HeapValue<Proc>,
     pub middleware: OnceLock<MiddlewareSet>,
     pub binds: Vec<Bind>,
     #[debug(skip)]
@@ -75,7 +79,6 @@ impl ServerParams {
             {
                 ruby.require("itsi/scheduler")?;
             }
-            let default_app: HeapVal = self.default_app_loader.call::<_, Value>(())?.into();
             let middleware = MiddlewareSet::new(
                 self.middleware_loader
                     .call::<_, Option<Value>>(())
@@ -85,7 +88,6 @@ impl ServerParams {
                         }
                     })?
                     .map(|mw| mw.into()),
-                default_app,
             )?;
             self.middleware.set(middleware).map_err(|_| {
                 magnus::Error::new(
@@ -104,7 +106,12 @@ impl ServerParams {
             .unwrap_or(num_cpus::get() as u8);
         let worker_memory_limit: Option<u64> = rb_param_hash.fetch("worker_memory_limit")?;
         let silence: bool = rb_param_hash.fetch("silence")?;
-        let multithreaded_reactor: bool = rb_param_hash.fetch("multithreaded_reactor")?;
+        let multithreaded_reactor: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("multithreaded_reactor")?
+            .unwrap_or(workers == 1);
+        let pin_worker_cores: bool = rb_param_hash
+            .fetch::<_, Option<bool>>("pin_worker_cores")?
+            .unwrap_or(true);
         let shutdown_timeout: f64 = rb_param_hash.fetch("shutdown_timeout")?;
 
         let hooks: Option<RHash> = rb_param_hash.fetch("hooks")?;
@@ -125,22 +132,34 @@ 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 notify_watchers: Option<Vec<(String, Vec<Vec<String>>)>> =
             rb_param_hash.fetch("notify_watchers")?;
         let threads: u8 = rb_param_hash.fetch("threads")?;
-        let script_name: String = rb_param_hash.fetch("script_name")?;
+        let scheduler_threads: Option<u8> = rb_param_hash.fetch("scheduler_threads")?;
         let streamable_body: bool = rb_param_hash.fetch("streamable_body")?;
         let scheduler_class: Option<String> = rb_param_hash.fetch("scheduler_class")?;
         let oob_gc_responses_threshold: Option<u64> =
             rb_param_hash.fetch("oob_gc_responses_threshold")?;
         let middleware_loader: Proc = rb_param_hash.fetch("middleware_loader")?;
-        let default_app_loader: Proc = rb_param_hash.fetch("default_app_loader")?;
         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")?;
 
         if let Some(level) = log_level {
             set_level(&level);
         }
 
+        if let Some(target) = log_target {
+            set_target(&target);
+        }
+
+        if let Some(format) = log_format {
+            set_format(&format);
+        }
+
         let binds: Option<Vec<String>> = rb_param_hash.fetch("binds")?;
         let binds = binds
             .unwrap_or_else(|| vec![DEFAULT_BIND.to_string()])
@@ -154,7 +173,7 @@ impl ServerParams {
             let bind_to_fd_map: HashMap<String, i32> = serde_json::from_str(&preexisting_listeners)
                 .map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Invalid listener info: {}", e),
                     )
                 })?;
@@ -196,12 +215,14 @@ impl ServerParams {
             worker_memory_limit,
             silence,
             multithreaded_reactor,
+            pin_worker_cores,
             shutdown_timeout,
             hooks,
             preload,
+            request_timeout,
             notify_watchers,
             threads,
-            script_name,
+            scheduler_threads,
             streamable_body,
             scheduler_class,
             oob_gc_responses_threshold,
@@ -209,7 +230,6 @@ impl ServerParams {
             listener_info: Mutex::new(listener_info),
             listeners: Mutex::new(listeners),
             middleware_loader: middleware_loader.into(),
-            default_app_loader: default_app_loader.into(),
             middleware: OnceLock::new(),
         })
     }
@@ -310,13 +330,13 @@ impl ItsiServerConfig {
             .map(|(str, fd)| {
                 let dupped_fd = dup(*fd).map_err(|errno| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Errno {} while trying to dup {}", errno, fd),
                     )
                 })?;
                 Self::clear_cloexec(dupped_fd).map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Failed to clear cloexec flag for fd {}: {}", dupped_fd, e),
                     )
                 })?;
@@ -339,7 +359,7 @@ impl ItsiServerConfig {
             serde_json::to_string(&self.server_params.read().listener_info.lock().clone())
                 .map_err(|e| {
                     magnus::Error::new(
-                        magnus::exception::exception(),
+                        magnus::exception::standard_error(),
                         format!("Invalid listener info: {}", e),
                     )
                 })?;

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

@@ -1,6 +1,7 @@
 use crate::server::{
+    lifecycle_event::LifecycleEvent,
     serve_strategy::{cluster_mode::ClusterMode, single_mode::SingleMode, ServeStrategy},
-    signal::{clear_signal_handlers, reset_signal_handlers, send_shutdown_event},
+    signal::{clear_signal_handlers, reset_signal_handlers, send_lifecycle_event},
 };
 use itsi_rb_helpers::{call_without_gvl, print_rb_backtrace};
 use itsi_server_config::ItsiServerConfig;
@@ -35,7 +36,7 @@ impl ItsiServer {
     }
 
     pub fn stop(&self) -> Result<()> {
-        send_shutdown_event();
+        send_lifecycle_event(LifecycleEvent::Shutdown);
         Ok(())
     }
 
@@ -44,7 +45,7 @@ impl ItsiServer {
         let result = if self.config.lock().server_params.read().silence {
             run_silently(|| self.build_and_run_strategy())
         } else {
-            info!("Itsi - Rolling into action. 💨 ⚪ ");
+            info!("Itsi - Rolling into action. ⚪💨");
             self.build_and_run_strategy()
         };
         if let Err(e) = result {

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

@@ -1,9 +1,8 @@
 use magnus::{value::Lazy, Module, RClass, RModule};
 
 pub mod itsi_body_proxy;
-pub mod itsi_grpc_request;
-pub mod itsi_grpc_response;
-pub mod itsi_grpc_stream;
+pub mod itsi_grpc_call;
+pub mod itsi_grpc_response_stream;
 pub mod itsi_http_request;
 pub mod itsi_http_response;
 pub mod itsi_server;
@@ -36,20 +35,14 @@ pub static ITSI_BODY_PROXY: Lazy<RClass> = Lazy::new(|ruby| {
         .unwrap()
 });
 
-pub static ITSI_GRPC_REQUEST: Lazy<RClass> = Lazy::new(|ruby| {
+pub static ITSI_GRPC_CALL: Lazy<RClass> = Lazy::new(|ruby| {
     ruby.get_inner(&ITSI_MODULE)
-        .define_class("GrpcRequest", ruby.class_object())
+        .define_class("GrpcCall", ruby.class_object())
         .unwrap()
 });
 
-pub static ITSI_GRPC_STREAM: Lazy<RClass> = Lazy::new(|ruby| {
+pub static ITSI_GRPC_RESPONSE_STREAM: Lazy<RClass> = Lazy::new(|ruby| {
     ruby.get_inner(&ITSI_MODULE)
-        .define_class("GrpcStream", ruby.class_object())
-        .unwrap()
-});
-
-pub static ITSI_GRPC_RESPONSE: Lazy<RClass> = Lazy::new(|ruby| {
-    ruby.get_inner(&ITSI_MODULE)
-        .define_class("GrpcResponse", ruby.class_object())
+        .define_class("GrpcResponseStream", ruby.class_object())
         .unwrap()
 });

data/crates/itsi_server/src/server/{bind.rs → binds/bind.rs}

@@ -2,6 +2,7 @@ use super::{
     bind_protocol::BindProtocol,
     tls::{configure_tls, ItsiTlsAcceptor},
 };
+use crate::prelude::*;
 use itsi_error::ItsiError;
 use std::{
     collections::HashMap,
@@ -28,7 +29,19 @@ pub struct Bind {
     pub address: BindAddress,
     pub port: Option<u16>, // None for Unix Sockets
     pub protocol: BindProtocol,
-    pub tls_config: Option<ItsiTlsAcceptor>,
+    pub tls_config: Option<TlsOptions>,
+}
+
+#[derive(Default, Clone)]
+pub struct TlsOptions {
+    pub host: String,
+    pub options: HashMap<String, String>,
+}
+
+impl TlsOptions {
+    pub fn build_acceptor(&self) -> Result<ItsiTlsAcceptor> {
+        configure_tls(&self.host, &self.options)
+    }
 }
 
 impl Bind {
@@ -73,7 +86,7 @@ impl std::fmt::Debug for Bind {
 impl FromStr for Bind {
     type Err = ItsiError;
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+    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)
         } else {
@@ -138,9 +151,15 @@ impl FromStr for Bind {
 
         let tls_config = match protocol {
             BindProtocol::Http => None,
-            BindProtocol::Https => Some(configure_tls(host, &options)?),
+            BindProtocol::Https => Some(TlsOptions {
+                host: host.to_owned(),
+                options,
+            }),
             BindProtocol::Unix => None,
-            BindProtocol::Unixs => Some(configure_tls(host, &options)?),
+            BindProtocol::Unixs => Some(TlsOptions {
+                host: host.to_owned(),
+                options,
+            }),
         };
         let bind = Self {
             address,

data/crates/itsi_server/src/server/{listener.rs → binds/listener.rs}

@@ -1,7 +1,10 @@
+use crate::prelude::*;
+use crate::server::io_stream::IoStream;
+use crate::server::serve_strategy::single_mode::RunningPhase;
+
 use super::bind::{Bind, BindAddress};
 use super::bind_protocol::BindProtocol;
-use super::io_stream::IoStream;
-use super::serve_strategy::single_mode::RunningPhase;
+
 use super::tls::ItsiTlsAcceptor;
 use itsi_error::{ItsiError, Result};
 use itsi_tracing::info;
@@ -17,7 +20,6 @@ use tokio::net::{unix, TcpStream, UnixStream};
 use tokio::sync::watch::Receiver;
 use tokio_rustls::TlsAcceptor;
 use tokio_stream::StreamExt;
-use tracing::error;
 
 pub(crate) enum Listener {
     Tcp(TcpListener),
@@ -143,7 +145,7 @@ impl TokioListener {
             ItsiTlsAcceptor::Automatic(acme_acceptor, _, rustls_config) => {
                 let accept_future = acme_acceptor.accept(tcp_stream.0);
                 match accept_future.await {
-                    Ok(None) => Err(ItsiError::Pass()),
+                    Ok(None) => Err(ItsiError::Pass),
                     Ok(Some(start_handshake)) => {
                         let tls_stream = start_handshake.into_stream(rustls_config.clone()).await?;
                         Ok(IoStream::TcpTls {
@@ -153,7 +155,7 @@ impl TokioListener {
                     }
                     Err(error) => {
                         error!(error = format!("{:?}", error));
-                        Err(ItsiError::Pass())
+                        Err(ItsiError::Pass)
                     }
                 }
             }
@@ -330,12 +332,18 @@ impl Listener {
                 BindProtocol::Http => Listener::Tcp(revive_tcp_socket(fd)?),
                 BindProtocol::Https => {
                     let tcp_listener = revive_tcp_socket(fd)?;
-                    Listener::TcpTls((tcp_listener, bind.tls_config.unwrap()))
+                    Listener::TcpTls((
+                        tcp_listener,
+                        bind.tls_config.unwrap().build_acceptor().unwrap(),
+                    ))
                 }
                 _ => unreachable!(),
             },
             BindAddress::UnixSocket(_) => match bind.tls_config {
-                Some(tls_config) => Listener::UnixTls((revive_unix_socket(fd)?, tls_config)),
+                Some(tls_config) => Listener::UnixTls((
+                    revive_unix_socket(fd)?,
+                    tls_config.build_acceptor().unwrap(),
+                )),
                 None => Listener::Unix(revive_unix_socket(fd)?),
             },
         };
@@ -352,12 +360,18 @@ impl TryFrom<Bind> for Listener {
                 BindProtocol::Http => Listener::Tcp(connect_tcp_socket(addr, bind.port.unwrap())?),
                 BindProtocol::Https => {
                     let tcp_listener = connect_tcp_socket(addr, bind.port.unwrap())?;
-                    Listener::TcpTls((tcp_listener, bind.tls_config.unwrap()))
+                    Listener::TcpTls((
+                        tcp_listener,
+                        bind.tls_config.unwrap().build_acceptor().unwrap(),
+                    ))
                 }
                 _ => unreachable!(),
             },
             BindAddress::UnixSocket(path) => match bind.tls_config {
-                Some(tls_config) => Listener::UnixTls((connect_unix_socket(&path)?, tls_config)),
+                Some(tls_config) => Listener::UnixTls((
+                    connect_unix_socket(&path)?,
+                    tls_config.build_acceptor().unwrap(),
+                )),
                 None => Listener::Unix(connect_unix_socket(&path)?),
             },
         };
@@ -393,8 +407,8 @@ fn connect_tcp_socket(addr: IpAddr, port: u16) -> Result<TcpListener> {
     };
     let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?;
     let socket_address: SocketAddr = SocketAddr::new(addr, port);
-    socket.set_reuse_port(true).ok();
     socket.set_reuse_address(true).ok();
+    socket.set_reuse_port(true).ok();
     socket.set_nonblocking(true).ok();
     socket.set_nodelay(true).ok();
     socket.set_recv_buffer_size(262_144).ok();