Allow providing static variables via the cli (#3216)

Signed-off-by: Brian Hardock <[email protected]>

Author: fibonacci1729

Cargo.lock

@@ -32,6 +32,7 @@ spin-factors = { path = "../factors" }
 spin-factors-executor = { path = "../factors-executor" }
 spin-runtime-config = { path = "../runtime-config" }
 spin-trigger = { path = "../trigger" }
+spin-variables-static = { path = "../variables-static" }
 terminal = { path = "../terminal" }
 tracing = { workspace = true }
 

crates/runtime-factors/Cargo.toml

@@ -10,6 +10,7 @@ use spin_trigger::cli::{
     RuntimeFactorsBuilder, SqlStatementExecutorHook, SqliteDefaultStoreSummaryHook,
     StdioLoggingExecutorHooks,
 };
+use spin_variables_static::StaticVariablesProvider;
 
 /// A [`RuntimeFactorsBuilder`] for [`TriggerFactors`].
 pub struct FactorsBuilder;
@@ -23,13 +24,26 @@ impl RuntimeFactorsBuilder for FactorsBuilder {
         config: &FactorsConfig,
         args: &Self::CliArgs,
     ) -> anyhow::Result<(Self::Factors, Self::RuntimeConfig)> {
-        let runtime_config = ResolvedRuntimeConfig::<TriggerFactorsRuntimeConfig>::from_file(
+        let mut runtime_config = ResolvedRuntimeConfig::<TriggerFactorsRuntimeConfig>::from_file(
             config.runtime_config_file.clone().as_deref(),
             config.local_app_dir.clone().map(PathBuf::from),
             config.state_dir.clone(),
             config.log_dir.clone(),
         )?;
 
+        let cli_static_variables = args.get_variables()?.clone();
+        let cli_static_variables_provider = StaticVariablesProvider::new(cli_static_variables);
+
+        // Insert the parsed static variables provided via cli arguments
+        // into the set of variable providers with highest precedence.
+        runtime_config
+            .runtime_config
+            .variables
+            .as_mut()
+            .unwrap()
+            .providers
+            .insert(0, Box::new(cli_static_variables_provider));
+
         runtime_config.summarize(config.runtime_config_file.as_deref());
 
         let factors = TriggerFactors::new(

crates/runtime-factors/src/build.rs

@@ -2,6 +2,8 @@ mod build;
 
 pub use build::FactorsBuilder;
 
+use std::cell::OnceCell;
+use std::collections::HashMap;
 use std::path::PathBuf;
 
 use anyhow::Context as _;
@@ -19,6 +21,7 @@ use spin_factor_variables::VariablesFactor;
 use spin_factor_wasi::{spin::SpinFilesMounter, WasiFactor};
 use spin_factors::RuntimeFactors;
 use spin_runtime_config::{ResolvedRuntimeConfig, TomlRuntimeConfigSource};
+use spin_variables_static::VariableSource;
 
 #[derive(RuntimeFactors)]
 pub struct TriggerFactors {
@@ -104,6 +107,22 @@ pub struct TriggerAppArgs {
     /// Sets the maxmimum memory allocation limit for an instance in bytes.
     #[clap(long, env = "SPIN_MAX_INSTANCE_MEMORY")]
     pub max_instance_memory: Option<usize>,
+
+    /// Variable(s) to be passed to the app
+    ///
+    /// A single key-value pair can be passed as `key=value`. Alternatively, the
+    /// path to a JSON or TOML file may be given as `@file.json` or
+    /// `@file.toml`.
+    ///
+    /// This option may be repeated. If the same key is specified multiple times
+    /// the last value will be used.
+    #[clap(long, multiple = true, value_parser = clap::value_parser!(VariableSource),
+        value_name = "KEY=VALUE | @FILE.json | @FILE.toml")]
+    pub variable: Vec<VariableSource>,
+
+    /// Cache variables to avoid reading files twice
+    #[clap(skip)]
+    variables_cache: OnceCell<HashMap<String, String>>,
 }
 
 impl From<ResolvedRuntimeConfig<TriggerFactorsRuntimeConfig>> for TriggerFactorsRuntimeConfig {
@@ -119,3 +138,17 @@ impl TryFrom<TomlRuntimeConfigSource<'_, '_>> for TriggerFactorsRuntimeConfig {
         Self::from_source(value)
     }
 }
+
+impl TriggerAppArgs {
+    /// Parse all variable sources into a single merged map.
+    pub fn get_variables(&self) -> anyhow::Result<&HashMap<String, String>> {
+        if self.variables_cache.get().is_none() {
+            let mut variables = HashMap::new();
+            for source in &self.variable {
+                variables.extend(source.get_variables()?);
+            }
+            self.variables_cache.set(variables).unwrap();
+        }
+        Ok(self.variables_cache.get().unwrap())
+    }
+}

crates/runtime-factors/src/lib.rs

@@ -10,8 +10,14 @@ rust-version.workspace = true
 
 [dependencies]
 serde = { workspace = true }
+serde_json = { workspace = true }
+spin-common = { path = "../common" }
 spin-expressions = { path = "../expressions" }
 spin-factors = { path = "../factors" }
+toml = { workspace = true }
 
 [lints]
 workspace = true
+
+[dev-dependencies]
+tempfile = { workspace = true }

crates/variables-static/Cargo.toml

@@ -1,9 +1,12 @@
-use std::{collections::HashMap, sync::Arc};
+use std::{collections::HashMap, hash::Hash, sync::Arc};
 
 use serde::Deserialize;
 use spin_expressions::{async_trait::async_trait, Key, Provider};
 use spin_factors::anyhow;
 
+pub use source::*;
+mod source;
+
 /// A [`Provider`] that reads variables from an static map.
 #[derive(Debug, Deserialize, Clone)]
 pub struct StaticVariablesProvider {
@@ -16,3 +19,20 @@ impl Provider for StaticVariablesProvider {
         Ok(self.values.get(key.as_str()).cloned())
     }
 }
+
+impl StaticVariablesProvider {
+    /// Creates a new `StaticVariablesProvider` with the given key-value pairs.
+    pub fn new<K, V>(values: impl IntoIterator<Item = (K, V)>) -> Self
+    where
+        K: Into<String> + Eq + Hash,
+        V: Into<String>,
+    {
+        let values = values
+            .into_iter()
+            .map(|(k, v)| (k.into(), v.into()))
+            .collect();
+        Self {
+            values: Arc::new(values),
+        }
+    }
+}

crates/variables-static/src/lib.rs

@@ -0,0 +1,117 @@
+use spin_common::ui::quoted_path;
+use spin_factors::anyhow::{self, bail, Context as _};
+use std::{collections::HashMap, path::PathBuf, str::FromStr};
+
+#[derive(Clone, Debug)]
+pub enum VariableSource {
+    Literal(String, String),
+    JsonFile(PathBuf),
+    TomlFile(PathBuf),
+}
+
+impl VariableSource {
+    pub fn get_variables(&self) -> anyhow::Result<HashMap<String, String>> {
+        match self {
+            VariableSource::Literal(key, val) => Ok([(key.to_string(), val.to_string())].into()),
+            VariableSource::JsonFile(path) => {
+                let json_bytes = std::fs::read(path)
+                    .with_context(|| format!("Failed to read {}.", quoted_path(path)))?;
+                let json_vars: HashMap<String, String> = serde_json::from_slice(&json_bytes)
+                    .with_context(|| format!("Failed to parse JSON from {}.", quoted_path(path)))?;
+                Ok(json_vars)
+            }
+            VariableSource::TomlFile(path) => {
+                let toml_str = std::fs::read_to_string(path)
+                    .with_context(|| format!("Failed to read {}.", quoted_path(path)))?;
+                let toml_vars: HashMap<String, String> = toml::from_str(&toml_str)
+                    .with_context(|| format!("Failed to parse TOML from {}.", quoted_path(path)))?;
+                Ok(toml_vars)
+            }
+        }
+    }
+}
+
+impl FromStr for VariableSource {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if let Some(path) = s.strip_prefix('@') {
+            let path = PathBuf::from(path);
+            match path.extension().and_then(|s| s.to_str()) {
+                Some("json") => Ok(VariableSource::JsonFile(path)),
+                Some("toml") => Ok(VariableSource::TomlFile(path)),
+                _ => bail!("variable files must end in .json or .toml"),
+            }
+        } else if let Some((key, val)) = s.split_once('=') {
+            Ok(VariableSource::Literal(key.to_string(), val.to_string()))
+        } else {
+            bail!("variables must be in the form 'key=value' or '@file'")
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Write;
+
+    use super::*;
+
+    #[test]
+    fn source_from_str() {
+        match "k=v".parse() {
+            Ok(VariableSource::Literal(key, val)) => {
+                assert_eq!(key, "k");
+                assert_eq!(val, "v");
+            }
+            Ok(other) => panic!("wrong variant {other:?}"),
+            Err(err) => panic!("{err:?}"),
+        }
+        match "@file.json".parse() {
+            Ok(VariableSource::JsonFile(_)) => {}
+            Ok(other) => panic!("wrong variant {other:?}"),
+            Err(err) => panic!("{err:?}"),
+        }
+        match "@file.toml".parse() {
+            Ok(VariableSource::TomlFile(_)) => {}
+            Ok(other) => panic!("wrong variant {other:?}"),
+            Err(err) => panic!("{err:?}"),
+        }
+    }
+
+    #[test]
+    fn source_from_str_errors() {
+        assert!(VariableSource::from_str("nope").is_err());
+        assert!(VariableSource::from_str("@whatami").is_err());
+        assert!(VariableSource::from_str("@wrong.kind").is_err());
+    }
+
+    #[test]
+    fn literal_get_variables() {
+        let vars = VariableSource::Literal("k".to_string(), "v".to_string())
+            .get_variables()
+            .unwrap();
+        assert_eq!(vars["k"], "v");
+    }
+
+    #[test]
+    fn json_get_variables() {
+        let mut json_file = tempfile::NamedTempFile::with_suffix(".json").unwrap();
+        json_file.write_all(br#"{"k": "v"}"#).unwrap();
+        let json_path = json_file.into_temp_path();
+        let vars = VariableSource::JsonFile(json_path.to_path_buf())
+            .get_variables()
+            .unwrap();
+        assert_eq!(vars["k"], "v");
+    }
+
+    #[test]
+    fn toml() {
+        let mut toml_file = tempfile::NamedTempFile::with_suffix(".toml").unwrap();
+        toml_file.write_all(br#"k = "v""#).unwrap();
+        let toml_path = toml_file.into_temp_path();
+        let vars = VariableSource::TomlFile(toml_path.to_path_buf())
+            .get_variables()
+            .unwrap();
+        assert_eq!(vars["k"], "v");
+    }
+}