VariablesFactor wip

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

Author: lann

crates/factor-outbound-networking/Cargo.toml

@@ -6,7 +6,9 @@ edition = { workspace = true }
 
 [dependencies]
 anyhow = "1"
+futures-util = "0.3"
 ipnet = "2.9.0"
+spin-factor-variables = { path = "../factor-variables" }
 spin-factor-wasi = { path = "../factor-wasi" }
 spin-factors = { path = "../factors" }
 # TODO: merge with this crate

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

@@ -1,6 +1,8 @@
 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, Result, SpinFactors};
 use spin_outbound_networking::{AllowedHostsConfig, HostConfig, PortConfig, ALLOWED_HOSTS_KEY};
@@ -17,33 +19,34 @@ impl Factor for OutboundNetworkingFactor {
         app: &spin_factors::App,
         _ctx: spin_factors::ConfigureAppContext<Factors>,
     ) -> Result<Self::AppConfig> {
-        let mut cfg = AppConfig::default();
-        // TODO: resolve resolver resolution
-        let resolver = Default::default();
-        for component in app.components() {
-            if let Some(hosts) = component.get_metadata(ALLOWED_HOSTS_KEY)? {
-                let allowed_hosts = AllowedHostsConfig::parse(&hosts, &resolver)?;
-                cfg.component_allowed_hosts
-                    .insert(component.id().to_string(), Arc::new(allowed_hosts));
-            }
-        }
-        Ok(cfg)
+        // Extract allowed_outbound_hosts for all components
+        let component_allowed_hosts = app
+            .components()
+            .map(|component| {
+                Ok((
+                    component.id().to_string(),
+                    component
+                        .get_metadata(ALLOWED_HOSTS_KEY)?
+                        .unwrap_or_default(),
+                ))
+            })
+            .collect::<Result<_>>()?;
+
+        Ok(AppConfig {
+            component_allowed_hosts,
+        })
     }
 }
 
 #[derive(Default)]
 pub struct AppConfig {
-    component_allowed_hosts: HashMap<String, Arc<AllowedHostsConfig>>,
+    component_allowed_hosts: HashMap<String, Vec<String>>,
 }
 
-pub struct InstancePreparer {
-    allowed_hosts: Arc<AllowedHostsConfig>,
-}
+type AllowedHostsFuture = Shared<BoxFuture<'static, Arc<anyhow::Result<AllowedHostsConfig>>>>;
 
