factors: Merge FactorInstancePreparer trait into Factor

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

Author: lann

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

@@ -8,8 +8,7 @@ use spin_factor_variables::VariablesFactor;
 use spin_factor_wasi::WasiFactor;
 use spin_factors::{
     anyhow::{self, Context},
-    ConfigureAppContext, Factor, FactorInstancePreparer, InstancePreparers, PrepareContext,
-    RuntimeConfig, RuntimeFactors,
+    ConfigureAppContext, Factor, InstancePreparers, PrepareContext, RuntimeConfig, RuntimeFactors,
 };
 use spin_outbound_networking::{AllowedHostsConfig, ALLOWED_HOSTS_KEY};
 
@@ -44,24 +43,11 @@ impl Factor for OutboundNetworkingFactor {
             component_allowed_hosts,
         })
     }
-}
-
-#[derive(Default)]
-pub struct AppState {
-    component_allowed_hosts: HashMap<String, Arc<[String]>>,
-}
-
-type SharedFutureResult<T> = Shared<BoxFuture<'static, Arc<anyhow::Result<T>>>>;
-
-pub struct InstancePreparer {
-    allowed_hosts_future: SharedFutureResult<AllowedHostsConfig>,
-}
 
-impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
-    fn new<Factors: RuntimeFactors>(
-        ctx: PrepareContext<OutboundNetworkingFactor>,
-        mut preparers: InstancePreparers<Factors>,
-    ) -> anyhow::Result<Self> {
+    fn create_preparer<T: RuntimeFactors>(
+        ctx: PrepareContext<Self>,
+        mut preparers: InstancePreparers<T>,
+    ) -> anyhow::Result<Self::InstancePreparer> {
         let hosts = ctx
             .app_config()
             .component_allowed_hosts
@@ -101,18 +87,40 @@ impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
                 }
             }
         });
-        Ok(Self {
-            allowed_hosts_future,
-        })
+        Ok(InstancePreparer::new(allowed_hosts_future))
     }
 
-    fn prepare(self) -> anyhow::Result<<OutboundNetworkingFactor as Factor>::InstanceState> {
+    fn prepare(
+        &self,
+        _preparer: InstancePreparer,
+    ) -> anyhow::Result<<OutboundNetworkingFactor as Factor>::InstanceState> {
         Ok(())
     }
 }
 
+#[derive(Default)]
+pub struct AppState {
+    component_allowed_hosts: HashMap<String, Arc<[String]>>,
+}
+
+type SharedFutureResult<T> = Shared<BoxFuture<'static, Arc<anyhow::Result<T>>>>;
+
+#[derive(Default)]
+pub struct InstancePreparer {
+    allowed_hosts_future: Option<SharedFutureResult<AllowedHostsConfig>>,
+}
+
 impl InstancePreparer {
+    fn new(allowed_hosts_future: SharedFutureResult<AllowedHostsConfig>) -> Self {
+        Self {
+            allowed_hosts_future: Some(allowed_hosts_future),
+        }
+    }
+
     pub async fn resolve_allowed_hosts(&self) -> Arc<anyhow::Result<AllowedHostsConfig>> {
-        self.allowed_hosts_future.clone().await
+        self.allowed_hosts_future
+            .clone()
+            .expect("allowed_hosts_future not set")
+            .await
     }
 }

crates/factor-variables/src/lib.rs

@@ -2,8 +2,8 @@ use std::sync::Arc;
 
 use spin_expressions::ProviderResolver;
 use spin_factors::{
-    anyhow, ConfigureAppContext, Factor, FactorInstancePreparer, InitContext, InstancePreparers,
-    PrepareContext, RuntimeConfig, RuntimeFactors,
+    anyhow, ConfigureAppContext, Factor, InitContext, InstancePreparers, PrepareContext,
+    RuntimeConfig, RuntimeFactors,
 };
 use spin_world::{async_trait, v1::config as v1_config, v2::variables};
 
@@ -42,13 +42,32 @@ impl Factor for VariablesFactor {
             resolver: Arc::new(resolver),
         })
     }
