factors: Add VariablesFactor runtime config

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

Author: lann

Cargo.lock

@@ -5,6 +5,8 @@ use std::{borrow::Cow, collections::HashMap, fmt::Debug};
 
 use spin_locked_app::Variable;
 
+pub use async_trait;
+
 pub use provider::Provider;
 use template::Part;
 pub use template::Template;
@@ -251,6 +253,14 @@ impl<'a> Key<'a> {
     }
 }
 
+impl<'a> TryFrom<&'a str> for Key<'a> {
+    type Error = Error;
+
+    fn try_from(value: &'a str) -> std::prelude::v1::Result<Self, Self::Error> {
+        Self::new(value)
+    }
+}
+
 impl<'a> AsRef<str> for Key<'a> {
     fn as_ref(&self) -> &str {
         self.0

crates/expressions/src/lib.rs

@@ -91,14 +91,12 @@ impl Factor for OutboundNetworkingFactor {
     }
 }
 
-#[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 InstanceBuilder {
     allowed_hosts_future: Option<SharedFutureResult<AllowedHostsConfig>>,
 }

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

@@ -5,9 +5,11 @@ authors = { workspace = true }
 edition = { workspace = true }
 
 [dependencies]
+serde = { version = "1.0", features = ["rc"] }
 spin-expressions = { path = "../expressions" }
 spin-factors = { path = "../factors" }
 spin-world = { path = "../world" }
+toml = "0.8"
 
 [lints]
 workspace = true

crates/factor-variables/Cargo.toml

@@ -1,18 +1,44 @@
-use std::sync::Arc;
+mod provider_type;
 
+use std::{collections::HashMap, sync::Arc};
+
+use provider_type::{provider_maker, ProviderMaker};
+use serde::Deserialize;
 use spin_expressions::ProviderResolver;
 use spin_factors::{
-    anyhow, ConfigureAppContext, Factor, FactorInstanceBuilder, InitContext, InstanceBuilders,
-    PrepareContext, RuntimeFactors,
+    anyhow::{self, bail, Context},
+    ConfigureAppContext, Factor, FactorRuntimeConfig, InitContext, InstanceBuilders,
+    PrepareContext, RuntimeFactors, SelfInstanceBuilder,
 };
 use spin_world::{async_trait, v1::config as v1_config, v2::variables};
 
