Spin up should check required variables

crates/common/src/env.rs

@@ -0,0 +1,12 @@
+//! Environment variable utilities
+
+/// Defines the default environment variable prefix used by Spin.
+pub const DEFAULT_ENV_PREFIX: &str = "SPIN_VARIABLE";
+
+/// Creates an environment variable key based on the given prefix and key.
+pub fn env_key(prefix: Option<String>, key: &str) -> String {
+    let prefix = prefix.unwrap_or_else(|| DEFAULT_ENV_PREFIX.to_string());
+    let upper_key = key.to_ascii_uppercase();
+    let key = format!("{prefix}_{upper_key}");
+    key
+}

crates/common/src/lib.rs

@@ -10,6 +10,7 @@
 
 pub mod arg_parser;
 pub mod data_dir;
+pub mod env;
 pub mod paths;
 pub mod sha256;
 pub mod sloth;

crates/factors-test/Cargo.toml

@@ -6,6 +6,7 @@ edition = { workspace = true }
 
 [dependencies]
 spin-app = { path = "../app" }
+spin-common = { path = "../common" }
 spin-factors = { path = "../factors" }
 spin-loader = { path = "../loader" }
 spin-telemetry = { path = "../telemetry", features = ["testing"] }

crates/factors-test/src/lib.rs

@@ -1,4 +1,5 @@
 use spin_app::locked::LockedApp;
+use spin_common::env::env_key;
 use spin_factors::{
     anyhow::{self, Context},
     wasmtime::{component::Linker, Config, Engine},
@@ -100,6 +101,8 @@ impl<T: RuntimeFactors> TestEnvironment<T> {
 pub async fn build_locked_app(manifest: &toml::Table) -> anyhow::Result<LockedApp> {
     let toml_str = toml::to_string(manifest).context("failed serializing manifest")?;
     let dir = tempfile::tempdir().context("failed creating tempdir")?;
+    // `foo` variable is set to require. As we're not providing a default value, env is checked.
+    std::env::set_var(env_key(None, "foo"), "baz");
     let path = dir.path().join("spin.toml");
     std::fs::write(&path, toml_str).context("failed writing manifest")?;
     spin_loader::from_file(&path, FilesMountStrategy::Direct, None).await

crates/loader/Cargo.toml

@@ -20,6 +20,7 @@ spin-locked-app = { path = "../locked-app" }
 spin-manifest = { path = "../manifest" }
 spin-outbound-networking-config = { path = "../outbound-networking-config" }
 spin-serde = { path = "../serde" }
+spin-variables = { path = "../variables" }
 tempfile = { workspace = true }
 terminal = { path = "../terminal" }
 tokio = { workspace = true }

crates/loader/src/local.rs

@@ -3,13 +3,14 @@ use std::path::{Path, PathBuf};
 use anyhow::{anyhow, bail, ensure, Context, Result};
 use futures::{future::try_join_all, StreamExt};
 use reqwest::Url;
-use spin_common::{paths::parent_dir, sloth, ui::quoted_path};
+use spin_common::{env::env_key, paths::parent_dir, sloth, ui::quoted_path};
 use spin_locked_app::{
     locked::{
         self, ContentPath, ContentRef, LockedApp, LockedComponent, LockedComponentDependency,
         LockedComponentSource, LockedTrigger,
     },
     values::{ValuesMap, ValuesMapBuilder},
+    Variable,
 };
 use spin_manifest::schema::v2::{self, AppManifest, KebabId, WasiFilesMount};
 use spin_outbound_networking_config::allowed_hosts::{
@@ -88,7 +89,7 @@ impl LocalLoader {
 
         let variables = variables
             .into_iter()
-            .map(|(name, v)| Ok((name.to_string(), locked_variable(v)?)))
+            .map(|(name, v)| Self::env_checker((name.to_string(), locked_variable(v)?)))
             .collect::<Result<_>>()?;
 
         let triggers = triggers
@@ -135,6 +136,21 @@ impl LocalLoader {
         })
     }
 
+    fn env_checker((key, val): (String, Variable)) -> anyhow::Result<(String, Variable)> {
+        if val.default.is_none() {
+            if std::env::var(env_key(None, key.as_ref())).is_err() {
+                Err(anyhow::anyhow!(
+                    "Variable data not provided for {}",
+                    quoted_path(key)
+                ))
+            } else {
+                Ok((key, val))
+            }
+        } else {
+            Ok((key, val))
+        }
+    }
+
     // Load the given component into a LockedComponent, ready for execution.
     async fn load_component(
         &self,

crates/variables/Cargo.toml

@@ -14,6 +14,7 @@ azure_identity = { git = "https://github.com/azure/azure-sdk-for-rust", rev = "8
 azure_security_keyvault = { git = "https://github.com/azure/azure-sdk-for-rust", rev = "8c4caa251c3903d5eae848b41bb1d02a4d65231c" }
 dotenvy = "0.15"
 serde = { workspace = true }
+spin-common = { path = "../common" }
 spin-expressions = { path = "../expressions" }
 spin-factor-variables = { path = "../factor-variables" }
 spin-factors = { path = "../factors" }

crates/variables/src/env.rs

@@ -6,6 +6,7 @@ use std::{
 };
 
 use serde::Deserialize;
+use spin_common::env::env_key;
 use spin_expressions::{Key, Provider};
 use spin_factors::anyhow::{self, Context as _};
 use spin_world::async_trait;
@@ -25,8 +26,6 @@ pub struct EnvVariablesConfig {
     pub dotenv_path: Option<PathBuf>,
 }
 
-const DEFAULT_ENV_PREFIX: &str = "SPIN_VARIABLE";
-
 type EnvFetcherFn = Box<dyn Fn(&str) -> Result<String, VarError> + Send + Sync>;
 
 /// A [`Provider`] that uses environment variables.
@@ -71,14 +70,7 @@ impl EnvVariablesProvider {
 
     /// Gets the value of a variable from the environment.
     fn get_sync(&self, key: &Key) -> anyhow::Result<Option<String>> {
-        let prefix = self
-            .prefix
-            .clone()
-            .unwrap_or_else(|| DEFAULT_ENV_PREFIX.to_string());
-
-        let upper_key = key.as_ref().to_ascii_uppercase();
-        let env_key = format!("{prefix}_{upper_key}");
-
+        let env_key = env_key(self.prefix.clone(), key.as_ref());
         self.query_env(&env_key)
     }