support instance reuse for WASIp3 HTTP components

This makes use of the new `wasmtime_wasi_http::handler::ProxyHandler` utility,
which provides both serial and concurrent instance reuse.

We could hypothetically enable opt-in serial reuse for WASIp2 components as well
using the same pattern (which is what `wasmtime serve` does), but I'll leave
that for a follow-up PR, if desired.

This hard-codes the configuration values (max reuse count = 128, max concurrent
reuse count = 16, idle timeout = 1s) for now.  Once we've decided where these
values should be configured (e.g. in the spin.toml manifest, in the runtime
config, or at runtime via the component itself), we can support that.  See
WebAssembly/wasi-http#190 for related discussion.

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

Author: dicej

Cargo.toml

@@ -179,7 +179,7 @@ wasm-pkg-common = "0.11"
 wasmparser = "0.240.0"
 wasmtime = { git = "https://github.com/bytecodealliance/wasmtime", rev = "8e22ff89", features = ["component-model-async"] }
 wasmtime-wasi = { git = "https://github.com/bytecodealliance/wasmtime", rev = "8e22ff89", features = ["p3"] }
-wasmtime-wasi-http = { git = "https://github.com/bytecodealliance/wasmtime", rev = "8e22ff89", features = ["p3"] }
+wasmtime-wasi-http = { git = "https://github.com/bytecodealliance/wasmtime", rev = "8e22ff89", features = ["p3", "component-model-async"] }
 wit-component = "0.240.0"
 wit-parser = "0.240.0"
 

crates/core/src/store.rs

@@ -48,6 +48,11 @@ impl<T: 'static> Store<T> {
     pub fn data_mut(&mut self) -> &mut T {
         self.inner.data_mut()
     }
+
+    /// Convert `self` to the inner [`wasmtime::Store`].
+    pub fn into_inner(self) -> wasmtime::Store<T> {
+        self.inner
+    }
 }
 
 impl<T: 'static> AsRef<wasmtime::Store<T>> for Store<T> {

crates/factors-executor/src/lib.rs

@@ -260,6 +260,18 @@ impl<T: RuntimeFactors, U: Send> FactorsInstanceBuilder<'_, T, U> {
         let instance = self.instance_pre.instantiate_async(&mut store).await?;
         Ok((instance, store))
     }
+
+    pub fn instantiate_store(
+        self,
+        executor_instance_state: U,
+    ) -> anyhow::Result<spin_core::Store<InstanceState<T::InstanceState, U>>> {
+        let instance_state = InstanceState {
+            core: Default::default(),
+            factors: self.factors.build_instance_state(self.factor_builders)?,
+            executor: executor_instance_state,
+        };
+        self.store_builder.build(instance_state)
+    }
 }
 
 /// InstanceState is the [`spin_core::Store`] `data` for an instance.

crates/http/src/trigger.rs

@@ -4,7 +4,8 @@ use spin_factor_outbound_http::wasi_2023_11_10::ProxyIndices as ProxyIndices2023
 use wasmtime::component::InstancePre;
 use wasmtime_wasi::p2::bindings::CommandIndices;
 use wasmtime_wasi_http::bindings::ProxyIndices;
-use wasmtime_wasi_http::p3::bindings::ProxyIndices as P3ProxyIndices;
+use wasmtime_wasi_http::handler::{HandlerState, ProxyHandler, ProxyPre};
+use wasmtime_wasi_http::p3::bindings::ProxyPre as P3ProxyPre;
 
 use crate::config::HttpExecutorType;
 
@@ -21,11 +22,11 @@ pub fn default_base() -> String {
 }
 
 /// The type of http handler export used by a component.