-impl InstancePreparer {
-    pub fn allowed_hosts(&self) -> &Arc<AllowedHostsConfig> {
-        &self.allowed_hosts
-    }
+pub struct InstancePreparer {
+    allowed_hosts_future: AllowedHostsFuture,
 }
 
 impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
@@ -52,16 +55,26 @@ impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
         app_component: &spin_factors::AppComponent,
         mut ctx: spin_factors::PrepareContext<Factors>,
     ) -> Result<Self> {
-        let allowed_hosts = ctx
-            .app_config::<OutboundNetworkingFactor>()?
-            .component_allowed_hosts
-            .get(app_component.id())
-            .context("missing component")?
-            .clone();
+        let hosts = 
+            ctx.app_config::<OutboundNetworkingFactor>()
+                .unwrap()
+                .component_allowed_hosts
+                .get(app_component.id())
+                .context("missing component allowed hosts")?;
+        let resolver = ctx.instance_preparer_mut::<VariablesFactor>()?.resolver().clone();
+        let allowed_hosts_future = async move {
+            let prepared = resolver.prepare().await?;
+            Ok(AllowedHostsConfig::parse(&hosts, &prepared))
+        }.boxed().shared();
+        let prepared_resolver = resolver.prepare().await?;
+        let allowed_hosts = AllowedHostsConfig::parse(
+                .context("missing component allowed hosts")?,
+            &prepared_resolver,
+        )?;
 
         // Update Wasi socket allowed ports
         let wasi_preparer = ctx.instance_preparer_mut::<WasiFactor>()?;
-        match &*allowed_hosts {
+        match &allowed_hosts {
             AllowedHostsConfig::All => wasi_preparer.inherit_network(),
             AllowedHostsConfig::SpecificHosts(configs) => {
                 for config in configs {
@@ -77,10 +90,18 @@ impl FactorInstancePreparer<OutboundNetworkingFactor> for InstancePreparer {
             }
         }
 
-        Ok(Self { allowed_hosts })
+        Ok(Self {
+            allowed_hosts: Arc::new(allowed_hosts),
+        })
     }
 
     fn prepare(self) -> Result<<OutboundNetworkingFactor as Factor>::InstanceState> {
         Ok(())
     }
 }
+
+impl InstancePreparer {
+    pub async fn resolve_allowed_hosts(&self) -> Arc<anyhow::Result<AllowedHostsConfig>> {
+        self.allowed_hosts_future.clone().await
+    }
+}

crates/factor-variables/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "spin-factor-variables"
+version = { workspace = true }
+authors = { workspace = true }
+edition = { workspace = true }
+
+[dependencies]
+anyhow = "1"
+spin-expressions = { path = "../expressions" }
+spin-factors = { path = "../factors" }
+spin-world = { path = "../world" }
+
+[lints]
+workspace = true

crates/factor-variables/src/lib.rs

@@ -0,0 +1,128 @@
+use std::sync::Arc;
+
+use spin_expressions::ProviderResolver;
+use spin_factors::{Factor, FactorInstancePreparer, Result, SpinFactors};
+use spin_world::{async_trait, v1::config as v1_config, v2::variables};
+
+pub struct VariablesFactor;
+
+impl Factor for VariablesFactor {
+    type AppConfig = AppConfig;
+    type InstancePreparer = InstancePreparer;
+    type InstanceState = InstanceState;
+
+    fn init<Factors: SpinFactors>(
+        &mut self,
+        mut ctx: spin_factors::InitContext<Factors, Self>,
+    ) -> 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> {
+        let mut resolver =
+            ProviderResolver::new(app.variables().map(|(key, val)| (key.clone(), val.clone())))?;
+        for component in app.components() {
+            resolver.add_component_variables(
+                component.id(),
+                component.config().map(|(k, v)| (k.into(), v.into())),
+            )?;
+        }
+        // TODO: add providers from runtime config
+        Ok(AppConfig {
+            resolver: Arc::new(resolver),
+        })
+    }
+}
+
+#[derive(Default)]
+pub struct AppConfig {
+    resolver: Arc<ProviderResolver>,
+}
+
+pub struct InstancePreparer {
+    state: InstanceState,
+}
+
+impl InstancePreparer {
+    pub fn resolver(&self) -> &Arc<ProviderResolver> {
+        &self.state.resolver
+    }
+}
+
+impl FactorInstancePreparer<VariablesFactor> for InstancePreparer {
+    fn new<Factors: SpinFactors>(
+        _factor: &VariablesFactor,
+        app_component: &spin_factors::AppComponent,
+        ctx: spin_factors::PrepareContext<Factors>,
+    ) -> Result<Self> {
+        let component_id = app_component.id().to_string();
+        let resolver = ctx
+            .app_config::<VariablesFactor>()
+            .unwrap()
+            .resolver
+            .clone();
+        Ok(Self {
+            state: InstanceState {
+                component_id,
+                resolver,
+            },
+        })
+    }
+
+    fn prepare(self) -> Result<<VariablesFactor as Factor>::InstanceState> {
+        Ok(self.state)
+    }
+}
+
+pub struct InstanceState {
+    component_id: String,
+    resolver: Arc<ProviderResolver>,
+}
+
+#[async_trait]
+impl variables::Host for InstanceState {
+    async fn get(&mut self, key: String) -> Result<String, variables::Error> {
+        let key = spin_expressions::Key::new(&key).map_err(expressions_to_variables_err)?;
+        self.resolver
+            .resolve(&self.component_id, key)
+            .await
+            .map_err(expressions_to_variables_err)
+    }
+
+    fn convert_error(&mut self, error: variables::Error) -> Result<variables::Error> {
+        Ok(error)
+    }
+}
+
+#[async_trait]
+impl v1_config::Host for InstanceState {
+    async fn get_config(&mut self, key: String) -> Result<String, v1_config::Error> {
+        <Self as variables::Host>::get(self, key)
+            .await
+            .map_err(|err| match err {
+                variables::Error::InvalidName(msg) => v1_config::Error::InvalidKey(msg),
+                variables::Error::Undefined(msg) => v1_config::Error::Provider(msg),
+                other => v1_config::Error::Other(format!("{other}")),
+            })
+    }
+
+    fn convert_error(&mut self, err: v1_config::Error) -> anyhow::Result<v1_config::Error> {
+        Ok(err)
+    }
+}
+
+fn expressions_to_variables_err(err: spin_expressions::Error) -> variables::Error {
+    use spin_expressions::Error;
+    match err {
+        Error::InvalidName(msg) => variables::Error::InvalidName(msg),
+        Error::Undefined(msg) => variables::Error::Undefined(msg),
+        Error::Provider(err) => variables::Error::Provider(err.to_string()),
+        other => variables::Error::Other(format!("{other}")),
+    }
+}

crates/factors/Cargo.toml

@@ -14,6 +14,7 @@ wasmtime = { workspace = true }
 serde_json = "1.0"
 spin-factors-derive = { path = "../factors-derive", features = ["expander"] }
 spin-factor-outbound-networking = { path = "../factor-outbound-networking" }
+spin-factor-variables = { path = "../factor-variables" }
 spin-factor-wasi = { path = "../factor-wasi" }
 
 [lints]

crates/factors/src/lib.rs

@@ -37,10 +37,9 @@ pub trait Factor: Any + Sized {
     }
 
     /// Performs factor-specific validation and configuration for the given
-    /// [`App`] and [`RuntimeConfig`]. A runtime may - but is not required to -
-    /// reuse the returned config across multiple instances. Note that this may
-    /// be called without any call to `init` in cases where only validation is
-    /// needed.
+    /// [`App`]. A runtime may - but is not required to - reuse the returned
+    /// config across multiple instances. Note that this may be called without
+    /// any call to `init` in cases where only validation is needed.
     fn configure_app<Factors: SpinFactors>(
         &self,
         app: &App,
@@ -150,6 +149,8 @@ pub trait FactorInstancePreparer<T: Factor>: Sized {
 /// to any already-initialized [`FactorInstancePreparer`]s, allowing for
 /// inter-[`Factor`] dependencies.
 pub struct PrepareContext<'a, Factors: SpinFactors> {
+    // TODO(lann): mixing & and &mut like this seems like a recipe for pain
+    // later; maybe use context only for & and separate params for &mut?
     configured_app: &'a ConfiguredApp<Factors>,
     instance_preparers: &'a mut Factors::InstancePreparers,
 }

crates/factors/tests/smoke.rs

@@ -1,19 +1,22 @@
 use spin_app::App;
 use spin_factor_outbound_networking::OutboundNetworkingFactor;
+use spin_factor_variables::VariablesFactor;
 use spin_factor_wasi::{preview1::WasiPreview1Factor, DummyFilesMounter, WasiFactor};
 use spin_factors::SpinFactors;
 
 #[derive(SpinFactors)]
 struct Factors {
     wasi: WasiFactor,
     wasip1: WasiPreview1Factor,
+    variables: VariablesFactor,
     outbound_networking_factor: OutboundNetworkingFactor,
 }
 
 fn main() -> anyhow::Result<()> {
     let mut factors = Factors {
         wasi: WasiFactor::new(DummyFilesMounter),
         wasip1: WasiPreview1Factor,
+        variables: VariablesFactor,
         outbound_networking_factor: OutboundNetworkingFactor,
         // outbound_http_factor: OutboundHttpFactor,
     };

crates/world/Cargo.toml

@@ -5,4 +5,5 @@ authors = { workspace = true }
 edition = { workspace = true }
 
 [dependencies]
+async-trait = "0.1"
 wasmtime = { workspace = true }

crates/world/src/lib.rs

@@ -1,5 +1,7 @@
 #![allow(missing_docs)]
 
+pub use async_trait::async_trait;
+
 wasmtime::component::bindgen!({
     inline: r#"
     package fermyon:runtime;