Validate host requirements as part of target environments

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

Author: itowlson

crates/environments/src/environment.rs

@@ -18,7 +18,9 @@ use definition::WorldName;
 pub struct TargetEnvironment {
     name: String,
     trigger_worlds: HashMap<TriggerType, CandidateWorlds>,
+    trigger_capabilities: HashMap<TriggerType, Vec<String>>,
     unknown_trigger: UnknownTrigger,
+    unknown_capabilities: Vec<String>,
 }
 
 impl TargetEnvironment {
@@ -52,6 +54,13 @@ impl TargetEnvironment {
             .or_else(|| self.unknown_trigger.worlds())
             .unwrap_or(NO_WORLDS)
     }
+
+    /// Lists all host capabilities supported for the given trigger type in this environment.
+    pub fn capabilities(&self, trigger_type: &TriggerType) -> &[String] {
+        self.trigger_capabilities
+            .get(trigger_type)
+            .unwrap_or(&self.unknown_capabilities)
+    }
 }
 
 /// How a `TargetEnvironment` should validate components associated with trigger types
@@ -229,7 +238,9 @@ mod test {
         TargetEnvironment {
             name: "test".to_owned(),
             trigger_worlds: [("s".to_owned(), candidate_worlds)].into_iter().collect(),
+            trigger_capabilities: Default::default(),
             unknown_trigger: UnknownTrigger::Deny,
+            unknown_capabilities: Default::default(),
         }
     }
 
@@ -242,7 +253,9 @@ mod test {
         TargetEnvironment {
             name: "test".to_owned(),
             trigger_worlds: [].into_iter().collect(),
+            trigger_capabilities: Default::default(),
             unknown_trigger: UnknownTrigger::Allow(candidate_worlds),
+            unknown_capabilities: Default::default(),
         }
     }
 
