Plan C

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

Author: itowlson

crates/build/src/lib.rs

@@ -77,7 +77,6 @@ pub async fn build(
             build_info.deployment_targets(),
             cache_root.clone(),
             &app_dir,
-            profile,
         )
         .await
         .context("unable to check if the application is compatible with deployment targets")?;
@@ -166,7 +165,7 @@ fn build_component(build_info: ComponentBuildInfo, app_dir: &Path) -> Result<()>
                 );
             }
 
-            for (index, command) in b.commands().iter().enumerate() {
+            for (index, command) in b.commands().enumerate() {
                 if command_count > 1 {
                     terminal::step!(
                         "Running build step",
@@ -341,7 +340,8 @@ mod tests {
     #[tokio::test]
     async fn has_meaningful_error_if_target_env_does_not_match() {
         let manifest_file = test_data_root().join("bad_target_env.toml");
-        let manifest = spin_manifest::manifest_from_file(&manifest_file).unwrap();
+        let mut manifest = spin_manifest::manifest_from_file(&manifest_file).unwrap();
+        spin_manifest::normalize::normalize_manifest(&mut manifest, None);
         let application = spin_environments::ApplicationToValidate::new(
             manifest.clone(),
             manifest_file.parent().unwrap(),
@@ -355,7 +355,6 @@ mod tests {
             &manifest.application.targets,
             None,
             manifest_file.parent().unwrap(),
-            None,
         )
         .await
         .context("unable to check if the application is compatible with deployment targets")

crates/build/src/manifest.rs

@@ -75,8 +75,8 @@ pub async fn component_build_configs(
         Ok(mut manifest) => {
             manifest.ensure_profile(profile)?;
 
-            spin_manifest::normalize::normalize_manifest(&mut manifest);
-            let components = build_configs_from_manifest(&manifest, profile);
+            spin_manifest::normalize::normalize_manifest(&mut manifest, profile);
+            let components = build_configs_from_manifest(&manifest);
             let deployment_targets = deployment_targets_from_manifest(&manifest);
             Ok(ManifestBuildInfo::Loadable {
                 components,
@@ -106,14 +106,13 @@ pub async fn component_build_configs(
 
 fn build_configs_from_manifest(
     manifest: &spin_manifest::schema::v2::AppManifest,
-    profile: Option<&str>,
 ) -> Vec<ComponentBuildInfo> {
     manifest
         .components
         .iter()
         .map(|(id, c)| ComponentBuildInfo {
             id: id.to_string(),
-            build: c.build(profile),
+            build: c.build.clone(),
         })
         .collect()
 }

crates/doctor/src/rustlang/target.rs

@@ -17,9 +17,10 @@ impl Diagnostic for TargetDiagnostic {
         let manifest_str = patient.manifest_doc.to_string();
         let manifest = spin_manifest::manifest_from_str(&manifest_str)?;
         let uses_rust = manifest.components.values().any(|c| {
-            c.build_commands(None)
-                .iter()
-                .any(|c| c.starts_with("cargo"))
+            c.build
+                .as_ref()
+                .map(|b| b.commands().any(|c| c.starts_with("cargo")))
+                .unwrap_or_default()
         });
 
         if uses_rust {

crates/doctor/src/wasm.rs

@@ -33,14 +33,14 @@ impl PatientWasm {
     }
 
     pub fn source_path(&self) -> Option<&Path> {
-        match &self.component.source(None) {
+        match &self.component.source {
             v2::ComponentSource::Local(path) => Some(Path::new(path)),
             _ => None,
         }
     }
 
     pub fn abs_source_path(&self) -> Option<PathBuf> {
-        match &self.component.source(None) {
+        match &self.component.source {
             v2::ComponentSource::Local(path) => {
                 // TODO: We probably need a doctor check to see if the path can be expanded!
                 // For now, fall back to the literal path.
@@ -54,7 +54,7 @@ impl PatientWasm {
     }
 
     pub fn has_build(&self) -> bool {
-        self.component.build(None).is_some()
+        self.component.build.is_some()
     }
 }
 

crates/environments/src/lib.rs

@@ -39,14 +39,13 @@ pub async fn validate_application_against_environment_ids(
     env_ids: &[TargetEnvironmentRef],
     cache_root: Option<std::path::PathBuf>,
     app_dir: &std::path::Path,
-    profile: Option<&str>,
 ) -> anyhow::Result<TargetEnvironmentValidation> {
     if env_ids.is_empty() {
         return Ok(Default::default());
     }
 
     let envs = TargetEnvironment::load_all(env_ids, cache_root, app_dir).await?;
-    validate_application_against_environments(application, &envs, profile).await
+    validate_application_against_environments(application, &envs).await
 }
 
 /// Validates *all* application components against the list of (realised) target enviroments. Each component must conform
@@ -56,7 +55,6 @@ pub async fn validate_application_against_environment_ids(
 async fn validate_application_against_environments(
     application: &ApplicationToValidate,
     envs: &[TargetEnvironment],
-    profile: Option<&str>,
 ) -> anyhow::Result<TargetEnvironmentValidation> {
     for trigger_type in application.trigger_types() {
         if let Some(env) = envs.iter().find(|e| !e.supports_trigger_type(trigger_type)) {
@@ -67,7 +65,7 @@ async fn validate_application_against_environments(
         }
     }
 
-    let components_by_trigger_type = application.components_by_trigger_type(profile).await?;
+    let components_by_trigger_type = application.components_by_trigger_type().await?;
 
     let mut errs = vec![];
 

crates/environments/src/loader.rs

@@ -67,7 +67,6 @@ impl ApplicationToValidate {
     fn component_source<'a>(
         &'a self,
         trigger: &'a spin_manifest::schema::v2::Trigger,
-        profile: Option<&str>,
     ) -> anyhow::Result<ComponentSource<'a>> {
         let component_spec = trigger
             .component
@@ -76,8 +75,8 @@ impl ApplicationToValidate {
         let (id, source, dependencies, service_chaining) = match component_spec {
             spin_manifest::schema::v2::ComponentSpec::Inline(c) => (
                 trigger.id.as_str(),
-                &c.source(profile),
-                &c.dependencies(profile),
+                &c.source,
+                &c.dependencies,
                 spin_loader::requires_service_chaining(c),
             ),
             spin_manifest::schema::v2::ComponentSpec::Reference(r) => {
@@ -90,8 +89,8 @@ impl ApplicationToValidate {
                 };
                 (
                     id,
-                    &component.source(profile),
-                    &component.dependencies(profile),
+                    &component.source,
+                    &component.dependencies,
                     spin_loader::requires_service_chaining(component),
                 )
             }
@@ -117,12 +116,11 @@ impl ApplicationToValidate {
 
     pub(crate) async fn components_by_trigger_type(
         &self,
-        profile: Option<&str>,
     ) -> anyhow::Result<Vec<(String, Vec<ComponentToValidate<'_>>)>> {
         use futures::FutureExt;
 
         let components_by_trigger_type_futs = self.triggers().map(|(ty, ts)| {
-            self.components_for_trigger(ts, profile)
+            self.components_for_trigger(ts)
                 .map(|css| css.map(|css| (ty.to_owned(), css)))
         });
         let components_by_trigger_type = try_join_all(components_by_trigger_type_futs)
@@ -134,20 +132,16 @@ impl ApplicationToValidate {
     async fn components_for_trigger<'a>(
         &'a self,
         triggers: &'a [spin_manifest::schema::v2::Trigger],
-        profile: Option<&str>,
     ) -> anyhow::Result<Vec<ComponentToValidate<'a>>> {
-        let component_futures = triggers
-            .iter()
-            .map(|t| self.load_and_resolve_trigger(t, profile));
+        let component_futures = triggers.iter().map(|t| self.load_and_resolve_trigger(t));
         try_join_all(component_futures).await
     }
 
     async fn load_and_resolve_trigger<'a>(
         &'a self,
         trigger: &'a spin_manifest::schema::v2::Trigger,
-        profile: Option<&str>,
     ) -> anyhow::Result<ComponentToValidate<'a>> {
-        let component = self.component_source(trigger, profile)?;
+        let component = self.component_source(trigger)?;
 
         let loader = ComponentSourceLoader::new(&self.wasm_loader);
 

crates/loader/src/lib.rs

@@ -49,7 +49,7 @@ pub async fn from_wasm_file(wasm_path: impl AsRef<Path>) -> Result<LockedApp> {
     let app_root = std::env::current_dir()?;
     let manifest = single_file_manifest(wasm_path)?;
     let loader = LocalLoader::new(&app_root, FilesMountStrategy::Direct, None, None).await?;
-    loader.load_manifest(manifest).await
+    loader.load_manifest(manifest, None).await
 }
 
 /// The strategy to use for mounting WASI files into a guest.

crates/loader/src/local.rs

@@ -62,7 +62,7 @@ impl LocalLoader {
             )
         })?;
         let mut locked = self
-            .load_manifest(manifest)
+            .load_manifest(manifest, self.profile())
             .await
             .with_context(|| format!("Failed to load Spin app from {}", quoted_path(path)))?;
 
@@ -82,8 +82,12 @@ impl LocalLoader {
     }
 
     // Load the given manifest into a LockedApp, ready for execution.
-    pub(crate) async fn load_manifest(&self, mut manifest: AppManifest) -> Result<LockedApp> {
-        spin_manifest::normalize::normalize_manifest(&mut manifest);
+    pub(crate) async fn load_manifest(
+        &self,
+        mut manifest: AppManifest,
+        profile: Option<&str>,
+    ) -> Result<LockedApp> {
+        spin_manifest::normalize::normalize_manifest(&mut manifest, profile);
 
         manifest.validate_dependencies()?;
 
@@ -166,33 +170,28 @@ impl LocalLoader {
         let component_requires_service_chaining = requires_service_chaining(&component);
 
         let source = self
-            .load_component_source(id, component.source(self.profile()).clone())
+            .load_component_source(id, component.source.clone())
             .await
-            .with_context(|| {
-                format!(
-                    "Failed to load Wasm source {}",
-                    component.source(self.profile())
-                )
-            })?;
+            .with_context(|| format!("Failed to load Wasm source {}", component.source))?;
 
         let metadata = ValuesMapBuilder::new()
-            .string("description", component.description.clone())
+            .string("description", component.description)
             .string_array("allowed_outbound_hosts", allowed_outbound_hosts)
-            .string_array("key_value_stores", component.key_value_stores.clone())
-            .string_array("databases", component.sqlite_databases.clone())
-            .string_array("ai_models", component.ai_models.clone())
-            .serializable("build", component.build(self.profile()))?
+            .string_array("key_value_stores", component.key_value_stores)
+            .string_array("databases", component.sqlite_databases)
+            .string_array("ai_models", component.ai_models)
+            .serializable("build", component.build)?
             .take();
 
         let dependencies = self
             .load_component_dependencies(
                 id,
                 component.dependencies_inherit_configuration,
-                &component.dependencies(self.profile()),
+                &component.dependencies,
             )
             .await?;
 
-        let env = component.environment(self.profile()).into_iter().collect();
+        let env = component.environment.into_iter().collect();
 
         let files = if component.files.is_empty() {
             vec![]

crates/manifest/src/normalize.rs

@@ -8,9 +8,10 @@ use crate::schema::v2::{AppManifest, ComponentSpec, KebabId};
 /// - Inline components in trigger configs are moved into top-level
 ///   components and replaced with a reference.
 /// - Any triggers without an ID are assigned a generated ID.
-pub fn normalize_manifest(manifest: &mut AppManifest) {
+pub fn normalize_manifest(manifest: &mut AppManifest, profile: Option<&str>) {
     normalize_trigger_ids(manifest);
     normalize_inline_components(manifest);
+    apply_profile_overrides(manifest, profile);
 }
 
 fn normalize_inline_components(manifest: &mut AppManifest) {
@@ -103,3 +104,45 @@ fn normalize_trigger_ids(manifest: &mut AppManifest) {
         }
     }
 }
+
+fn apply_profile_overrides(manifest: &mut AppManifest, profile: Option<&str>) {
+    let Some(profile) = profile else {
+        return;
+    };
+
+    for (_, component) in &mut manifest.components {
+        let Some(overrides) = component.profile.get(profile) else {
+            continue;
+        };
+
+        if let Some(profile_build) = overrides.build.as_ref() {
+            match component.build.as_mut() {
+                None => {
+                    component.build = Some(crate::schema::v2::ComponentBuildConfig {
+                        command: profile_build.command.clone(),
+                        workdir: None,
+                        watch: vec![],
+                    })
+                }
+                Some(build) => {
+                    build.command = profile_build.command.clone();
+                }
+            }
+        }
+
+        if let Some(source) = overrides.source.as_ref() {
+            component.source = source.clone();
+        }
+
+        for (name, value) in &overrides.environment {
+            component.environment.insert(name.clone(), value.clone());
+        }
+
+        for (reference, value) in &overrides.dependencies.inner {
+            component
+                .dependencies
+                .inner
+                .insert(reference.clone(), value.clone());
+        }
+    }
+}

crates/manifest/src/schema/common.rs

@@ -190,8 +190,12 @@ pub struct ComponentBuildConfig {
 
 impl ComponentBuildConfig {
     /// The commands to execute for the build
-    pub fn commands(&self) -> Vec<&String> {
-        self.command.as_vec()
+    pub fn commands(&self) -> impl ExactSizeIterator<Item = &String> {
+        let as_vec = match &self.command {
+            Commands::Single(cmd) => vec![cmd],
+            Commands::Multiple(cmds) => cmds.iter().collect(),
+        };
+        as_vec.into_iter()
     }
 }
 
@@ -212,15 +216,6 @@ pub enum Commands {
     Multiple(Vec<String>),
 }
 
-impl Commands {
-    pub(crate) fn as_vec(&self) -> Vec<&String> {
-        match self {
-            Self::Single(cmd) => vec![cmd],
-            Self::Multiple(cmds) => cmds.iter().collect(),
-        }
-    }
-}
-
 fn is_false(v: &bool) -> bool {
     !*v
 }