VariablesFactor wip

Signed-off-by: Lann Martin <[email protected]>

Author: lann

Cargo.lock

@@ -6,11 +6,14 @@ 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
 spin-outbound-networking = { path = "../outbound-networking" }
+tracing = { workspace = true }
 
 [lints]
 workspace = true

crates/factor-outbound-networking/Cargo.toml

@@ -1,9 +1,16 @@
 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};
+use spin_factors::{
+    Factor, FactorInstancePreparer, InstancePreparers, PrepareContext, Result, SpinFactors,
+};
+use spin_outbound_networking::{AllowedHostsConfig, ALLOWED_HOSTS_KEY};
 
 pub struct OutboundNetworkingFactor;
 
@@ -17,70 +24,93 @@ 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()
+                        .into_boxed_slice()
+                        .into(),
+                ))
+            })
+            .collect::<Result<_>>()?;
+        Ok(AppConfig {
+            component_allowed_hosts,
+        })
     }
 }
 
 #[derive(Default)]
 pub struct AppConfig {
-    component_allowed_hosts: HashMap<String, Arc<AllowedHostsConfig>>,
+    component_allowed_hosts: HashMap<String, Arc<[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 {
     fn new<Factors: SpinFactors>(
-        _factor: &OutboundNetworkingFactor,
-        app_component: &spin_factors::AppComponent,
-        mut ctx: spin_factors::PrepareContext<Factors>,
+        ctx: PrepareContext<OutboundNetworkingFactor>,
+        mut preparers: InstancePreparers<Factors>,
     ) -> Result<Self> {
-        let allowed_hosts = ctx
-            .app_config::<OutboundNetworkingFactor>()?
+        let hosts = ctx
+            .app_config()
             .component_allowed_hosts
-            .get(app_component.id())
-            .context("missing component")?
-            .clone();
+            .get(ctx.app_component().id())
+            .cloned()
+            .context("missing component allowed hosts")?;
+        let resolver = preparers.get_mut::<VariablesFactor>()?.resolver().clone();
+        let allowed_hosts_future = async move {
+            let prepared = resolver.prepare().await?;
+            AllowedHostsConfig::parse(&hosts, &prepared)
+        }
+        .map(Arc::new)
+        .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 {
-            AllowedHostsConfig::All => wasi_preparer.inherit_network(),
-            AllowedHostsConfig::SpecificHosts(configs) => {
-                for config in configs {
-                    if config.scheme().allows_any() {
-                        match (config.host(), config.port()) {
-                            (HostConfig::Cidr(ip_net), PortConfig::Any) => {
-                                wasi_preparer.socket_allow_ports(*ip_net, 0, None)
-                            }
-                            _ => todo!(), // TODO: complete and validate against existing Network TriggerHooks
-                        }
+        let wasi_preparer = preparers.get_mut::<WasiFactor>()?;
+        let hosts_future = allowed_hosts_future.clone();
+        wasi_preparer.outbound_socket_addr_check(move |addr| {
+            let hosts_future = hosts_future.clone();
+            async move {
+                match &*hosts_future.await {
+                    Ok(allowed_hosts) => {
+                        // TODO: verify this actually works...
+                        spin_outbound_networking::check_url(&addr.to_string(), "*", allowed_hosts)
+                    }
+                    Err(err) => {
+                        // TODO: should this trap (somehow)?
+                        tracing::error!(%err, "allowed_outbound_hosts variable resolution failed");
+                        false
                     }
                 }
             }
-        }
-
-        Ok(Self { allowed_hosts })
+        });
+        Ok(Self {
+            allowed_hosts_future,
+        })
     }
 
     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-outbound-networking/src/lib.rs

@@ -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/Cargo.toml

@@ -0,0 +1,125 @@
+use std::sync::Arc;
+
+use spin_expressions::ProviderResolver;
+use spin_factors::{
+    Factor, FactorInstancePreparer, InstancePreparers, PrepareContext, 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>(
+        ctx: PrepareContext<VariablesFactor>,
+        _preparers: InstancePreparers<Factors>,
+    ) -> 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) -> 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}")),
+    }
+}