make outbound HTTP connection pooling runtime-configurable

It's enabled by default, but can be disabled via a runtime config file
containing:

```toml
[outbound_http]
connection_pooling = false
```

Signed-off-by: Joel Dice <[email protected]>

Author: dicej

Cargo.lock

@@ -13,6 +13,7 @@ hyper = { workspace = true }
 hyper-util = { workspace = true }
 reqwest = { workspace = true, features = ["gzip"] }
 rustls = { workspace = true }
+serde = { workspace = true }
 spin-factor-outbound-networking = { path = "../factor-outbound-networking" }
 spin-factors = { path = "../factors" }
 spin-telemetry = { path = "../telemetry" }
@@ -29,5 +30,10 @@ wasmtime-wasi-http = { workspace = true }
 spin-factor-variables = { path = "../factor-variables" }
 spin-factors-test = { path = "../factors-test" }
 
+[features]
+default = ["spin-cli"]
+# Includes the runtime configuration handling used by the Spin CLI
+spin-cli = []
+
 [lints]
 workspace = true

crates/factor-outbound-http/Cargo.toml

@@ -1,4 +1,5 @@
 pub mod intercept;
+pub mod runtime_config;
 mod spin;
 mod wasi;
 pub mod wasi_2023_10_18;
@@ -12,6 +13,7 @@ use http::{
     HeaderValue, Uri,
 };
 use intercept::OutboundHttpInterceptor;
