use alloc::sync::Arc;
use tokio::net::TcpListener;
use super::tls_error::Error;
pub const MAX_CONNECTIONS: usize = 256;
pub const HANDSHAKE_TIMEOUT: core::time::Duration = core::time::Duration::from_secs(10);
pub async fn serve<F>(
listener: TcpListener,
config: Arc<rustls::ServerConfig>,
router: axum::Router,
shutdown: F,
) -> Result<(), Error>
where
F: core::future::Future<Output = ()> + Send + 'static,
{
let mut config = Arc::unwrap_or_clone(config);
config.alpn_protocols = alloc::vec![b"h2".to_vec(), b"http/1.1".to_vec()];
let acceptor = tokio_rustls::TlsAcceptor::from(Arc::new(config));
let slots = Arc::new(tokio::sync::Semaphore::new(MAX_CONNECTIONS));
let mut shutdown = Box::pin(shutdown);
loop {
let (stream, peer) = tokio::select! {
accepted = listener.accept() => accepted.map_err(Error::Io)?,
() = &mut shutdown => return Ok(()),
};
let Ok(slot) = slots.clone().try_acquire_owned() else {
drop(stream);
continue;
};
let acceptor = acceptor.clone();
let router = router.clone();
tokio::spawn(async move {
let _slot = slot;
let Ok(Ok(stream)) =
tokio::time::timeout(HANDSHAKE_TIMEOUT, acceptor.accept(stream)).await
else {
return;
};
let service = hyper_util::service::TowerToHyperService::new(
tower::ServiceBuilder::new()
.map_request(move |mut request: axum::http::Request<_>| {
request
.extensions_mut()
.insert(axum::extract::ConnectInfo(peer));
request
})
.service(router),
);
let mut builder =
hyper_util::server::conn::auto::Builder::new(hyper_util::rt::TokioExecutor::new());
builder
.http1()
.timer(hyper_util::rt::TokioTimer::new())
.header_read_timeout(HANDSHAKE_TIMEOUT);
let _ = builder
.serve_connection_with_upgrades(hyper_util::rt::TokioIo::new(stream), service)
.await;
});
}
}