move spin-app and spin-core in from their temporary home

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

Author: lann

crates/http/Cargo.toml

@@ -40,8 +40,8 @@ wasmtime = "0.39.1"
 wit-bindgen-wasmtime = { git = "https://github.com/bytecodealliance/wit-bindgen", rev = "cb871cfa1ee460b51eb1d144b175b9aab9c50aba", features = ["async"] }
 
 # Temporary refactor deps
-spin-app = { path = "../../../lhc/crates/spin-app" }
-spin-core = { path = "../../../lhc/crates/spin-core" }
+spin-app = { path = "../spin-app" }
+spin-core = { path = "../spin-core" }
 
 [dev-dependencies]
 criterion = { version = "0.3.5", features = ["async_tokio"] }

crates/loader/Cargo.toml

@@ -31,4 +31,4 @@ walkdir = "2.3.2"
 wasi-outbound-http = { path = "../outbound-http" } 
 
 # Temporary refactor deps
-spin-app = { path = "../../../lhc/crates/spin-app" }
+spin-app = { path = "../spin-app" }

crates/redis/Cargo.toml

@@ -27,8 +27,8 @@ wasmtime-wasi = "0.39.1"
 wit-bindgen-wasmtime = { git = "https://github.com/bytecodealliance/wit-bindgen", rev = "cb871cfa1ee460b51eb1d144b175b9aab9c50aba" }
 
 # Temporary refactor deps
-spin-app = { path = "../../../lhc/crates/spin-app" }
-spin-core = { path = "../../../lhc/crates/spin-core" }
+spin-app = { path = "../spin-app" }
+spin-core = { path = "../spin-core" }
 
 [dev-dependencies]
 spin-testing = { path = "../testing" }

crates/spin-app/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "spin-app"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0"
+async-trait = "0.1"
+ouroboros = "0.15"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+spin-core = { path = "../spin-core" }
+thiserror = "1.0"

crates/spin-app/src/host_component.rs

@@ -0,0 +1,51 @@
+use std::sync::Arc;
+
+use spin_core::{EngineBuilder, HostComponent, HostComponentsData};
+
+use crate::AppComponent;
+
+pub trait DynamicHostComponent: HostComponent {
+    fn update_data(&self, data: &mut Self::Data, component: &AppComponent) -> anyhow::Result<()>;
+}
+
+impl<DHC: DynamicHostComponent> DynamicHostComponent for Arc<DHC> {
+    fn update_data(&self, data: &mut Self::Data, component: &AppComponent) -> anyhow::Result<()> {
+        (**self).update_data(data, component)
+    }
+}
+
+type DataUpdater =
+    Box<dyn Fn(&mut HostComponentsData, &AppComponent) -> anyhow::Result<()> + Send + Sync>;
+
+#[derive(Default)]
+pub struct DynamicHostComponents {
+    data_updaters: Vec<DataUpdater>,
+}
+
+impl DynamicHostComponents {
+    pub fn add_dynamic_host_component<T: Send + Sync, DHC: DynamicHostComponent>(
+        &mut self,
+        engine_builder: &mut EngineBuilder<T>,
+        host_component: DHC,
+    ) -> anyhow::Result<()> {
+        let host_component = Arc::new(host_component);
+        let handle = engine_builder.add_host_component(host_component.clone())?;
+        self.data_updaters
+            .push(Box::new(move |host_components_data, component| {
+                let data = host_components_data.get_or_insert(handle);
+                host_component.update_data(data, component)
+            }));
+        Ok(())
+    }
+
+    pub fn update_data(
+        &self,
+        host_components_data: &mut HostComponentsData,
+        component: &AppComponent,
+    ) -> anyhow::Result<()> {
+        for data_updater in &self.data_updaters {
+            data_updater(host_components_data, component)?;
+        }
+        Ok(())
+    }
+}

crates/spin-app/src/lib.rs

