Migrate spin-config to new core

Signed-off-by: Lann Martin <lann.martin@fermyon.com>

Author: lann

Cargo.lock

@@ -7,15 +7,17 @@ authors = [ "Fermyon Engineering <engineering@fermyon.com>" ]
 [dependencies]
 anyhow = "1.0"
 async-trait = "0.1"
-spin-engine = { path = "../engine" }
-spin-manifest = { path = "../manifest" }
+dotenvy = "0.15"
+once_cell = "1"
+spin-app = { path = "../app" }
+spin-core = { path = "../core" }
 thiserror = "1"
+tokio = { version = "1", features = ["rt-multi-thread"] }
 
 [dependencies.wit-bindgen-wasmtime]
 git = "https://github.com/bytecodealliance/wit-bindgen"
 rev = "cb871cfa1ee460b51eb1d144b175b9aab9c50aba"
 features = ["async"]
 
 [dev-dependencies]
-tokio = { version = "1", features = [ "rt-multi-thread" ] }
 toml = "0.5"

crates/config/Cargo.toml

@@ -1,60 +1,87 @@
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 
-use spin_engine::host_component::HostComponent;
-use spin_manifest::CoreComponent;
-use wit_bindgen_wasmtime::async_trait;
+use async_trait::async_trait;
+use once_cell::sync::OnceCell;
+use spin_app::{AppComponent, DynamicHostComponent};
+use spin_core::HostComponent;
 
-use crate::{Error, Key, Resolver};
+use crate::{Error, Key, Provider, Resolver};
 