-pub enum HandlerType {
+pub enum HandlerType<S: HandlerState> {
     Spin,
     Wagi(CommandIndices),
     Wasi0_2(ProxyIndices),
-    Wasi0_3(P3ProxyIndices),
+    Wasi0_3(ProxyHandler<S>),
     Wasi2023_11_10(ProxyIndices2023_11_10),
     Wasi2023_10_18(ProxyIndices2023_10_18),
 }
@@ -41,15 +42,18 @@ const WASI_HTTP_EXPORT_0_3_0_RC_2025_09_16: &str = "wasi:http/[email protected]
 /// The `inbound-http` export for `fermyon:spin`
 const SPIN_HTTP_EXPORT: &str = "fermyon:spin/inbound-http";
 
-impl HandlerType {
+impl<T, S: HandlerState<StoreData = T>> HandlerType<S> {
     /// Determine the handler type from the exports of a component.
-    pub fn from_instance_pre<T>(pre: &InstancePre<T>) -> anyhow::Result<HandlerType> {
+    pub fn from_instance_pre(pre: &InstancePre<T>, handler_state: S) -> anyhow::Result<Self> {
         let mut candidates = Vec::new();
         if let Ok(indices) = ProxyIndices::new(pre) {
             candidates.push(HandlerType::Wasi0_2(indices));
         }
-        if let Ok(indices) = P3ProxyIndices::new(pre) {
-            candidates.push(HandlerType::Wasi0_3(indices));
+        if let Ok(pre) = P3ProxyPre::new(pre.clone()) {
+            candidates.push(HandlerType::Wasi0_3(ProxyHandler::new(
+                handler_state,
+                ProxyPre::P3(pre),
+            )));
         }
         if let Ok(indices) = ProxyIndices2023_10_18::new(pre) {
             candidates.push(HandlerType::Wasi2023_10_18(indices));

crates/trigger-http/src/server.rs

@@ -4,6 +4,7 @@ use std::{
     io::{ErrorKind, IsTerminal},
     net::SocketAddr,
     sync::Arc,
+    time::Duration,
 };
 
 use anyhow::{bail, Context};
@@ -23,6 +24,7 @@ use hyper_util::{
 use spin_app::{APP_DESCRIPTION_KEY, APP_NAME_KEY};
 use spin_factor_outbound_http::{OutboundHttpFactor, SelfRequestOrigin};
 use spin_factors::RuntimeFactors;
+use spin_factors_executor::InstanceState;
 use spin_http::{
     app_info::AppInfo,
     body,
@@ -38,6 +40,7 @@ use tokio::{
 use tracing::Instrument;
 use wasmtime_wasi::p2::bindings::CommandIndices;
 use wasmtime_wasi_http::body::HyperOutgoingBody;
+use wasmtime_wasi_http::handler::{HandlerState, StoreBundle};
 
 use crate::{
     headers::strip_forbidden_headers,
@@ -63,11 +66,11 @@ pub struct HttpServer<F: RuntimeFactors> {
     /// Request router.
     router: Router,
     /// The app being triggered.
-    trigger_app: TriggerApp<F>,
+    trigger_app: Arc<TriggerApp<F>>,
     // Component ID -> component trigger config
     component_trigger_configs: HashMap<spin_http::routes::TriggerLookupKey, HttpTriggerConfig>,
     // Component ID -> handler type
-    component_handler_types: HashMap<String, HandlerType>,
+    component_handler_types: HashMap<String, HandlerType<HttpHandlerState<F>>>,
 }
 
 impl<F: RuntimeFactors> HttpServer<F> {
@@ -119,6 +122,8 @@ impl<F: RuntimeFactors> HttpServer<F> {
         // Now that router is built we can merge duplicate routes by component
         let component_trigger_configs = HashMap::from_iter(component_trigger_configs);
 
+        let trigger_app = Arc::new(trigger_app);
+
         let component_handler_types = component_trigger_configs
             .iter()
             .filter_map(|(key, trigger_config)| match key {
@@ -145,14 +150,20 @@ impl<F: RuntimeFactors> HttpServer<F> {
     }
 
     fn handler_type_for_component(
-        trigger_app: &TriggerApp<F>,
+        trigger_app: &Arc<TriggerApp<F>>,
         component_id: &str,
         executor: &Option<HttpExecutorType>,
-    ) -> anyhow::Result<HandlerType> {
+    ) -> anyhow::Result<HandlerType<HttpHandlerState<F>>> {
         let pre = trigger_app.get_instance_pre(component_id)?;
         let handler_type = match executor {
             None | Some(HttpExecutorType::Http) | Some(HttpExecutorType::Wasip3Unstable) => {
-                let handler_type = HandlerType::from_instance_pre(pre)?;
+                let handler_type = HandlerType::from_instance_pre(
+                    pre,
+                    HttpHandlerState {
+                        trigger_app: trigger_app.clone(),
+                        component_id: component_id.into(),
+                    },
+                )?;
                 handler_type.validate_executor(executor)?;
                 handler_type
             }
@@ -330,12 +341,16 @@ impl<F: RuntimeFactors> HttpServer<F> {
                 )
                 .await
             }
-            (None, Some(static_response)) => {
-                Self::respond_static_response(static_response)
-            },
+            (None, Some(static_response)) => Self::respond_static_response(static_response),
             // These error cases should have been ruled out by this point but belt and braces
-            (None, None) => Err(anyhow::anyhow!("Triggers must specify either component or static_response - neither is specified for {}", route_match.raw_route())),
-            (Some(_), Some(_)) => Err(anyhow::anyhow!("Triggers must specify either component or static_response - both are specified for {}", route_match.raw_route())),
+            (None, None) => Err(anyhow::anyhow!(
+                "Triggers must specify either component or static_response - neither is specified for {}",
+                route_match.raw_route()
+            )),
+            (Some(_), Some(_)) => Err(anyhow::anyhow!(
+                "Triggers must specify either component or static_response - both are specified for {}",
+                route_match.raw_route()
+            )),
         }
     }
 
@@ -377,9 +392,9 @@ impl<F: RuntimeFactors> HttpServer<F> {
                         .execute(instance_builder, &route_match, req, client_addr)
                         .await
                 }
-                HandlerType::Wasi0_3(indices) => {
-                    Wasip3HttpExecutor(indices)
-                        .execute(instance_builder, &route_match, req, client_addr)
+                HandlerType::Wasi0_3(handler) => {
+                    Wasip3HttpExecutor(handler)
+                        .execute(&route_match, req, client_addr)
                         .await
                 }
                 HandlerType::Wasi0_2(_)
@@ -607,3 +622,47 @@ pub(crate) trait HttpExecutor {
         client_addr: SocketAddr,
     ) -> impl Future<Output = anyhow::Result<Response<Body>>>;
 }
+
+pub(crate) struct HttpHandlerState<F: RuntimeFactors> {
+    trigger_app: Arc<TriggerApp<F>>,
+    component_id: String,
+}
+
+impl<F: RuntimeFactors> HandlerState for HttpHandlerState<F> {
+    type StoreData = InstanceState<F::InstanceState, ()>;
+
+    fn new_store(&self, _req_id: Option<u64>) -> anyhow::Result<StoreBundle<Self::StoreData>> {
+        Ok(StoreBundle {
+            store: self
+                .trigger_app
+                .prepare(&self.component_id)?
+                .instantiate_store(())?
+                .into_inner(),
+            write_profile: Box::new(|_| ()),
+        })
+    }
+
+    fn request_timeout(&self) -> Duration {
+        // TODO: Make this configurable
+        Duration::MAX
+    }
+
+    fn idle_instance_timeout(&self) -> Duration {
+        // TODO: Make this configurable
+        Duration::from_secs(1)
+    }
+
+    fn max_instance_reuse_count(&self) -> usize {
+        // TODO: Make this configurable
+        128
+    }
+
+    fn max_instance_concurrent_reuse_count(&self) -> usize {
+        // TODO: Make this configurable
+        16
+    }
+
+    fn handle_worker_error(&self, error: anyhow::Error) {
+        tracing::warn!("worker error: {error:?}")
+    }
+}

crates/trigger-http/src/wasi.rs

@@ -13,7 +13,9 @@ use spin_http::trigger::HandlerType;
 use tokio::{sync::oneshot, task};
 use tracing::{instrument, Instrument, Level};
 use wasmtime_wasi_http::bindings::http::types::Scheme;
-use wasmtime_wasi_http::{bindings::Proxy, body::HyperIncomingBody as Body, WasiHttpView};
+use wasmtime_wasi_http::{
+    bindings::Proxy, body::HyperIncomingBody as Body, handler::HandlerState, WasiHttpView,
+};
 
 use crate::{headers::prepare_request_headers, server::HttpExecutor, TriggerInstanceBuilder};
 
@@ -46,11 +48,11 @@ pub(super) fn prepare_request(
 }
 
 /// An [`HttpExecutor`] that uses the `wasi:http/incoming-handler` interface.
-pub struct WasiHttpExecutor<'a> {
-    pub handler_type: &'a HandlerType,
+pub struct WasiHttpExecutor<'a, S: HandlerState> {
+    pub handler_type: &'a HandlerType<S>,
 }
 
-impl HttpExecutor for WasiHttpExecutor<'_> {
+impl<S: HandlerState> HttpExecutor for WasiHttpExecutor<'_, S> {
     #[instrument(name = "spin_trigger_http.execute_wasm", skip_all, err(level = Level::INFO), fields(otel.name = format!("execute_wasm_component {}", route_match.lookup_key().to_string())))]
     async fn execute<F: RuntimeFactors>(
         &self,

crates/trigger-http/src/wasip3.rs

@@ -1,4 +1,4 @@
-use crate::{server::HttpExecutor, TriggerInstanceBuilder};
+use crate::server::HttpHandlerState;
 use anyhow::{Context as _, Result};
 use futures::{channel::oneshot, FutureExt};
 use http_body_util::BodyExt;
@@ -7,50 +7,51 @@ use spin_factors::RuntimeFactors;
 use spin_factors_executor::InstanceState;
 use spin_http::routes::RouteMatch;
 use std::net::SocketAddr;
-use tokio::task;
 use tracing::{instrument, Instrument, Level};
-use wasmtime::AsContextMut;
+use wasmtime::component::Accessor;
 use wasmtime_wasi_http::{
     body::HyperIncomingBody as Body,
-    p3::{
-        bindings::{http::types, ProxyIndices},
-        WasiHttpCtxView,
-    },
+    handler::{Proxy, ProxyHandler},
+    p3::{bindings::http::types, WasiHttpCtxView},
 };
 
 /// An [`HttpExecutor`] that uses the `wasi:[email protected].*/handler` interface.
-pub(super) struct Wasip3HttpExecutor<'a>(pub(super) &'a ProxyIndices);
+pub(super) struct Wasip3HttpExecutor<'a, F: RuntimeFactors>(
+    pub(super) &'a ProxyHandler<HttpHandlerState<F>>,
+);
 
-impl HttpExecutor for Wasip3HttpExecutor<'_> {
+impl<F: RuntimeFactors> Wasip3HttpExecutor<'_, F> {
     #[instrument(name = "spin_trigger_http.execute_wasm", skip_all, err(level = Level::INFO), fields(otel.name = format!("execute_wasm_component {}", route_match.lookup_key().to_string())))]
-    async fn execute<F: RuntimeFactors>(
+    pub async fn execute(
         &self,
-        instance_builder: TriggerInstanceBuilder<'_, F>,
         route_match: &RouteMatch<'_, '_>,
         mut req: http::Request<Body>,
         client_addr: SocketAddr,
     ) -> Result<http::Response<Body>> {
         super::wasi::prepare_request(route_match, &mut req, client_addr)?;
 
-        let (instance, mut store) = instance_builder.instantiate(()).await?;
-
         let getter = (|data| wasi_http::<F>(data).unwrap())
             as fn(&mut InstanceState<F::InstanceState, ()>) -> WasiHttpCtxView<'_>;
 
         let (request, body) = req.into_parts();
         let body = body.map_err(spin_factor_outbound_http::p2_to_p3_error_code);
         let request = http::Request::from_parts(request, body);
         let (request, request_io_result) = types::Request::from_http(request);
-        let request = wasi_http::<F>(store.data_mut())?.table.push(request)?;
-
-        let guest = self.0.load(&mut store, &instance)?;
 
         let (tx, rx) = oneshot::channel();
-        task::spawn(
-            async move {
-                store
-                    .as_context_mut()
-                    .run_concurrent(async move |store| {
+        self.0.spawn(
+            None,
+            Box::new(move |store: &Accessor<_>, guest: &Proxy| {
+                Box::pin(
+                    async move {
+                        let Proxy::P3(guest) = guest else {
+                            unreachable!();
+                        };
+
+                        let request = store.with(|mut store| {
+                            anyhow::Ok(wasi_http::<F>(store.data_mut())?.table.push(request)?)
+                        })?;
+
                         let (response, task) = guest
                             .wasi_http_handler()
                             .call_handle(store, request)
@@ -67,14 +68,14 @@ impl HttpExecutor for Wasip3HttpExecutor<'_> {
                         task.block(store).await;
 
                         anyhow::Ok(())
-                    })
-                    .await?
-            }
-            .in_current_span()
-            .inspect(|result| {
-                if let Err(error) = result {
-                    tracing::error!("Component error handling request: {error:?}");
-                }
+                    }
+                    .in_current_span()
+                    .map(|result| {
+                        if let Err(error) = result {
+                            tracing::error!("Component error handling request: {error:?}");
+                        }
+                    }),
+                )
             }),
         );