Less ghastly

Signed-off-by: itowlson <ivan.towlson@fermyon.com>

Author: itowlson

crates/build/src/lib.rs

@@ -64,20 +64,21 @@ pub async fn build(
             manifest.clone(),
             manifest_file.parent().unwrap(),
         )
-        .await?;
-        let errors = spin_environments::validate_application_against_environment_ids(
+        .await
+        .context("unable to load application for checking against deployment targets")?;
+        let target_validation = spin_environments::validate_application_against_environment_ids(
             &application,
             build_info.deployment_targets(),
             cache_root.clone(),
             &app_dir,
         )
-        .await?;
-
-        for error in &errors {
-            terminal::error!("{error}");
-        }
+        .await
+        .context("unable to check if the application is compatible with deployment targets")?;
 
-        if !errors.is_empty() {
+        if !target_validation.is_ok() {
+            for error in target_validation.errors() {
+                terminal::error!("{error}");
+            }
             anyhow::bail!("All components built successfully, but one or more was incompatible with one or more of the deployment targets.");
         }
     }

crates/build/src/manifest.rs

@@ -8,7 +8,7 @@ use spin_manifest::{schema::v2, ManifestVersion};
 pub enum ManifestBuildInfo {
     Loadable {
         components: Vec<ComponentBuildInfo>,
-        deployment_targets: Vec<spin_manifest::schema::v2::TargetEnvironmentRef2>,
+        deployment_targets: Vec<spin_manifest::schema::v2::TargetEnvironmentRef>,
         manifest: spin_manifest::schema::v2::AppManifest,
     },
     Unloadable {
@@ -33,7 +33,7 @@ impl ManifestBuildInfo {
         }
     }
 
-    pub fn deployment_targets(&self) -> &[spin_manifest::schema::v2::TargetEnvironmentRef2] {
+    pub fn deployment_targets(&self) -> &[spin_manifest::schema::v2::TargetEnvironmentRef] {
         match self {
             Self::Loadable {
                 deployment_targets, ..
@@ -114,7 +114,7 @@ fn build_configs_from_manifest(
 
 fn deployment_targets_from_manifest(
     manifest: &spin_manifest::schema::v2::AppManifest,
-) -> Vec<spin_manifest::schema::v2::TargetEnvironmentRef2> {
+) -> Vec<spin_manifest::schema::v2::TargetEnvironmentRef> {
     manifest.application.targets.clone()
 }
 

crates/environments/src/environment.rs

@@ -0,0 +1,192 @@
+use std::{collections::HashMap, path::Path};
+
+use anyhow::Context;
+use spin_common::ui::quoted_path;
+use spin_manifest::schema::v2::TargetEnvironmentRef;
+
+mod definition;
+mod env_loader;
+mod lockfile;
+
+use definition::WorldName;
+
+/// A fully realised deployment environment, e.g. Spin 2.7,
+/// SpinKube 3.1, Fermyon Cloud. The `TargetEnvironment` provides a mapping
+/// from the Spin trigger types supported in the environment to the Component Model worlds
+/// supported by that trigger type. (A trigger type may support more than one world,
+/// for example when it supports multiple versions of the Spin or WASI interfaces.)
+pub struct TargetEnvironment {
+    name: String,
+    trigger_worlds: HashMap<TriggerType, CandidateWorlds>,
+    unknown_trigger: UnknownTrigger,
+}
+
+impl TargetEnvironment {
+    /// Loads the specified list of environments. This fetches all required
+    /// environment definitions from their references, and then chases packages
+    /// references until the entire target environment is fully loaded.
+    /// The function also caches registry references in the application directory,
+    /// to avoid loading from the network when the app is validated again.
+    pub async fn load_all(
+        env_ids: &[TargetEnvironmentRef],
+        cache_root: Option<std::path::PathBuf>,
+        app_dir: &std::path::Path,
+    ) -> anyhow::Result<Vec<Self>> {
+        env_loader::load_environments(env_ids, cache_root, app_dir).await
+    }
+
+    /// The environment name for UI purposes
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Returns true if the given trigger type can run in this environment.
+    pub fn supports_trigger_type(&self, trigger_type: &TriggerType) -> bool {
+        self.unknown_trigger.allows(trigger_type) || self.trigger_worlds.contains_key(trigger_type)
+    }
+
+    /// Lists all worlds supported for the given trigger type in this environment.
+    pub fn worlds(&self, trigger_type: &TriggerType) -> &CandidateWorlds {
+        self.trigger_worlds
+            .get(trigger_type)
+            .or_else(|| self.unknown_trigger.worlds())
+            .unwrap_or(NO_WORLDS)
+    }
+}
+
+/// How a `TargetEnvironment` should validate components associated with trigger types
+/// not listed in the/ environment definition. This is used for best-effort validation in
+/// extensible environments.
+///
+/// For example, a "forgiving" definition of Spin CLI environment would
+/// validate that components associated with `cron` or `sqs` triggers adhere
+/// to the platform world, even though it cannot validate that the exports are correct
+/// or that the plugins are installed or up to date. This can result in failure at
+/// runtime, but that may be better than refusing to let cron jobs run!
+///
+/// On the other hand, the SpinKube environment rejects unknown triggers
+/// because SpinKube does not allow arbitrary triggers to be linked at
+/// runtime: the set of triggers is static for a given version.
+enum UnknownTrigger {
+    /// Components for unknown trigger types fail validation.
+    Deny,
+    /// Components for unknown trigger types pass validation if they
+    /// conform to (at least) one of the listed worlds.
+    Allow(CandidateWorlds),
+}
+
+impl UnknownTrigger {
+    fn allows(&self, _trigger_type: &TriggerType) -> bool {
+        matches!(self, Self::Allow(_))
+    }
+
+    fn worlds(&self) -> Option<&CandidateWorlds> {
+        match self {
+            Self::Deny => None,
+            Self::Allow(cw) => Some(cw),
+        }
+    }
+}
+
+/// The set of worlds that a particular trigger type (in a given environment)
+/// can accept. For example, the Spin 3.2 CLI `http` trigger accepts various
+/// versions of the `spin:up/http-trigger` world.
+///
+/// A component will pass target validation if it conforms to
+/// at least one of these worlds.
+#[derive(Default)]
+pub struct CandidateWorlds {
+    worlds: Vec<CandidateWorld>,
+}
+
+impl<'a> IntoIterator for &'a CandidateWorlds {
+    type Item = &'a CandidateWorld;
+
+    type IntoIter = std::slice::Iter<'a, CandidateWorld>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.worlds.iter()
+    }
+}
+
+const NO_WORLDS: &CandidateWorlds = &CandidateWorlds { worlds: vec![] };
+
+/// A WIT world; specifically, a WIT world provided by a Spin host, against which
+/// a component can be validated.
+pub struct CandidateWorld {
+    world: WorldName,
+    package: wit_parser::Package,
+    package_bytes: Vec<u8>,
+}
+
+impl std::fmt::Display for CandidateWorld {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.world.fmt(f)
+    }
+}
+
+impl CandidateWorld {
+    /// Namespaced but unversioned package name (e.g. spin:up)
+    pub fn package_namespaced_name(&self) -> String {
+        format!("{}:{}", self.package.name.namespace, self.package.name.name)
+    }
+
+    /// The package version for the environment package.
+    pub fn package_version(&self) -> Option<&semver::Version> {
+        self.package.name.version.as_ref()
+    }
+
+    /// The Wasm-encoded bytes of the environment package.
+    pub fn package_bytes(&self) -> &[u8] {
+        &self.package_bytes
+    }
+
+    fn from_package_bytes(world: &WorldName, bytes: Vec<u8>) -> anyhow::Result<Self> {
+        let decoded = wit_component::decode(&bytes)
+            .with_context(|| format!("Failed to decode package for environment {world}"))?;
+        let package_id = decoded.package();
+        let package = decoded
+            .resolve()
+            .packages
+            .get(package_id)
+            .with_context(|| {
+                format!("The {world} package is invalid (no package for decoded package ID)")
+            })?
+            .clone();
+
+        Ok(Self {
+            world: world.to_owned(),
+            package,
+            package_bytes: bytes,
+        })
+    }
+
+    fn from_decoded_wasm(
+        world: &WorldName,
+        source: &Path,
+        decoded: wit_parser::decoding::DecodedWasm,
+    ) -> anyhow::Result<Self> {
+        let package_id = decoded.package();
+        let package = decoded
+            .resolve()
+            .packages
+            .get(package_id)
+            .with_context(|| {
+                format!(
+                    "The {} environment is invalid (no package for decoded package ID)",
+                    quoted_path(source)
+                )
+            })?
+            .clone();
+
+        let bytes = wit_component::encode(decoded.resolve(), package_id)?;
+
+        Ok(Self {
+            world: world.to_owned(),
+            package,
+            package_bytes: bytes,
+        })
+    }
+}
+
+pub type TriggerType = String;

crates/environments/src/environment/definition.rs

@@ -0,0 +1,125 @@
+//! Environment definition types and serialisation (TOML) formats
+//!
+//! This module does *not* cover loading those definitions from remote
+//! sources, or materialising WIT packages from files or registry references -
+//! only the types.
+
+use std::collections::HashMap;
+
+use anyhow::Context;
+
+/// An environment definition, usually deserialised from a TOML document.
+/// Example:
+///
+/// ```
+/// # spin-up.3.2.toml
+/// [triggers]
+/// http = ["spin:up/http-trigger@3.2.0", "spin:up/http-trigger-rc20231018@3.2.0"]
+/// redis = ["spin:up/redis-trigger@3.2.0"]
+/// ```
+#[derive(Debug, serde::Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct EnvironmentDefinition {
+    triggers: HashMap<String, Vec<WorldRef>>,
+    default: Option<Vec<WorldRef>>,
+}
+
+impl EnvironmentDefinition {
+    pub fn triggers(&self) -> &HashMap<String, Vec<WorldRef>> {
+        &self.triggers
+    }
+
+    pub fn default(&self) -> Option<&Vec<WorldRef>> {
+        self.default.as_ref()
+    }
+}
+
+/// A reference to a world in an [EnvironmentDefinition]. This is formed
+/// of a fully qualified (ns:pkg/id) world name, optionally with
+/// a location from which to get the package (a registry or WIT directory).
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(untagged, deny_unknown_fields)]
+pub enum WorldRef {
+    DefaultRegistry(WorldName),
+    Registry {
+        registry: String,
+        world: WorldName,
+    },
+    WitDirectory {
+        path: std::path::PathBuf,
+        world: WorldName,
+    },
+}
+
+/// The qualified name of a world, e.g. spin:up/http-trigger@3.2.0.
+///
+/// (Internally it is represented as a PackageName plus unqualified
+/// world name, but it stringises to the standard WIT qualified name.)
+#[derive(Clone, Debug, serde::Deserialize)]
+#[serde(try_from = "String")]
+pub struct WorldName {
+    package: wit_parser::PackageName,
+    world: String,
+}
+
+impl WorldName {
+    pub fn package(&self) -> &wit_parser::PackageName {
+        &self.package
+    }
+
+    pub fn package_namespaced_name(&self) -> String {
+        format!("{}:{}", self.package.namespace, self.package.name)
+    }
+
+    pub fn package_ref(&self) -> anyhow::Result<wasm_pkg_client::PackageRef> {
+        let pkg_name = self.package_namespaced_name();
+        pkg_name
+            .parse()
+            .with_context(|| format!("Environment {pkg_name} is not a valid package name"))
+    }
+
+    pub fn package_version(&self) -> Option<&semver::Version> {
+        self.package.version.as_ref()
+    }
+}
+
+impl TryFrom<String> for WorldName {
+    type Error = anyhow::Error;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        use wasmparser::names::{ComponentName, ComponentNameKind};
+
+        // World qnames have the same syntactic form as interface qnames
+        let parsed = ComponentName::new(&value, 0)?;
+        let ComponentNameKind::Interface(itf) = parsed.kind() else {
+            anyhow::bail!("{value} is not a well-formed world name");
+        };
+
+        let package = wit_parser::PackageName {
+            namespace: itf.namespace().to_string(),
+            name: itf.package().to_string(),
+            version: itf.version(),
+        };
+
+        let world = itf.interface().to_string();
+
+        Ok(Self { package, world })
+    }
+}
+
+impl std::fmt::Display for WorldName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.package.namespace)?;
+        f.write_str(":")?;
+        f.write_str(&self.package.name)?;
+        f.write_str("/")?;
+        f.write_str(&self.world)?;
+
+        if let Some(v) = self.package.version.as_ref() {
+            f.write_str("@")?;
+            f.write_str(&v.to_string())?;
+        }
+
+        Ok(())
+    }
+}