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]>

rename: VariablesPreparationExecutorHook

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

Author: seun-ja

Cargo.lock

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

crates/expressions/Cargo.toml

@@ -3,7 +3,6 @@ mod template;
 
 use std::{borrow::Cow, collections::HashMap, fmt::Debug};
 
-use spin_common::ui::quoted_path;
 use spin_locked_app::Variable;
 
 pub use async_trait;
@@ -12,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>>>;
@@ -91,15 +92,27 @@ 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() {
-            if self.resolve_variable(name).await.is_err() {
-                eprintln!(
-                    "Default value not found for variable: {}",
-                    quoted_path(name)
-                );
+            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(())
     }
 
@@ -322,6 +335,8 @@ pub enum Error {
 mod tests {
     use async_trait::async_trait;
 
+    use crate::provider::ProviderVariableKind;
+
     use super::*;
 
     #[derive(Debug)]
@@ -336,6 +351,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
+    #[default]
+    Static,
+    /// Variable can be made available at runtime
+    Dynamic,
 }

crates/expressions/src/provider.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, VariablesPreparationExecutorHooks,
+    StdioLoggingExecutorHooks, VariablesPreparationExecutorHook,
 };
 use spin_variables_static::StaticVariablesProvider;
 
@@ -72,7 +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(VariablesPreparationExecutorHooks);
+        executor.add_hooks(VariablesPreparationExecutorHook);
 
         let max_instance_memory = args
             .max_instance_memory

crates/runtime-factors/src/build.rs

@@ -26,7 +26,7 @@ pub use sqlite_statements::SqlStatementExecutorHook;
 use stdio::FollowComponents;
 pub use stdio::StdioLoggingExecutorHooks;
 pub use summary::{KeyValueDefaultStoreSummaryHook, SqliteDefaultStoreSummaryHook};
-pub use variable::VariablesPreparationExecutorHooks;
+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

@@ -2,10 +2,11 @@ use spin_factor_variables::VariablesFactor;
 use spin_factors::RuntimeFactors;
 use spin_factors_executor::ExecutorHooks;
 
-pub struct VariablesPreparationExecutorHooks;
+/// 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 VariablesPreparationExecutorHooks {
+impl<F: RuntimeFactors, U> ExecutorHooks<F, U> for VariablesPreparationExecutorHook {
     async fn configure_app(
         &self,
         configured_app: &spin_factors::ConfiguredApp<F>,

crates/trigger/src/cli/variable.rs

@@ -4,7 +4,7 @@ use anyhow::Context as _;
 use azure_core::{auth::TokenCredential, Url};
 use azure_security_keyvault::SecretClient;
 use serde::Deserialize;
-use spin_expressions::{Key, Provider};
+use spin_expressions::{provider::ProviderVariableKind, Key, Provider};
 use spin_factors::anyhow;
 use spin_world::async_trait;
 use tracing::{instrument, Level};
@@ -107,6 +107,7 @@ pub enum AzureKeyVaultAuthOptions {
 #[derive(Debug)]
 pub struct AzureKeyVaultProvider {
     secret_client: SecretClient,
+    kind: ProviderVariableKind,
 }
 
 impl AzureKeyVaultProvider {
@@ -136,6 +137,7 @@ impl AzureKeyVaultProvider {
 
         Ok(Self {
             secret_client: SecretClient::new(&vault_url.into(), token_credential)?,
+            kind: ProviderVariableKind::Dynamic,
         })
     }
 }
@@ -151,6 +153,10 @@ impl Provider for AzureKeyVaultProvider {
             .context("Failed to read variable from Azure Key Vault")?;
         Ok(Some(secret.value))
     }
+
+    fn kind(&self) -> &ProviderVariableKind {
+        &self.kind
+    }
 }
 
 impl From<AzureAuthorityHost> for Url {

crates/variables-azure/src/lib.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use serde::Deserialize;
-use spin_expressions::{Key, Provider};
+use spin_expressions::{provider::ProviderVariableKind, Key, Provider};
 use spin_factors::anyhow::{self, Context as _};
 use spin_world::async_trait;
 use tracing::{instrument, Level};
@@ -35,6 +35,7 @@ pub struct EnvVariablesProvider {
     env_fetcher: EnvFetcherFn,
     dotenv_path: Option<PathBuf>,
     dotenv_cache: OnceLock<HashMap<String, String>>,
+    kind: ProviderVariableKind,
 }
 
 impl Default for EnvVariablesProvider {
@@ -44,6 +45,7 @@ impl Default for EnvVariablesProvider {
             env_fetcher: Box::new(|s| std::env::var(s)),
             dotenv_path: Some(".env".into()),
             dotenv_cache: Default::default(),
+            kind: Default::default(),
         }
     }
 }
@@ -66,6 +68,7 @@ impl EnvVariablesProvider {
             dotenv_path,
             env_fetcher: Box::new(env_fetcher),
             dotenv_cache: Default::default(),
+            kind: ProviderVariableKind::Static,
         }
     }
 
@@ -132,6 +135,10 @@ impl Provider for EnvVariablesProvider {
     async fn get(&self, key: &Key) -> anyhow::Result<Option<String>> {
         tokio::task::block_in_place(|| self.get_sync(key))
     }
+
+    fn kind(&self) -> &ProviderVariableKind {
+        &self.kind
+    }
 }
 
 #[cfg(test)]