feat(keepalive): expose tcp keep-alive options (#1583)

nuel77 · jsdw · web-flow · commit c0b947fb2e6f · 2025-08-11T11:41:52.000+01:00
* expose tcp keep-alive options

* expose tcp keep-alive options

* add to client

* add to server

* cleanup

* serve only if http2 is available

* http2 is always available from crates feature flags

* remove http2 feature flag

* typo fix

---------

Co-authored-by: James Wilson &lt;james@jsdw.me&gt;
diff --git a/client/http-client/src/client.rs b/client/http-client/src/client.rs
@@ -90,6 +90,9 @@ pub struct HttpClientBuilder<HttpMiddleware = Identity, RpcMiddleware = Logger>
 	rpc_middleware: RpcServiceBuilder<RpcMiddleware>,
 	tcp_no_delay: bool,
 	max_concurrent_requests: Option<usize>,
+	keep_alive_duration: Option<Duration>,
+	keep_alive_interval: Option<Duration>,
+	keep_alive_retries: Option<u32>,
 }
 
 impl<HttpMiddleware, RpcMiddleware> HttpClientBuilder<HttpMiddleware, RpcMiddleware> {
@@ -210,6 +213,24 @@ impl<HttpMiddleware, RpcMiddleware> HttpClientBuilder<HttpMiddleware, RpcMiddlew
 		self
 	}
 
+	/// Set the keep-alive duration.
+	pub fn set_keep_alive(mut self, duration: Option<Duration>) -> Self {
+		self.keep_alive_duration = duration;
+		self
+	}
+
+	/// Set the keep-alive interval.
+	pub fn set_keep_alive_interval(mut self, interval: Option<Duration>) -> Self {
+		self.keep_alive_interval = interval;
+		self
+	}
+
+	/// Set the number of keep-alive retries.
+	pub fn set_keep_alive_retries(mut self, retries: Option<u32>) -> Self {
+		self.keep_alive_retries = retries;
+		self
+	}
+
 	/// Set the RPC middleware.
 	pub fn set_rpc_middleware<T>(self, rpc_builder: RpcServiceBuilder<T>) -> HttpClientBuilder<HttpMiddleware, T> {
 		HttpClientBuilder {
@@ -224,6 +245,9 @@ impl<HttpMiddleware, RpcMiddleware> HttpClientBuilder<HttpMiddleware, RpcMiddlew
 			request_timeout: self.request_timeout,
 			tcp_no_delay: self.tcp_no_delay,
 			max_concurrent_requests: self.max_concurrent_requests,
+			keep_alive_duration: self.keep_alive_duration,
+			keep_alive_interval: self.keep_alive_interval,
+			keep_alive_retries: self.keep_alive_retries,
 		}
 	}
 
@@ -244,6 +268,9 @@ impl<HttpMiddleware, RpcMiddleware> HttpClientBuilder<HttpMiddleware, RpcMiddlew
 			request_timeout: self.request_timeout,
 			tcp_no_delay: self.tcp_no_delay,
 			max_concurrent_requests: self.max_concurrent_requests,
+			keep_alive_duration: self.keep_alive_duration,
+			keep_alive_retries: self.keep_alive_retries,
+			keep_alive_interval: self.keep_alive_interval,
 		}
 	}
 }
@@ -271,6 +298,9 @@ where
 			service_builder,
 			tcp_no_delay,
 			rpc_middleware,
+			keep_alive_duration,
+			keep_alive_interval,
+			keep_alive_retries,
 			..
 		} = self;
 
@@ -280,6 +310,9 @@ where
 			headers,
 			tcp_no_delay,
 			service_builder,
+			keep_alive_duration,
+			keep_alive_interval,
+			keep_alive_retries,
 			#[cfg(feature = "tls")]
 			certificate_store,
 		}
@@ -313,6 +346,9 @@ impl Default for HttpClientBuilder {
 			rpc_middleware: RpcServiceBuilder::default().rpc_logger(1024),
 			tcp_no_delay: true,
 			max_concurrent_requests: None,
+			keep_alive_duration: None,
+			keep_alive_interval: None,
+			keep_alive_retries: None,
 		}
 	}
 }
