Working generic factors

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

Cargo.lock

@@ -48,12 +48,14 @@ spin-build = { path = "crates/build" }
 spin-common = { path = "crates/common" }
 spin-doctor = { path = "crates/doctor" }
 spin-expressions = { path = "crates/expressions" }
+spin-factors = { path = "crates/factors" }
 spin-http = { path = "crates/http" }
 spin-loader = { path = "crates/loader" }
 spin-locked-app = { path = "crates/locked-app" }
 spin-manifest = { path = "crates/manifest" }
 spin-oci = { path = "crates/oci" }
 spin-plugins = { path = "crates/plugins" }
+spin-runtime-config = { path = "crates/runtime-config" }
 spin-telemetry = { path = "crates/telemetry", features = [
   "tracing-log-compat",
 ] }

Cargo.toml

@@ -30,13 +30,13 @@ use crate::{factor::FactorInstanceState, App, ConfiguredApp, Factor};
 /// // Instantiate the component
 /// let instance = linker.instantiate_async(&mut store, &component).await?;
 /// ```
-pub trait RuntimeFactors: Sized + 'static {
+pub trait RuntimeFactors: Send + Sync + Sized + 'static {
     /// The per application state of all the factors.
-    type AppState: Sync;
+    type AppState: Sync + Send;
     /// The per instance state of the factors.
     type InstanceState: RuntimeFactorsInstanceState;
     /// The collection of all the `InstanceBuilder`s of the factors.
-    type InstanceBuilders;
+    type InstanceBuilders: Send;
     /// The runtime configuration of all the factors.
     type RuntimeConfig: Default;
 

crates/factors/src/runtime_factors.rs

@@ -31,6 +31,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1"
 spin-app = { path = "../app" }
 spin-core = { path = "../core" }
+spin-factors = { path = "../factors" }
 spin-factor-outbound-http = { path = "../factor-outbound-http" }
 spin-factor-wasi = { path = "../factor-wasi" }
 spin-http = { path = "../http" }

crates/trigger-http/Cargo.toml

@@ -20,6 +20,7 @@ use anyhow::{bail, Context};
 use clap::Args;
 use serde::Deserialize;
 use spin_app::App;
+use spin_factors::RuntimeFactors;
 use spin_trigger::Trigger;
 use wasmtime_wasi_http::bindings::wasi::http::types::ErrorCode;
 
@@ -29,8 +30,9 @@ pub use tls::TlsConfig;
 
 pub(crate) use wasmtime_wasi_http::body::HyperIncomingBody as Body;
 