@@ -0,0 +1,252 @@
+mod host_component;
+pub mod locked;
+pub mod values;
+
+pub use async_trait::async_trait;
+pub use host_component::DynamicHostComponent;
+
+use host_component::DynamicHostComponents;
+use locked::{ContentPath, LockedApp, LockedComponent, LockedComponentSource, LockedTrigger};
+use ouroboros::self_referencing;
+use serde::Deserialize;
+use spin_core::{wasmtime, Engine, EngineBuilder, StoreBuilder};
+
+// TODO(lann): Should this migrate to spin-loader?
+#[async_trait]
+pub trait Loader {
+    async fn load_app(&self, uri: &str) -> anyhow::Result<LockedApp>;
+
+    async fn load_module(
+        &self,
+        engine: &wasmtime::Engine,
+        source: &LockedComponentSource,
+    ) -> anyhow::Result<spin_core::Module>;
+
+    async fn mount_files(
+        &self,
+        store_builder: &mut StoreBuilder,
+        component: &AppComponent,
+    ) -> anyhow::Result<()>;
+}
+
+pub struct AppLoader {
+    inner: Box<dyn Loader + Send + Sync>,
+    dynamic_host_components: DynamicHostComponents,
+}
+
+impl AppLoader {
+    pub fn new(loader: impl Loader + Send + Sync + 'static) -> Self {
+        Self {
+            inner: Box::new(loader),
+            dynamic_host_components: Default::default(),
+        }
+    }
+
+    pub fn add_dynamic_host_component<T: Send + Sync, DHC: DynamicHostComponent>(
+        &mut self,
+        engine_builder: &mut EngineBuilder<T>,
+        host_component: DHC,
+    ) -> anyhow::Result<()> {
+        self.dynamic_host_components
+            .add_dynamic_host_component(engine_builder, host_component)
+    }
+
+    pub async fn load_app(&self, uri: String) -> Result<App> {
+        let locked = self
+            .inner
+            .load_app(&uri)
+            .await
+            .map_err(Error::LoaderError)?;
+        Ok(App {
+            loader: self,
+            uri,
+            locked,
+        })
+    }
+
+    pub async fn load_owned_app(self, uri: String) -> Result<OwnedApp> {
+        OwnedApp::try_new_async(self, |loader| Box::pin(loader.load_app(uri))).await
+    }
+}
+
+impl std::fmt::Debug for AppLoader {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("AppLoader").finish()
+    }
+}
+
+#[self_referencing]
+#[derive(Debug)]
+pub struct OwnedApp {
+    loader: AppLoader,
+    #[borrows(loader)]
+    #[covariant]
+    app: App<'this>,
+}
+
+impl std::ops::Deref for OwnedApp {
+    type Target = App<'static>;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe {
+            // We know that App's lifetime param is for AppLoader, which is owned by self here.
+            std::mem::transmute::<&App, &App<'static>>(self.borrow_app())
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct App<'a> {
+    loader: &'a AppLoader,
+    uri: String,
+    locked: LockedApp,
+}
+
+impl<'a> App<'a> {
+    pub fn uri(&self) -> &str {
+        &self.uri
+    }
+
+    pub fn get_metadata<'this, T: Deserialize<'this>>(&'this self, key: &str) -> Option<Result<T>> {
+        self.locked
+            .metadata
+            .get(key)
+            .map(|value| Ok(T::deserialize(value)?))
+    }
+
+    pub fn components(&self) -> impl Iterator<Item = AppComponent> {
+        self.locked
+            .components
+            .iter()
+            .map(|locked| AppComponent { app: self, locked })
+    }
+
+    pub fn get_component(&self, component_id: &str) -> Option<AppComponent> {
+        self.components()
+            .find(|component| component.locked.id == component_id)
+    }
+
+    pub fn triggers(&self) -> impl Iterator<Item = AppTrigger> {
+        self.locked
+            .triggers
+            .iter()
+            .map(|locked| AppTrigger { app: self, locked })
+    }
+
+    pub fn triggers_with_type(&'a self, trigger_type: &'a str) -> impl Iterator<Item = AppTrigger> {
+        self.triggers()
+            .filter(move |trigger| trigger.locked.trigger_type == trigger_type)
+    }
+}
+
+pub struct AppComponent<'a> {
+    pub app: &'a App<'a>,
+    locked: &'a LockedComponent,
+}
+
+impl<'a> AppComponent<'a> {
+    pub fn id(&self) -> &str {
+        &self.locked.id
+    }
+
+    pub fn source(&self) -> &LockedComponentSource {
+        &self.locked.source
+    }
+
+    pub fn files(&self) -> std::slice::Iter<ContentPath> {
+        self.locked.files.iter()
+    }
+
+    pub fn get_metadata<T: Deserialize<'a>>(&self, key: &str) -> Option<Result<T>> {
+        self.locked
+            .metadata
+            .get(key)
+            .map(|value| Ok(T::deserialize(value)?))
+    }
+
+    pub async fn load_module<T: Send + Sync>(
+        &self,
+        engine: &Engine<T>,
+    ) -> Result<spin_core::Module> {
+        self.app
+            .loader
+            .inner
+            .load_module(engine.as_ref(), &self.locked.source)
+            .await
+            .map_err(Error::LoaderError)
+    }
+
+    pub async fn apply_store_config(&self, builder: &mut StoreBuilder) -> Result<()> {
+        builder.env(&self.locked.env).map_err(Error::CoreError)?;
+
+        let loader = self.app.loader;
+        loader
+            .inner
+            .mount_files(builder, self)
+            .await
+            .map_err(Error::LoaderError)?;
+
+        loader
+            .dynamic_host_components
+            .update_data(builder.host_components_data(), self)
+            .map_err(Error::HostComponentError)?;
+
+        Ok(())
+    }
+}
+
+pub struct AppTrigger<'a> {
+    pub app: &'a App<'a>,
+    locked: &'a LockedTrigger,
+}
+
+impl<'a> AppTrigger<'a> {
+    pub fn id(&self) -> &str {
+        &self.locked.id
+    }
+
+    pub fn trigger_type(&self) -> &str {
+        &self.locked.trigger_type
+    }
+
+    pub fn component(&self) -> Result<AppComponent<'a>> {
+        let component_id = self.locked.trigger_config.get("component").ok_or_else(|| {
+            Error::ManifestError(format!(
+                "trigger {:?} missing 'component' config field",
+                self.locked.id
+            ))
+        })?;
+        let component_id = component_id.as_str().ok_or_else(|| {
+            Error::ManifestError(format!(
+                "trigger {:?} 'component' field has unexpected value {:?}",
+                self.locked.id, component_id
+            ))
+        })?;
+        self.app.get_component(component_id).ok_or_else(|| {
+            Error::ManifestError(format!(
+                "missing component {:?} configured for trigger {:?}",
+                component_id, self.locked.id
+            ))
+        })
+    }
+
+    pub fn typed_config<Config: Deserialize<'a>>(&self) -> Result<Config> {
+        Ok(Config::deserialize(&self.locked.trigger_config)?)
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("spin core error: {0}")]
+    CoreError(anyhow::Error),
+    #[error("host component error: {0}")]
+    HostComponentError(anyhow::Error),
+    #[error("loader error: {0}")]
+    LoaderError(anyhow::Error),
+    #[error("manifest error: {0}")]
+    ManifestError(String),
+    #[error("json error: {0}")]
+    JsonError(#[from] serde_json::Error),
+}