use hyper::server::conn::http1::Builder as Http1Builder;
#[cfg(feature = "http2")]
use hyper::server::conn::http2::Builder as Http2Builder;
#[cfg(feature = "http2")]
use hyper_util::rt::TokioExecutor;
use hyper_util::rt::{TokioIo, TokioTimer};
use std::future::Future;
use std::net::{SocketAddr, TcpListener};
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::time::Duration;
use tokio::sync::OwnedSemaphorePermit;
use tokio::sync::watch::Receiver;
use self::conn_limit::ConnLimit;
use self::idle_timeout::IdleTimeout;
use crate::handler::RequestHandler;
use crate::service::RouterService;
use crate::settings::cli::General;
use crate::{Context, Result, Settings};
mod browser;
mod conn_limit;
mod http1;
#[cfg(feature = "tls")]
mod http1_tls;
#[cfg(feature = "http2")]
mod http2;
mod idle_timeout;
mod listener;
mod opts;
#[cfg(feature = "tls")]
mod redirect;
#[cfg(unix)]
mod uds;
#[derive(Debug)]
pub(crate) struct ServerRunConfig<'a> {
pub addr_str: &'a str,
pub threads: usize,
pub open: bool,
pub open_path: Option<&'a str>,
pub conn: ConnConfig,
}
#[derive(Clone, Debug)]
pub(crate) struct ConnConfig {
pub idle_timeout: Option<Duration>,
pub max_header_size: u32,
pub limit: Option<ConnLimit>,
}
#[cfg(test)]
impl Default for ConnConfig {
fn default() -> Self {
use clap::Parser;
Self::new(&General::parse_from(["static-web-server"]))
}
}
impl ConnConfig {
fn new(general: &General) -> Self {
Self {
idle_timeout: (general.idle_timeout > 0)
.then(|| Duration::from_secs(general.idle_timeout.into())),
max_header_size: general.max_header_size,
limit: ConnLimit::new(general.max_connections),
}
}
fn has_limit_without_idle_timeout(&self) -> bool {
self.limit.is_some() && self.idle_timeout.is_none()
}
async fn accept<T>(
&self,
accept: impl Future<Output = std::io::Result<T>>,
) -> (std::io::Result<T>, Option<OwnedSemaphorePermit>) {
let accepted = accept.await;
let slot = match (&self.limit, &accepted) {
(Some(limit), Ok(_)) => Some(limit.acquire().await),
_ => None,
};
(accepted, slot)
}
fn http1_builder(&self) -> Http1Builder {
let mut builder = Http1Builder::new();
builder
.timer(TokioTimer::new())
.header_read_timeout(self.idle_timeout)
.max_header_size(self.max_header_size as usize);
builder
}
#[cfg(feature = "http2")]
fn http2_builder(&self) -> Http2Builder<TokioExecutor> {
let mut builder = Http2Builder::new(TokioExecutor::new());
builder.max_header_list_size(self.max_header_size);
builder
}
fn io<T>(&self, io: T, peer: Option<SocketAddr>) -> TokioIo<IdleTimeout<T>> {
TokioIo::new(IdleTimeout::new(io, self.idle_timeout, peer))
}
fn serve<C>(&self, conn: C, peer: Option<SocketAddr>, slot: Option<OwnedSemaphorePermit>)
where
C: Future<Output = hyper::Result<()>> + Send + 'static,
{
let header_timeout = self.idle_timeout;
tokio::spawn(async move {
let _slot = slot;
if let (Err(err), Some(timeout)) = (conn.await, header_timeout)
&& err.is_timeout()
{
tracing::debug!(
peer = peer.map(tracing::field::display),
"closing connection: request header not received within {:?}",
timeout
);
}
});
}
}
#[cfg(feature = "tls")]
pub(crate) struct TlsConfig {
pub tls_cert: std::path::PathBuf,
pub tls_key: std::path::PathBuf,
pub https_redirect: bool,
pub https_redirect_host: String,
pub https_redirect_from_port: u16,
pub https_redirect_from_hosts: String,
pub host: String,
pub port: u16,
pub page404: std::path::PathBuf,
pub page50x: std::path::PathBuf,
}
pub(crate) struct ShutdownCtx {
pub grace_period: u8,
pub cancel_recv: Option<Receiver<()>>,
pub shutting_down: Arc<AtomicBool>,
#[cfg(windows)]
pub windows_service: bool,
#[cfg(windows)]
pub ctrl_c_recv: Receiver<()>,
#[cfg(windows)]
pub ctrlc_task: tokio::task::JoinHandle<crate::Result<()>>,
}
const ACCEPT_ERROR_DELAY: Duration = Duration::from_secs(1);
async fn accept_error_backoff(err: &std::io::Error) {
if let Some(delay) = accept_error_delay(err) {
tokio::time::sleep(delay).await;
}
}
fn accept_error_delay(err: &std::io::Error) -> Option<Duration> {
use std::io::ErrorKind;
match err.kind() {
ErrorKind::ConnectionRefused
| ErrorKind::ConnectionAborted
| ErrorKind::ConnectionReset => None,
_ => Some(ACCEPT_ERROR_DELAY),
}
}
pub struct Server {
opts: Settings,
worker_threads: usize,
max_blocking_threads: usize,
pre_bound_listener: Option<(TcpListener, String)>,
}
impl Server {
pub fn new(opts: Settings) -> Result<Server> {
let cpus = std::thread::available_parallelism()
.with_context(|| {
"unable to get current platform cpus or lack of permissions to query available parallelism"
})?
.get();
let worker_threads = match opts.general.threads_multiplier {
0 | 1 => cpus,
n => cpus * n,
};
let max_blocking_threads = opts.general.max_blocking_threads;
Ok(Server {
opts,
worker_threads,
max_blocking_threads,
pre_bound_listener: None,
})
}
pub fn with_pre_bound_listener(mut self, listener: std::net::TcpListener) -> Self {
let addr = listener
.local_addr()
.map(|a| a.to_string())
.unwrap_or_else(|_| "pre-bound".into());
self.pre_bound_listener = Some((listener, addr));
self
}
pub fn run_standalone(self, cancel: Option<Receiver<()>>) -> Result {
self.run_server_on_rt(cancel, || {}, true)
}
#[cfg(windows)]
pub fn run_as_service<F>(self, cancel: Option<Receiver<()>>, cancel_fn: F) -> Result
where
F: FnOnce(),
{
self.run_server_on_rt(cancel, cancel_fn, true)
}
pub fn run_server_on_rt<F>(
self,
cancel_recv: Option<Receiver<()>>,
cancel_fn: F,
exit_on_error: bool,
) -> Result
where
F: FnOnce(),
{
tracing::debug!(
%self.worker_threads,
"initializing tokio runtime with multi-threaded scheduler"
);
let rt = tokio::runtime::Builder::new_multi_thread()
.worker_threads(self.worker_threads)
.max_blocking_threads(self.max_blocking_threads)
.thread_name("static-web-server")
.enable_all()
.build()?;
let res = rt.block_on(async {
tracing::trace!("tokio runtime initialized");
self.start_server(cancel_recv, cancel_fn).await
});
if let Err(err) = &res {
tracing::error!("server failed to start up: {:?}", err);
if exit_on_error {
std::process::exit(1)
}
}
res
}
async fn start_server<F>(self, cancel_recv: Option<Receiver<()>>, cancel_fn: F) -> Result
where
F: FnOnce(),
{
tracing::trace!("starting web server");
tracing::info!(
name = env!("CARGO_PKG_NAME"),
version = env!("CARGO_PKG_VERSION"),
"starting Static Web Server"
);
let general = self.opts.general;
let advanced = self.opts.advanced;
let pre_bound = self.pre_bound_listener;
tracing::info!(log_level = %general.log_level, "log level");
if general.config_file.is_file() {
tracing::info!(path = %general.config_file.display(), "config file used");
} else {
tracing::debug!(
"config file path not found or not a regular file: {}",
general.config_file.display()
);
}
#[cfg(unix)]
let unix_listener_info = if let Some(path) = general.unix_socket.as_ref() {
use crate::server::listener::create_unix_listener;
Some(create_unix_listener(
path,
general.unix_socket_mode,
general.unix_socket_force,
)?)
} else {
None
};
#[cfg(unix)]
let tcp_listener_info = if unix_listener_info.is_none() {
Some(match pre_bound {
Some(pre) => pre,
None => crate::server::listener::create_tcp_listener(&general)?,
})
} else {
None
};
#[cfg(not(unix))]
let tcp_listener_info = Some(match pre_bound {
Some(pre) => pre,
None => crate::server::listener::create_tcp_listener(&general)?,
});
tracing::info!(
worker_threads = self.worker_threads,
"runtime worker threads"
);
tracing::info!(
max_blocking_threads = general.max_blocking_threads,
"runtime max blocking threads"
);
tracing::info!(
grace_period_seconds = general.grace_period,
"grace period before graceful shutdown"
);
tracing::info!(
idle_timeout_seconds = general.idle_timeout,
"connection idle timeout"
);
tracing::info!(
max_header_size_bytes = general.max_header_size,
"maximum request header size"
);
tracing::info!(
max_connections = general.max_connections,
"maximum connections served at the same time"
);
let conn = ConnConfig::new(&general);
if conn.has_limit_without_idle_timeout() {
tracing::warn!(
"max connections is set but the idle timeout is disabled: \
connections that send nothing keep their slot until the client closes them"
);
}
let opts_result = opts::init(&general, advanced)?;
let shutting_down = opts_result.handler_opts.shutting_down.clone();
let router_service = RouterService::new(RequestHandler {
opts: Arc::from(opts_result.handler_opts),
});
#[cfg(windows)]
let (sender, ctrl_c_recv) = tokio::sync::watch::channel(());
#[cfg(windows)]
let windows_service = general.windows_service;
#[cfg(windows)]
let ctrlc_task = tokio::spawn(async move {
if !windows_service {
tracing::info!("installing graceful shutdown ctrl+c signal handler");
if let Err(err) = tokio::signal::ctrl_c().await {
return Err(
crate::Error::new(err).context("failed to install ctrl+c signal handler")
);
}
tracing::info!("graceful shutdown ctrl+c signal received");
let _ = sender.send(());
}
Ok::<_, crate::Error>(())
});
let ctx = ShutdownCtx {
grace_period: general.grace_period,
cancel_recv,
shutting_down,
#[cfg(windows)]
windows_service,
#[cfg(windows)]
ctrl_c_recv,
#[cfg(windows)]
ctrlc_task,
};
#[cfg(unix)]
if let Some((unix_listener, socket_path, addr_str)) = unix_listener_info {
let run_cfg = ServerRunConfig {
addr_str: &addr_str,
threads: self.worker_threads,
open: false,
open_path: None,
conn,
};
return uds::run(
unix_listener,
socket_path,
router_service,
run_cfg,
ctx,
cancel_fn,
)
.await;
}
let (tcp_listener, addr_str) = tcp_listener_info.unwrap();
let run_cfg = ServerRunConfig {
addr_str: &addr_str,
threads: self.worker_threads,
open: general.open,
open_path: general.open_path.as_deref(),
conn,
};
#[cfg(feature = "tls")]
if general.tls {
let tls_cert = general
.tls_cert
.ok_or_else(|| anyhow!("TLS cert file path is required when --tls is enabled"))?;
let tls_key = general
.tls_key
.ok_or_else(|| anyhow!("TLS key file path is required when --tls is enabled"))?;
let tls_cfg = TlsConfig {
tls_cert,
tls_key,
https_redirect: general.https_redirect,
https_redirect_host: general.https_redirect_host,
https_redirect_from_port: general.https_redirect_from_port,
https_redirect_from_hosts: general.https_redirect_from_hosts,
host: general.host,
port: general.port,
page404: opts_result.page404,
page50x: opts_result.page50x,
};
#[cfg(feature = "http2")]
if general.http2 {
return http2::run(
tcp_listener,
router_service,
run_cfg,
tls_cfg,
ctx,
cancel_fn,
)
.await;
}
return http1_tls::run(
tcp_listener,
router_service,
run_cfg,
tls_cfg,
ctx,
cancel_fn,
)
.await;
}
http1::run(tcp_listener, router_service, run_cfg, ctx, cancel_fn).await
}
}
#[cfg(test)]
pub(crate) mod tests {
use super::{ACCEPT_ERROR_DELAY, ConnConfig, accept_error_delay};
use std::io::{Error, ErrorKind};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
fn conn_config(args: &[&str]) -> ConnConfig {
let settings = crate::Settings::get_unparsed(false, args).expect("settings parse");
ConnConfig::new(&settings.general)
}
#[test]
fn conn_config_idle_timeout_defaults_to_30_seconds() {
let conn = conn_config(&["static-web-server"]);
assert_eq!(conn.idle_timeout, Some(Duration::from_secs(30)));
}
#[test]
fn conn_config_idle_timeout_zero_disables_it() {
let conn = conn_config(&["static-web-server", "--idle-timeout", "0"]);
assert_eq!(conn.idle_timeout, None);
}
#[derive(Clone, Default)]
pub(super) struct Capture(Arc<Mutex<Vec<u8>>>);
impl Capture {
pub(super) fn lines(&self, pattern: &str) -> Vec<String> {
String::from_utf8_lossy(&self.0.lock().unwrap())
.lines()
.filter(|line| line.contains(pattern))
.map(String::from)
.collect()
}
}
impl std::io::Write for Capture {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.0.lock().unwrap().extend_from_slice(buf);
Ok(buf.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
pub(super) fn capture_debug_logs() -> (Capture, tracing::subscriber::DefaultGuard) {
static SECOND: std::sync::LazyLock<tracing::Dispatch> =
std::sync::LazyLock::new(|| tracing::Dispatch::new(tracing_subscriber::registry()));
std::sync::LazyLock::force(&SECOND);
let capture = Capture::default();
let writer = capture.clone();
let subscriber = tracing_subscriber::fmt()
.with_max_level(tracing::Level::DEBUG)
.with_ansi(false)
.with_writer(move || writer.clone())
.finish();
(capture, tracing::subscriber::set_default(subscriber))
}
#[tokio::test]
async fn serve_logs_request_header_timeout() {
let (logs, _guard) = capture_debug_logs();
let timeout = Duration::from_millis(200);
let conn_cfg = ConnConfig {
idle_timeout: Some(timeout),
..ConnConfig::default()
};
let peer = "192.0.2.1:4321".parse().ok();
let (server, mut client) = tokio::io::duplex(1024);
let svc = hyper::service::service_fn(|_req| async {
Ok::<_, std::convert::Infallible>(hyper::Response::new(crate::body::empty()))
});
let conn = conn_cfg
.http1_builder()
.serve_connection(conn_cfg.io(server, peer), svc);
conn_cfg.serve(conn, peer, None);
let mut buf = [0u8; 1024];
for byte in b"GET / HTTP/1.1\r\nHost: localhost\r\n" {
if client.write_all(&[*byte]).await.is_err() {
break;
}
tokio::time::sleep(timeout / 4).await;
}
while client.read(&mut buf).await.is_ok_and(|n| n > 0) {}
let lines = logs.lines("closing connection");
assert_eq!(lines.len(), 1, "expected one log line, got: {lines:?}");
assert!(lines[0].contains("DEBUG"), "{}", lines[0]);
assert!(
lines[0].contains("request header not received within 200ms"),
"{}",
lines[0]
);
assert!(lines[0].contains("peer=192.0.2.1:4321"), "{}", lines[0]);
}
#[test]
fn conn_config_max_connections_defaults_to_no_limit() {
let conn = conn_config(&["static-web-server"]);
assert!(conn.limit.is_none());
}
#[test]
fn conn_config_has_limit_without_idle_timeout() {
let cases = [
(&["--max-connections", "2"][..], false),
(&["--idle-timeout", "0"][..], false),
(&["--max-connections", "2", "--idle-timeout", "0"][..], true),
];
for (args, expected) in cases {
let args: Vec<_> = ["static-web-server"].iter().chain(args).copied().collect();
let conn = conn_config(&args);
assert_eq!(conn.has_limit_without_idle_timeout(), expected, "{args:?}");
}
}
#[test]
fn conn_config_max_connections_sets_limit() {
let conn = conn_config(&["static-web-server", "--max-connections", "2"]);
assert_eq!(conn.limit.map(|limit| limit.max()), Some(2));
}
#[tokio::test]
async fn accept_takes_no_slot_while_listener_is_idle() {
let conn = ConnConfig {
idle_timeout: None,
limit: super::ConnLimit::new(1),
..ConnConfig::default()
};
let idle = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let busy = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let idle_loop = tokio::spawn({
let conn = conn.clone();
async move { conn.accept(idle.accept()).await }
});
tokio::time::sleep(Duration::from_millis(50)).await;
let _client = tokio::net::TcpStream::connect(busy.local_addr().unwrap())
.await
.unwrap();
let (accepted, slot) =
tokio::time::timeout(Duration::from_secs(5), conn.accept(busy.accept()))
.await
.expect("the idle listener held the only connection slot");
assert!(accepted.is_ok());
assert!(slot.is_some());
idle_loop.abort();
}
#[tokio::test]
async fn accept_waits_for_a_slot_after_accepting() {
let conn = ConnConfig {
idle_timeout: None,
limit: super::ConnLimit::new(1),
..ConnConfig::default()
};
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let _first_client = tokio::net::TcpStream::connect(addr).await.unwrap();
let (_, first_slot) = conn.accept(listener.accept()).await;
assert!(first_slot.is_some());
let _second_client = tokio::net::TcpStream::connect(addr).await.unwrap();
let second = conn.accept(listener.accept());
tokio::pin!(second);
assert!(
tokio::time::timeout(Duration::from_millis(100), &mut second)
.await
.is_err(),
"a second slot was granted with a limit of 1"
);
drop(first_slot);
let (accepted, slot) = tokio::time::timeout(Duration::from_secs(5), second)
.await
.expect("no slot after the first one was released");
assert!(accepted.is_ok());
assert!(slot.is_some());
}
#[test]
fn accept_error_delay_skips_per_connection_errors() {
for kind in [
ErrorKind::ConnectionRefused,
ErrorKind::ConnectionAborted,
ErrorKind::ConnectionReset,
] {
assert_eq!(accept_error_delay(&Error::from(kind)), None);
}
}
#[test]
fn accept_error_delay_waits_on_other_errors() {
let emfile = Error::from_raw_os_error(24);
assert_eq!(accept_error_delay(&emfile), Some(ACCEPT_ERROR_DELAY));
}
}