-pub struct VariablesFactor;
+pub use provider_type::{StaticVariables, VariablesProviderType};
+
+#[derive(Default)]
+pub struct VariablesFactor {
+    provider_types: HashMap<&'static str, ProviderMaker>,
+}
+
+impl VariablesFactor {
+    pub fn add_provider_type<T: VariablesProviderType>(
+        &mut self,
+        provider_type: T,
+    ) -> anyhow::Result<()> {
+        if self
+            .provider_types
+            .insert(T::TYPE, provider_maker(provider_type))
+            .is_some()
+        {
+            bail!("duplicate provider type {:?}", T::TYPE);
+        }
+        Ok(())
+    }
+}
 
 impl Factor for VariablesFactor {
-    type RuntimeConfig = ();
+    type RuntimeConfig = RuntimeConfig;
     type AppState = AppState;
-    type InstanceBuilder = InstanceBuilder;
+    type InstanceBuilder = InstanceState;
 
     fn init<Factors: RuntimeFactors>(
         &mut self,
@@ -25,18 +51,30 @@ impl Factor for VariablesFactor {
 
     fn configure_app<T: RuntimeFactors>(
         &self,
-        ctx: ConfigureAppContext<T, Self>,
+        mut ctx: ConfigureAppContext<T, Self>,
     ) -> anyhow::Result<Self::AppState> {
         let app = ctx.app();
         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
+
+        if let Some(runtime_config) = ctx.take_runtime_config() {
+            for ProviderConfig { type_, config } in runtime_config.provider_configs {
+                let provider_maker = self
+                    .provider_types
+                    .get(type_.as_str())
+                    .with_context(|| format!("unknown variables provider type {type_}"))?;
+                let provider = provider_maker(config)?;
+                resolver.add_provider(provider);
+            }
+        }
+
         Ok(AppState {
             resolver: Arc::new(resolver),
         })
@@ -45,47 +83,51 @@ impl Factor for VariablesFactor {
     fn prepare<T: RuntimeFactors>(
         ctx: PrepareContext<Self>,
         _builders: &mut InstanceBuilders<T>,
-    ) -> anyhow::Result<InstanceBuilder> {
+    ) -> anyhow::Result<InstanceState> {
         let component_id = ctx.app_component().id().to_string();
         let resolver = ctx.app_state().resolver.clone();
-        Ok(InstanceBuilder {
-            state: InstanceState {
-                component_id,
-                resolver,
-            },
+        Ok(InstanceState {
+            component_id,
+            resolver,
         })
     }
 }
 
-#[derive(Default)]
-pub struct AppState {
-    resolver: Arc<ProviderResolver>,
+#[derive(Deserialize)]
+#[serde(transparent)]
+pub struct RuntimeConfig {
+    provider_configs: Vec<ProviderConfig>,
 }
 
-pub struct InstanceBuilder {
-    state: InstanceState,
+impl FactorRuntimeConfig for RuntimeConfig {
+    const KEY: &'static str = "variable_provider";
 }
 
-impl InstanceBuilder {
-    pub fn resolver(&self) -> &Arc<ProviderResolver> {
-        &self.state.resolver
-    }
+#[derive(Deserialize)]
+struct ProviderConfig {
+    #[serde(rename = "type")]
+    type_: String,
+    #[serde(flatten)]
+    config: toml::Table,
 }
 
-impl FactorInstanceBuilder for InstanceBuilder {
-    type InstanceState = InstanceState;
-
-    fn build(self) -> anyhow::Result<Self::InstanceState> {
-        Ok(self.state)
-    }
+pub struct AppState {
+    resolver: Arc<ProviderResolver>,
 }
 
-#[derive(Default)]
 pub struct InstanceState {
     component_id: String,
     resolver: Arc<ProviderResolver>,
 }
 
+impl InstanceState {
+    pub fn resolver(&self) -> &Arc<ProviderResolver> {
+        &self.resolver
+    }
+}
+
+impl SelfInstanceBuilder for InstanceState {}
+
 #[async_trait]
 impl variables::Host for InstanceState {
     async fn get(&mut self, key: String) -> Result<String, variables::Error> {

crates/factor-variables/src/lib.rs

@@ -0,0 +1,49 @@
+use std::{collections::HashMap, sync::Arc};
+
+use serde::{de::DeserializeOwned, Deserialize};
+use spin_expressions::{async_trait::async_trait, Key, Provider};
+use spin_factors::anyhow;
+
+pub trait VariablesProviderType: 'static {
+    const TYPE: &'static str;
+
+    type RuntimeConfig: DeserializeOwned;
+    type Provider: Provider;
+
+    fn make_provider(&self, runtime_config: Self::RuntimeConfig) -> anyhow::Result<Self::Provider>;
+}
+
+pub(crate) type ProviderMaker = Box<dyn Fn(toml::Table) -> anyhow::Result<Box<dyn Provider>>>;
+
+pub(crate) fn provider_maker<T: VariablesProviderType>(provider_type: T) -> ProviderMaker {
+    Box::new(move |table| {
+        let runtime_config: T::RuntimeConfig = table.try_into()?;
+        let provider = provider_type.make_provider(runtime_config)?;
+        Ok(Box::new(provider))
+    })
+}
+
+pub struct StaticVariables;
+
+impl VariablesProviderType for StaticVariables {
+    const TYPE: &'static str = "static";
+
+    type RuntimeConfig = StaticVariablesProvider;
+    type Provider = StaticVariablesProvider;
+
+    fn make_provider(&self, runtime_config: Self::RuntimeConfig) -> anyhow::Result<Self::Provider> {
+        Ok(runtime_config)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct StaticVariablesProvider {
+    values: Arc<HashMap<String, String>>,
+}
+
+#[async_trait]
+impl Provider for StaticVariablesProvider {
+    async fn get(&self, key: &Key) -> anyhow::Result<Option<String>> {
+        Ok(self.values.get(key.as_str()).cloned())
+    }
+}

crates/factor-variables/src/provider_type.rs

@@ -104,6 +104,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
                         )?
                     );
                 )*
+                runtime_config_tracker.validate_all_keys_used()?;
                 Ok(#ConfiguredApp::new(app, app_state))
             }
 
@@ -142,32 +143,29 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
             type InstanceBuilders = #builders_name;
             type InstanceState = #state_name;
 
-            unsafe fn instance_builder_offset<T: #Factor>() -> Option<usize> {
-                let type_id = #TypeId::of::<T>();
+            fn app_state<F: #Factor>(app_state: &Self::AppState) -> Option<&F::AppState> {
+                let type_id = #TypeId::of::<F>();
                 #(
                     if type_id == #TypeId::of::<#factor_types>() {
-                        return Some(std::mem::offset_of!(Self::InstanceBuilders, #factor_names));
+                        unsafe {
+                            return Some(::std::mem::transmute(&app_state.#factor_names));
+                        }
                     }
                 )*
                 None
             }
 
-            unsafe fn instance_state_offset<T: #Factor>() -> Option<usize> {
-                let type_id = #TypeId::of::<T>();
+            fn instance_builder_mut<F: #Factor>(
+                builders: &mut Self::InstanceBuilders,
+            ) -> Option<Option<&mut F::InstanceBuilder>> {
+                let type_id = #TypeId::of::<F>();
                 #(
                     if type_id == #TypeId::of::<#factor_types>() {
-                        return Some(std::mem::offset_of!(Self::InstanceState, #factor_names));
-                    }
-                )*
-                None
-
-            }
-
-            fn app_state<T: #Factor>(app_state: &Self::AppState) -> Option<&T::AppState> {
-                let type_id = #TypeId::of::<T>();
-                #(
-                    if type_id == #TypeId::of::<#factor_types>() {
-                        return Some(unsafe { std::mem::transmute(&app_state.#factor_names) });
+                        return Some(
+                            builders.#factor_names.as_mut().map(|builder| {
+                                unsafe { ::std::mem::transmute(builder) }
+                            })
+                        );
                     }
                 )*
                 None

crates/factors-derive/src/lib.rs

@@ -19,6 +19,8 @@ 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" }
+tokio = { version = "1", features = ["macros", "rt"] }
+toml = "0.8"
 
 [lints]
 workspace = true

crates/factors/Cargo.toml

@@ -10,7 +10,7 @@ pub use spin_factors_derive::RuntimeFactors;
 
 pub use crate::{
     factor::{ConfigureAppContext, ConfiguredApp, Factor, InitContext},
-    prepare::{FactorInstanceBuilder, InstanceBuilders, PrepareContext},
+    prepare::{FactorInstanceBuilder, InstanceBuilders, PrepareContext, SelfInstanceBuilder},
     runtime_config::{FactorRuntimeConfig, RuntimeConfigSource},
     runtime_factors::RuntimeFactors,
 };