use std::sync::Arc;
use tokio::{
net::TcpListener,
sync::{watch, Semaphore},
};
use log::info;
use crate::{
config::{AcceptMode, ServerConfig},
guard::GuardContext,
handler::{attach_guard_session, AsyncStream, Connection, ConnectionHandler},
server::{build_guard_stack, tcp},
SynError,
};
#[cfg(any(feature = "rustls-backend", feature = "aws-lc-backend"))]
use crate::server::tls;
#[derive(Clone, Debug)]
pub struct AsyncServerShutdown {
sender: watch::Sender<bool>,
}
impl AsyncServerShutdown {
pub fn shutdown(&self) -> Result<(), SynError> {
self.sender
.send(true)
.map_err(|_| SynError::runtime("async shutdown signal failed"))
}
}
pub struct AsyncServer<H> {
config: ServerConfig,
handler: Arc<H>,
guards: crate::guard::GuardStack,
listener: Option<TcpListener>,
}
impl<H> AsyncServer<H>
where
H: ConnectionHandler,
{
pub fn shutdown_channel() -> (AsyncServerShutdown, watch::Receiver<bool>) {
let (sender, receiver) = watch::channel(false);
(AsyncServerShutdown { sender }, receiver)
}
pub fn new(config: ServerConfig, handler: H) -> Self {
let guards = build_guard_stack(&config.guards);
Self {
config,
handler: Arc::new(handler),
guards,
listener: None,
}
}
pub fn from_listener(listener: TcpListener, config: ServerConfig, handler: H) -> Self {
let guards = build_guard_stack(&config.guards);
Self {
config,
handler: Arc::new(handler),
guards,
listener: Some(listener),
}
}
pub async fn run(self) -> Result<(), SynError> {
self.run_internal(None).await
}
pub async fn run_until_shutdown(self, shutdown: watch::Receiver<bool>) -> Result<(), SynError> {
self.run_internal(Some(shutdown)).await
}
async fn run_internal(self, mut shutdown: Option<watch::Receiver<bool>>) -> Result<(), SynError> {
let listener = if let Some(l) = self.listener {
l
} else {
TcpListener::bind(self.config.bind_addr).await?
};
let actual_addr = listener.local_addr()?;
info!("server {} listening on {}", self.config.name, actual_addr);
let semaphore = Arc::new(Semaphore::new(self.config.max_connections));
loop {
let (stream, peer_addr) = if let Some(signal) = shutdown.as_mut() {
tokio::select! {
accepted = listener.accept() => accepted?,
signal_result = signal.changed() => {
if signal_result.is_err() || *signal.borrow() {
break;
}
continue;
}
}
} else {
listener.accept().await?
};
if let Err(error) = tcp::set_nodelay_async(&stream, self.config.tcp_nodelay).await {
log::debug!("[{}] failed to set TCP_NODELAY: {}", peer_addr, error);
}
let permit = match semaphore.clone().try_acquire_owned() {
Ok(permit) => permit,
Err(_) => {
log::warn!("[{}] dropping connection (max_connections reached)", peer_addr);
continue;
}
};
let local_addr = stream.local_addr().ok();
let is_tls_expected = self.config.tls.enabled || self.config.accept_mode == AcceptMode::Tls;
let context = GuardContext::new(peer_addr, local_addr, is_tls_expected);
let guard_session = match self.guards.reserve(context.clone()) {
Ok(session) => session,
Err(error) => {
log::warn!("[{}] guard rejected connection: {}", peer_addr, error);
drop(permit);
continue;
}
};
let handler = Arc::clone(&self.handler);
let config = self.config.clone();
let timeout = config.connection_timeout;
tokio::spawn(async move {
match tokio::time::timeout(
timeout,
handle_async_connection(stream, context.clone(), guard_session, config, handler),
).await {
Ok(Err(error)) => {
log::error!("[{}] connection closed with error: {}", peer_addr, error);
}
Err(_) => {
log::debug!("[{}] connection timed out after {:?}", peer_addr, timeout);
}
Ok(Ok(())) => {}
}
drop(permit);
});
}
let max_permits = u32::try_from(self.config.max_connections)
.map_err(|_| SynError::runtime("max_connections exceeds async shutdown limit"))?;
let all_permits = semaphore
.acquire_many(max_permits)
.await
.map_err(|_| SynError::runtime("semaphore closed during async shutdown"))?;
drop(all_permits);
Ok(())
}
}
async fn handle_async_connection<H>(
stream: tokio::net::TcpStream,
context: GuardContext,
guard_session: crate::guard::GuardSession,
config: ServerConfig,
handler: Arc<H>,
) -> Result<(), SynError>
where
H: ConnectionHandler,
{
let effective_mode = if config.accept_mode == AcceptMode::Mixed {
AcceptMode::Mixed
} else if config.tls.enabled || config.accept_mode == AcceptMode::Tls {
AcceptMode::Tls
} else {
AcceptMode::Tcp
};
let (async_stream, is_tls) = match effective_mode {
AcceptMode::Tls => {
#[cfg(any(feature = "rustls-backend", feature = "aws-lc-backend"))]
{
let s = tls::accept_async(stream, &config.tls).await?;
(AsyncStream::ServerTls(s), true)
}
#[cfg(not(any(feature = "rustls-backend", feature = "aws-lc-backend")))]
return Err(SynError::UnsupportedFeature(
"TLS requires the rustls-backend or aws-lc-backend feature",
));
}
AcceptMode::Mixed => {
#[cfg(any(feature = "rustls-backend", feature = "aws-lc-backend"))]
{
if peek_is_tls(&stream).await {
let s = tls::accept_async(stream, &config.tls).await?;
(AsyncStream::ServerTls(s), true)
} else {
(AsyncStream::Tcp(stream), false)
}
}
#[cfg(not(any(feature = "rustls-backend", feature = "aws-lc-backend")))]
return Err(SynError::UnsupportedFeature(
"Mixed mode requires the rustls-backend or aws-lc-backend feature",
));
}
AcceptMode::Tcp => (AsyncStream::Tcp(stream), false),
};
let mut metadata = tcp::metadata(context.peer_addr, context.local_addr, is_tls);
if is_tls {
metadata.tls_server_name = config.tls.server_name.clone();
}
let connection = Connection::from_async_stream(metadata, async_stream);
guard_session.mark_established()?;
let connection = attach_guard_session(connection, guard_session);
handler.handle(connection).await
}
#[cfg(any(feature = "rustls-backend", feature = "aws-lc-backend"))]
async fn peek_is_tls(stream: &tokio::net::TcpStream) -> bool {
let mut buf = [0u8; 1];
matches!(stream.peek(&mut buf).await, Ok(1) if buf[0] == 0x16)
}