+
+    fn create_preparer<T: RuntimeFactors>(
+        ctx: PrepareContext<Self>,
+        _preparers: InstancePreparers<T>,
+    ) -> anyhow::Result<Self::InstancePreparer> {
+        let component_id = ctx.app_component().id().to_string();
+        let resolver = ctx.app_config().resolver.clone();
+        Ok(InstancePreparer {
+            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 {
     state: InstanceState,
 }
@@ -59,26 +78,7 @@ impl InstancePreparer {
     }
 }
 
-impl FactorInstancePreparer<VariablesFactor> for InstancePreparer {
-    fn new<Factors: RuntimeFactors>(
-        ctx: PrepareContext<VariablesFactor>,
-        _preparers: InstancePreparers<Factors>,
-    ) -> anyhow::Result<Self> {
-        let component_id = ctx.app_component().id().to_string();
-        let resolver = ctx.app_config().resolver.clone();
-        Ok(Self {
-            state: InstanceState {
-                component_id,
-                resolver,
-            },
-        })
-    }
-
-    fn prepare(self) -> anyhow::Result<InstanceState> {
-        Ok(self.state)
-    }
-}
-
+#[derive(Default)]
 pub struct InstanceState {
     component_id: String,
     resolver: Arc<ProviderResolver>,

crates/factor-wasi/src/lib.rs

@@ -3,8 +3,7 @@ pub mod preview1;
 use std::{future::Future, net::SocketAddr, path::Path};
 
 use spin_factors::{
-    anyhow, AppComponent, Factor, FactorInstancePreparer, InitContext, InstancePreparers,
-    PrepareContext, RuntimeFactors,
+    anyhow, AppComponent, Factor, InitContext, InstancePreparers, PrepareContext, RuntimeFactors,
 };
 use wasmtime_wasi::{ResourceTable, WasiCtx, WasiCtxBuilder, WasiView};
 
@@ -69,6 +68,36 @@ impl Factor for WasiFactor {
         }
         Ok(())
     }
+
+    fn create_preparer<T: RuntimeFactors>(
+        ctx: PrepareContext<Self>,
+        _preparers: InstancePreparers<T>,
+    ) -> anyhow::Result<Self::InstancePreparer> {
+        let mut wasi_ctx = WasiCtxBuilder::new();
+
+        // Apply environment variables
+        for (key, val) in ctx.app_component().environment() {
+            wasi_ctx.env(key, val);
+        }
+
+        // Mount files
+        let mount_ctx = MountFilesContext {
+            wasi_ctx: &mut wasi_ctx,
+        };
+        ctx.factor()
+            .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(),
+        })
+    }
 }
 
 pub trait FilesMounter {
@@ -122,36 +151,11 @@ pub struct InstancePreparer {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl FactorInstancePreparer<WasiFactor> for InstancePreparer {
-    // NOTE: Replaces WASI parts of AppComponent::apply_store_config
-    fn new<Factors: RuntimeFactors>(
-        ctx: PrepareContext<WasiFactor>,
-        _preparers: InstancePreparers<Factors>,
-    ) -> anyhow::Result<Self> {
-        let mut wasi_ctx = WasiCtxBuilder::new();
-
-        // Apply environment variables
-        for (key, val) in ctx.app_component().environment() {
-            wasi_ctx.env(key, val);
+impl Default for InstancePreparer {
+    fn default() -> Self {
+        Self {
+            wasi_ctx: WasiCtxBuilder::new(),
         }
-
-        // Mount files
-        let mount_ctx = MountFilesContext {
-            wasi_ctx: &mut wasi_ctx,
-        };
-        ctx.factor()
-            .files_mounter
-            .mount_files(ctx.app_component(), mount_ctx)?;
-
-        Ok(Self { wasi_ctx })
-    }
-
-    fn prepare(self) -> anyhow::Result<InstanceState> {
-        let Self { mut wasi_ctx } = self;
-        Ok(InstanceState {
-            ctx: wasi_ctx.build(),
-            table: Default::default(),
-        })
     }
 }
 

crates/factor-wasi/src/preview1.rs

@@ -1,7 +1,4 @@
-use spin_factors::{
-    anyhow, Factor, FactorInstancePreparer, InitContext, InstancePreparers, PrepareContext,
-    RuntimeFactors,
-};
+use spin_factors::{anyhow, Factor, InitContext, RuntimeFactors};
 use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
 pub struct WasiPreview1Factor;
@@ -17,23 +14,20 @@ impl Factor for WasiPreview1Factor {
     ) -> anyhow::Result<()> {
         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())
+    }
 }
 
 pub struct InstancePreparer {
     wasi_ctx: WasiCtxBuilder,
 }
 
-impl FactorInstancePreparer<WasiPreview1Factor> for InstancePreparer {
-    fn new<Factors: RuntimeFactors>(
-        _ctx: PrepareContext<WasiPreview1Factor>,
-        _preparers: InstancePreparers<Factors>,
-    ) -> anyhow::Result<Self> {
-        Ok(Self {
+impl Default for InstancePreparer {
+    fn default() -> Self {
+        Self {
             wasi_ctx: WasiCtxBuilder::new(),
-        })
-    }
-
-    fn prepare(mut self) -> anyhow::Result<WasiP1Ctx> {
-        Ok(self.wasi_ctx.build_p1())
+        }
     }
 }

crates/factors-derive/src/lib.rs

@@ -112,7 +112,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
                 };
                 #(
                     preparers.#factor_names = Some(
-                        #factors_path::FactorInstancePreparer::<#factor_types>::new::<#name>(
+                        #Factor::create_preparer::<Self>(
                             #factors_path::PrepareContext::new(
                                 &self.#factor_names,
                                 configured_app.app_config::<#factor_types>().unwrap(),
@@ -124,7 +124,8 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
                 )*
                 Ok(#state_name {
                     #(
-                        #factor_names: #factors_path::FactorInstancePreparer::<#factor_types>::prepare(
+                        #factor_names: #Factor::prepare(
+                            &self.#factor_names,
                             preparers.#factor_names.unwrap(),
                         )?,
                     )*

crates/factors/src/factor.rs

@@ -2,7 +2,9 @@ use std::any::Any;
 
 use anyhow::Context;
 
-use crate::{App, FactorInstancePreparer, Linker, ModuleLinker, RuntimeConfig, RuntimeFactors};
+use crate::{
+    App, InstancePreparers, Linker, ModuleLinker, PrepareContext, RuntimeConfig, RuntimeFactors,
+};
 
 pub trait Factor: Any + Sized {
     /// Per-app state for this factor.
@@ -11,7 +13,7 @@ pub trait Factor: Any + Sized {
     type AppState: Default;
 
     /// The [`FactorInstancePreparer`] for this factor.
-    type InstancePreparer: FactorInstancePreparer<Self>;
+    type InstancePreparer: Default;
 
     /// The per-instance state for this factor, constructed by a
     /// [`FactorInstancePreparer`] and available to any host-provided imports
@@ -38,6 +40,18 @@ pub trait Factor: Any + Sized {
         _ = ctx;
         Ok(Default::default())
     }
+
+    /// Returns a new instance of this preparer for the given [`Factor`].
+    fn create_preparer<T: RuntimeFactors>(
+        ctx: PrepareContext<Self>,
+        _preparers: InstancePreparers<T>,
+    ) -> anyhow::Result<Self::InstancePreparer> {
+        _ = ctx;
+        Ok(Default::default())
+    }
+
+    /// Returns a new instance of the associated [`Factor::InstanceState`].
+    fn prepare(&self, preparer: Self::InstancePreparer) -> anyhow::Result<Self::InstanceState>;
 }
 
 pub(crate) type GetDataFn<Facts, Fact> =

crates/factors/src/lib.rs

@@ -1,5 +1,5 @@
 mod factor;
-mod instance_preparer;
+mod prepare;
 mod runtime_config;
 mod spin_factors;
 
@@ -10,7 +10,7 @@ pub use spin_factors_derive::RuntimeFactors;
 
 pub use crate::{
     factor::{ConfigureAppContext, ConfiguredApp, Factor, InitContext},
-    instance_preparer::{FactorInstancePreparer, InstancePreparers, PrepareContext},
+    prepare::{InstancePreparers, PrepareContext},
     runtime_config::{RuntimeConfig, RuntimeConfigSource},
     spin_factors::RuntimeFactors,
 };

crates/factors/src/instance_preparer.rs renamed to crates/factors/src/prepare.rs

@@ -2,33 +2,6 @@ use anyhow::Context;
 
 use crate::{AppComponent, Factor, RuntimeFactors};
 
-pub trait FactorInstancePreparer<F: Factor>: Sized {
-    /// Returns a new instance of this preparer for the given [`Factor`].
-    fn new<T: RuntimeFactors>(
-        ctx: PrepareContext<F>,
-        _preparers: InstancePreparers<T>,
-    ) -> anyhow::Result<Self>;
-
-    /// Returns a new instance of the associated [`Factor::InstanceState`].
-    fn prepare(self) -> anyhow::Result<F::InstanceState>;
-}
-
-impl<F: Factor> FactorInstancePreparer<F> for ()
-where
-    F::InstanceState: Default,
-{
-    fn new<T: RuntimeFactors>(
-        _ctx: PrepareContext<F>,
-        _preparers: InstancePreparers<T>,
-    ) -> anyhow::Result<Self> {
-        Ok(())
-    }
-
-    fn prepare(self) -> anyhow::Result<F::InstanceState> {
-        Ok(Default::default())
-    }
-}
-
 /// A PrepareContext is passed to [`FactorInstancePreparer::new`], giving access
 /// to any already-initialized [`FactorInstancePreparer`]s, allowing for
 /// inter-[`Factor`] dependencies.