Support non-local Wasm. Support alternate worlds.

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

Author: itowlson

Cargo.lock

@@ -9,7 +9,7 @@ anyhow = "1.0.57"
 futures = "0.3.21"
 serde = { version = "1.0", features = ["derive"] }
 spin-common = { path = "../common" }
-spin-environments = { path = "../environments" }  # TODO: it would be good to break this dependency because not everything should have to drag this dep around
+spin-environments = { path = "../environments" }
 spin-manifest = { path = "../manifest" }
 subprocess = "0.2.8"
 terminal = { path = "../terminal" }

crates/build/Cargo.toml

@@ -18,7 +18,7 @@ spin-componentize = { workspace = true }
 spin-serde = { path = "../serde" }
 thiserror = "1"
 tokio = { version = "1.23", features = ["fs"] }
-wac-graph = "0.5.0"
+wac-graph = "0.6.0"
 
 [lints]
 workspace = true

crates/compose/Cargo.toml

@@ -15,11 +15,12 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 spin-common = { path = "../common" }
 spin-componentize = { path = "../componentize" }
+spin-loader = { path = "../loader" }
 spin-manifest = { path = "../manifest" }
 tracing = { workspace = true }
-wac-parser = "0.5.0"
-wac-resolver = "0.5.0"
-wac-types = "0.5.0"
+wac-parser = "0.6.0"
+wac-resolver = "0.6.0"
+wac-types = "0.6.0"
 wasm-pkg-loader = "0.4.1"
 
 [lints]

crates/environments/Cargo.toml

