Merge pull request #3063 from alexcrichton/optimize-per-request-dispatch

Optimize per-request work dispatching to wasm

Author: lann

Cargo.lock

@@ -43,6 +43,7 @@ pub mod exports {
     }
 }
 
+pub use bindings::{Proxy, ProxyIndices};
 use wasi::http::types::{
     Error as HttpError, Fields, FutureIncomingResponse, FutureTrailers, Headers, IncomingBody,
     IncomingRequest, IncomingResponse, Method, OutgoingBody, OutgoingRequest, OutgoingResponse,

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

@@ -47,6 +47,7 @@ pub mod exports {
     }
 }
 
+pub use bindings::{Proxy, ProxyIndices};
 use wasi::http::types::{
     DnsErrorPayload, ErrorCode as HttpErrorCode, FieldSizePayload, Fields, FutureIncomingResponse,
     FutureTrailers, HeaderError, Headers, IncomingBody, IncomingRequest, IncomingResponse, Method,

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

@@ -16,11 +16,13 @@ serde = { workspace = true }
 spin-app = { path = "../app", optional = true }
 tracing = { workspace = true }
 wasmtime = { workspace = true }
-wasmtime-wasi-http = { workspace = true, optional = true }
+wasmtime-wasi = { workspace = true }
+wasmtime-wasi-http = { workspace = true }
+spin-factor-outbound-http = { path = "../factor-outbound-http" }
 
 [dev-dependencies]
 toml = { workspace = true }
 
 [features]
 default = ["runtime"]
-runtime = ["dep:spin-app", "dep:wasmtime-wasi-http"]
+runtime = ["dep:spin-app"]

crates/http/Cargo.toml

@@ -1,5 +1,9 @@
 use serde::{Deserialize, Serialize};
+use spin_factor_outbound_http::wasi_2023_10_18::ProxyIndices as ProxyIndices2023_10_18;
+use spin_factor_outbound_http::wasi_2023_11_10::ProxyIndices as ProxyIndices2023_11_10;
 use wasmtime::component::Component;
+use wasmtime_wasi::bindings::CommandIndices;
+use wasmtime_wasi_http::bindings::ProxyIndices;
 
 #[derive(Clone, Debug, Default, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
@@ -14,64 +18,57 @@ pub fn default_base() -> String {
 }
 
 /// The type of http handler export used by a component.
-#[derive(Clone, Copy)]
 pub enum HandlerType {
     Spin,
-    Wagi,
-    Wasi0_2,
-    Wasi2023_11_10,
-    Wasi2023_10_18,
+    Wagi(CommandIndices),
+    Wasi0_2(ProxyIndices),
+    Wasi2023_11_10(ProxyIndices2023_11_10),
+    Wasi2023_10_18(ProxyIndices2023_10_18),
 }
 
 /// The `incoming-handler` export for `wasi:http` version rc-2023-10-18
-pub const WASI_HTTP_EXPORT_2023_10_18: &str = "wasi:http/incoming-handler@0.2.0-rc-2023-10-18";
+const WASI_HTTP_EXPORT_2023_10_18: &str = "wasi:http/incoming-handler@0.2.0-rc-2023-10-18";
 /// The `incoming-handler` export for `wasi:http` version rc-2023-11-10
-pub const WASI_HTTP_EXPORT_2023_11_10: &str = "wasi:http/incoming-handler@0.2.0-rc-2023-11-10";
+const WASI_HTTP_EXPORT_2023_11_10: &str = "wasi:http/incoming-handler@0.2.0-rc-2023-11-10";
 /// The `incoming-handler` export prefix for all `wasi:http` 0.2 versions
-pub const WASI_HTTP_EXPORT_0_2_PREFIX: &str = "wasi:http/incoming-handler@0.2";
+const WASI_HTTP_EXPORT_0_2_PREFIX: &str = "wasi:http/incoming-handler@0.2";
 /// The `inbound-http` export for `fermyon:spin`
-pub const SPIN_HTTP_EXPORT: &str = "fermyon:spin/inbound-http";
+const SPIN_HTTP_EXPORT: &str = "fermyon:spin/inbound-http";
 
 impl HandlerType {
     /// Determine the handler type from the exports of a component.
-    pub fn from_component(
-        engine: &wasmtime::Engine,
-        component: &Component,
-    ) -> anyhow::Result<HandlerType> {
-        let mut handler_ty = None;
+    pub fn from_component(component: &Component) -> anyhow::Result<HandlerType> {
+        let mut candidates = Vec::new();
+        if let Ok(indices) = ProxyIndices::new(component) {
+            candidates.push(HandlerType::Wasi0_2(indices));
+        }
+        if let Ok(indices) = ProxyIndices2023_10_18::new(component) {
+            candidates.push(HandlerType::Wasi2023_10_18(indices));
+        }
+        if let Ok(indices) = ProxyIndices2023_11_10::new(component) {
+            candidates.push(HandlerType::Wasi2023_11_10(indices));
+        }
+        if component.export_index(None, SPIN_HTTP_EXPORT).is_some() {
+            candidates.push(HandlerType::Spin);
+        }
 
-        let mut set = |ty: HandlerType| {
-            if handler_ty.is_none() {
-                handler_ty = Some(ty);
-                Ok(())
-            } else {
-                Err(anyhow::anyhow!(
-                    "component exports multiple different handlers but \
-                     it's expected to export only one"
-                ))
-            }
-        };
-        let ty = component.component_type();
-        for (name, _) in ty.exports(engine) {
-            match name {
-                WASI_HTTP_EXPORT_2023_10_18 => set(HandlerType::Wasi2023_10_18)?,
-                WASI_HTTP_EXPORT_2023_11_10 => set(HandlerType::Wasi2023_11_10)?,
-                SPIN_HTTP_EXPORT => set(HandlerType::Spin)?,
-                name if name.starts_with(WASI_HTTP_EXPORT_0_2_PREFIX) => set(HandlerType::Wasi0_2)?,
-                _ => {}
+        match candidates.len() {
+            0 => {
+                anyhow::bail!(
+                    "Expected component to export one of \
+                    `{WASI_HTTP_EXPORT_2023_10_18}`, \
+                    `{WASI_HTTP_EXPORT_2023_11_10}`, \
+                    `{WASI_HTTP_EXPORT_0_2_PREFIX}.*`, \
+                     or `{SPIN_HTTP_EXPORT}` but it exported none of those. \
+                     This may mean the component handles a different trigger, or that its `wasi:http` export is newer then those supported by Spin. \
+                     If you're sure this is an HTTP module, check if a Spin upgrade is available: this may handle the newer version."
+                )
             }
+            1 => Ok(candidates.pop().unwrap()),
+            _ => anyhow::bail!(
+                "component exports multiple different handlers but \
+                     it's expected to export only one"
+            ),
         }
-
-        handler_ty.ok_or_else(|| {
-            anyhow::anyhow!(
-                "Expected component to export one of \
-                `{WASI_HTTP_EXPORT_2023_10_18}`, \
-                `{WASI_HTTP_EXPORT_2023_11_10}`, \
-                `{WASI_HTTP_EXPORT_0_2_PREFIX}.*`, \
-                 or `{SPIN_HTTP_EXPORT}` but it exported none of those. \
-                 This may mean the component handles a different trigger, or that its `wasi:http` export is newer then those supported by Spin. \
-                 If you're sure this is an HTTP module, check if a Spin upgrade is available: this may handle the newer version."
-            )
-        })
     }
 }

crates/http/src/trigger.rs

@@ -28,6 +28,7 @@ use tokio::{
     task,
 };
 use tracing::Instrument;
+use wasmtime_wasi::bindings::CommandIndices;
 use wasmtime_wasi_http::body::HyperOutgoingBody;
 
 use crate::{
@@ -107,17 +108,18 @@ impl<F: RuntimeFactors> HttpServer<F> {
         let component_handler_types = component_trigger_configs
             .iter()
             .map(|(component_id, trigger_config)| {
+                        let component = trigger_app.get_component(component_id)?;
                 let handler_type = match &trigger_config.executor {
                     None | Some(HttpExecutorType::Http) => {
-                        let component = trigger_app.get_component(component_id)?;
-                        HandlerType::from_component(trigger_app.engine().as_ref(), component)?
+                        HandlerType::from_component(component)?
                     }
                     Some(HttpExecutorType::Wagi(wagi_config)) => {
                         anyhow::ensure!(
                             wagi_config.entrypoint == "_start",
                             "Wagi component '{component_id}' cannot use deprecated 'entrypoint' field"
                         );
-                        HandlerType::Wagi
+                        HandlerType::Wagi(CommandIndices::new(component)
+                            .context("failed to find wasi command interface for wagi executor")?)
                     }
                 };
                 Ok((component_id.clone(), handler_type))
@@ -269,20 +271,23 @@ impl<F: RuntimeFactors> HttpServer<F> {
                         .execute(instance_builder, &route_match, req, client_addr)
                         .await
                 }
-                HandlerType::Wasi0_2
-                | HandlerType::Wasi2023_11_10
-                | HandlerType::Wasi2023_10_18 => {
-                    WasiHttpExecutor {
-                        handler_type: *handler_type,
-                    }
-                    .execute(instance_builder, &route_match, req, client_addr)
-                    .await
+                HandlerType::Wasi0_2(_)
+                | HandlerType::Wasi2023_11_10(_)
+                | HandlerType::Wasi2023_10_18(_) => {
+                    WasiHttpExecutor { handler_type }
+                        .execute(instance_builder, &route_match, req, client_addr)
+                        .await
                 }
-                HandlerType::Wagi => unreachable!(),
+                HandlerType::Wagi(_) => unreachable!(),
             },
             HttpExecutorType::Wagi(wagi_config) => {
+                let indices = match handler_type {
+                    HandlerType::Wagi(indices) => indices,
+                    _ => unreachable!(),
+                };
                 let executor = WagiHttpExecutor {
-                    wagi_config: wagi_config.clone(),
+                    wagi_config,
+                    indices,
                 };
                 executor
                     .execute(instance_builder, &route_match, req, client_addr)
@@ -461,7 +466,7 @@ fn set_req_uri(req: &mut Request<Body>, scheme: Scheme) -> anyhow::Result<()> {
 }
 
 /// An HTTP executor.
-pub(crate) trait HttpExecutor: Clone + Send + Sync + 'static {
+pub(crate) trait HttpExecutor {
     fn execute<F: RuntimeFactors>(
         &self,
         instance_builder: TriggerInstanceBuilder<F>,

crates/trigger-http/src/server.rs

@@ -7,17 +7,18 @@ use spin_factor_wasi::WasiFactor;
 use spin_factors::RuntimeFactors;
 use spin_http::{config::WagiTriggerConfig, routes::RouteMatch, wagi};
 use tracing::{instrument, Level};
+use wasmtime_wasi::bindings::CommandIndices;
 use wasmtime_wasi::pipe::MemoryOutputPipe;
 use wasmtime_wasi_http::body::HyperIncomingBody as Body;
 
 use crate::{headers::compute_default_headers, server::HttpExecutor, TriggerInstanceBuilder};
 
-#[derive(Clone)]
-pub struct WagiHttpExecutor {
-    pub wagi_config: WagiTriggerConfig,
+pub struct WagiHttpExecutor<'a> {
+    pub wagi_config: &'a WagiTriggerConfig,
+    pub indices: &'a CommandIndices,
 }
 
-impl HttpExecutor for WagiHttpExecutor {
+impl HttpExecutor for WagiHttpExecutor<'_> {
     #[instrument(name = "spin_trigger_http.execute_wagi", skip_all, err(level = Level::INFO), fields(otel.name = format!("execute_wagi_component {}", route_match.component_id())))]
     async fn execute<F: RuntimeFactors>(
         &self,
@@ -87,7 +88,7 @@ impl HttpExecutor for WagiHttpExecutor {
 
         let (instance, mut store) = instance_builder.instantiate(()).await?;
 
-        let command = wasmtime_wasi::bindings::Command::new(&mut store, &instance)?;
+        let command = self.indices.load(&mut store, &instance)?;
 
         tracing::trace!("Calling Wasm entry point");
         if let Err(()) = command

crates/trigger-http/src/wagi.rs

@@ -5,8 +5,8 @@ use anyhow::{anyhow, Context, Result};
 use futures::TryFutureExt;
 use http::{HeaderName, HeaderValue};
 use hyper::{Request, Response};
-use spin_factor_outbound_http::wasi_2023_10_18::exports::wasi::http::incoming_handler as incoming_handler2023_10_18;
-use spin_factor_outbound_http::wasi_2023_11_10::exports::wasi::http::incoming_handler as incoming_handler2023_11_10;
+use spin_factor_outbound_http::wasi_2023_10_18::Proxy as Proxy2023_10_18;
+use spin_factor_outbound_http::wasi_2023_11_10::Proxy as Proxy2023_11_10;
 use spin_factors::RuntimeFactors;
 use spin_http::routes::RouteMatch;
 use spin_http::trigger::HandlerType;
@@ -18,12 +18,11 @@ use wasmtime_wasi_http::{bindings::Proxy, body::HyperIncomingBody as Body, WasiH
 use crate::{headers::prepare_request_headers, server::HttpExecutor, TriggerInstanceBuilder};
 
 /// An [`HttpExecutor`] that uses the `wasi:http/incoming-handler` interface.
-#[derive(Clone)]
-pub struct WasiHttpExecutor {
-    pub handler_type: HandlerType,
+pub struct WasiHttpExecutor<'a> {
+    pub handler_type: &'a HandlerType,
 }
 
-impl HttpExecutor for WasiHttpExecutor {
+impl HttpExecutor for WasiHttpExecutor<'_> {
     #[instrument(name = "spin_trigger_http.execute_wasm", skip_all, err(level = Level::INFO), fields(otel.name = format!("execute_wasm_component {}", route_match.component_id())))]
     async fn execute<F: RuntimeFactors>(
         &self,
@@ -76,26 +75,22 @@ impl HttpExecutor for WasiHttpExecutor {
 
         enum Handler {
             Latest(Proxy),
-            Handler2023_11_10(incoming_handler2023_11_10::Guest),
-            Handler2023_10_18(incoming_handler2023_10_18::Guest),
+            Handler2023_11_10(Proxy2023_11_10),
+            Handler2023_10_18(Proxy2023_10_18),
         }
 
         let handler = match self.handler_type {
-            HandlerType::Wasi2023_10_18 => {
-                let indices =
-                    incoming_handler2023_10_18::GuestIndices::new_instance(&mut store, &instance)?;
+            HandlerType::Wasi2023_10_18(indices) => {
                 let guest = indices.load(&mut store, &instance)?;
                 Handler::Handler2023_10_18(guest)
             }
-            HandlerType::Wasi2023_11_10 => {
-                let indices =
-                    incoming_handler2023_11_10::GuestIndices::new_instance(&mut store, &instance)?;
+            HandlerType::Wasi2023_11_10(indices) => {
                 let guest = indices.load(&mut store, &instance)?;
                 Handler::Handler2023_11_10(guest)
             }
-            HandlerType::Wasi0_2 => Handler::Latest(Proxy::new(&mut store, &instance)?),
+            HandlerType::Wasi0_2(indices) => Handler::Latest(indices.load(&mut store, &instance)?),
             HandlerType::Spin => unreachable!("should have used SpinHttpExecutor"),
-            HandlerType::Wagi => unreachable!("should have used WagiExecutor instead"),
+            HandlerType::Wagi(_) => unreachable!("should have used WagiExecutor instead"),
         };
 
         let span = tracing::debug_span!("execute_wasi");
@@ -111,12 +106,14 @@ impl HttpExecutor for WasiHttpExecutor {
                     }
                     Handler::Handler2023_10_18(handler) => {
                         handler
+                            .wasi_http0_2_0_rc_2023_10_18_incoming_handler()
                             .call_handle(&mut store, request, response)
                             .instrument(span)
                             .await
                     }
                     Handler::Handler2023_11_10(handler) => {
                         handler
+                            .wasi_http0_2_0_rc_2023_11_10_incoming_handler()
                             .call_handle(&mut store, request, response)
                             .instrument(span)
                             .await