@@ -260,7 +273,7 @@ mod test {
         assert!(env.supports_trigger_type(&"s".to_owned()));
         assert!(!env.supports_trigger_type(&"t".to_owned()));
 
-        let component = crate::ComponentToValidate::new("scomp", "scomp.wasm", wasm);
+        let component = crate::ComponentToValidate::new("scomp", "scomp.wasm", wasm, vec![]);
         let errs =
             crate::validate_component_against_environments(&[env], &"s".to_owned(), &component)
                 .await;
@@ -291,7 +304,7 @@ mod test {
 
         assert!(env.supports_trigger_type(&non_existent_trigger));
 
-        let component = crate::ComponentToValidate::new("comp", "comp.wasm", wasm);
+        let component = crate::ComponentToValidate::new("comp", "comp.wasm", wasm, vec![]);
         let errs = crate::validate_component_against_environments(
             &[env],
             &non_existent_trigger,
@@ -308,6 +321,46 @@ mod test {
         );
     }
 
+    #[tokio::test]
+    async fn can_validate_component_with_host_requirement() {
+        let wit_path = PathBuf::from(SIMPLE_WIT_DIR);
+
+        let wit_text = tokio::fs::read_to_string(wit_path.join("world.wit"))
+            .await
+            .unwrap();
+        let wasm = generate_dummy_component(&wit_text, "spin:test/[email protected]");
+
+        let mut env = target_simple_world(&wit_path);
+        env.trigger_capabilities.insert(
+            "s".to_owned(),
+            vec![
+                "local_spline_reticulation".to_owned(),
+                "nice_cup_of_tea".to_owned(),
+            ],
+        );
+
+        assert!(env.supports_trigger_type(&"s".to_owned()));
+        assert!(!env.supports_trigger_type(&"t".to_owned()));
+
+        let component = crate::ComponentToValidate::new(
+            "cscomp",
+            "cscomp.wasm",
+            wasm,
+            vec!["nice_cup_of_tea".to_string()],
+        );
+        let errs =
+            crate::validate_component_against_environments(&[env], &"s".to_owned(), &component)
+                .await;
+        assert!(
+            errs.is_empty(),
+            "{}",
+            errs.iter()
+                .map(|e| e.to_string())
+                .collect::<Vec<_>>()
+                .join("\n")
+        );
+    }
+
     #[tokio::test]
     async fn unavailable_import_invalidates_component() {
         let wit_path = PathBuf::from(SIMPLE_WIT_DIR);
@@ -319,7 +372,7 @@ mod test {
 
         let env = target_simple_world(&wit_path);
 
-        let component = crate::ComponentToValidate::new("nscomp", "nscomp.wasm", wasm);
+        let component = crate::ComponentToValidate::new("nscomp", "nscomp.wasm", wasm, vec![]);
         let errs =
             crate::validate_component_against_environments(&[env], &"s".to_owned(), &component)
                 .await;
@@ -346,7 +399,7 @@ mod test {
 
         let env = target_simple_world(&wit_path);
 
-        let component = crate::ComponentToValidate::new("tdscomp", "tdscomp.wasm", wasm);
+        let component = crate::ComponentToValidate::new("tdscomp", "tdscomp.wasm", wasm, vec![]);
         let errs =
             crate::validate_component_against_environments(&[env], &"s".to_owned(), &component)
                 .await;
@@ -359,6 +412,39 @@ mod test {
         );
     }
 
+    #[tokio::test]
+    async fn unsupported_host_req_invalidates_component() {
+        let wit_path = PathBuf::from(SIMPLE_WIT_DIR);
+
+        let wit_text = tokio::fs::read_to_string(wit_path.join("world.wit"))
+            .await
+            .unwrap();
+        let wasm = generate_dummy_component(&wit_text, "spin:test/[email protected]");
+
+        let env = target_simple_world(&wit_path);
+
+        assert!(env.supports_trigger_type(&"s".to_owned()));
+        assert!(!env.supports_trigger_type(&"t".to_owned()));
+
+        let component = crate::ComponentToValidate::new(
+            "cscomp",
+            "cscomp.wasm",
+            wasm,
+            vec!["nice_cup_of_tea".to_string()],
+        );
+        let errs =
+            crate::validate_component_against_environments(&[env], &"s".to_owned(), &component)
+                .await;
+        assert!(!errs.is_empty());
+
+        let err = errs[0].to_string();
+        assert!(
+            err.contains("Component cscomp can't run in environment test"),
+            "unexpected error {err}"
+        );
+        assert!(err.contains("nice_cup_of_tea"), "unexpected error {err}");
+    }
+
     fn generate_dummy_component(wit: &str, world: &str) -> Vec<u8> {
         let mut resolve = wit_parser::Resolve::default();
         let package_id = resolve.push_str("test", wit).expect("should parse WIT");

crates/environments/src/environment/definition.rs

@@ -14,22 +14,44 @@ use anyhow::Context;
 /// ```ignore
 /// # spin-up.3.2.toml
 /// [triggers]
-/// http = ["spin:up/[email protected]", "spin:up/[email protected]"]
-/// redis = ["spin:up/[email protected]"]
+/// http = { worlds = ["spin:up/[email protected]", "spin:up/[email protected]"], capabilities = ["local_service_chaining"] }
+/// redis = { worlds = ["spin:up/[email protected]"] }
 /// ```
 #[derive(Debug, serde::Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct EnvironmentDefinition {
-    triggers: HashMap<String, Vec<WorldRef>>,
-    default: Option<Vec<WorldRef>>,
+    triggers: HashMap<String, TriggerEnvironment>,
+    #[serde(default)]
+    default: Option<TriggerEnvironment>,
+}
+
+/// The environment definition for a trigger, comprising the worlds which are
+/// compatible with that trigger and the host capabilities which the trigger
+/// supports.
+#[derive(Debug, serde::Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct TriggerEnvironment {
+    worlds: Vec<WorldRef>,
+    #[serde(default)]
+    capabilities: Vec<String>,
+}
+
+impl TriggerEnvironment {
+    pub fn world_refs(&self) -> &[WorldRef] {
+        &self.worlds
+    }
+
+    pub fn capabilities(&self) -> Vec<String> {
+        self.capabilities.clone()
+    }
 }
 
 impl EnvironmentDefinition {
-    pub fn triggers(&self) -> &HashMap<String, Vec<WorldRef>> {
+    pub fn triggers(&self) -> &HashMap<String, TriggerEnvironment> {
         &self.triggers
     }
 
-    pub fn default(&self) -> Option<&Vec<WorldRef>> {
+    pub fn default(&self) -> Option<&TriggerEnvironment> {
         self.default.as_ref()
     }
 }

crates/environments/src/environment/env_loader.rs

@@ -128,25 +128,33 @@ async fn load_environment_from_toml(
     let env: EnvironmentDefinition = toml::from_str(toml_text)?;
 
     let mut trigger_worlds = HashMap::new();
+    let mut trigger_capabilities = HashMap::new();
 
     // TODO: parallel all the things
     // TODO: this loads _all_ triggers not just the ones we need
-    for (trigger_type, world_refs) in env.triggers() {
+    for (trigger_type, trigger_env) in env.triggers() {
         trigger_worlds.insert(
             trigger_type.to_owned(),
-            load_worlds(world_refs, cache, lockfile).await?,
+            load_worlds(trigger_env.world_refs(), cache, lockfile).await?,
         );
+        trigger_capabilities.insert(trigger_type.to_owned(), trigger_env.capabilities());
     }
 
     let unknown_trigger = match env.default() {
         None => UnknownTrigger::Deny,
-        Some(world_refs) => UnknownTrigger::Allow(load_worlds(world_refs, cache, lockfile).await?),
+        Some(env) => UnknownTrigger::Allow(load_worlds(env.world_refs(), cache, lockfile).await?),
+    };
+    let unknown_capabilities = match env.default() {
+        None => vec![],
+        Some(env) => env.capabilities(),
     };
 
     Ok(TargetEnvironment {
         name: name.to_owned(),
         trigger_worlds,
+        trigger_capabilities,
         unknown_trigger,
+        unknown_capabilities,
     })
 }
 

crates/environments/src/lib.rs

@@ -102,6 +102,11 @@ async fn validate_component_against_environments(
         {
             errs.push(e);
         }
+
+        let host_caps = env.capabilities(trigger_type);
+        if let Some(e) = validate_host_reqs(env, host_caps, component).err() {
+            errs.push(e);
+        }
     }
 
     if errs.is_empty() {
@@ -215,3 +220,25 @@ async fn validate_wasm_against_world(
         },
     }
 }
+
+fn validate_host_reqs(
+    env: &TargetEnvironment,
+    host_caps: &[String],
+    component: &ComponentToValidate,
+) -> anyhow::Result<()> {
+    let unsatisfied: Vec<_> = component
+        .host_requirements()
+        .iter()
+        .filter(|host_req| !satisfies(host_caps, host_req))
+        .cloned()
+        .collect();
+    if unsatisfied.is_empty() {
+        Ok(())
+    } else {
+        Err(anyhow!("Component {} can't run in environment {} because it requires the feature(s) '{}' which the environment does not support", component.id(), env.name(), unsatisfied.join(", ")))
+    }
+}
+
+fn satisfies(host_caps: &[String], host_req: &String) -> bool {
+    host_caps.contains(host_req)
+}

crates/environments/src/loader.rs

@@ -10,6 +10,7 @@ pub(crate) struct ComponentToValidate<'a> {
     id: &'a str,
     source_description: String,
     wasm: Vec<u8>,
+    host_requirements: Vec<String>,
 }
 
 impl ComponentToValidate<'_> {
@@ -25,12 +26,22 @@ impl ComponentToValidate<'_> {
         &self.wasm
     }
 
+    pub fn host_requirements(&self) -> &[String] {
+        &self.host_requirements
+    }
+
     #[cfg(test)]
-    pub(crate) fn new(id: &'static str, description: &str, wasm: Vec<u8>) -> Self {
+    pub(crate) fn new(
+        id: &'static str,
+        description: &str,
+        wasm: Vec<u8>,
+        host_requirements: Vec<String>,
+    ) -> Self {
         Self {
             id,
             source_description: description.to_owned(),
             wasm,
+            host_requirements,
         }
     }
 }
@@ -61,10 +72,13 @@ impl ApplicationToValidate {
             .component
             .as_ref()
             .ok_or_else(|| anyhow!("No component specified for trigger {}", trigger.id))?;
-        let (id, source, dependencies) = match component_spec {
-            spin_manifest::schema::v2::ComponentSpec::Inline(c) => {
-                (trigger.id.as_str(), &c.source, &c.dependencies)
-            }
+        let (id, source, dependencies, service_chaining) = match component_spec {
+            spin_manifest::schema::v2::ComponentSpec::Inline(c) => (
+                trigger.id.as_str(),
+                &c.source,
+                &c.dependencies,
+                spin_loader::requires_service_chaining(c),
+            ),
             spin_manifest::schema::v2::ComponentSpec::Reference(r) => {
                 let id = r.as_ref();
                 let Some(component) = self.manifest.components.get(r) else {
@@ -73,14 +87,20 @@ impl ApplicationToValidate {
                         trigger.id
                     );
                 };
-                (id, &component.source, &component.dependencies)
+                (
+                    id,
+                    &component.source,
+                    &component.dependencies,
+                    spin_loader::requires_service_chaining(component),
+                )
             }
         };
 
         Ok(ComponentSource {
             id,
             source,
             dependencies: WrappedComponentDependencies::new(dependencies),
+            requires_service_chaining: service_chaining,
         })
     }
 
@@ -127,10 +147,17 @@ impl ApplicationToValidate {
 
         let wasm = spin_compose::compose(&loader, &component).await.with_context(|| format!("Spin needed to compose dependencies for {} as part of target checking, but composition failed", component.id))?;
 
+        let host_requirements = if component.requires_service_chaining {
+            vec!["local_service_chaining".to_string()]
+        } else {
+            vec![]
+        };
+
         Ok(ComponentToValidate {
             id: component.id,
             source_description: source_description(component.source),
             wasm,
+            host_requirements,
         })
     }
 }
@@ -139,6 +166,7 @@ struct ComponentSource<'a> {
     id: &'a str,
     source: &'a spin_manifest::schema::v2::ComponentSource,
     dependencies: WrappedComponentDependencies,
+    requires_service_chaining: bool,
 }
 
 struct ComponentSourceLoader<'a> {

crates/loader/src/lib.rs

@@ -23,6 +23,7 @@ mod fs;
 mod http;
 mod local;
 
+pub use local::requires_service_chaining;
 pub use local::WasmLoader;
 
 /// Maximum number of files to copy (or download) concurrently