Build profiles

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

Author: itowlson

crates/build/src/lib.rs

@@ -15,9 +15,13 @@ use subprocess::{Exec, Redirection};
 
 use crate::manifest::component_build_configs;
 
+const LAST_BUILD_PROFILE_FILE: &str = "last-build.txt";
+const LAST_BUILD_ANON_VALUE: &str = "<anonymous>";
+
 /// If present, run the build command of each component.
 pub async fn build(
     manifest_file: &Path,
+    profile: Option<&str>,
     component_ids: &[String],
     target_checks: TargetChecking,
     cache_root: Option<PathBuf>,
@@ -32,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);
+    let build_result = build_components(component_ids, build_info.components(), &app_dir, profile);
 
     // Emit any required warnings now, so that they don't bury any errors.
     if let Some(e) = build_info.load_error() {
@@ -53,6 +57,8 @@ pub async fn build(
     // If the build failed, exit with an error at this point.
     build_result?;
 
+    save_last_build_profile(&app_dir, profile);
+
     let Some(manifest) = build_info.manifest() else {
         // We can't proceed to checking (because that needs a full healthy manifest), and we've
         // already emitted any necessary warning, so quit.
@@ -89,14 +95,26 @@ pub async fn build(
 /// Run all component build commands, using the default options (build all
 /// components, perform target checking). We run a "default build" in several
 /// places and this centralises the logic of what such a "default build" means.
-pub async fn build_default(manifest_file: &Path, cache_root: Option<PathBuf>) -> Result<()> {
-    build(manifest_file, &[], TargetChecking::Check, cache_root).await
+pub async fn build_default(
+    manifest_file: &Path,
+    profile: Option<&str>,
+    cache_root: Option<PathBuf>,
+) -> Result<()> {
+    build(
+        manifest_file,
+        profile,
+        &[],
+        TargetChecking::Check,
+        cache_root,
+    )
+    .await
 }
 
 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
@@ -126,18 +144,24 @@ fn build_components(
 
     components_to_build
         .into_iter()
-        .map(|c| build_component(c, app_dir))
+        .map(|c| build_component(c, app_dir, profile))
         .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) -> Result<()> {
+fn build_component(
+    build_info: ComponentBuildInfo,
+    app_dir: &Path,
+    profile: Option<&str>,
+) -> Result<()> {
     match build_info.build {
         Some(b) => {
-            let command_count = b.commands().len();
+            let commands = b.commands(profile);
+
+            let command_count = commands.len();
 
             if command_count > 1 {
                 terminal::step!(
@@ -148,7 +172,7 @@ fn build_component(build_info: ComponentBuildInfo, app_dir: &Path) -> Result<()>
                 );
             }
 
-            for (index, command) in b.commands().enumerate() {
+            for (index, command) in commands.into_iter().enumerate() {
                 if command_count > 1 {
                     terminal::step!(
                         "Running build step",
@@ -215,6 +239,56 @@ fn construct_workdir(app_dir: &Path, workdir: Option<impl AsRef<Path>>) -> Resul
     Ok(cwd)
 }
 
+/// Saves the build profile to the "last build profile" file.
+/// Errors are ignored as they should not block building.
+pub fn save_last_build_profile(app_dir: &Path, profile: Option<&str>) {
+    let app_stash_dir = app_dir.join(".spin");
+    _ = std::fs::create_dir_all(&app_stash_dir);
+    let last_build_profile_file = app_stash_dir.join(LAST_BUILD_PROFILE_FILE);
+    _ = std::fs::write(
+        &last_build_profile_file,
+        profile.unwrap_or(LAST_BUILD_ANON_VALUE),
+    );
+}
+
+/// Reads the last build profile from the "last build profile" file.
+/// Errors are ignored.
+pub fn read_last_build_profile(app_dir: &Path) -> Option<String> {
+    let app_stash_dir = app_dir.join(".spin");
+    let last_build_profile_file = app_stash_dir.join(LAST_BUILD_PROFILE_FILE);
+    let last_build_str = std::fs::read_to_string(&last_build_profile_file).ok()?;
+
+    if last_build_str == LAST_BUILD_ANON_VALUE {
+        None
+    } else {
+        Some(last_build_str)
+    }
+}
+
+/// Prints a warning to stderr if the given profile is not the same
+/// as the most recent build in the given application directory.
+pub fn warn_if_not_latest_build(manifest_path: &Path, profile: Option<&str>) {
+    let Some(app_dir) = manifest_path.parent() else {
+        return;
+    };
+
+    let latest_build = read_last_build_profile(app_dir);
+
+    let is_match = match (profile, latest_build) {
+        (None, None) => true,
+        (Some(_), None) | (None, Some(_)) => false,
+        (Some(p), Some(latest)) => p == latest,
+    };
+
+    if !is_match {
+        let profile_opt = match profile {
+            Some(p) => format!(" --profile {p}"),
+            None => "".to_string(),
+        };
+        terminal::warn!("You built a different profile more recently than the one you are running. If the app appears to be behaving like an older version then run `spin up --build{profile_opt}`.");
+    }
+}
+
 /// Specifies target environment checking behaviour
 pub enum TargetChecking {
     /// The build should check that all components are compatible with all target environments.
@@ -242,23 +316,23 @@ mod tests {
     #[tokio::test]
     async fn can_load_even_if_trigger_invalid() {
         let bad_trigger_file = test_data_root().join("bad_trigger.toml");
-        build(&bad_trigger_file, &[], TargetChecking::Skip, None)
+        build(&bad_trigger_file, None, &[], TargetChecking::Skip, None)
             .await
             .unwrap();
     }
 
     #[tokio::test]
     async fn succeeds_if_target_env_matches() {
         let manifest_path = test_data_root().join("good_target_env.toml");
-        build(&manifest_path, &[], TargetChecking::Check, None)
+        build(&manifest_path, None, &[], TargetChecking::Check, None)
             .await
             .unwrap();
     }
 
     #[tokio::test]
     async fn fails_if_target_env_does_not_match() {
         let manifest_path = test_data_root().join("bad_target_env.toml");
-        let err = build(&manifest_path, &[], TargetChecking::Check, None)
+        let err = build(&manifest_path, None, &[], TargetChecking::Check, None)
             .await
             .expect_err("should have failed")
             .to_string();

crates/doctor/src/rustlang/target.rs

@@ -19,7 +19,7 @@ impl Diagnostic for TargetDiagnostic {
         let uses_rust = manifest.components.values().any(|c| {
             c.build
                 .as_ref()
-                .map(|b| b.commands().any(|c| c.starts_with("cargo")))
+                .map(|b| b.commands(None).iter().any(|c| c.starts_with("cargo")))
                 .unwrap_or_default()
         });
 

crates/factors-test/src/lib.rs

@@ -102,5 +102,5 @@ pub async fn build_locked_app(manifest: &toml::Table) -> anyhow::Result<LockedAp
     let dir = tempfile::tempdir().context("failed creating tempdir")?;
     let path = dir.path().join("spin.toml");
     std::fs::write(&path, toml_str).context("failed writing manifest")?;
-    spin_loader::from_file(&path, FilesMountStrategy::Direct, None).await
+    spin_loader::from_file(&path, FilesMountStrategy::Direct, None, None).await
 }

crates/loader/src/lib.rs

@@ -35,19 +35,20 @@ pub(crate) const MAX_FILE_LOADING_CONCURRENCY: usize = 16;
 pub async fn from_file(
     manifest_path: impl AsRef<Path>,
     files_mount_strategy: FilesMountStrategy,
+    profile: Option<&str>,
     cache_root: Option<PathBuf>,
 ) -> Result<LockedApp> {
     let path = manifest_path.as_ref();
     let app_root = parent_dir(path).context("manifest path has no parent directory")?;
-    let loader = LocalLoader::new(&app_root, files_mount_strategy, cache_root).await?;
+    let loader = LocalLoader::new(&app_root, files_mount_strategy, profile, cache_root).await?;
     loader.load_file(path).await
 }
 
 /// Load a Spin locked app from a standalone Wasm file.
 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).await?;
+    let loader = LocalLoader::new(&app_root, FilesMountStrategy::Direct, None, None).await?;
     loader.load_manifest(manifest).await
 }
 

crates/loader/src/local.rs

@@ -26,12 +26,14 @@ pub struct LocalLoader {
     files_mount_strategy: FilesMountStrategy,
     file_loading_permits: std::sync::Arc<Semaphore>,
     wasm_loader: WasmLoader,
+    profile: Option<String>,
 }
 
 impl LocalLoader {
     pub async fn new(
         app_root: &Path,
         files_mount_strategy: FilesMountStrategy,
+        profile: Option<&str>,
         cache_root: Option<PathBuf>,
     ) -> Result<Self> {
         let app_root = safe_canonicalize(app_root)
@@ -44,6 +46,7 @@ impl LocalLoader {
             // Limit concurrency to avoid hitting system resource limits
             file_loading_permits: file_loading_permits.clone(),
             wasm_loader: WasmLoader::new(app_root, cache_root, Some(file_loading_permits)).await?,
+            profile: profile.map(|s| s.to_owned()),
         })
     }
 
@@ -68,6 +71,13 @@ impl LocalLoader {
             .metadata
             .insert("origin".into(), file_url(path)?.into());
 
+        // Set build profile metadata
+        if let Some(profile) = self.profile.as_ref() {
+            locked
+                .metadata
+                .insert("profile".into(), profile.as_str().into());
+        }
+
         Ok(locked)
     }
 
@@ -155,6 +165,11 @@ impl LocalLoader {
 
         let component_requires_service_chaining = requires_service_chaining(&component);
 
+        let source = self
+            .load_component_source(id, component.source(self.profile.as_ref()))
+            .await
+            .with_context(|| format!("Failed to load Wasm source {}", component.source))?;
+
         let metadata = ValuesMapBuilder::new()
             .string("description", component.description)
             .string_array("allowed_outbound_hosts", allowed_outbound_hosts)
@@ -164,11 +179,6 @@ impl LocalLoader {
             .serializable("build", component.build)?
             .take();
 
-        let source = self
-            .load_component_source(id, component.source.clone())
-            .await
-            .with_context(|| format!("Failed to load Wasm source {}", component.source))?;
-
         let dependencies = self
             .load_component_dependencies(
                 id,
@@ -925,6 +935,7 @@ mod test {
             &app_root,
             FilesMountStrategy::Copy(wd.path().to_owned()),
             None,
+            None,
         )
         .await?;
         let err = loader

crates/loader/tests/ui.rs

@@ -50,6 +50,7 @@ fn run_test(input: &Path, normalizer: &mut Normalizer) -> Result<String, Failed>
             input,
             spin_loader::FilesMountStrategy::Copy(files_mount_root),
             None,
+            None,
         )
         .await
         .map_err(|err| format!("{err:?}"))?;

crates/manifest/src/compat.rs

@@ -78,6 +78,7 @@ pub fn v1_to_v2_app(manifest: v1::AppManifestV1) -> Result<v2::AppManifest, Erro
                 allowed_http_hosts: Vec::new(),
                 dependencies_inherit_configuration: false,
                 dependencies: Default::default(),
+                profile: Default::default(),
             },
         );
         triggers

crates/manifest/src/schema/common.rs

@@ -161,13 +161,18 @@ pub enum WasiFilesMount {
 #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct ComponentBuildConfig {
-    /// The command or commands to build the application. If multiple commands
+    /// The command or commands to build the component. If multiple commands
     /// are specified, they are run sequentially from left to right.
     ///
-    /// Example: `command = "cargo build"`, `command = ["npm install", "npm run build"]`
+    /// Example: `command = "cargo build --release"`, `command = ["npm install", "npm run build"]`
     ///
     /// 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`.
     ///
@@ -188,14 +193,28 @@ 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) -> 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()
+    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();
+            }
+        }
+        self.command.as_vec()
     }
 }
 
@@ -216,6 +235,15 @@ pub enum Commands {
     Multiple(Vec<String>),
 }
 
+impl Commands {
+    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
 }