diff --git a/client/http-client/src/transport.rs b/client/http-client/src/transport.rs
@@ -98,6 +98,12 @@ pub struct HttpTransportClientBuilder<L> {
 	pub(crate) service_builder: tower::ServiceBuilder<L>,
 	/// TCP_NODELAY
 	pub(crate) tcp_no_delay: bool,
+	/// KEEP_ALIVE duration
+	pub(crate) keep_alive_duration: Option<std::time::Duration>,
+	/// KEEP_ALIVE interval
+	pub(crate) keep_alive_interval: Option<std::time::Duration>,
+	/// KEEP_ALIVE retries
+	pub(crate) keep_alive_retries: Option<u32>,
 }
 
 impl Default for HttpTransportClientBuilder<Identity> {
@@ -117,6 +123,9 @@ impl HttpTransportClientBuilder<Identity> {
 			headers: HeaderMap::new(),
 			service_builder: tower::ServiceBuilder::new(),
 			tcp_no_delay: true,
+			keep_alive_duration: None,
+			keep_alive_interval: None,
+			keep_alive_retries: None,
 		}
 	}
 }
@@ -157,6 +166,24 @@ impl<L> HttpTransportClientBuilder<L> {
 		self
 	}
 
+	/// Configure the keep-alive duration for the connection.
+	pub fn set_keep_alive(mut self, duration: Option<std::time::Duration>) -> Self {
+		self.keep_alive_duration = duration;
+		self
+	}
+
+	/// Configure the keep-alive interval for the connection.
+	pub fn set_keep_alive_interval(mut self, interval: Option<std::time::Duration>) -> Self {
+		self.keep_alive_interval = interval;
+		self
+	}
+
+	/// Configure the number of keep-alive retries for the connection.
+	pub fn set_keep_alive_retries(mut self, retries: Option<u32>) -> Self {
+		self.keep_alive_retries = retries;
+		self
+	}
+
 	/// Configure a tower service.
 	pub fn set_service<T>(self, service: tower::ServiceBuilder<T>) -> HttpTransportClientBuilder<T> {
 		HttpTransportClientBuilder {
@@ -167,6 +194,9 @@ impl<L> HttpTransportClientBuilder<L> {
 			max_response_size: self.max_response_size,
 			service_builder: service,
 			tcp_no_delay: self.tcp_no_delay,
+			keep_alive_duration: self.keep_alive_duration,
+			keep_alive_retries: self.keep_alive_retries,
+			keep_alive_interval: self.keep_alive_interval,
 		}
 	}
 
@@ -187,6 +217,9 @@ impl<L> HttpTransportClientBuilder<L> {
 			headers,
 			service_builder,
 			tcp_no_delay,
+			keep_alive_duration,
+			keep_alive_interval,
+			keep_alive_retries,
 		} = self;
 		let mut url = Url::parse(target.as_ref()).map_err(|e| Error::Url(format!("Invalid URL: {e}")))?;
 
@@ -199,6 +232,9 @@ impl<L> HttpTransportClientBuilder<L> {
 			"http" => {
 				let mut connector = HttpConnector::new();
 				connector.set_nodelay(tcp_no_delay);
+				connector.set_keepalive(keep_alive_duration);
+				connector.set_keepalive_interval(keep_alive_interval);
+				connector.set_keepalive_retries(keep_alive_retries);
 				HttpBackend::Http(Client::builder(TokioExecutor::new()).build(connector))
 			}
 			#[cfg(feature = "tls")]
@@ -212,6 +248,9 @@ impl<L> HttpTransportClientBuilder<L> {
 				let mut http_conn = HttpConnector::new();
 				http_conn.set_nodelay(tcp_no_delay);
 				http_conn.enforce_http(false);
+				http_conn.set_keepalive(keep_alive_duration);
+				http_conn.set_keepalive_interval(keep_alive_interval);
+				http_conn.set_keepalive_retries(keep_alive_retries);
 
 				let https_conn = match certificate_store {
 					CertificateStore::Native => {
diff --git a/server/src/server.rs b/server/src/server.rs
@@ -196,6 +196,10 @@ pub struct ServerConfig {
 	pub(crate) id_provider: Arc<dyn IdProvider>,
 	/// `TCP_NODELAY` settings.
 	pub(crate) tcp_no_delay: bool,
+	/// `KEEP_ALIVE` duration.
+	pub(crate) keep_alive: Option<std::time::Duration>,
+	/// `KEEP_ALIVE_TIMEOUT` duration.
+	pub(crate) keep_alive_timeout: Duration,
 }
 
 /// The builder to configure and create a JSON-RPC server configuration.
@@ -225,6 +229,10 @@ pub struct ServerConfigBuilder {
 	id_provider: Arc<dyn IdProvider>,
 	/// `TCP_NODELAY` settings.
 	tcp_no_delay: bool,
+	/// `KEEP_ALIVE` duration.
+	keep_alive: Option<std::time::Duration>,
+	/// `KEEP_ALIVE_TIMEOUT` duration.
+	keep_alive_timeout: std::time::Duration,
 }
 
 /// Builder for [`TowerService`].
@@ -363,6 +371,9 @@ impl Default for ServerConfigBuilder {
 			ping_config: None,
 			id_provider: Arc::new(RandomIntegerIdProvider),
 			tcp_no_delay: true,
+			keep_alive: None,
+			//same as `hyper` default
+			keep_alive_timeout: Duration::from_secs(20),
 		}
 	}
 }
@@ -518,6 +529,18 @@ impl ServerConfigBuilder {
 		self
 	}
 
+	/// Configure `KEEP_ALIVE` hyper to the supplied value `keep_alive`.
+	pub fn set_keep_alive(mut self, keep_alive: Option<std::time::Duration>) -> Self {
+		self.keep_alive = keep_alive;
+		self
+	}
+
+	/// Configure `KEEP_ALIVE_TIMEOUT` hyper to the supplied value `keep_alive_timeout`.
+	pub fn set_keep_alive_timeout(mut self, keep_alive_timeout: Duration) -> Self {
+		self.keep_alive_timeout = keep_alive_timeout;
+		self
+	}
+
 	/// Build the [`ServerConfig`].
 	pub fn build(self) -> ServerConfig {
 		ServerConfig {
@@ -533,6 +556,8 @@ impl ServerConfigBuilder {
 			ping_config: self.ping_config,
 			id_provider: self.id_provider,
 			tcp_no_delay: self.tcp_no_delay,
+			keep_alive: self.keep_alive,
+			keep_alive_timeout: self.keep_alive_timeout,
 		}
 	}
 }
@@ -1166,6 +1191,9 @@ where
 		return;
 	}
 
+	let keep_alive = server_cfg.keep_alive;
+	let keep_alive_timeout = server_cfg.keep_alive_timeout;
+
 	let tower_service = TowerServiceNoHttp {
 		inner: ServiceData {
 			server_cfg,
@@ -1180,11 +1208,14 @@ where
 
 	let service = http_middleware.service(tower_service);
 
-	tokio::spawn(async {
+	tokio::spawn(async move {
 		// this requires Clone.
 		let service = crate::utils::TowerToHyperService::new(service);
 		let io = TokioIo::new(socket);
-		let builder = hyper_util::server::conn::auto::Builder::new(TokioExecutor::new());
+		let mut builder = hyper_util::server::conn::auto::Builder::new(TokioExecutor::new());
+
+		//default is true for http1, if set to false then websocket connections will not be upgraded.
+		builder.http2().keep_alive_interval(keep_alive).keep_alive_timeout(keep_alive_timeout);
 
 		let conn = builder.serve_connection_with_upgrades(io, service);
 		let stopped = stop_handle.shutdown();
