factors: Reorganize spin-factors

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

Author: lann

Cargo.lock

@@ -5,7 +5,6 @@ authors = { workspace = true }
 edition = { workspace = true }
 
 [dependencies]
-anyhow = "1"
 futures-util = "0.3"
 ipnet = "2.9.0"
 spin-factor-variables = { path = "../factor-variables" }

crates/factor-outbound-networking/Cargo.toml

@@ -1,14 +1,15 @@
 use std::{collections::HashMap, sync::Arc};
 
-use anyhow::Context;
 use futures_util::{
     future::{BoxFuture, Shared},
     FutureExt,
 };
 use spin_factor_variables::VariablesFactor;
 use spin_factor_wasi::WasiFactor;
 use spin_factors::{
-    Factor, FactorInstancePreparer, InstancePreparers, PrepareContext, Result, SpinFactors,
+    anyhow::{self, Context},
+    ConfigureAppContext, Factor, FactorInstancePreparer, InstancePreparers, PrepareContext,
+    RuntimeConfig, SpinFactors,
 };
 use spin_outbound_networking::{AllowedHostsConfig, ALLOWED_HOSTS_KEY};
 
@@ -21,11 +22,12 @@ impl Factor for OutboundNetworkingFactor {
 
     fn configure_app<Factors: SpinFactors>(
         &self,
-        app: &spin_factors::App,
-        _ctx: spin_factors::ConfigureAppContext<Factors>,
-    ) -> Result<Self::AppConfig> {
+        ctx: ConfigureAppContext<Factors>,
+        _runtime_config: &mut impl RuntimeConfig,
+    ) -> anyhow::Result<Self::AppConfig> {
         // Extract allowed_outbound_hosts for all components
-        let component_allowed_hosts = app
+        let component_allowed_hosts = ctx
+            .app()
             .components()
             .map(|component| {
                 Ok((
@@ -37,7 +39,7 @@ impl Factor for OutboundNetworkingFactor {
                         .into(),
                 ))
             })
-            .collect::<Result<_>>()?;
+            .collect::<anyhow::Result<_>>()?;
         Ok(AppConfig {
             component_allowed_hosts,
         })
@@ -49,17 +51,17 @@ pub struct AppConfig {
     component_allowed_hosts: HashMap<String, Arc<[String]>>,
 }
 
-type AllowedHostsFuture = Shared<BoxFuture<'static, Arc<anyhow::Result<AllowedHostsConfig>>>>;
+type SharedFutureResult<T> = Shared<BoxFuture<'static, Arc<anyhow::Result<T>>>>;
 
 pub struct InstancePreparer {
-    allowed_hosts_future: AllowedHostsFuture,
+    allowed_hosts_future: SharedFutureResult<AllowedHostsConfig>,
 }
 
 impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
     fn new<Factors: SpinFactors>(
         ctx: PrepareContext<OutboundNetworkingFactor>,
         mut preparers: InstancePreparers<Factors>,
-    ) -> Result<Self> {
+    ) -> anyhow::Result<Self> {
         let hosts = ctx
             .app_config()
             .component_allowed_hosts
@@ -104,7 +106,7 @@ impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
         })
     }
 
-    fn prepare(self) -> Result<<OutboundNetworkingFactor as Factor>::InstanceState> {
+    fn prepare(self) -> anyhow::Result<<OutboundNetworkingFactor as Factor>::InstanceState> {
         Ok(())
     }
 }

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

@@ -5,7 +5,6 @@ authors = { workspace = true }
 edition = { workspace = true }
 
 [dependencies]
-anyhow = "1"
 spin-expressions = { path = "../expressions" }
 spin-factors = { path = "../factors" }
 spin-world = { path = "../world" }

crates/factor-variables/Cargo.toml

@@ -2,7 +2,8 @@ use std::sync::Arc;
 
 use spin_expressions::ProviderResolver;
 use spin_factors::{
-    Factor, FactorInstancePreparer, InstancePreparers, PrepareContext, Result, SpinFactors,
+    anyhow, ConfigureAppContext, Factor, FactorInstancePreparer, InitContext, InstancePreparers,
+    PrepareContext, RuntimeConfig, SpinFactors,
 };
 use spin_world::{async_trait, v1::config as v1_config, v2::variables};
 
@@ -15,18 +16,19 @@ impl Factor for VariablesFactor {
 
     fn init<Factors: SpinFactors>(
         &mut self,
-        mut ctx: spin_factors::InitContext<Factors, Self>,
-    ) -> Result<()> {
+        mut ctx: InitContext<Factors, Self>,
+    ) -> anyhow::Result<()> {
         ctx.link_bindings(v1_config::add_to_linker)?;
         ctx.link_bindings(variables::add_to_linker)?;
         Ok(())
     }
 
     fn configure_app<Factors: SpinFactors>(
         &self,
-        app: &spin_factors::App,
-        _ctx: spin_factors::ConfigureAppContext<Factors>,
-    ) -> Result<Self::AppConfig> {
+        ctx: ConfigureAppContext<Factors>,
+        _runtime_config: &mut impl RuntimeConfig,
+    ) -> anyhow::Result<Self::AppConfig> {
+        let app = ctx.app();
         let mut resolver =
             ProviderResolver::new(app.variables().map(|(key, val)| (key.clone(), val.clone())))?;
         for component in app.components() {
@@ -61,7 +63,7 @@ impl FactorInstancePreparer<VariablesFactor> for InstancePreparer {
     fn new<Factors: SpinFactors>(
         ctx: PrepareContext<VariablesFactor>,
         _preparers: InstancePreparers<Factors>,
-    ) -> Result<Self> {
+    ) -> anyhow::Result<Self> {
         let component_id = ctx.app_component().id().to_string();
         let resolver = ctx.app_config().resolver.clone();
         Ok(Self {
@@ -72,7 +74,7 @@ impl FactorInstancePreparer<VariablesFactor> for InstancePreparer {
         })
     }
 
-    fn prepare(self) -> Result<<VariablesFactor as Factor>::InstanceState> {
+    fn prepare(self) -> anyhow::Result<InstanceState> {
         Ok(self.state)
     }
 }
@@ -92,7 +94,7 @@ impl variables::Host for InstanceState {
             .map_err(expressions_to_variables_err)
     }
 
-    fn convert_error(&mut self, error: variables::Error) -> Result<variables::Error> {
+    fn convert_error(&mut self, error: variables::Error) -> anyhow::Result<variables::Error> {
         Ok(error)
     }
 }

crates/factor-variables/src/lib.rs

@@ -5,7 +5,6 @@ authors = { workspace = true }
 edition = { workspace = true }
 
 [dependencies]
-anyhow = "1"
 cap-primitives = "3.0.0"
 spin-factors = { path = "../factors" }
 wasmtime-wasi = { workspace = true }

crates/factor-wasi/Cargo.toml

@@ -2,10 +2,9 @@ pub mod preview1;
 
 use std::{future::Future, net::SocketAddr, path::Path};
 
-use anyhow::ensure;
 use spin_factors::{
-    AppComponent, Factor, FactorInstancePreparer, InitContext, InstancePreparers, PrepareContext,
-    Result, SpinFactors,
+    anyhow, AppComponent, Factor, FactorInstancePreparer, InitContext, InstancePreparers,
+    PrepareContext, SpinFactors,
 };
 use wasmtime_wasi::{ResourceTable, WasiCtx, WasiCtxBuilder, WasiView};
 
@@ -26,7 +25,10 @@ impl Factor for WasiFactor {
     type InstancePreparer = InstancePreparer;
     type InstanceState = InstanceState;
 
-    fn init<Factors: SpinFactors>(&mut self, mut ctx: InitContext<Factors, Self>) -> Result<()> {
+    fn init<Factors: SpinFactors>(
+        &mut self,
+        mut ctx: InitContext<Factors, Self>,
+    ) -> anyhow::Result<()> {
         fn type_annotate<T, F>(f: F) -> F
         where
             F: Fn(&mut T) -> &mut dyn WasiView,
@@ -70,14 +72,22 @@ impl Factor for WasiFactor {
 }
 
 pub trait FilesMounter {
-    fn mount_files(&self, app_component: &AppComponent, ctx: MountFilesContext) -> Result<()>;
+    fn mount_files(
+        &self,
+        app_component: &AppComponent,
+        ctx: MountFilesContext,
+    ) -> anyhow::Result<()>;
 }
 
 pub struct DummyFilesMounter;
 
 impl FilesMounter for DummyFilesMounter {
-    fn mount_files(&self, app_component: &AppComponent, _ctx: MountFilesContext) -> Result<()> {
-        ensure!(
+    fn mount_files(
+        &self,
+        app_component: &AppComponent,
+        _ctx: MountFilesContext,
+    ) -> anyhow::Result<()> {
+        anyhow::ensure!(
             app_component.files().next().is_none(),
             "DummyFilesMounter can't actually mount files"
         );
@@ -95,7 +105,7 @@ impl<'a> MountFilesContext<'a> {
         host_path: impl AsRef<Path>,
         guest_path: impl AsRef<str>,
         writable: bool,
-    ) -> Result<()> {
+    ) -> anyhow::Result<()> {
         use wasmtime_wasi::{DirPerms, FilePerms};
         let (dir_perms, file_perms) = if writable {
             (DirPerms::all(), FilePerms::all())
@@ -117,7 +127,7 @@ impl FactorInstancePreparer<WasiFactor> for InstancePreparer {
     fn new<Factors: SpinFactors>(
         ctx: PrepareContext<WasiFactor>,
         _preparers: InstancePreparers<Factors>,
-    ) -> Result<Self> {
+    ) -> anyhow::Result<Self> {
         let mut wasi_ctx = WasiCtxBuilder::new();
 
         // Apply environment variables
@@ -136,7 +146,7 @@ impl FactorInstancePreparer<WasiFactor> for InstancePreparer {
         Ok(Self { wasi_ctx })
     }
 
-    fn prepare(self) -> Result<InstanceState> {
+    fn prepare(self) -> anyhow::Result<InstanceState> {
         let Self { mut wasi_ctx } = self;
         Ok(InstanceState {
             ctx: wasi_ctx.build(),

crates/factor-wasi/src/lib.rs

@@ -1,5 +1,6 @@
 use spin_factors::{
-    Factor, FactorInstancePreparer, InitContext, InstancePreparers, PrepareContext, Result, SpinFactors
+    anyhow, Factor, FactorInstancePreparer, InitContext, InstancePreparers, PrepareContext,
+    SpinFactors,
 };
 use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
@@ -10,7 +11,10 @@ impl Factor for WasiPreview1Factor {
     type InstancePreparer = InstancePreparer;
     type InstanceState = WasiP1Ctx;
 
-    fn init<Factors: SpinFactors>(&mut self, mut ctx: InitContext<Factors, Self>) -> Result<()> {
+    fn init<Factors: SpinFactors>(
+        &mut self,
+        mut ctx: InitContext<Factors, Self>,
+    ) -> anyhow::Result<()> {
         ctx.link_module_bindings(wasmtime_wasi::preview1::add_to_linker_async)
     }
 }
@@ -23,13 +27,13 @@ impl FactorInstancePreparer<WasiPreview1Factor> for InstancePreparer {
     fn new<Factors: SpinFactors>(
         _ctx: PrepareContext<WasiPreview1Factor>,
         _preparers: InstancePreparers<Factors>,
-    ) -> Result<Self> {
+    ) -> anyhow::Result<Self> {
         Ok(Self {
             wasi_ctx: WasiCtxBuilder::new(),
         })
     }
 
-    fn prepare(mut self) -> Result<<WasiPreview1Factor as Factor>::InstanceState> {
+    fn prepare(mut self) -> anyhow::Result<WasiP1Ctx> {
         Ok(self.wasi_ctx.build_p1())
     }
 }

crates/factor-wasi/src/preview1.rs

@@ -53,13 +53,14 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
         factor_types.push(&field.ty);
     }
 
+    let TypeId = quote!(::std::any::TypeId);
     let factors_crate = format_ident!("spin_factors");
     let factors_path = quote!(::#factors_crate);
-    let Factor = quote!(#factors_path::Factor);
-    let Result = quote!(#factors_path::Result);
     let wasmtime = quote!(#factors_path::wasmtime);
+    let Result = quote!(#factors_path::Result);
+    let Factor = quote!(#factors_path::Factor);
     let ConfiguredApp = quote!(#factors_path::ConfiguredApp);
-    let TypeId = quote!(::std::any::TypeId);
+    let RuntimeConfigTracker = quote!(#factors_path::__internal::RuntimeConfigTracker);
 
     Ok(quote! {
         impl #name {
@@ -81,16 +82,21 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
                 Ok(())
             }
 
-            pub fn configure_app(&self, app: #factors_path::App) -> #Result<#ConfiguredApp<Self>> {
+            pub fn configure_app(
+                &self,
+                app: #factors_path::App,
+                runtime_config: impl #factors_path::RuntimeConfigSource
+            ) -> #Result<#ConfiguredApp<Self>> {
                 let mut app_configs = #app_configs_name {
                     #( #factor_names: None, )*
                 };
+                let mut runtime_config = #RuntimeConfigTracker::new(runtime_config);
                 #(
                     app_configs.#factor_names = Some(
                         #Factor::configure_app(
                             &self.#factor_names,
-                            &app,
-                            #factors_path::ConfigureAppContext::<Self>::new(&app_configs),
+                            #factors_path::ConfigureAppContext::<Self>::new(&app, &app_configs),
+                            &mut runtime_config,
                         )?
                     );
                 )*
@@ -99,7 +105,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
 
             pub fn build_store_data(&self, configured_app: &#ConfiguredApp<Self>, component_id: &str) -> #Result<#state_name> {
                 let app_component = configured_app.app().get_component(component_id).ok_or_else(|| {
-                    #factors_path::Error::msg(format!("unknown component {component_id:?}"))
+                    #wasmtime::Error::msg("unknown component")
                 })?;
                 let mut preparers = #preparers_name {
                     #( #factor_names: None, )*

crates/factors-derive/src/lib.rs

@@ -6,8 +6,11 @@ edition = { workspace = true }
 
 [dependencies]
 anyhow = "1.0"
+serde = "1.0"
 spin-app = { path = "../app" }
 spin-factors-derive = { path = "../factors-derive" }
+thiserror = "1.0"
+tracing = { workspace = true }
 wasmtime = { workspace = true }
 
 [dev-dependencies]