-pub(crate) type TriggerApp = spin_trigger::TriggerApp<HttpTrigger>;
-pub(crate) type TriggerInstanceBuilder<'a> = spin_trigger::TriggerInstanceBuilder<'a, HttpTrigger>;
+pub(crate) type TriggerApp<F> = spin_trigger::TriggerApp<HttpTrigger, F>;
+pub(crate) type TriggerInstanceBuilder<'a, F> =
+    spin_trigger::TriggerInstanceBuilder<'a, HttpTrigger, F>;
 
 #[derive(Args)]
 pub struct CliArgs {
@@ -70,7 +72,7 @@ pub struct HttpTrigger {
     tls_config: Option<TlsConfig>,
 }
 
-impl Trigger for HttpTrigger {
+impl<F: RuntimeFactors> Trigger<F> for HttpTrigger {
     const TYPE: &'static str = "http";
 
     type CliArgs = CliArgs;
@@ -80,7 +82,7 @@ impl Trigger for HttpTrigger {
         Self::new(app, cli_args.address, cli_args.into_tls_config())
     }
 
-    async fn run(self, trigger_app: TriggerApp) -> anyhow::Result<()> {
+    async fn run(self, trigger_app: TriggerApp<F>) -> anyhow::Result<()> {
         let server = self.into_server(trigger_app)?;
 
         server.serve().await?;
@@ -109,7 +111,10 @@ impl HttpTrigger {
     }
 
     /// Turn this [`HttpTrigger`] into an [`HttpServer`].
-    pub fn into_server(self, trigger_app: TriggerApp) -> anyhow::Result<Arc<HttpServer>> {
+    pub fn into_server<F: RuntimeFactors>(
+        self,
+        trigger_app: TriggerApp<F>,
+    ) -> anyhow::Result<Arc<HttpServer<F>>> {
         let Self {
             listen_addr,
             tls_config,

crates/trigger-http/src/lib.rs

@@ -8,25 +8,28 @@ use spin_factor_outbound_http::{
     HostFutureIncomingResponse, InterceptOutcome, OutgoingRequestConfig, Request,
 };
 use spin_factor_outbound_networking::parse_service_chaining_target;
+use spin_factors::RuntimeFactors;
 use spin_http::routes::RouteMatch;
 use wasmtime_wasi_http::types::IncomingResponse;
 
 use crate::HttpServer;
 
 /// An outbound HTTP interceptor that handles service chaining requests.
-pub struct OutboundHttpInterceptor {
-    server: Arc<HttpServer>,
+pub struct OutboundHttpInterceptor<F: RuntimeFactors> {
+    server: Arc<HttpServer<F>>,
 }
 
-impl OutboundHttpInterceptor {
-    pub fn new(server: Arc<HttpServer>) -> Self {
+impl<F: RuntimeFactors> OutboundHttpInterceptor<F> {
+    pub fn new(server: Arc<HttpServer<F>>) -> Self {
         Self { server }
     }
 }
 
 const CHAINED_CLIENT_ADDR: SocketAddr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
 
-impl spin_factor_outbound_http::OutboundHttpInterceptor for OutboundHttpInterceptor {
+impl<F: RuntimeFactors> spin_factor_outbound_http::OutboundHttpInterceptor
+    for OutboundHttpInterceptor<F>
+{
     fn intercept(
         &self,
         request: &mut Request,

crates/trigger-http/src/outbound_http.rs

@@ -14,6 +14,7 @@ use hyper::{
 use hyper_util::rt::TokioIo;
 use spin_app::{APP_DESCRIPTION_KEY, APP_NAME_KEY};
 use spin_factor_outbound_http::SelfRequestOrigin;
+use spin_factors::RuntimeFactors;
 use spin_http::{
     app_info::AppInfo,
     body,
@@ -40,27 +41,27 @@ use crate::{
 };
 
 /// An HTTP server which runs Spin apps.
-pub struct HttpServer {
+pub struct HttpServer<F: RuntimeFactors> {
     /// The address the server is listening on.
     listen_addr: SocketAddr,
     /// The TLS configuration for the server.
     tls_config: Option<TlsConfig>,
     /// Request router.
     router: Router,
     /// The app being triggered.
-    trigger_app: TriggerApp,
+    trigger_app: TriggerApp<F>,
     // Component ID -> component trigger config
     component_trigger_configs: HashMap<String, HttpTriggerConfig>,
     // Component ID -> handler type
     component_handler_types: HashMap<String, HandlerType>,
 }
 
-impl HttpServer {
+impl<F: RuntimeFactors> HttpServer<F> {
     /// Create a new [`HttpServer`].
     pub fn new(
         listen_addr: SocketAddr,
         tls_config: Option<TlsConfig>,
-        trigger_app: TriggerApp,
+        trigger_app: TriggerApp<F>,
     ) -> anyhow::Result<Self> {
         // This needs to be a vec before building the router to handle duplicate routes
         let component_trigger_configs = Vec::from_iter(
@@ -235,10 +236,11 @@ impl HttpServer {
         let mut instance_builder = self.trigger_app.prepare(component_id)?;
 
         // Set up outbound HTTP request origin and service chaining
-        let outbound_http = instance_builder.factor_builders().outbound_http();
-        let origin = SelfRequestOrigin::create(server_scheme, &self.listen_addr)?;
-        outbound_http.set_self_request_origin(origin);
-        outbound_http.set_request_interceptor(OutboundHttpInterceptor::new(self.clone()))?;
+        // TODO: bring back once outbound networking is refactored
+        // let outbound_http = instance_builder.factor_builders().outbound_http();
+        // let origin = SelfRequestOrigin::create(server_scheme, &self.listen_addr)?;
+        // outbound_http.set_self_request_origin(origin);
+        // outbound_http.set_request_interceptor(OutboundHttpInterceptor::new(self.clone()))?;
 
         // Prepare HTTP executor
         let trigger_config = self.component_trigger_configs.get(component_id).unwrap();
@@ -448,9 +450,9 @@ fn set_req_uri(req: &mut Request<Body>, scheme: Scheme) -> anyhow::Result<()> {
 
 /// An HTTP executor.
 pub(crate) trait HttpExecutor: Clone + Send + Sync + 'static {
-    fn execute(
+    fn execute<F: RuntimeFactors>(
         &self,
-        instance_builder: TriggerInstanceBuilder,
+        instance_builder: TriggerInstanceBuilder<F>,
         route_match: &RouteMatch,
         req: Request<Body>,
         client_addr: SocketAddr,

crates/trigger-http/src/server.rs

@@ -3,6 +3,7 @@ use std::net::SocketAddr;
 use anyhow::Result;
 use http_body_util::BodyExt;
 use hyper::{Request, Response};
+use spin_factors::RuntimeFactors;
 use spin_http::body;
 use spin_http::routes::RouteMatch;
 use spin_world::v1::http_types;
@@ -20,9 +21,9 @@ pub struct SpinHttpExecutor;
 
 impl HttpExecutor for SpinHttpExecutor {
     #[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(
+    async fn execute<F: RuntimeFactors>(
         &self,
-        instance_builder: TriggerInstanceBuilder<'_>,
+        instance_builder: TriggerInstanceBuilder<'_, F>,
         route_match: &RouteMatch,
         req: Request<Body>,
         client_addr: SocketAddr,

crates/trigger-http/src/spin.rs

@@ -3,6 +3,7 @@ use std::{io::Cursor, net::SocketAddr};
 use anyhow::{ensure, Result};
 use http_body_util::BodyExt;
 use hyper::{Request, Response};
+use spin_factors::RuntimeFactors;
 use spin_http::{config::WagiTriggerConfig, routes::RouteMatch, wagi};
 use tracing::{instrument, Level};
 use wasmtime_wasi::pipe::MemoryOutputPipe;
@@ -17,9 +18,9 @@ pub struct 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(
+    async fn execute<F: RuntimeFactors>(
         &self,
-        mut instance_builder: TriggerInstanceBuilder<'_>,
+        mut instance_builder: TriggerInstanceBuilder<'_, F>,
         route_match: &RouteMatch,
         req: Request<Body>,
         client_addr: SocketAddr,
@@ -73,13 +74,14 @@ impl HttpExecutor for WagiHttpExecutor {
 
         let stdout = MemoryOutputPipe::new(usize::MAX);
 
-        let wasi_builder = instance_builder.factor_builders().wasi();
+        // TODO:
+        // let wasi_builder = instance_builder.factor_builders().wasi();
 
-        // Set up Wagi environment
-        wasi_builder.args(argv.split(' '));
-        wasi_builder.env(headers);
-        wasi_builder.stdin_pipe(Cursor::new(body));
-        wasi_builder.stdout(stdout.clone());
+        // // Set up Wagi environment
+        // wasi_builder.args(argv.split(' '));
+        // wasi_builder.env(headers);
+        // wasi_builder.stdin_pipe(Cursor::new(body));
+        // wasi_builder.stdout(stdout.clone());
 
         let (instance, mut store) = instance_builder.instantiate(()).await?;
 

crates/trigger-http/src/wagi.rs

@@ -6,6 +6,7 @@ use http::{HeaderName, HeaderValue};
 use hyper::{Request, Response};
 use spin_factor_outbound_http::wasi_2023_10_18::exports::wasi::http::incoming_handler::Guest as IncomingHandler2023_10_18;
 use spin_factor_outbound_http::wasi_2023_11_10::exports::wasi::http::incoming_handler::Guest as IncomingHandler2023_11_10;
+use spin_factors::RuntimeFactors;
 use spin_http::routes::RouteMatch;
 use tokio::{sync::oneshot, task};
 use tracing::{instrument, Instrument, Level};
@@ -25,9 +26,9 @@ pub struct 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(
+    async fn execute<F: RuntimeFactors>(
         &self,
-        instance_builder: TriggerInstanceBuilder<'_>,
+        instance_builder: TriggerInstanceBuilder<'_, F>,
         route_match: &RouteMatch,
         mut req: Request<Body>,
         client_addr: SocketAddr,