dont block for tls acceptance

1 files changed, 37 insertions, 35 deletions

diff --git a/src/main.rs b/src/main.rs
index 38fae53..2edbe3d 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -59,7 +59,8 @@ async fn serve_http(config: Arc<Config>) -> Result<()> {
     loop {
         let (stream, addr) = listener.accept().await.context("accepting connection")?;
         debug!("connection from {addr}");
-        serve_stream(config.clone(), stream, addr)
+        let config = config.clone();
+        tokio::spawn(async move { serve_stream(config, stream, addr) });
     }
 }
 async fn serve_https(config: Arc<Config>) -> Result<()> {
@@ -81,51 +82,53 @@ async fn serve_https(config: Arc<Config>) -> Result<()> {
         Arc::new(cfg)
     };
     let listener = TcpListener::bind(https_config.bind).await?;
-    let tls_acceptor = TlsAcceptor::from(tls_config);
+    let tls_acceptor = Arc::new(TlsAcceptor::from(tls_config));
 
     info!("serving https");
     loop {
         let (stream, addr) = listener.accept().await.context("accepting connection")?;
-        debug!("connection from {addr}");
-        match tls_acceptor.accept(stream).await {
-            Ok(stream) => serve_stream(config.clone(), stream, addr),
-            Err(e) => warn!("error accepting tls: {e}"),
-        };
+        let config = config.clone();
+        let tls_acceptor = tls_acceptor.clone();
+        tokio::task::spawn(async move {
+            debug!("connection from {addr}");
+            match tls_acceptor.accept(stream).await {
+                Ok(stream) => serve_stream(config, stream, addr).await,
+                Err(e) => warn!("error accepting tls: {e}"),
+            };
+        });
     }
 }
 
-pub fn serve_stream<T: AsyncRead + AsyncWrite + Unpin + Send + 'static>(
+pub async fn serve_stream<T: AsyncRead + AsyncWrite + Unpin + Send + 'static>(
     config: Arc<Config>,
     stream: T,
     addr: SocketAddr,
 ) {
-    tokio::task::spawn(async move {
-        let conn = http1::Builder::new()
-            .serve_connection(
-                stream,
-                service_fn(move |req| {
-                    let config = config.clone();
-                    async move {
-                        match service(config, req, addr).await {
-                            Ok(r) => Ok(r),
-                            Err(ServiceError::Hyper(e)) => Err(e),
-                            Err(error) => Ok({
-                                let mut resp = Response::new(format!(
-                                    "the reverse proxy encountered an issue: {error}"
-                                ));
-                                *resp.status_mut() = StatusCode::BAD_REQUEST;
-                                resp
-                            }
-                            .map(|b| b.map_err(|e| match e {}).boxed())),
+    let conn = http1::Builder::new()
+        .serve_connection(
+            stream,
+            service_fn(move |req| {
+                let config = config.clone();
+                async move {
+                    match service(config, req, addr).await {
+                        Ok(r) => Ok(r),
+                        Err(ServiceError::Hyper(e)) => Err(e),
+                        Err(error) => Ok({
+                            let mut resp = Response::new(format!(
+                                "the reverse proxy encountered an issue: {error}"
+                            ));
+                            *resp.status_mut() = StatusCode::BAD_REQUEST;
+                            resp
                         }
+                        .map(|b| b.map_err(|e| match e {}).boxed())),
                     }
-                }),
-            )
-            .with_upgrades();
-        if let Err(err) = conn.await {
-            warn!("error: {:?}", err);
-        }
-    });
+                }
+            }),
+        )
+        .with_upgrades();
+    if let Err(err) = conn.await {
+        warn!("error: {:?}", err);
+    }
 }
 
 fn load_certs(path: &Path) -> anyhow::Result<Vec<rustls::Certificate>> {
@@ -151,8 +154,6 @@ async fn service(
     let scheme_secure = req.uri().scheme() == Some(&Scheme::HTTPS);
     debug!("{addr} ~> {:?} {}", req.headers().get(HOST), req.uri());
     *req.uri_mut() = Uri::builder()
-        .scheme("http")
-        .authority("backend")
         .path_and_query(
             req.uri()
                 .clone()
@@ -190,6 +191,7 @@ async fn service(
     let do_upgrade = req.headers().contains_key(UPGRADE);
     let on_upgrade_downstream = req.extensions_mut().remove::<OnUpgrade>();
 
+    debug!("\tforwarding to {}", route.backend);
     let mut resp = {
         let client_stream = TcpStream::connect(&route.backend)
             .await