+use runtime_config::RuntimeConfig;
 use spin_factor_outbound_networking::{
     config::{allowed_hosts::OutboundAllowedHosts, blocked_networks::BlockedNetworks},
     ComponentTlsClientConfigs, OutboundNetworkingFactor,
@@ -34,8 +36,8 @@ pub struct OutboundHttpFactor {
 }
 
 impl Factor for OutboundHttpFactor {
-    type RuntimeConfig = ();
-    type AppState = ();
+    type RuntimeConfig = RuntimeConfig;
+    type AppState = AppState;
     type InstanceBuilder = InstanceState;
 
     fn init(&mut self, ctx: &mut impl spin_factors::InitContext<Self>) -> anyhow::Result<()> {
@@ -46,9 +48,14 @@ impl Factor for OutboundHttpFactor {
 
     fn configure_app<T: RuntimeFactors>(
         &self,
-        _ctx: ConfigureAppContext<T, Self>,
+        mut ctx: ConfigureAppContext<T, Self>,
     ) -> anyhow::Result<Self::AppState> {
-        Ok(())
+        Ok(AppState {
+            connection_pooling: ctx
+                .take_runtime_config()
+                .unwrap_or_default()
+                .connection_pooling,
+        })
     }
 
     fn prepare<T: RuntimeFactors>(
@@ -68,6 +75,7 @@ impl Factor for OutboundHttpFactor {
             request_interceptor: None,
             spin_http_client: None,
             wasi_http_clients: None,
+            connection_pooling: ctx.app_state().connection_pooling,
         })
     }
 }
@@ -83,6 +91,7 @@ pub struct InstanceState {
     spin_http_client: Option<reqwest::Client>,
     // Connection pooling client for `wasi:http/outgoing-handler` interface
     wasi_http_clients: Option<wasi::HttpClients>,
+    connection_pooling: bool,
 }
 
 impl InstanceState {
@@ -160,3 +169,7 @@ impl std::fmt::Display for SelfRequestOrigin {
         write!(f, "{}://{}", self.scheme, self.authority)
     }
 }
+
+pub struct AppState {
+    connection_pooling: bool,
+}

crates/factor-outbound-http/src/lib.rs

@@ -0,0 +1,17 @@
+#[cfg(feature = "spin-cli")]
+pub mod spin;
+
+/// Runtime configuration for outbound HTTP.
+#[derive(Debug)]
+pub struct RuntimeConfig {
+    /// If true, enable connection pooling and reuse.
+    pub connection_pooling: bool,
+}
+
+impl Default for RuntimeConfig {
+    fn default() -> Self {
+        Self {
+            connection_pooling: true,
+        }
+    }
+}

crates/factor-outbound-http/src/runtime_config.rs

@@ -0,0 +1,31 @@
+use serde::Deserialize;
+use spin_factors::runtime_config::toml::GetTomlValue;
+
+/// Get the runtime configuration for outbound HTTP from a TOML table.
+///
+/// Expects table to be in the format:
+/// ```toml
+/// [outbound_http]
+/// connection_pooling = true
+/// ```
+pub fn config_from_table(
+    table: &impl GetTomlValue,
+) -> anyhow::Result<Option<super::RuntimeConfig>> {
+    if let Some(outbound_http) = table.get("outbound_http") {
+        Ok(Some(super::RuntimeConfig {
+            connection_pooling: outbound_http
+                .clone()
+                .try_into::<OutboundHttpToml>()?
+                .connection_pooling,
+        }))
+    } else {
+        Ok(None)
+    }
+}
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct OutboundHttpToml {
+    #[serde(default)]
+    connection_pooling: bool,
+}

crates/factor-outbound-http/src/runtime_config/spin.rs

@@ -90,7 +90,13 @@ impl spin_http::Host for crate::InstanceState {
 
         // Allow reuse of Client's internal connection pool for multiple requests
         // in a single component execution
-        let client = self.spin_http_client.get_or_insert_with(Default::default);
+        let client = self.spin_http_client.get_or_insert_with(|| {
+            let mut builder = reqwest::Client::builder();
+            if !self.connection_pooling {
+                builder = builder.pool_max_idle_per_host(0);
+            }
+            builder.build().unwrap()
+        });
 
         let resp = client.execute(req).await.map_err(log_reqwest_error)?;
 

crates/factor-outbound-http/src/spin.rs

@@ -135,15 +135,22 @@ impl WasiHttpView for WasiHttpImplInner<'_> {
         request: Request<wasmtime_wasi_http::body::HyperOutgoingBody>,
         config: wasmtime_wasi_http::types::OutgoingRequestConfig,
     ) -> wasmtime_wasi_http::HttpResult<wasmtime_wasi_http::types::HostFutureIncomingResponse> {
+        let connection_pooling = self.state.connection_pooling;
+        let builder = move || {
+            let mut builder = Client::builder(TokioExecutor::new());
+            if !connection_pooling {
+                builder.pool_max_idle_per_host(0);
+            }
+            builder
+        };
+
         let http_clients = self
             .state
             .wasi_http_clients
             .get_or_insert_with(|| HttpClients {
-                http1: Client::builder(TokioExecutor::new()).build(HttpConnector),
-                http2: Client::builder(TokioExecutor::new())
-                    .http2_only(true)
-                    .build(HttpConnector),
-                https: Client::builder(TokioExecutor::new()).build(HttpsConnector),
+                http1: builder().build(HttpConnector),
+                http2: builder().http2_only(true).build(HttpConnector),
+                https: builder().build(HttpsConnector),
             })
             .clone();
 

crates/factor-outbound-http/src/wasi.rs

@@ -379,8 +379,10 @@ impl FactorRuntimeConfigSource<WasiFactor> for TomlRuntimeConfigSource<'_, '_> {
 }
 
 impl FactorRuntimeConfigSource<OutboundHttpFactor> for TomlRuntimeConfigSource<'_, '_> {
-    fn get_runtime_config(&mut self) -> anyhow::Result<Option<()>> {
-        Ok(None)
+    fn get_runtime_config(
+        &mut self,
+    ) -> anyhow::Result<Option<<OutboundHttpFactor as spin_factors::Factor>::RuntimeConfig>> {
+        spin_factor_outbound_http::runtime_config::spin::config_from_table(&self.toml.table)
     }
 }