Merge pull request #707 from FrankYang0529/read-dotenv

feat(config): support dotenv

Author: lann

Cargo.lock

@@ -1,20 +1,24 @@
+use std::collections::HashMap;
+
 use anyhow::Context;
 
 use crate::{Key, Provider};
 
-const DEFAULT_PREFIX: &str = "SPIN_APP";
+pub const DEFAULT_PREFIX: &str = "SPIN_APP";
 
 /// A config Provider that uses environment variables.
 #[derive(Debug)]
 pub struct EnvProvider {
     prefix: String,
+    envs: HashMap<String, String>,
 }
 
 impl EnvProvider {
     /// Creates a new EnvProvider.
-    pub fn new(prefix: impl Into<String>) -> Self {
+    pub fn new(prefix: impl Into<String>, envs: HashMap<String, String>) -> Self {
         Self {
             prefix: prefix.into(),
+            envs,
         }
     }
 }
@@ -23,6 +27,7 @@ impl Default for EnvProvider {
     fn default() -> Self {
         Self {
             prefix: DEFAULT_PREFIX.to_string(),
+            envs: HashMap::new(),
         }
     }
 }
@@ -31,7 +36,13 @@ impl Provider for EnvProvider {
     fn get(&self, key: &Key) -> anyhow::Result<Option<String>> {
         let env_key = format!("{}_{}", &self.prefix, key.as_ref().to_ascii_uppercase());
         match std::env::var(&env_key) {
-            Err(std::env::VarError::NotPresent) => Ok(None),
+            Err(std::env::VarError::NotPresent) => {
+                if let Some(value) = self.envs.get(&env_key) {
+                    return Ok(Some(value.to_string()));
+                }
+
+                Ok(None)
+            }
             other => other
                 .map(Some)
                 .with_context(|| format!("failed to resolve env var {}", &env_key)),
@@ -46,11 +57,30 @@ mod test {
     #[test]
     fn provider_get() {
         std::env::set_var("TESTING_SPIN_ENV_KEY1", "val");
-        let key = Key::new("env_key1").unwrap();
+        let key1 = Key::new("env_key1").unwrap();
+        let mut envs = HashMap::new();
+        envs.insert(
+            "TESTING_SPIN_ENV_KEY1".to_string(),
+            "dotenv_val".to_string(),
+        );
         assert_eq!(
-            EnvProvider::new("TESTING_SPIN").get(&key).unwrap(),
+            EnvProvider::new("TESTING_SPIN", envs.clone())
+                .get(&key1)
+                .unwrap(),
             Some("val".to_string())
         );
+
+        let key2 = Key::new("env_key2").unwrap();
+        envs.insert(
+            "TESTING_SPIN_ENV_KEY2".to_string(),
+            "dotenv_val".to_string(),
+        );
+        assert_eq!(
+            EnvProvider::new("TESTING_SPIN", envs.clone())
+                .get(&key2)
+                .unwrap(),
+            Some("dotenv_val".to_string())
+        );
     }
 
     #[test]

crates/config/src/provider/env.rs

@@ -21,3 +21,4 @@ spin-manifest = { path = "../manifest" }
 tracing = { version = "0.1", features = [ "log" ] }
 wasi-outbound-http = { path = "../outbound-http" } 
 wasmtime = "0.35.3"
+dotenvy = "0.15.1"

crates/trigger/Cargo.toml

@@ -1,4 +1,9 @@
-use std::{error::Error, path::PathBuf, sync::Arc};
+use std::{
+    collections::HashMap,
+    error::Error,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 use anyhow::{bail, Context, Result};
 use clap::{Args, IntoApp, Parser};
@@ -141,7 +146,9 @@ where
             .context("SPIN_ALLOW_TRANSIENT_WRITE")?;
 
         // TODO(lann): Find a better home for this; spin_loader?
+        let dotenv_path;
         let mut app = if let Some(manifest_file) = manifest_url.strip_prefix("file://") {
+            dotenv_path = Path::new(manifest_file).parent().unwrap().join(".env");
             let bindle_connection = std::env::var("BINDLE_URL")
                 .ok()
                 .map(|url| BindleConnectionInfo::new(url, false, None, None));
@@ -153,6 +160,7 @@ where
             )
             .await?
         } else if let Some(bindle_url) = manifest_url.strip_prefix("bindle+") {
+            dotenv_path = Path::new("./.env").to_path_buf();
             let (bindle_server, bindle_id) = bindle_url
                 .rsplit_once("?id=")
                 .context("invalid bindle URL")?;
@@ -169,12 +177,17 @@ where
             }
         }
 
+        let envs = read_dotenv(dotenv_path)?;
+
         // Add default config provider(s).
         // TODO(lann): Make config provider(s) configurable.
         if let Some(ref mut resolver) = app.config_resolver {
             let resolver = Arc::get_mut(resolver)
                 .context("Internal error: app.config_resolver unexpectedly shared")?;
-            resolver.add_provider(spin_config::provider::env::EnvProvider::default());
+            resolver.add_provider(spin_config::provider::env::EnvProvider::new(
+                spin_config::provider::env::DEFAULT_PREFIX,
+                envs,
+            ));
         }
 
         Ok(app)
@@ -211,3 +224,18 @@ fn parse_env_var(s: &str) -> Result<(String, String)> {
     }
     Ok((parts[0].to_owned(), parts[1].to_owned()))
 }
+
+// Return environment key value mapping in ".env" file.
+fn read_dotenv(dotenv_path: impl AsRef<Path>) -> Result<HashMap<String, String>> {
+    let mut envs = HashMap::new();
+    if !dotenv_path.as_ref().exists() {
+        return Ok(envs);
+    }
+
+    let env_iter = dotenvy::from_path_iter(dotenv_path)?;
+    for env_item in env_iter {
+        let (key, value) = env_item?;
+        envs.insert(key, value);
+    }
+    Ok(envs)
+}

crates/trigger/src/cli.rs

@@ -0,0 +1 @@
+SPIN_APP_DOTENV = "dotenv"

examples/config-rust/.env

@@ -7,6 +7,7 @@ version = "0.1.0"
 
 [variables]
 object = { default = "teapot" }
+dotenv = { default = "should-be-replaced" }
 
 [[component]]
 id = "spin_config_rust"
@@ -15,5 +16,6 @@ source = "target/wasm32-wasi/release/spin_config_example.wasm"
 route = "/..."
 [component.config]
 message = "I'm a {{object}}"
+dotenv = "{{dotenv}}"
 [component.build]
 command = "cargo build --target wasm32-wasi --release"

examples/config-rust/spin.toml

@@ -7,7 +7,15 @@ use spin_sdk::{
 
 /// This endpoint returns the config value specified by key.
 #[http_component]
-fn get(_req: Request) -> Result<Response> {
+fn get(req: Request) -> Result<Response> {
+    let path = req.uri().path();
+
+    if path.contains("dotenv") {
+        let val = config::get("dotenv").expect("Failed to acquire dotenv from spin.toml");
+        return Ok(http::Response::builder()
+            .status(200)
+            .body(Some(val.into()))?);
+    }
     let val = format!("message: {}", config::get("message")?);
     Ok(http::Response::builder()
         .status(200)