wip: refactor: reconsider timeouts of connections

rpxy-lib/src/proxy/mod.rs

@@ -19,9 +19,11 @@ pub(crate) fn connection_builder(globals: &Arc<Globals>) -> Arc<ConnectionBuilde
   http_server
     .http1()
     .keep_alive(globals.proxy_config.keepalive)
+    .header_read_timeout(globals.proxy_config.proxy_idle_timeout)
     .pipeline_flush(true);
   http_server
     .http2()
+    .keep_alive_interval(Some(globals.proxy_config.proxy_idle_timeout))
     .max_concurrent_streams(globals.proxy_config.max_concurrent_streams);
   Arc::new(http_server)
 }

rpxy-lib/src/proxy/proxy_h3.rs

@@ -10,8 +10,7 @@ use bytes::{Buf, Bytes};
 use http::{Request, Response};
 use http_body_util::BodyExt;
 use hyper_util::client::legacy::connect::Connect;
-use std::{net::SocketAddr, time::Duration};
-use tokio::time::timeout;
+use std::net::SocketAddr;
 
 #[cfg(feature = "http3-quinn")]
 use h3::{quic::BidiStream, quic::Connection as ConnectionQuic, server::RequestStream};
@@ -71,13 +70,11 @@ where
           let self_inner = self.clone();
           let tls_server_name_inner = tls_server_name.clone();
           self.globals.runtime_handle.spawn(async move {
-            if let Err(e) = timeout(
-              self_inner.globals.proxy_config.proxy_timeout + Duration::from_secs(1), // timeout per stream are considered as same as one in http2
-              self_inner.h3_serve_stream(req, stream, client_addr, tls_server_name_inner),
-            )
-            .await
+            if let Err(e) = self_inner
+              .h3_serve_stream(req, stream, client_addr, tls_server_name_inner)
+              .await
             {
-              error!("HTTP/3 failed to process stream: {}", e);
+              warn!("HTTP/3 error on serve stream: {}", e);
             }
             request_count.decrement();
             debug!("Request processed: current # {}", request_count.current());

rpxy-lib/src/proxy/proxy_main.rs

@@ -86,13 +86,11 @@ where
 
     let server_clone = self.connection_builder.clone();
     let message_handler_clone = self.message_handler.clone();
-    let timeout_sec = self.globals.proxy_config.proxy_timeout;
     let tls_enabled = self.tls_enabled;
     let listening_on = self.listening_on;
     self.globals.runtime_handle.clone().spawn(async move {
-      timeout(
-        timeout_sec + Duration::from_secs(1),
-        server_clone.serve_connection_with_upgrades(
+      server_clone
+        .serve_connection_with_upgrades(
           stream,
           service_fn(move |req: Request<Incoming>| {
             serve_request(
@@ -104,10 +102,9 @@ where
               tls_server_name.clone(),
             )
           }),
-        ),
-      )
-      .await
-      .ok();
+        )
+        .await
+        .ok();
 
       request_count.decrement();
       debug!("Request processed: current # {}", request_count.current());
@@ -201,8 +198,7 @@ where
                 return Err(RpxyError::FailedToTlsHandshake(e.to_string()));
               }
             };
-            self_inner.serve_connection(stream, client_addr, server_name);
-            Ok(()) as RpxyResult<()>
+            Ok((stream, client_addr, server_name))
           };
 
           self.globals.runtime_handle.spawn( async move {
@@ -214,8 +210,13 @@ where
               error!("Timeout to handshake TLS");
               return;
             };
-            if let Err(e) = v {
-              error!("{}", e);
+            match v {
+              Ok((stream, client_addr, server_name)) => {
+                self_inner.serve_connection(stream, client_addr, server_name);
+              }
+              Err(e) => {
+                error!("{}", e);
+              }
             }
           });
         }