Validate against target environments during build

Signed-off-by: itowlson <[email protected]>

Author: itowlson

Cargo.lock

@@ -59,6 +59,7 @@ spin-app = { path = "crates/app" }
 spin-build = { path = "crates/build" }
 spin-common = { path = "crates/common" }
 spin-doctor = { path = "crates/doctor" }
+spin-environments = { path = "crates/environments" }
 spin-expressions = { path = "crates/expressions" }
 spin-factor-outbound-networking = { path = "crates/factor-outbound-networking" }
 spin-http = { path = "crates/http" }

Cargo.toml

@@ -9,6 +9,7 @@ anyhow = { workspace = true }
 futures = { workspace = true }
 serde = { workspace = true }
 spin-common = { path = "../common" }
+spin-environments = { path = "../environments" }
 spin-manifest = { path = "../manifest" }
 subprocess = "0.2"
 terminal = { path = "../terminal" }

crates/build/Cargo.toml

@@ -0,0 +1,23 @@
+#[derive(Default)]
+pub struct DeploymentTargets {
+    target_environments: Vec<DeploymentTarget>,
+}
+pub type DeploymentTarget = String;
+
+impl DeploymentTargets {
+    pub fn new(envs: Vec<String>) -> Self {
+        Self {
+            target_environments: envs,
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &str> {
+        self.target_environments.iter().map(|s| s.as_str())
+    }
+
+    pub fn is_empty(&self) -> bool {
+        // TODO: it would be nice to let "no-op" behaviour fall out organically,
+        // but currently we do some stuff eagerly, so...
+        self.target_environments.is_empty()
+    }
+}

crates/build/src/deployment.rs

@@ -2,6 +2,7 @@
 
 //! A library for building Spin components.
 
+mod deployment;
 mod manifest;
 
 use anyhow::{anyhow, bail, Context, Result};
@@ -17,24 +18,38 @@ use crate::manifest::component_build_configs;
 
 /// If present, run the build command of each component.
 pub async fn build(manifest_file: &Path, component_ids: &[String]) -> Result<()> {
-    let (components, manifest_err) =
-        component_build_configs(manifest_file)
-            .await
-            .with_context(|| {
-                format!(
-                    "Cannot read manifest file from {}",
-                    quoted_path(manifest_file)
-                )
-            })?;
+    let (components, deployment_targets, manifest) = component_build_configs(manifest_file)
+        .await
+        .with_context(|| {
+        format!(
+            "Cannot read manifest file from {}",
+            quoted_path(manifest_file)
+        )
+    })?;
     let app_dir = parent_dir(manifest_file)?;
 
     let build_result = build_components(component_ids, components, app_dir);
 
-    if let Some(e) = manifest_err {
+    if let Err(e) = &manifest {
         terminal::warn!("The manifest has errors not related to the Wasm component build. Error details:\n{e:#}");
     }
 
-    build_result
+    build_result?;
+
+    if let Ok(manifest) = &manifest {
+        if !deployment_targets.is_empty() {
+            let resolution_context =
+                spin_environments::ResolutionContext::new(manifest_file.parent().unwrap()).await?;
+            spin_environments::validate_application_against_environment_ids(
+                deployment_targets.iter(),
+                manifest,
+                &resolution_context,
+            )
+            .await?;
+        }
+    }
+
+    Ok(())
 }
 
 fn build_components(

crates/build/src/lib.rs

@@ -4,37 +4,60 @@ use std::{collections::BTreeMap, path::Path};
 
 use spin_manifest::{schema::v2, ManifestVersion};
 
+use crate::deployment::DeploymentTargets;
+
 /// Returns a map of component IDs to [`v2::ComponentBuildConfig`]s for the
 /// given (v1 or v2) manifest path. If the manifest cannot be loaded, the
 /// function attempts fallback: if fallback succeeds, result is Ok but the load error
 /// is also returned via the second part of the return value tuple.
 pub async fn component_build_configs(
     manifest_file: impl AsRef<Path>,
-) -> Result<(Vec<ComponentBuildInfo>, Option<spin_manifest::Error>)> {
+) -> Result<(
+    Vec<ComponentBuildInfo>,
+    DeploymentTargets,
+    Result<spin_manifest::schema::v2::AppManifest, spin_manifest::Error>,
+)> {
     let manifest = spin_manifest::manifest_from_file(&manifest_file);
     match manifest {
-        Ok(manifest) => Ok((build_configs_from_manifest(manifest), None)),
-        Err(e) => fallback_load_build_configs(&manifest_file)
-            .await
-            .map(|bc| (bc, Some(e))),
+        Ok(mut manifest) => {
+            spin_manifest::normalize::normalize_manifest(&mut manifest);
+            let bc = build_configs_from_manifest(&manifest);
+            let dt = deployment_targets_from_manifest(&manifest);
+            Ok((bc, dt, Ok(manifest)))
+        }
+        Err(e) => {
+            let bc = fallback_load_build_configs(&manifest_file).await?;
+            let dt = fallback_load_deployment_targets(&manifest_file).await?;
+            Ok((bc, dt, Err(e)))
+        }
     }
 }
 
 fn build_configs_from_manifest(
-    mut manifest: spin_manifest::schema::v2::AppManifest,
+    manifest: &spin_manifest::schema::v2::AppManifest,
 ) -> Vec<ComponentBuildInfo> {
-    spin_manifest::normalize::normalize_manifest(&mut manifest);
-
     manifest
         .components
-        .into_iter()
+        .iter()
         .map(|(id, c)| ComponentBuildInfo {
             id: id.to_string(),
-            build: c.build,
+            build: c.build.clone(),
         })
         .collect()
 }
 
+fn deployment_targets_from_manifest(
+    manifest: &spin_manifest::schema::v2::AppManifest,
+) -> DeploymentTargets {
+    let target_environments = manifest.application.targets.clone();
+    // let components = manifest
+    //     .components
+    //     .iter()
+    //     .map(|(id, c)| (id.to_string(), c.source.clone()))
+    //     .collect();
+    DeploymentTargets::new(target_environments)
+}
+
 async fn fallback_load_build_configs(
     manifest_file: impl AsRef<Path>,
 ) -> Result<Vec<ComponentBuildInfo>> {
@@ -57,6 +80,42 @@ async fn fallback_load_build_configs(
     })
 }
 
+async fn fallback_load_deployment_targets(
+    manifest_file: impl AsRef<Path>,
+) -> Result<DeploymentTargets> {
+    // fn try_parse_component_source(c: (&String, &toml::Value)) -> Option<(String, spin_manifest::schema::v2::ComponentSource)> {
+    //     let (id, ctab) = c;
+    //     let cs = ctab.as_table()
+    //         .and_then(|c| c.get("source"))
+    //         .and_then(|cs| spin_manifest::schema::v2::ComponentSource::deserialize(cs.clone()).ok());
+    //     cs.map(|cs| (id.to_string(), cs))
+    // }
+    let manifest_text = tokio::fs::read_to_string(manifest_file).await?;
+    Ok(match ManifestVersion::detect(&manifest_text)? {
+        ManifestVersion::V1 => Default::default(),
+        ManifestVersion::V2 => {
+            let table: toml::value::Table = toml::from_str(&manifest_text)?;
+            let target_environments = table
+                .get("application")
+                .and_then(|a| a.as_table())
+                .and_then(|t| t.get("targets"))
+                .and_then(|arr| arr.as_array())
+                .map(|v| v.as_slice())
+                .unwrap_or_default()
+                .iter()
+                .filter_map(|t| t.as_str())
+                .map(|s| s.to_owned())
+                .collect();
+            // let components = table
+            //     .get("component")
+            //     .and_then(|cs| cs.as_table())
+            //     .map(|table| table.iter().filter_map(try_parse_component_source).collect())
+            //     .unwrap_or_default();
+            DeploymentTargets::new(target_environments)
+        }
+    })
+}
+
 #[derive(Deserialize)]
 pub struct ComponentBuildInfo {
     #[serde(default)]

crates/build/src/manifest.rs

@@ -14,9 +14,11 @@ async-trait = { workspace = true }
 indexmap = "2"
 semver = "1"
 spin-app = { path = "../app" }
+spin-common = { path = "../common" }
 spin-componentize = { workspace = true }
 spin-serde = { path = "../serde" }
 thiserror = { workspace = true }
+tokio = { version = "1.23", features = ["fs"] }
 wac-graph = "0.6"
 
 [lints]

crates/compose/Cargo.toml

@@ -1,7 +1,7 @@
 use anyhow::Context;
 use indexmap::IndexMap;
 use semver::Version;
-use spin_app::locked::{self, InheritConfiguration, LockedComponent, LockedComponentDependency};
+use spin_app::locked::InheritConfiguration as LockedInheritConfiguration;
 use spin_serde::{DependencyName, KebabId};
 use std::collections::BTreeMap;
 use thiserror::Error;
@@ -28,18 +28,68 @@ use wac_graph::{CompositionGraph, NodeId};
 /// composition graph into a byte array and return it.
 pub async fn compose<'a, L: ComponentSourceLoader>(
     loader: &'a L,
-    component: &LockedComponent,
+    component: &L::Component,
 ) -> Result<Vec<u8>, ComposeError> {
     Composer::new(loader).compose(component).await
 }
 
+#[async_trait::async_trait]
+pub trait DependencyLike {
+    fn inherit(&self) -> InheritConfiguration;
+    fn export(&self) -> &Option<String>;
+}
+
+pub enum InheritConfiguration {
+    All,
+    Some(Vec<String>),
+}
+
+#[async_trait::async_trait]
+pub trait ComponentLike {
+    type Dependency: DependencyLike;
+
+    fn dependencies(
+        &self,
+    ) -> impl std::iter::ExactSizeIterator<Item = (&DependencyName, &Self::Dependency)>;
+    fn id(&self) -> &str;
+}
+
+#[async_trait::async_trait]
+impl ComponentLike for spin_app::locked::LockedComponent {
+    type Dependency = spin_app::locked::LockedComponentDependency;
+
+    fn dependencies(
+        &self,
+    ) -> impl std::iter::ExactSizeIterator<Item = (&DependencyName, &Self::Dependency)> {
+        self.dependencies.iter()
+    }
+
+    fn id(&self) -> &str {
+        &self.id
+    }
+}
+
+#[async_trait::async_trait]
+impl DependencyLike for spin_app::locked::LockedComponentDependency {
+    fn inherit(&self) -> InheritConfiguration {
+        match &self.inherit {
+            LockedInheritConfiguration::All => InheritConfiguration::All,
+            LockedInheritConfiguration::Some(cfgs) => InheritConfiguration::Some(cfgs.clone()),
+        }
+    }
+
+    fn export(&self) -> &Option<String> {
+        &self.export
+    }
+}
+
 /// This trait is used to load component source code from a locked component source across various embdeddings.
 #[async_trait::async_trait]
 pub trait ComponentSourceLoader {
-    async fn load_component_source(
-        &self,
-        source: &locked::LockedComponentSource,
-    ) -> anyhow::Result<Vec<u8>>;
+    type Component: ComponentLike<Dependency = Self::Dependency>;
+    type Dependency: DependencyLike;
+    async fn load_component_source(&self, source: &Self::Component) -> anyhow::Result<Vec<u8>>;
+    async fn load_dependency_source(&self, source: &Self::Dependency) -> anyhow::Result<Vec<u8>>;
 }
 
 /// Represents an error that can occur when composing dependencies.
@@ -98,19 +148,19 @@ struct Composer<'a, L> {
 }
 
 impl<'a, L: ComponentSourceLoader> Composer<'a, L> {
-    async fn compose(mut self, component: &LockedComponent) -> Result<Vec<u8>, ComposeError> {
+    async fn compose(mut self, component: &L::Component) -> Result<Vec<u8>, ComposeError> {
         let source = self
             .loader
-            .load_component_source(&component.source)
+            .load_component_source(component)
             .await
             .map_err(ComposeError::PrepareError)?;
 
-        if component.dependencies.is_empty() {
+        if component.dependencies().len() == 0 {
             return Ok(source);
         }
 
         let (world_id, instantiation_id) = self
-            .register_package(&component.id, None, source)
+            .register_package(component.id(), None, source)
             .map_err(ComposeError::PrepareError)?;
 
         let prepared = self.prepare_dependencies(world_id, component).await?;
@@ -150,15 +200,15 @@ impl<'a, L: ComponentSourceLoader> Composer<'a, L> {
     async fn prepare_dependencies(
         &mut self,
         world_id: WorldId,
-        component: &LockedComponent,
+        component: &L::Component,
     ) -> Result<IndexMap<String, DependencyInfo>, ComposeError> {
         let imports = self.graph.types()[world_id].imports.clone();
 
         let import_keys = imports.keys().cloned().collect::<Vec<_>>();
 
         let mut mappings: BTreeMap<String, Vec<DependencyInfo>> = BTreeMap::new();
 
-        for (dependency_name, dependency) in &component.dependencies {
+        for (dependency_name, dependency) in component.dependencies() {
             let mut matched = Vec::new();
 
             for import_name in &import_keys {
@@ -171,7 +221,7 @@ impl<'a, L: ComponentSourceLoader> Composer<'a, L> {
 
             if matched.is_empty() {
                 return Err(ComposeError::UnmatchedDependencyName {
-                    component_id: component.id.clone(),
+                    component_id: component.id().to_owned(),
                     dependency_name: dependency_name.clone(),
                 });
             }
@@ -195,7 +245,7 @@ impl<'a, L: ComponentSourceLoader> Composer<'a, L> {
 
         if !conflicts.is_empty() {
             return Err(ComposeError::DependencyConflicts {
-                component_id: component.id.clone(),
+                component_id: component.id().to_owned(),
                 conflicts: conflicts
                     .into_iter()
                     .map(|(import_name, infos)| {
@@ -300,19 +350,16 @@ impl<'a, L: ComponentSourceLoader> Composer<'a, L> {
     async fn register_dependency(
         &mut self,
         dependency_name: DependencyName,
-        dependency: &LockedComponentDependency,
+        dependency: &L::Dependency,
     ) -> anyhow::Result<DependencyInfo> {
-        let mut dependency_source = self
-            .loader
-            .load_component_source(&dependency.source)
-            .await?;
+        let mut dependency_source = self.loader.load_dependency_source(dependency).await?;
 
         let package_name = match &dependency_name {
             DependencyName::Package(name) => name.package.to_string(),
             DependencyName::Plain(name) => name.to_string(),
         };
 
-        match &dependency.inherit {
+        match dependency.inherit() {
             InheritConfiguration::Some(configurations) => {
                 if configurations.is_empty() {
                     // Configuration inheritance is disabled, apply deny_all adapter
@@ -333,7 +380,7 @@ impl<'a, L: ComponentSourceLoader> Composer<'a, L> {
             manifest_name: dependency_name,
             instantiation_id,
             world_id,
-            export_name: dependency.export.clone(),
+            export_name: dependency.export().clone(),
         })
     }