Adds new dynamism metadata for Providers

New logic only allows no default variable before runtime if Provider it is of a Dynamic type

Signed-off-by: Aminu Oluwaseun Joshua <[email protected]>

Author: seun-ja

Cargo.lock

@@ -8,6 +8,7 @@ edition = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 futures = { workspace = true }
+serde = { workspace = true }
 spin-locked-app = { path = "../locked-app" }
 thiserror = { workspace = true }
 

crates/expressions/Cargo.toml

@@ -11,6 +11,8 @@ pub use provider::Provider;
 use template::Part;
 pub use template::Template;
 
+use crate::provider::ProviderVariableKind;
+
 /// A [`ProviderResolver`] that can be shared.
 pub type SharedPreparedResolver =
     std::sync::Arc<std::sync::OnceLock<std::sync::Arc<PreparedResolver>>>;
@@ -90,6 +92,30 @@ impl ProviderResolver {
         Ok(PreparedResolver { variables })
     }
 
+    /// Prepares the resolver by attempting to resolve all variables, printing warnings for any
+    /// that cannot be resolved.
+    pub async fn pre_runtime_prepare(&self) -> Result<()> {
+        for name in self.internal.variables.keys() {
+            self.check_variable_existence(name).await?;
+        }
+        Ok(())
+    }
+
+    async fn check_variable_existence(&self, key: &str) -> Result<()> {
+        for provider in &self.providers {
+            if provider.kind() == &ProviderVariableKind::Dynamic {
+                continue;
+            }
+
+            match provider.get(&Key(key)).await {
+                Ok(Some(_)) => return Ok(()),
+                Err(_) | Ok(None) => return self.internal.resolve_variable(key).map(|_| ()),
+            }
+        }
+
+        Ok(())
+    }
+
     async fn resolve_variable(&self, key: &str) -> Result<String> {
         for provider in &self.providers {
             if let Some(value) = provider.get(&Key(key)).await.map_err(Error::Provider)? {
@@ -310,6 +336,7 @@ mod tests {
     use async_trait::async_trait;
 
     use super::*;
+    use crate::provider::ProviderVariableKind;
 
     #[derive(Debug)]
     struct TestProvider;
@@ -323,6 +350,10 @@ mod tests {
                 _ => Ok(None),
             }
         }
+
+        fn kind(&self) -> &ProviderVariableKind {
+            &ProviderVariableKind::Static
+        }
     }
 
     async fn test_resolve(template: &str) -> Result<String> {

crates/expressions/src/lib.rs

@@ -1,6 +1,7 @@
 use std::fmt::Debug;
 
 use async_trait::async_trait;
+use serde::Deserialize;
 
 use crate::Key;
 
@@ -9,4 +10,15 @@ use crate::Key;
 pub trait Provider: Debug + Send + Sync {
     /// Returns the value at the given config path, if it exists.
     async fn get(&self, key: &Key) -> anyhow::Result<Option<String>>;
+    fn kind(&self) -> &ProviderVariableKind;
+}
+
+/// The dynamism of a Provider.
+#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
+pub enum ProviderVariableKind {
+    /// Variable must be declared on start
+    Static,
+    /// Variable can be made available at runtime
+    #[default]
+    Dynamic,
 }

crates/expressions/src/provider.rs

@@ -85,6 +85,10 @@ impl AppState {
         let template = Template::new(expr)?;
         self.expression_resolver.resolve_template(&template).await
     }
+
+    pub fn expression_resolver(&self) -> &Arc<ExpressionResolver> {
+        &self.expression_resolver
+    }
 }
 
 pub struct InstanceState {

crates/factor-variables/src/lib.rs

@@ -1,4 +1,4 @@
-use spin_expressions::{Key, Provider};
+use spin_expressions::{provider::ProviderVariableKind, Key, Provider};
 use spin_factor_variables::{runtime_config::RuntimeConfig, VariablesFactor};
 use spin_factors::{anyhow, RuntimeFactors};
 use spin_factors_test::{toml, TestEnvironment};
@@ -46,4 +46,8 @@ impl Provider for MockProvider {
             _ => Ok(None),
         }
     }
+
+    fn kind(&self) -> &ProviderVariableKind {
+        &ProviderVariableKind::Static
+    }
 }

crates/factor-variables/tests/factor_test.rs

@@ -8,7 +8,7 @@ use spin_runtime_config::ResolvedRuntimeConfig;
 use spin_trigger::cli::{
     FactorsConfig, InitialKvSetterHook, KeyValueDefaultStoreSummaryHook, MaxInstanceMemoryHook,
     RuntimeFactorsBuilder, SqlStatementExecutorHook, SqliteDefaultStoreSummaryHook,
-    StdioLoggingExecutorHooks,
+    StdioLoggingExecutorHooks, VariablesPreparationExecutorHook,
 };
 use spin_variables_static::StaticVariablesProvider;
 
@@ -72,6 +72,7 @@ impl RuntimeFactorsBuilder for FactorsBuilder {
         executor.add_hooks(InitialKvSetterHook::new(args.key_values.clone()));
         executor.add_hooks(SqliteDefaultStoreSummaryHook);
         executor.add_hooks(KeyValueDefaultStoreSummaryHook);
+        executor.add_hooks(VariablesPreparationExecutorHook);
 
         let max_instance_memory = args
             .max_instance_memory

crates/runtime-factors/src/build.rs

@@ -28,6 +28,7 @@ spin-compose = { path = "../compose" }
 spin-core = { path = "../core" }
 spin-factor-key-value = { path = "../factor-key-value" }
 spin-factor-sqlite = { path = "../factor-sqlite" }
+spin-factor-variables = { path = "../factor-variables" }
 spin-factor-wasi = { path = "../factor-wasi" }
 spin-factors = { path = "../factors" }
 spin-factors-executor = { path = "../factors-executor" }

crates/trigger/Cargo.toml

@@ -4,6 +4,7 @@ mod max_instance_memory;
 mod sqlite_statements;
 mod stdio;
 mod summary;
+mod variable;
 
 use std::path::PathBuf;
 use std::{future::Future, sync::Arc};
@@ -25,6 +26,7 @@ pub use sqlite_statements::SqlStatementExecutorHook;
 use stdio::FollowComponents;
 pub use stdio::StdioLoggingExecutorHooks;
 pub use summary::{KeyValueDefaultStoreSummaryHook, SqliteDefaultStoreSummaryHook};
+pub use variable::VariablesPreparationExecutorHook;
 
 pub const APP_LOG_DIR: &str = "APP_LOG_DIR";
 pub const SPIN_TRUNCATE_LOGS: &str = "SPIN_TRUNCATE_LOGS";

crates/trigger/src/cli.rs

@@ -0,0 +1,21 @@
+use spin_factor_variables::VariablesFactor;
+use spin_factors::RuntimeFactors;
+use spin_factors_executor::ExecutorHooks;
+
+/// An executor hook that prepares the variables factor before runtime execution.
+pub struct VariablesPreparationExecutorHook;
+
+#[spin_core::async_trait]
+impl<F: RuntimeFactors, U> ExecutorHooks<F, U> for VariablesPreparationExecutorHook {
+    async fn configure_app(
+        &self,
+        configured_app: &spin_factors::ConfiguredApp<F>,
+    ) -> anyhow::Result<()> {
+        let variables_factor = configured_app.app_state::<VariablesFactor>()?;
+
+        let expression_resolver = variables_factor.expression_resolver();
+        expression_resolver.pre_runtime_prepare().await?;
+
+        Ok(())
+    }
+}