@@ -8,15 +8,28 @@ use wasm_pkg_loader::PackageRef;
 struct TargetWorld {
     wit_package: PackageRef,
     package_ver: String, // TODO: tidy to semver::Version
-    world_name: String,
+    world_name: WorldNames,
+}
+
+#[derive(Debug, Eq, Hash, PartialEq, serde::Deserialize)]
+#[serde(untagged)]
+enum WorldNames {
+    Exactly(String),
+    AnyOf(Vec<String>),
 }
 
 impl TargetWorld {
-    fn versioned_name(&self) -> String {
-        format!(
-            "{}/{}@{}",
-            self.wit_package, self.world_name, self.package_ver
-        )
+    fn versioned_name(&self, world_name: &str) -> String {
+        format!("{}/{}@{}", self.wit_package, world_name, self.package_ver)
+    }
+
+    fn versioned_names(&self) -> Vec<String> {
+        match &self.world_name {
+            WorldNames::Exactly(name) => vec![self.versioned_name(name)],
+            WorldNames::AnyOf(names) => {
+                names.iter().map(|name| self.versioned_name(name)).collect()
+            }
+        }
     }
 }
 
@@ -59,22 +72,20 @@ fn component_source<'a>(
         .component
         .as_ref()
         .ok_or_else(|| anyhow!("No component specified for trigger {}", trigger.id))?;
-    let (id, csrc) = match component_spec {
+    let (id, source) = match component_spec {
         spin_manifest::schema::v2::ComponentSpec::Inline(c) => (trigger.id.as_str(), &c.source),
-        spin_manifest::schema::v2::ComponentSpec::Reference(r) => (
-            r.as_ref(),
-            &app.components
-                .get(r)
-                .ok_or_else(|| {
-                    anyhow!(
-                        "Component {r} specified for trigger {} does not exist",
-                        trigger.id
-                    )
-                })?
-                .source,
-        ),
+        spin_manifest::schema::v2::ComponentSpec::Reference(r) => {
+            let id = r.as_ref();
+            let Some(component) = app.components.get(r) else {
+                anyhow::bail!(
+                    "Component {id} specified for trigger {} does not exist",
+                    trigger.id
+                );
+            };
+            (id, &component.source)
+        }
     };
-    Ok(ComponentToValidate { id, source: csrc })
+    Ok(ComponentToValidate { id, source })
 }
 
 pub async fn validate_application_against_environment_ids(
@@ -180,32 +191,28 @@ async fn validate_component_against_environments(
                 .map(|w| (e.name.as_str(), w))
         })
         .collect::<Result<std::collections::HashSet<_>, _>>()?;
-    validate_file_against_worlds(worlds.into_iter(), component, resolution_context).await?;
+    validate_component_against_worlds(worlds.into_iter(), component, resolution_context).await?;
     Ok(())
 }
 
 impl ResolutionContext {
-    async fn load_wasm(
-        &self,
-        source: &spin_manifest::schema::v2::ComponentSource,
-    ) -> anyhow::Result<Vec<u8>> {
-        if let spin_manifest::schema::v2::ComponentSource::Local(path) = source {
-            let wasm_file = self.base_dir.join(path);
-            Ok(std::fs::read(&wasm_file)
-                .with_context(|| format!("Can't read Wasm file {}", quoted_path(wasm_file)))?)
-        } else {
-            anyhow::bail!("can't do non-local component sources yet");
-        }
+    async fn load_wasm(&self, component: &ComponentToValidate<'_>) -> anyhow::Result<Vec<u8>> {
+        let loader = spin_loader::WasmLoader::new(self.base_dir.clone(), None, None).await?;
+        let wasm_file = loader
+            .load_component_source(component.id, component.source)
+            .await?;
+        std::fs::read(&wasm_file)
+            .with_context(|| format!("Can't read Wasm file {}", quoted_path(wasm_file)))
     }
 }
 
-async fn validate_file_against_worlds(
+async fn validate_component_against_worlds(
     target_worlds: impl Iterator<Item = (&str, &TargetWorld)>,
     component: &ComponentToValidate<'_>,
     resolution_context: &ResolutionContext,
 ) -> anyhow::Result<()> {
     let raw_wasm = resolution_context
-        .load_wasm(component.source)
+        .load_wasm(component)
         .await
         .with_context(|| format!("Couldn't read Wasm {}", component.source_description()))?;
     // FUTURE: take in manifest composition as well
@@ -218,14 +225,8 @@ async fn validate_file_against_worlds(
         })?;
 
     for (env_name, target_world) in target_worlds {
-        validate_wasm_against_world(env_name, target_world, component, cooked_wasm.as_ref())
+        validate_wasm_against_any_world(env_name, target_world, component, cooked_wasm.as_ref())
             .await?;
-        tracing::info!(
-            "Validated component {} {} against target world {}",
-            component.id,
-            component.source_description(),
-            target_world.versioned_name()
-        );
     }
 
     tracing::info!(
@@ -236,13 +237,48 @@ async fn validate_file_against_worlds(
     Ok(())
 }
 
-async fn validate_wasm_against_world(
+async fn validate_wasm_against_any_world(
     env_name: &str,
     target_world: &TargetWorld,
     component: &ComponentToValidate<'_>,
     wasm: &[u8],
 ) -> anyhow::Result<()> {
-    let target_str = target_world.versioned_name();
+    let mut result = Ok(());
+    for target_str in target_world.versioned_names() {
+        tracing::info!(
+            "Trying component {} {} against target world {target_str}",
+            component.id,
+            component.source_description(),
+        );
+        match validate_wasm_against_world(env_name, &target_str, component, wasm).await {
+            Ok(()) => {
+                tracing::info!(
+                    "Validated component {} {} against target world {target_str}",
+                    component.id,
+                    component.source_description(),
+                );
+                return Ok(());
+            }
+            Err(e) => {
+                // Record the error, but continue in case a different world succeeds
+                tracing::info!(
+                    "Rejecting component {} {} for target world {target_str} because {e:?}",
+                    component.id,
+                    component.source_description(),
+                );
+                result = Err(e);
+            }
+        }
+    }
+    result
+}
+
+async fn validate_wasm_against_world(
+    env_name: &str,
+    target_str: &str,
+    component: &ComponentToValidate<'_>,
+    wasm: &[u8],
+) -> anyhow::Result<()> {
     let comp_name = "root:component";
 
     let wac_text = format!(
@@ -266,7 +302,7 @@ async fn validate_wasm_against_world(
         .await
         .context("reg_resolver.resolve failed")?;
 
-    packages.insert(compkey, wasm.to_owned().to_vec());
+    packages.insert(compkey, wasm.to_vec());
 
     match doc.resolve(packages) {
         Ok(_) => Ok(()),

crates/environments/src/lib.rs

@@ -23,6 +23,8 @@ mod fs;
 mod http;
 mod local;
 
+pub use local::WasmLoader;
+
 /// Maximum number of files to copy (or download) concurrently
 pub(crate) const MAX_FILE_LOADING_CONCURRENCY: usize = 16;