factors: Add RuntimeConfig

Also address a bunch of feedback.

Signed-off-by: Lann Martin <lann.martin@fermyon.com>

Author: lann

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

@@ -8,21 +8,21 @@ use spin_factor_variables::VariablesFactor;
 use spin_factor_wasi::WasiFactor;
 use spin_factors::{
     anyhow::{self, Context},
-    ConfigureAppContext, Factor, InstancePreparers, PrepareContext, RuntimeConfig, RuntimeFactors,
+    ConfigureAppContext, Factor, FactorInstanceBuilder, InstanceBuilders, PrepareContext,
+    RuntimeFactors,
 };
 use spin_outbound_networking::{AllowedHostsConfig, ALLOWED_HOSTS_KEY};
 
 pub struct OutboundNetworkingFactor;
 
 impl Factor for OutboundNetworkingFactor {
+    type RuntimeConfig = ();
     type AppState = AppState;
-    type InstancePreparer = InstancePreparer;
-    type InstanceState = ();
+    type InstanceBuilder = InstanceBuilder;
 
-    fn configure_app<Factors: RuntimeFactors>(
+    fn configure_app<T: RuntimeFactors>(
         &self,
-        ctx: ConfigureAppContext<Factors>,
-        _runtime_config: &mut impl RuntimeConfig,
+        ctx: ConfigureAppContext<T, Self>,
     ) -> anyhow::Result<Self::AppState> {
         // Extract allowed_outbound_hosts for all components
         let component_allowed_hosts = ctx
@@ -44,17 +44,17 @@ impl Factor for OutboundNetworkingFactor {
         })
     }
 
-    fn create_preparer<T: RuntimeFactors>(
+    fn prepare<T: RuntimeFactors>(
         ctx: PrepareContext<Self>,
-        mut preparers: InstancePreparers<T>,
-    ) -> anyhow::Result<Self::InstancePreparer> {
+        builders: &mut InstanceBuilders<T>,
+    ) -> anyhow::Result<Self::InstanceBuilder> {
         let hosts = ctx
-            .app_config()
+            .app_state()
             .component_allowed_hosts
             .get(ctx.app_component().id())
             .cloned()
             .context("missing component allowed hosts")?;
-        let resolver = preparers.get_mut::<VariablesFactor>()?.resolver().clone();
+        let resolver = builders.get_mut::<VariablesFactor>()?.resolver().clone();
         let allowed_hosts_future = async move {
             let prepared = resolver.prepare().await?;
             AllowedHostsConfig::parse(&hosts, &prepared)
@@ -69,7 +69,7 @@ impl Factor for OutboundNetworkingFactor {
         // )?;
 
         // Update Wasi socket allowed ports
-        let wasi_preparer = preparers.get_mut::<WasiFactor>()?;
+        let wasi_preparer = builders.get_mut::<WasiFactor>()?;
         let hosts_future = allowed_hosts_future.clone();
         wasi_preparer.outbound_socket_addr_check(move |addr| {
             let hosts_future = hosts_future.clone();
@@ -87,14 +87,7 @@ impl Factor for OutboundNetworkingFactor {
                 }
             }
         });
-        Ok(InstancePreparer::new(allowed_hosts_future))
-    }
-
-    fn prepare(
-        &self,
-        _preparer: InstancePreparer,
-    ) -> anyhow::Result<<OutboundNetworkingFactor as Factor>::InstanceState> {
-        Ok(())
+        Ok(InstanceBuilder::new(allowed_hosts_future))
     }
 }
 
@@ -106,11 +99,11 @@ pub struct AppState {
 type SharedFutureResult<T> = Shared<BoxFuture<'static, Arc<anyhow::Result<T>>>>;
 
 #[derive(Default)]
-pub struct InstancePreparer {
+pub struct InstanceBuilder {
     allowed_hosts_future: Option<SharedFutureResult<AllowedHostsConfig>>,
 }
 
-impl InstancePreparer {
+impl InstanceBuilder {
     fn new(allowed_hosts_future: SharedFutureResult<AllowedHostsConfig>) -> Self {
         Self {
             allowed_hosts_future: Some(allowed_hosts_future),
@@ -124,3 +117,11 @@ impl InstancePreparer {
             .await
     }
 }
+
+impl FactorInstanceBuilder for InstanceBuilder {
+    type InstanceState = ();
+
+    fn build(self) -> anyhow::Result<Self::InstanceState> {
+        Ok(())
+    }
+}

crates/factor-variables/src/lib.rs

@@ -2,17 +2,17 @@ use std::sync::Arc;
 
 use spin_expressions::ProviderResolver;
 use spin_factors::{
-    anyhow, ConfigureAppContext, Factor, InitContext, InstancePreparers, PrepareContext,
-    RuntimeConfig, RuntimeFactors,
+    anyhow, ConfigureAppContext, Factor, FactorInstanceBuilder, InitContext, InstanceBuilders,
+    PrepareContext, RuntimeFactors,
 };
 use spin_world::{async_trait, v1::config as v1_config, v2::variables};
 
 pub struct VariablesFactor;
 
 impl Factor for VariablesFactor {
+    type RuntimeConfig = ();
     type AppState = AppState;
-    type InstancePreparer = InstancePreparer;
-    type InstanceState = InstanceState;
+    type InstanceBuilder = InstanceBuilder;
 
     fn init<Factors: RuntimeFactors>(
         &mut self,
@@ -23,10 +23,9 @@ impl Factor for VariablesFactor {
         Ok(())
     }
 
-    fn configure_app<Factors: RuntimeFactors>(
+    fn configure_app<T: RuntimeFactors>(
         &self,
-        ctx: ConfigureAppContext<Factors>,
-        _runtime_config: &mut impl RuntimeConfig,
+        ctx: ConfigureAppContext<T, Self>,
     ) -> anyhow::Result<Self::AppState> {
         let app = ctx.app();
         let mut resolver =
@@ -43,41 +42,44 @@ impl Factor for VariablesFactor {
         })
     }
 
-    fn create_preparer<T: RuntimeFactors>(
+    fn prepare<T: RuntimeFactors>(
         ctx: PrepareContext<Self>,
-        _preparers: InstancePreparers<T>,
-    ) -> anyhow::Result<Self::InstancePreparer> {
+        _builders: &mut InstanceBuilders<T>,
+    ) -> anyhow::Result<InstanceBuilder> {
         let component_id = ctx.app_component().id().to_string();
-        let resolver = ctx.app_config().resolver.clone();
-        Ok(InstancePreparer {
+        let resolver = ctx.app_state().resolver.clone();
+        Ok(InstanceBuilder {
             state: InstanceState {
                 component_id,
                 resolver,
             },
         })
     }
-
-    fn prepare(&self, preparer: InstancePreparer) -> anyhow::Result<InstanceState> {
-        Ok(preparer.state)
-    }
 }
 
 #[derive(Default)]
 pub struct AppState {
     resolver: Arc<ProviderResolver>,
 }
 
-#[derive(Default)]
-pub struct InstancePreparer {
+pub struct InstanceBuilder {
     state: InstanceState,
 }
 
-impl InstancePreparer {
+impl InstanceBuilder {
     pub fn resolver(&self) -> &Arc<ProviderResolver> {
         &self.state.resolver
     }
 }
 
+impl FactorInstanceBuilder for InstanceBuilder {
+    type InstanceState = InstanceState;
+
+    fn build(self) -> anyhow::Result<Self::InstanceState> {
+        Ok(self.state)
+    }
+}
+
 #[derive(Default)]
 pub struct InstanceState {
     component_id: String,

crates/factor-wasi/src/lib.rs

@@ -3,7 +3,8 @@ pub mod preview1;
 use std::{future::Future, net::SocketAddr, path::Path};
 
 use spin_factors::{
-    anyhow, AppComponent, Factor, InitContext, InstancePreparers, PrepareContext, RuntimeFactors,
+    anyhow, AppComponent, Factor, FactorInstanceBuilder, InitContext, InstanceBuilders,
+    PrepareContext, RuntimeFactors,
 };
 use wasmtime_wasi::{ResourceTable, WasiCtx, WasiCtxBuilder, WasiView};
 
@@ -20,9 +21,9 @@ impl WasiFactor {
 }
 
 impl Factor for WasiFactor {
+    type RuntimeConfig = ();
     type AppState = ();
-    type InstancePreparer = InstancePreparer;
-    type InstanceState = InstanceState;
+    type InstanceBuilder = InstanceBuilder;
 
     fn init<Factors: RuntimeFactors>(
         &mut self,
@@ -69,10 +70,10 @@ impl Factor for WasiFactor {
         Ok(())
     }
 
-    fn create_preparer<T: RuntimeFactors>(
+    fn prepare<T: RuntimeFactors>(
         ctx: PrepareContext<Self>,
-        _preparers: InstancePreparers<T>,
-    ) -> anyhow::Result<Self::InstancePreparer> {
+        _builders: &mut InstanceBuilders<T>,
+    ) -> anyhow::Result<InstanceBuilder> {
         let mut wasi_ctx = WasiCtxBuilder::new();
 
         // Apply environment variables
@@ -88,15 +89,7 @@ impl Factor for WasiFactor {
             .files_mounter
             .mount_files(ctx.app_component(), mount_ctx)?;
 
-        Ok(InstancePreparer { wasi_ctx })
-    }
-
-    fn prepare(&self, preparer: InstancePreparer) -> anyhow::Result<InstanceState> {
-        let InstancePreparer { mut wasi_ctx } = preparer;
-        Ok(InstanceState {
-            ctx: wasi_ctx.build(),
-            table: Default::default(),
-        })
+        Ok(InstanceBuilder { wasi_ctx })
     }
 }
 
@@ -147,19 +140,23 @@ impl<'a> MountFilesContext<'a> {
     }
 }
 
-pub struct InstancePreparer {
+pub struct InstanceBuilder {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl Default for InstancePreparer {
-    fn default() -> Self {
-        Self {
-            wasi_ctx: WasiCtxBuilder::new(),
-        }
+impl FactorInstanceBuilder for InstanceBuilder {
+    type InstanceState = InstanceState;
+
+    fn build(self) -> anyhow::Result<Self::InstanceState> {
+        let InstanceBuilder { mut wasi_ctx } = self;
+        Ok(InstanceState {
+            ctx: wasi_ctx.build(),
+            table: Default::default(),
+        })
     }
 }
 
-impl InstancePreparer {
+impl InstanceBuilder {
     pub fn outbound_socket_addr_check<F, Fut>(&mut self, check: F)
     where
         F: Fn(SocketAddr) -> Fut + Send + Sync + Clone + 'static,

crates/factor-wasi/src/preview1.rs

@@ -1,12 +1,12 @@
-use spin_factors::{anyhow, Factor, InitContext, RuntimeFactors};
+use spin_factors::{anyhow, Factor, FactorInstanceBuilder, InitContext, RuntimeFactors};
 use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
 pub struct WasiPreview1Factor;
 
 impl Factor for WasiPreview1Factor {
+    type RuntimeConfig = ();
     type AppState = ();
-    type InstancePreparer = InstancePreparer;
-    type InstanceState = WasiP1Ctx;
+    type InstanceBuilder = InstanceBuilder;
 
     fn init<Factors: RuntimeFactors>(
         &mut self,
@@ -15,19 +15,25 @@ impl Factor for WasiPreview1Factor {
         ctx.link_module_bindings(wasmtime_wasi::preview1::add_to_linker_async)
     }
 
-    fn prepare(&self, mut preparer: InstancePreparer) -> anyhow::Result<WasiP1Ctx> {
-        Ok(preparer.wasi_ctx.build_p1())
+    fn prepare<T: RuntimeFactors>(
+        _ctx: spin_factors::PrepareContext<Self>,
+        _builders: &mut spin_factors::InstanceBuilders<T>,
+    ) -> anyhow::Result<Self::InstanceBuilder> {
+        Ok(InstanceBuilder {
+            wasi_ctx: WasiCtxBuilder::new(),
+        })
     }
 }
 
-pub struct InstancePreparer {
+pub struct InstanceBuilder {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl Default for InstancePreparer {
-    fn default() -> Self {
-        Self {
-            wasi_ctx: WasiCtxBuilder::new(),
-        }
+impl FactorInstanceBuilder for InstanceBuilder {
+    type InstanceState = WasiP1Ctx;
+
+    fn build(self) -> anyhow::Result<Self::InstanceState> {
+        let Self { mut wasi_ctx } = self;
+        Ok(wasi_ctx.build_p1())
     }
 }