Merge spin locked app into spin app

Cargo.toml

@@ -60,7 +60,6 @@ spin-environments = { path = "crates/environments" }
 spin-factor-outbound-networking = { path = "crates/factor-outbound-networking" }
 spin-http = { path = "crates/http" }
 spin-loader = { path = "crates/loader" }
-spin-locked-app = { path = "crates/locked-app" }
 spin-manifest = { path = "crates/manifest" }
 spin-oci = { path = "crates/oci" }
 spin-plugins = { path = "crates/plugins" }

crates/app/Cargo.toml

@@ -6,11 +6,12 @@ edition = { workspace = true }
 
 [dependencies]
 anyhow = { workspace = true }
+itertools = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-spin-locked-app = { path = "../locked-app" }
+spin-serde = { path = "../serde" }
+thiserror = { workspace = true }
 
 [dev-dependencies]
 toml = { workspace = true }
-spin-factors-test = { path = "../factors-test" }
 tokio = { workspace = true }

crates/app/src/error.rs

@@ -0,0 +1,25 @@
+/// Type alias for a [`Result`]s with [`Error`].
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// Errors returned by methods in this crate.
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    /// An error propagated from the `spin_core` crate.
+    #[error(transparent)]
+    Core(anyhow::Error),
+    /// An error from a `DynamicHostComponent`.
+    #[error("host component error: {0:#}")]
+    HostComponent(#[source] anyhow::Error),
+    /// An error from a `Loader` implementation.
+    #[error(transparent)]
+    Loader(anyhow::Error),
+    /// An error indicating missing or unexpected metadata.
+    #[error("metadata error: {0}")]
+    Metadata(String),
+    /// An error indicating failed JSON (de)serialization.
+    #[error("json error: {0}")]
+    Json(#[from] serde_json::Error),
+    /// A validation error that can be presented directly to the user.
+    #[error(transparent)]
+    Validation(anyhow::Error),
+}

crates/app/src/lib.rs

@@ -11,15 +11,22 @@ use std::sync::Arc;
 
 use serde::Deserialize;
 use serde_json::Value;
-use spin_locked_app::MetadataExt;
 
-use locked::{ContentPath, LockedApp, LockedComponent, LockedComponentSource, LockedTrigger};
+use crate::locked::{
+    ContentPath, LockedApp, LockedComponent, LockedComponentSource, LockedTrigger,
+};
 
-pub use spin_locked_app::locked;
-pub use spin_locked_app::values;
-pub use spin_locked_app::{Error, MetadataKey, Result};
+pub use crate::locked::Variable;
 
-pub use locked::Variable;
+use crate::error::{Error, Result};
+use crate::metadata::MetadataExt as _;
+
+mod error;
+pub mod locked;
+mod metadata;
+pub mod values;
+
+pub use metadata::MetadataKey;
 
 /// MetadataKey for extracting the application name.
 pub const APP_NAME_KEY: MetadataKey = MetadataKey::new("name");
@@ -121,7 +128,7 @@ impl App {
             return Ok(None);
         };
         let metadata = T::deserialize(value).map_err(|err| {
-            Error::MetadataError(format!(
+            Error::Metadata(format!(
                 "invalid metadata value for {trigger_type:?}: {err:?}"
             ))
         })?;
@@ -186,7 +193,7 @@ impl App {
     ) -> Result<LockedApp> {
         self.validate_retained_components_exist(retained_components)?;
         for validator in validators {
-            validator(&self, retained_components).map_err(Error::ValidationError)?;
+            validator(&self, retained_components).map_err(Error::Validation)?;
         }
         let (component_ids, trigger_ids): (HashSet<String>, HashSet<String>) = self
             .triggers()
@@ -211,7 +218,7 @@ impl App {
             .collect::<HashSet<_>>();
         for c in retained_components {
             if !app_components.contains(*c) {
-                return Err(Error::ValidationError(anyhow::anyhow!(
+                return Err(Error::Validation(anyhow::anyhow!(
                     "Specified component \"{c}\" not found in application"
                 )));
             }
@@ -310,10 +317,10 @@ impl<'a> AppTrigger<'a> {
         let id = &self.locked.id;
         let common_config: CommonTriggerConfig = self.typed_config()?;
         let component_id = common_config.component.ok_or_else(|| {
-            Error::MetadataError(format!("trigger {id:?} missing 'component' config field"))
+            Error::Metadata(format!("trigger {id:?} missing 'component' config field"))
         })?;
         self.app.get_component(&component_id).ok_or_else(|| {
-            Error::MetadataError(format!(
+            Error::Metadata(format!(
                 "missing component {component_id:?} configured for trigger {id:?}"
             ))
         })
@@ -337,29 +344,45 @@ pub fn retain_components(
 
 #[cfg(test)]
 mod test {
-    use spin_factors_test::build_locked_app;
+    use std::collections::HashSet;
 
     use super::*;
 
+    pub fn locked_app() -> LockedApp {
+        LockedApp {
+            spin_lock_version: Default::default(),
+            must_understand: Default::default(),
+            metadata: Default::default(),
+            host_requirements: Default::default(),
+            variables: Default::default(),
+            triggers: vec![LockedTrigger {
+                id: "trigger".into(),
+                trigger_type: "dummy".into(),
+                trigger_config: toml::from_str(r#"component = "empty""#).unwrap(),
+            }],
+            components: vec![LockedComponent {
+                id: "empty".to_owned(),
+                metadata: Default::default(),
+                source: LockedComponentSource {
+                    content_type: "application/wasm".to_owned(),
+                    content: Default::default(),
+                },
+                env: Default::default(),
+                files: Default::default(),
+                config: Default::default(),
+                dependencies: Default::default(),
+                host_requirements: Default::default(),
+            }],
+        }
+    }
+
     fn does_nothing_validator(_: &App, _: &[&str]) -> anyhow::Result<()> {
         Ok(())
     }
 
     #[tokio::test]
     async fn test_retain_components_filtering_for_only_component_works() {
-        let manifest = toml::toml! {
-            spin_manifest_version = 2
-
-            [application]
-            name = "test-app"
-
-            [[trigger.test-trigger]]
-            component = "empty"
-
-            [component.empty]
-            source = "does-not-exist.wasm"
-        };
-        let mut locked_app = build_locked_app(&manifest).await.unwrap();
+        let mut locked_app = locked_app();
         locked_app = retain_components(locked_app, &["empty"], &[&does_nothing_validator]).unwrap();
         let components = locked_app
             .components

crates/locked-app/src/metadata.rs → crates/app/src/metadata.rs

@@ -57,16 +57,14 @@ pub trait MetadataExt {
         self.get_value(key.as_ref())
             .map(T::deserialize)
             .transpose()
-            .map_err(|err| {
-                Error::MetadataError(format!("invalid metadata value for {key:?}: {err:?}"))
-            })
+            .map_err(|err| Error::Metadata(format!("invalid metadata value for {key:?}: {err:?}")))
     }
 
     /// Get a required value from a metadata map, returning an error
     /// if it is not present
     fn require_typed<'a, T: Deserialize<'a>>(&'a self, key: MetadataKey<T>) -> Result<T> {
         self.get_typed(key)?
-            .ok_or_else(|| Error::MetadataError(format!("missing required metadata {key:?}")))
+            .ok_or_else(|| Error::Metadata(format!("missing required metadata {key:?}")))
     }
 }
 

crates/core/Cargo.toml

@@ -16,7 +16,7 @@ spin-componentize = { workspace = true }
 spin-factor-wasi = { path = "../factor-wasi" }
 spin-factors = { path = "../factors" }
 spin-factors-test = { path = "../factors-test" }
-spin-locked-app = { path = "../locked-app" }
+spin-app = { path = "../app" }
 tokio = { workspace = true, features = ["macros", "rt", "rt-multi-thread"] }
 wasmtime-wasi = { workspace = true }
 

crates/core/tests/integration_test.rs

@@ -5,10 +5,10 @@ use std::{
 
 use anyhow::Context;
 use serde_json::json;
+use spin_app::locked::LockedApp;
 use spin_core::{AsState, Component, Config, Engine, State, Store, StoreBuilder, Trap};
 use spin_factor_wasi::{DummyFilesMounter, WasiFactor};
 use spin_factors::{App, AsInstanceState, RuntimeFactors};
-use spin_locked_app::locked::LockedApp;
 use tokio::fs;
 use wasmtime_wasi::I32Exit;
 

crates/expressions/Cargo.toml

@@ -8,7 +8,7 @@ edition = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 futures = { workspace = true }
-spin-locked-app = { path = "../locked-app" }
+spin-app = { path = "../app" }
 thiserror = { workspace = true }
 
 [dev-dependencies]

crates/expressions/src/lib.rs

@@ -3,7 +3,7 @@ mod template;
 
 use std::{borrow::Cow, collections::HashMap, fmt::Debug, vec};
 
-use spin_locked_app::Variable;
+use spin_app::Variable;
 
 pub use async_trait;
 

crates/expressions/tests/validation_test.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
 use async_trait::async_trait;
+use spin_app::Variable;
 use spin_expressions::{Key, Provider, ProviderResolver};
-use spin_locked_app::Variable;
 
 #[derive(Default)]
 struct ResolverTester {