Plan B

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

Author: itowlson

crates/build/src/lib.rs

@@ -26,7 +26,7 @@ pub async fn build(
     target_checks: TargetChecking,
     cache_root: Option<PathBuf>,
 ) -> Result<()> {
-    let build_info = component_build_configs(manifest_file)
+    let build_info = component_build_configs(manifest_file, profile)
         .await
         .with_context(|| {
             format!(
@@ -36,7 +36,7 @@ pub async fn build(
         })?;
     let app_dir = parent_dir(manifest_file)?;
 
-    let build_result = build_components(component_ids, build_info.components(), &app_dir, profile);
+    let build_result = build_components(component_ids, build_info.components(), &app_dir);
 
     // Emit any required warnings now, so that they don't bury any errors.
     if let Some(e) = build_info.load_error() {
@@ -114,7 +114,6 @@ fn build_components(
     component_ids: &[String],
     components: Vec<ComponentBuildInfo>,
     app_dir: &Path,
-    profile: Option<&str>,
 ) -> Result<(), anyhow::Error> {
     let components_to_build = if component_ids.is_empty() {
         components
@@ -144,24 +143,18 @@ fn build_components(
 
     components_to_build
         .into_iter()
-        .map(|c| build_component(c, app_dir, profile))
+        .map(|c| build_component(c, app_dir))
         .collect::<Result<Vec<_>, _>>()?;
 
     terminal::step!("Finished", "building all Spin components");
     Ok(())
 }
 
 /// Run the build command of the component.
-fn build_component(
-    build_info: ComponentBuildInfo,
-    app_dir: &Path,
-    profile: Option<&str>,
-) -> Result<()> {
+fn build_component(build_info: ComponentBuildInfo, app_dir: &Path) -> Result<()> {
     match build_info.build {
         Some(b) => {
-            let commands = b.commands(profile);
-
-            let command_count = commands.len();
+            let command_count = b.commands().len();
 
             if command_count > 1 {
                 terminal::step!(
@@ -172,7 +165,7 @@ fn build_component(
                 );
             }
 
-            for (index, command) in commands.into_iter().enumerate() {
+            for (index, command) in b.commands().iter().enumerate() {
                 if command_count > 1 {
                     terminal::step!(
                         "Running build step",

crates/build/src/manifest.rs

@@ -66,12 +66,17 @@ impl ManifestBuildInfo {
 /// 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<ManifestBuildInfo> {
+pub async fn component_build_configs(
+    manifest_file: impl AsRef<Path>,
+    profile: Option<&str>,
+) -> Result<ManifestBuildInfo> {
     let manifest = spin_manifest::manifest_from_file(&manifest_file);
     match manifest {
         Ok(mut manifest) => {
+            manifest.ensure_profile(profile)?;
+
             spin_manifest::normalize::normalize_manifest(&mut manifest);
-            let components = build_configs_from_manifest(&manifest);
+            let components = build_configs_from_manifest(&manifest, profile);
             let deployment_targets = deployment_targets_from_manifest(&manifest);
             Ok(ManifestBuildInfo::Loadable {
                 components,
@@ -101,13 +106,14 @@ pub async fn component_build_configs(manifest_file: impl AsRef<Path>) -> Result<
 
 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.clone(),
+            build: c.build_config(profile),
         })
         .collect()
 }

crates/doctor/src/rustlang/target.rs

@@ -17,10 +17,9 @@ 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
-                .as_ref()
-                .map(|b| b.commands(None).iter().any(|c| c.starts_with("cargo")))
-                .unwrap_or_default()
+            c.build_commands(None)
+                .iter()
+                .any(|c| c.starts_with("cargo"))
         });
 
         if uses_rust {

crates/loader/src/local.rs

@@ -166,7 +166,7 @@ impl LocalLoader {
         let component_requires_service_chaining = requires_service_chaining(&component);
 
         let source = self
-            .load_component_source(id, component.source(self.profile.as_ref()))
+            .load_component_source(id, component.source(self.profile.as_ref()).clone())
             .await
             .with_context(|| format!("Failed to load Wasm source {}", component.source))?;
 

crates/manifest/src/schema/common.rs

@@ -168,11 +168,6 @@ pub struct ComponentBuildConfig {
     ///
     /// Learn more: https://spinframework.dev/build#setting-up-for-spin-build
     pub command: Commands,
-    /// The command or commands for building the component in non-default profiles.
-    /// If a component has no special build instructions for a profile, the
-    /// default build command is used.
-    #[serde(default, skip_serializing_if = "super::v2::Map::is_empty")]
-    pub profile: super::v2::Map<String, ComponentProfileBuildCommand>,
     /// The working directory for the build command. If omitted, the build working
     /// directory is the directory containing `spin.toml`.
     ///
@@ -193,27 +188,9 @@ pub struct ComponentBuildConfig {
     pub watch: Vec<String>,
 }
 
-/// Component build configuration
-#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
-#[serde(deny_unknown_fields)]
-pub struct ComponentProfileBuildCommand {
-    /// The command or commands to build the component in a named profile. If multiple commands
-    /// are specified, they are run sequentially from left to right.
-    ///
-    /// Example: `profile.debug.command = "cargo build"`
-    ///
-    /// Learn more: https://spinframework.dev/build#setting-up-for-spin-build
-    pub command: Commands,
-}
-
 impl ComponentBuildConfig {
     /// The commands to execute for the build
-    pub fn commands(&self, profile: Option<&str>) -> Vec<&String> {
-        if let Some(profile) = profile {
-            if let Some(profile_cmd) = self.profile.get(profile) {
-                return profile_cmd.command.as_vec();
-            }
-        }
+    pub fn commands(&self) -> Vec<&String> {
         self.command.as_vec()
     }
 }
@@ -236,7 +213,7 @@ pub enum Commands {
 }
 
 impl Commands {
-    fn as_vec(&self) -> Vec<&String> {
+    pub(crate) fn as_vec(&self) -> Vec<&String> {
         match self {
             Self::Single(cmd) => vec![cmd],
             Self::Multiple(cmds) => cmds.iter().collect(),

crates/manifest/src/schema/v2.rs

@@ -52,6 +52,25 @@ impl AppManifest {
         }
         Ok(())
     }
+
+    /// Whether any component in the application defines the given profile.
+    /// Not every component defines every profile, and components intentionally
+    /// fall back to the anonymouse profile if they are asked for a profile
+    /// they don't define. So this can be used to detect that a user might have
+    /// mistyped a profile (e.g. `spin up --profile deugb`).
+    pub fn ensure_profile(&self, profile: Option<&str>) -> anyhow::Result<()> {
+        let Some(p) = profile else {
+            return Ok(());
+        };
+
+        let is_defined = self.components.values().any(|c| c.profile.contains_key(p));
+
+        if is_defined {
+            Ok(())
+        } else {
+            Err(anyhow!("Profile {p} is not defined in this application"))
+        }
+    }
 }
 
 /// App details
@@ -397,31 +416,89 @@ pub struct Component {
     pub dependencies: ComponentDependencies,
     /// TODO: profile docs
     #[serde(default, skip_serializing_if = "Map::is_empty")]
-    pub profile: Map<String, ComponentProfileUp>,
+    pub profile: Map<String, ComponentProfileOverride>,
 }
 
-/// Customisations for running a Spin component in a non-default profile.
+/// Customisations for a Spin component in a non-default profile.
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
-pub struct ComponentProfileUp {
+pub struct ComponentProfileOverride {
     /// The file, package, or URL containing the component Wasm binary.
     ///
-    /// Example: `source = "bin/cart.wasm"`
+    /// Example: `source = "bin/debug/cart.wasm"`
     ///
     /// Learn more: https://spinframework.dev/writing-apps#the-component-source
-    pub source: ComponentSource,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source: Option<ComponentSource>,
+
+    /// The command or commands for building the component in non-default profiles.
+    /// If a component has no special build instructions for a profile, the
+    /// default build command is used.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub build: Option<ComponentProfileBuildOverride>,
+}
+
+/// Customisations for a Spin component build in a non-default profile.
+#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct ComponentProfileBuildOverride {
+    /// The command or commands to build the component in a named profile. If multiple commands
+    /// are specified, they are run sequentially from left to right.
+    ///
+    /// Example: `build.command = "cargo build"`
+    ///
+    /// Learn more: https://spinframework.dev/build#setting-up-for-spin-build
+    pub command: super::common::Commands,
 }
 
 impl Component {
-    /// TODO: docs! docs! docs!
-    pub fn source(&self, profile: Option<impl AsRef<str>>) -> ComponentSource {
-        let Some(profile) = profile.as_ref() else {
-            return self.source.clone();
+    fn profile(&self, profile: Option<impl AsRef<str>>) -> Option<&ComponentProfileOverride> {
+        profile.and_then(|p| self.profile.get(p.as_ref()))
+    }
+
+    /// The commands to execute for the build
+    pub fn build_commands(&self, profile: Option<&str>) -> Vec<&String> {
+        let profile_build = self.profile(profile).and_then(|o| o.build.as_ref());
+
+        match profile_build {
+            None => match &self.build {
+                Some(b) => b.command.as_vec(),
+                None => vec![],
+            },
+            Some(b) => b.command.as_vec(),
+        }
+    }
+
+    /// The build configuration for the component
+    pub fn build_config(&self, profile: Option<impl AsRef<str>>) -> Option<ComponentBuildConfig> {
+        let build_config = self.build.clone();
+        let build_profile = self.profile(profile).and_then(|o| o.build.as_ref());
+
+        let Some(build_profile) = build_profile else {
+            return build_config;
         };
-        let Some(source) = self.profile.get(profile.as_ref()) else {
-            return self.source.clone();
+
+        let Some(mut build_config) = build_config else {
+            return Some(ComponentBuildConfig {
+                command: build_profile.command.clone(),
+                workdir: None,
+                watch: vec![],
+            });
         };
-        source.source.clone()
+
+        build_config.command = build_profile.command.clone();
+
+        Some(build_config)
+    }
+
+    /// TODO: docs! docs! docs!
+    pub fn source(&self, profile: Option<impl AsRef<str>>) -> &ComponentSource {
+        let profile_source = self.profile(profile).and_then(|o| o.source.as_ref());
+
+        match profile_source {
+            Some(s) => s,
+            None => &self.source,
+        }
     }
 }
 

src/commands/up.rs

@@ -174,6 +174,8 @@ impl UpCommand {
             .context("Could not canonicalize working directory")?;
 
         let resolved_app_source = self.resolve_app_source(&app_source, &working_dir).await?;
+        resolved_app_source.ensure_profile(self.profile())?;
+
         if self.help {
             let trigger_cmds =
                 trigger_commands_for_trigger_types(resolved_app_source.trigger_types())

src/commands/up/app_source.rs

@@ -126,4 +126,11 @@ impl ResolvedAppSource {
 
         types.into_iter().collect()
     }
+
+    pub fn ensure_profile(&self, profile: Option<&str>) -> anyhow::Result<()> {
+        match self {
+            Self::File { manifest, .. } => manifest.ensure_profile(profile),
+            _ => Ok(()),
+        }
+    }
 }