-mod wit {
-    wit_bindgen_wasmtime::export!({paths: ["../../wit/ephemeral/spin-config.wit"], async: *});
-}
+wit_bindgen_wasmtime::export!({paths: ["../../wit/ephemeral/spin-config.wit"], async: *});
 
 pub struct ConfigHostComponent {
-    resolver: Arc<Resolver>,
+    providers: Mutex<Vec<Box<dyn Provider>>>,
+    resolver: Arc<OnceCell<Resolver>>,
 }
 
 impl ConfigHostComponent {
-    pub fn new(resolver: Resolver) -> Self {
+    pub fn new(providers: Vec<Box<dyn Provider>>) -> Self {
         Self {
-            resolver: Arc::new(resolver),
+            providers: Mutex::new(providers),
+            resolver: Default::default(),
         }
     }
 }
 
 impl HostComponent for ConfigHostComponent {
-    type State = ComponentConfig;
+    type Data = ComponentConfig;
 
     fn add_to_linker<T: Send>(
-        linker: &mut wit_bindgen_wasmtime::wasmtime::Linker<spin_engine::RuntimeContext<T>>,
-        state_handle: spin_engine::host_component::HostComponentsStateHandle<Self::State>,
+        linker: &mut spin_core::Linker<T>,
+        get: impl Fn(&mut spin_core::Data<T>) -> &mut Self::Data + Send + Sync + Copy + 'static,
     ) -> anyhow::Result<()> {
-        wit::spin_config::add_to_linker(linker, move |ctx| state_handle.get_mut(ctx))
+        spin_config::add_to_linker(linker, get)
     }
 
-    fn build_state(&self, component: &CoreComponent) -> anyhow::Result<Self::State> {
-        Ok(ComponentConfig {
-            component_id: component.id.clone(),
+    fn build_data(&self) -> Self::Data {
+        ComponentConfig {
             resolver: self.resolver.clone(),
-        })
+            component_id: None,
+        }
+    }
+}
+
+impl DynamicHostComponent for ConfigHostComponent {
+    fn update_data(&self, data: &mut Self::Data, component: &AppComponent) -> anyhow::Result<()> {
+        self.resolver.get_or_try_init(|| {
+            let mut resolver = Resolver::new(
+                component
+                    .app
+                    .variables()
+                    .map(|(key, var)| (key.clone(), var.clone())),
+            )?;
+            for provider in self.providers.lock().unwrap().drain(..) {
+                resolver.add_provider(provider);
+            }
+            Ok::<_, anyhow::Error>(resolver)
+        })?;
+        data.component_id = Some(component.id().to_string());
+        Ok(())
     }
 }
 
 /// A component configuration interface implementation.
 pub struct ComponentConfig {
-    component_id: String,
-    resolver: Arc<Resolver>,
+    resolver: Arc<OnceCell<Resolver>>,
+    component_id: Option<String>,
 }
 
 #[async_trait]
-impl wit::spin_config::SpinConfig for ComponentConfig {
-    async fn get_config(&mut self, key: &str) -> Result<String, wit::spin_config::Error> {
+impl spin_config::SpinConfig for ComponentConfig {
+    async fn get_config(&mut self, key: &str) -> Result<String, spin_config::Error> {
+        // Set by DynamicHostComponent::update_data
+        let component_id = self.component_id.as_deref().unwrap();
         let key = Key::new(key)?;
-        Ok(self.resolver.resolve(&self.component_id, key).await?)
+        Ok(self
+            .resolver
+            .get()
+            .unwrap()
+            .resolve(component_id, key)
+            .await?)
     }
 }
 
-impl From<Error> for wit::spin_config::Error {
+impl From<Error> for spin_config::Error {
     fn from(err: Error) -> Self {
         match err {
             Error::InvalidKey(msg) => Self::InvalidKey(msg),

crates/config/src/host_component.rs

@@ -1,25 +1,21 @@
-pub mod host_component;
+mod host_component;
 pub mod provider;
-
 mod template;
 
 use std::{borrow::Cow, collections::HashMap, fmt::Debug};
 
-pub use async_trait::async_trait;
+use spin_app::Variable;
 
-pub use provider::Provider;
-use spin_manifest::Variable;
+pub use crate::{host_component::ConfigHostComponent, provider::Provider};
 use template::{Part, Template};
 
-type Result<T> = std::result::Result<T, Error>;
-
 /// A configuration resolver.
 #[derive(Debug, Default)]
 pub struct Resolver {
     // variable key -> variable
     variables: HashMap<String, Variable>,
     // component ID -> config key -> config value template
-    components_configs: HashMap<String, HashMap<String, Template>>,
+    component_configs: HashMap<String, HashMap<String, Template>>,
     providers: Vec<Box<dyn Provider>>,
 }
 
@@ -31,7 +27,7 @@ impl Resolver {
         variables.keys().try_for_each(|key| Key::validate(key))?;
         Ok(Self {
             variables,
-            components_configs: Default::default(),
+            component_configs: Default::default(),
             providers: Default::default(),
         })
     }
@@ -53,19 +49,19 @@ impl Resolver {
             })
             .collect::<Result<_>>()?;
 
-        self.components_configs.insert(component_id, templates);
+        self.component_configs.insert(component_id, templates);
 
         Ok(())
     }
 
     /// Adds a config Provider to the Resolver.
-    pub fn add_provider(&mut self, provider: impl Provider + 'static) {
-        self.providers.push(Box::new(provider));
+    pub fn add_provider(&mut self, provider: Box<dyn Provider>) {
+        self.providers.push(provider);
     }
 
     /// Resolves a config value for the given path.
     pub async fn resolve(&self, component_id: &str, key: Key<'_>) -> Result<String> {
-        let configs = self.components_configs.get(component_id).ok_or_else(|| {
+        let configs = self.component_configs.get(component_id).ok_or_else(|| {
             Error::UnknownPath(format!("no config for component {component_id:?}"))
         })?;
 
@@ -165,6 +161,8 @@ impl<'a> AsRef<str> for Key<'a> {
     }
 }
 
+type Result<T> = std::result::Result<T, Error>;
+
 /// A config resolution error.
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
@@ -195,6 +193,8 @@ pub enum Error {
 
 #[cfg(test)]
 mod tests {
+    use async_trait::async_trait;
+
     use super::*;
 
     #[derive(Debug)]
@@ -235,7 +235,7 @@ mod tests {
                 [("test_key".into(), config_template.into())],
             )
             .unwrap();
-        resolver.add_provider(TestProvider);
+        resolver.add_provider(Box::new(TestProvider));
         resolver.resolve("test-component", Key("test_key")).await
     }
 

crates/config/src/lib.rs

@@ -1,59 +1,73 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, path::PathBuf, sync::Mutex};
 
-use anyhow::Context;
+use anyhow::{Context, Result};
 use async_trait::async_trait;
 
 use crate::{Key, Provider};
 
-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>,
+    dotenv_path: Option<PathBuf>,
+    dotenv_cache: Mutex<Option<HashMap<String, String>>>,
 }
 
 impl EnvProvider {
     /// Creates a new EnvProvider.
-    pub fn new(prefix: impl Into<String>, envs: HashMap<String, String>) -> Self {
+    pub fn new(prefix: impl Into<String>, dotenv_path: Option<PathBuf>) -> Self {
         Self {
             prefix: prefix.into(),
-            envs,
+            dotenv_path,
+            dotenv_cache: Default::default(),
         }
     }
 
-    fn get_sync(&self, key: &Key) -> anyhow::Result<Option<String>> {
+    fn get_sync(&self, key: &Key) -> 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(self.envs.get(&env_key).map(|value| value.to_string()))
-            }
+            Err(std::env::VarError::NotPresent) => self.get_dotenv(&env_key),
             other => other
                 .map(Some)
                 .with_context(|| format!("failed to resolve env var {}", &env_key)),
         }
     }
-}
 
-impl Default for EnvProvider {
-    fn default() -> Self {
-        Self {
-            prefix: DEFAULT_PREFIX.to_string(),
-            envs: HashMap::new(),
+    fn get_dotenv(&self, key: &str) -> Result<Option<String>> {
+        if self.dotenv_path.is_none() {
+            return Ok(None);
         }
+        let mut maybe_cache = self
+            .dotenv_cache
+            .lock()
+            .expect("dotenv_cache lock poisoned");
+        let cache = match maybe_cache.as_mut() {
+            Some(cache) => cache,
+            None => maybe_cache.insert(self.load_dotenv()?),
+        };
+        Ok(cache.get(key).cloned())
+    }
+
+    fn load_dotenv(&self) -> Result<HashMap<String, String>> {
+        let path = self.dotenv_path.as_deref().unwrap();
+        Ok(dotenvy::from_path_iter(path)
+            .into_iter()
+            .flatten()
+            .collect::<Result<HashMap<String, String>, _>>()?)
     }
 }
 
 #[async_trait]
 impl Provider for EnvProvider {
-    async fn get(&self, key: &Key) -> anyhow::Result<Option<String>> {
-        self.get_sync(key)
+    async fn get(&self, key: &Key) -> Result<Option<String>> {
+        tokio::task::block_in_place(|| self.get_sync(key))
     }
 }
 
 #[cfg(test)]
 mod test {
+    use std::env::temp_dir;
+
     use super::*;
 
     #[test]
@@ -66,20 +80,22 @@ mod test {
             "dotenv_val".to_string(),
         );
         assert_eq!(
-            EnvProvider::new("TESTING_SPIN", envs.clone())
+            EnvProvider::new("TESTING_SPIN", None)
                 .get_sync(&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(),
-        );
+    #[test]
+    fn provider_get_dotenv() {
+        let dotenv_path = temp_dir().join("spin-env-provider-test");
+        std::fs::write(&dotenv_path, b"TESTING_SPIN_ENV_KEY2=dotenv_val").unwrap();
+
+        let key = Key::new("env_key2").unwrap();
         assert_eq!(
-            EnvProvider::new("TESTING_SPIN", envs.clone())
-                .get_sync(&key2)
+            EnvProvider::new("TESTING_SPIN", Some(dotenv_path))
+                .get_sync(&key)
                 .unwrap(),
             Some("dotenv_val".to_string())
         );
@@ -88,6 +104,11 @@ mod test {
     #[test]
     fn provider_get_missing() {
         let key = Key::new("please_do_not_ever_set_this_during_tests").unwrap();
-        assert_eq!(EnvProvider::default().get_sync(&key).unwrap(), None);
+        assert_eq!(
+            EnvProvider::new("TESTING_SPIN", Default::default())
+                .get_sync(&key)
+                .unwrap(),
+            None
+        );
     }
 }