feat: add http_keep_alive to Config

Also renamed `no_delay` to `tcp_no_delay`.

the options for configuring this in Isahc and Hyper are unfortunately not super clear.

Author: Fishrock123

src/config.rs

@@ -6,10 +6,14 @@ use std::time::Duration;
 #[non_exhaustive]
 #[derive(Clone, Debug)]
 pub struct Config {
+    /// HTTP/1.1 `keep-alive` (connection pooling).
+    ///
+    /// Default: `true`.
+    pub http_keep_alive: bool,
     /// TCP `NO_DELAY`.
     ///
     /// Default: `false`.
-    pub no_delay: bool,
+    pub tcp_no_delay: bool,
     /// Connection timeout duration.
     ///
     /// Default: `Some(Duration::from_secs(60))`.
@@ -20,7 +24,8 @@ impl Config {
     /// Construct new empty config.
     pub fn new() -> Self {
         Self {
-            no_delay: false,
+            http_keep_alive: true,
+            tcp_no_delay: false,
             timeout: Some(Duration::from_secs(60)),
         }
     }
@@ -33,9 +38,15 @@ impl Default for Config {
 }
 
 impl Config {
+    /// Set HTTP/1.1 `keep-alive` (connection pooling).
+    pub fn set_http_keep_alive(mut self, keep_alive: bool) -> Self {
+        self.http_keep_alive = keep_alive;
+        self
+    }
+
     /// Set TCP `NO_DELAY`.
-    pub fn set_no_delay(mut self, no_delay: bool) -> Self {
-        self.no_delay = no_delay;
+    pub fn set_tcp_no_delay(mut self, no_delay: bool) -> Self {
+        self.tcp_no_delay = no_delay;
         self
     }
 

src/h1/mod.rs

@@ -156,6 +156,37 @@ impl HttpClient for H1Client {
         for (idx, addr) in addrs.into_iter().enumerate() {
             let has_another_addr = idx != max_addrs_idx;
 
+            #[cfg(feature = "unstable-config")]
+            if !self.config.http_keep_alive {
+                match scheme {
+                    "http" => {
+                        let stream = async_std::net::TcpStream::connect(addr).await?;
+                        req.set_peer_addr(stream.peer_addr().ok());
+                        req.set_local_addr(stream.local_addr().ok());
+                        let tcp_conn = client::connect(stream, req);
+                        return if let Some(timeout) = self.config.timeout {
+                            async_std::future::timeout(timeout, tcp_conn).await?
+                        } else {
+                            tcp_conn.await
+                        };
+                    }
+                    #[cfg(any(feature = "native-tls", feature = "rustls"))]
+                    "https" => {
+                        let raw_stream = async_std::net::TcpStream::connect(addr).await?;
+                        req.set_peer_addr(raw_stream.peer_addr().ok());
+                        req.set_local_addr(raw_stream.local_addr().ok());
+                        let tls_stream = tls::add_tls(&host, raw_stream).await?;
+                        let tsl_conn = client::connect(tls_stream, req);
+                        return if let Some(timeout) = self.config.timeout {
+                            async_std::future::timeout(timeout, tsl_conn).await?
+                        } else {
+                            tsl_conn.await
+                        };
+                    }
+                    _ => unreachable!(),
+                }
+            }
+
             match scheme {
                 "http" => {
                     let pool_ref = if let Some(pool_ref) = self.http_pools.get(&addr) {

src/h1/tcp.rs

@@ -65,7 +65,7 @@ impl Manager<TcpStream, std::io::Error> for TcpConnection {
         let tcp_stream = TcpStream::connect(self.addr).await?;
 
         #[cfg(feature = "unstable-config")]
-        tcp_stream.set_nodelay(self.config.no_delay)?;
+        tcp_stream.set_nodelay(self.config.tcp_no_delay)?;
 
         Ok(tcp_stream)
     }
@@ -75,7 +75,7 @@ impl Manager<TcpStream, std::io::Error> for TcpConnection {
         let mut cx = Context::from_waker(futures::task::noop_waker_ref());
 
         #[cfg(feature = "unstable-config")]
-        conn.set_nodelay(self.config.no_delay)?;
+        conn.set_nodelay(self.config.tcp_no_delay)?;
 
         match Pin::new(conn).poll_read(&mut cx, &mut buf) {
             Poll::Ready(Err(error)) => Err(error),

src/h1/tls.rs

@@ -74,7 +74,7 @@ impl Manager<TlsStream<TcpStream>, Error> for TlsConnection {
         let raw_stream = async_std::net::TcpStream::connect(self.addr).await?;
 
         #[cfg(feature = "unstable-config")]
-        raw_stream.set_nodelay(self.config.no_delay)?;
+        raw_stream.set_nodelay(self.config.tcp_no_delay)?;
 
         let tls_stream = add_tls(&self.host, raw_stream).await?;
         Ok(tls_stream)
@@ -86,7 +86,7 @@ impl Manager<TlsStream<TcpStream>, Error> for TlsConnection {
 
         #[cfg(feature = "unstable-config")]
         conn.get_ref()
-            .set_nodelay(self.config.no_delay)
+            .set_nodelay(self.config.tcp_no_delay)
             .map_err(Error::from)?;
 
         match Pin::new(conn).poll_read(&mut cx, &mut buf) {
@@ -105,12 +105,12 @@ impl Manager<TlsStream<TcpStream>, Error> for TlsConnection {
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "rustls")] {
-        async fn add_tls(host: &str, stream: TcpStream) -> Result<TlsStream<TcpStream>, std::io::Error> {
+        pub(crate) async fn add_tls(host: &str, stream: TcpStream) -> Result<TlsStream<TcpStream>, std::io::Error> {
             let connector = async_tls::TlsConnector::default();
             connector.connect(host, stream).await
         }
     } else if #[cfg(feature = "native-tls")] {
-        async fn add_tls(
+        pub(crate) async fn add_tls(
             host: &str,
             stream: TcpStream,
         ) -> Result<TlsStream<TcpStream>, async_native_tls::Error> {

src/hyper.rs

@@ -97,6 +97,14 @@ impl HttpClient for HyperClient {
     ///
     /// Config options may not impact existing connections.
     fn set_config(&mut self, config: Config) -> http_types::Result<()> {
+        let connector = HttpsConnector::new();
+        let mut builder = hyper::Client::builder();
+
+        if !config.http_keep_alive {
+            builder.pool_max_idle_per_host(1);
+        }
+
+        self.client = Box::new(builder.build(connector));
         self.config = config;
 
         Ok(())
@@ -115,7 +123,11 @@ impl TryFrom<Config> for HyperClient {
 
     fn try_from(config: Config) -> Result<Self, Self::Error> {
         let connector = HttpsConnector::new();
-        let builder = hyper::Client::builder();
+        let mut builder = hyper::Client::builder();
+
+        if !config.http_keep_alive {
+            builder.pool_max_idle_per_host(1);
+        }
 
         Ok(Self {
             client: Box::new(builder.build(connector)),

src/isahc.rs

@@ -82,7 +82,10 @@ impl HttpClient for IsahcClient {
     fn set_config(&mut self, config: Config) -> http_types::Result<()> {
         let mut builder = isahc::HttpClient::builder();
 
-        if config.no_delay {
+        if !config.http_keep_alive {
+            builder = builder.connection_cache_size(0);
+        }
+        if config.tcp_no_delay {
             builder = builder.tcp_nodelay();
         }
         if let Some(timeout) = config.timeout {
@@ -109,7 +112,10 @@ impl TryFrom<Config> for IsahcClient {
     fn try_from(config: Config) -> Result<Self, Self::Error> {
         let mut builder = isahc::HttpClient::builder();
 
-        if config.no_delay {
+        if !config.http_keep_alive {
+            builder = builder.connection_cache_size(0);
+        }
+        if config.tcp_no_delay {
             builder = builder.tcp_nodelay();
         }
         if let Some(timeout) = config.timeout {