feat(extend_payload_to_esp):stage payload to /usr for installation

Bootup extend_payload_to_esp <path> will move the it to /usr

This features gives user ability to stage payloads so that install and update
can  install the contents to esp.It will move all the files and sub dirs
under the path provide by user.
example usage: `bootupctl backend extend_payload_to_esp /usr/lib/mydata`
will move the content of the dir to
`/usr/lib/efi/firmware/<name>/<version>/EFI/`
stores metadata at `/usr/lib/efi/firmware/<name>/<version>/EFI.json`.
Added test_extend_payload_to_esp unit test.

Author: say-paul

src/bios.rs

@@ -268,4 +268,7 @@ impl Component for Bios {
     fn get_efi_vendor(&self, _: &openat::Dir) -> Result<Option<String>> {
         Ok(None)
     }
+    fn extend_payload(&self, _: &str, _: &str) -> Result<Option<bool>> {
+        Ok(None)
+    }
 }

src/cli/bootupctl.rs

@@ -73,6 +73,8 @@ pub enum CtlBackend {
     Generate(super::bootupd::GenerateOpts),
     #[clap(name = "install", hide = true)]
     Install(super::bootupd::InstallOpts),
+    #[clap(name = "extend-payload-to-esp", hide = true)]
+    ExtendPayload(super::bootupd::ExtendPayloadOpts),
 }
 
 #[derive(Debug, Parser)]
@@ -109,6 +111,9 @@ impl CtlCommand {
             CtlVerb::Backend(CtlBackend::Install(opts)) => {
                 super::bootupd::DCommand::run_install(opts)
             }
+            CtlVerb::Backend(CtlBackend::ExtendPayload(opts)) => {
+                super::bootupd::DCommand::run_extend_payload(opts)
+            }
             CtlVerb::MigrateStaticGrubConfig => Self::run_migrate_static_grub_config(),
         }
     }

src/cli/bootupd.rs

@@ -35,6 +35,11 @@ pub enum DVerb {
     GenerateUpdateMetadata(GenerateOpts),
     #[clap(name = "install", about = "Install components")]
     Install(InstallOpts),
+    #[clap(
+        name = "extend-payload-to-esp",
+        about = "Extend bootloader payload with additional files"
+    )]
+    ExtendPayload(ExtendPayloadOpts),
 }
 
 #[derive(Debug, Parser)]
@@ -82,12 +87,20 @@ pub struct GenerateOpts {
     sysroot: Option<String>,
 }
 
+#[derive(Debug, Parser)]
+pub struct ExtendPayloadOpts {
+    /// Source directory containing files to add
+    #[clap(value_parser)]
+    src_root: String,
+}
+
 impl DCommand {
     /// Run CLI application.
     pub fn run(self) -> Result<()> {
         match self.cmd {
             DVerb::Install(opts) => Self::run_install(opts),
             DVerb::GenerateUpdateMetadata(opts) => Self::run_generate_meta(opts),
+            DVerb::ExtendPayload(opts) => Self::run_extend_payload(opts),
         }
     }
 
@@ -122,4 +135,17 @@ impl DCommand {
         .context("boot data installation failed")?;
         Ok(())
     }
+
+    pub(crate) fn run_extend_payload(opts: ExtendPayloadOpts) -> Result<()> {
+        let components = crate::bootupd::get_components();
+        let sysroot = "/";
+        for component in components.values() {
+            if let Some(updated) = component.extend_payload(sysroot, &opts.src_root)? {
+                if updated {
+                    println!("Extended payload for {} successfully", component.name());
+                }
+            }
+        }
+        Ok(())
+    }
 }

src/component.rs

@@ -79,6 +79,9 @@ pub(crate) trait Component {
 
     /// Locating efi vendor dir
     fn get_efi_vendor(&self, sysroot: &openat::Dir) -> Result<Option<String>>;
+
+    /// Extending payload from input dir
+    fn extend_payload(&self, sysroot: &str, src_root: &str) -> Result<Option<bool>>;
 }
 
 /// Given a component name, create an implementation.

src/efi.rs

@@ -9,9 +9,8 @@ use std::os::unix::io::AsRawFd;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use anyhow::{bail, Context, Result};
-use bootc_internal_utils::CommandRunExt;
-use camino::{Utf8Path, Utf8PathBuf};
+use anyhow::{anyhow, bail, Context, Result};
+use bootc_utils::CommandRunExt;
 use cap_std::fs::Dir;
 use cap_std_ext::cap_std;
 use chrono::prelude::*;
@@ -506,6 +505,84 @@ impl Component for Efi {
         Ok(meta)
     }
 
+    fn extend_payload(&self, sysroot_path: &str, src_input: &str) -> Result<Option<bool>> {
+        let dest_efidir_base = Path::new(sysroot_path).join("usr/lib/efi").join("firmware");
+
+        let src_input_path = Path::new(src_input);
+        let path_to_query = if src_input_path.is_dir() {
+            WalkDir::new(src_input_path)
+                .into_iter()
+                .filter_map(|e| e.ok())
+                .find(|e| e.file_type().is_file())
+                .map(|e| e.path().to_path_buf())
+                .ok_or_else(|| anyhow!("No file found in directory {}", src_input))?
+        } else {
+            src_input_path.to_path_buf()
+        };
+
+        let meta_from_src = packagesystem::query_files(sysroot_path, [path_to_query])
+            .context(format!("Querying RPM metadata for {:?}", src_input_path))?;
+
+        let version_string_part =
+            meta_from_src.version.split(',').next().ok_or_else(|| {
+                anyhow!("RPM query returned an empty or malformed version string")
+            })?;
+
+        let parts: Vec<&str> = version_string_part.split('-').collect();
+        let (pkg_name, version_release_str) = if parts.len() >= 3 {
+            (
+                parts[0].to_string(),
+                format!(
+                    "{}-{}",
+                    parts[parts.len() - 2],
+                    parts[parts.len() - 1]
+                        .split('.')
+                        .next()
+                        .unwrap_or(parts[parts.len() - 1])
+                ),
+            )
+        } else {
+            anyhow::bail!("Unexpected RPM version string format");
+        };
+
+        // Use the flattened destination path
+        let final_dest_path = dest_efidir_base.join(&pkg_name).join(&version_release_str);
+        std::fs::create_dir_all(&final_dest_path)?;
+
+        let efi_dest_path = final_dest_path.join("EFI");
+        std::fs::create_dir_all(&efi_dest_path)?;
+
+        // Copy the payload files
+        let src_metadata = std::fs::metadata(src_input_path)?;
+        if src_metadata.is_dir() {
+            Command::new("cp")
+                .args([
+                    "-rp",
+                    &format!("{}/.", src_input),
+                    efi_dest_path.to_str().unwrap(),
+                ])
+                .run()
+                .with_context(|| {
+                    format!(
+                        "Failed to copy contents of {:?} to {:?}",
+                        src_input, &efi_dest_path
+                    )
+                })?;
+        } else {
+            Command::new("cp")
+                .args(["-p", src_input, efi_dest_path.to_str().unwrap()])
+                .run()?;
+        }
+
+        // Create the metadata file for the firmware
+        let firmware_meta_path = final_dest_path.join("EFI.json");
+        let meta_file = std::fs::File::create(firmware_meta_path)?;
+        serde_json::to_writer(meta_file, &meta_from_src)?;
+        log::debug!("Wrote firmware metadata for {}", pkg_name);
+
+        Ok(Some(true))
+    }
+
     fn query_update(&self, sysroot: &openat::Dir) -> Result<Option<ContentMetadata>> {
         get_component_update(sysroot, self)
     }
@@ -858,6 +935,172 @@ Boot0003* test";
             paths,
             ["usr/lib/efi/FOO/1.1/EFI", "usr/lib/efi/BAR/1.1/EFI"]
         );
+    }
+    #[test]
+    fn test_extend_payload() -> Result<()> {
+        use std::fs;
+        use tempfile::TempDir;
+
+        let temp_sysroot = TempDir::new()?;
+        let temp_src = TempDir::new()?;
+
+        let sysroot_path = temp_sysroot.path().to_str().unwrap();
+        let src_path = temp_src.path().to_str().unwrap();
+
+        // mockup data source: /usr/share/uboot/rpi/
+        // content: u-boot.bin, overlays/i2c.dtb
+        // mockup rpm: uboot-images-2023.04-2.fc42.noarch
+        // mockup rpm_db: /usr/lib/sysimage/rpm/Packages
+        let src_uboot_dir = temp_src
+            .path()
+            .join("usr")
+            .join("share")
+            .join("uboot")
+            .join("rpi");
+        fs::create_dir_all(&src_uboot_dir)?;
+
+        let src_overlays_dir = src_uboot_dir.join("overlays");
+        fs::create_dir_all(&src_overlays_dir)?;
+
+        // Create content files
+        let uboot_bin = src_uboot_dir.join("u-boot.bin");
+        fs::write(&uboot_bin, b"uboot binary content")?;
+        let overlay_dtb = src_overlays_dir.join("i2c.dtb");
+        fs::write(&overlay_dtb, b"device tree overlay content")?;
+
+        // Create a mockup RPM database structure
+        let rpm_db_dir = temp_sysroot
+            .path()
+            .join("usr")
+            .join("lib")
+            .join("sysimage")
+            .join("rpm");
+        fs::create_dir_all(&rpm_db_dir)?;
+        fs::write(rpm_db_dir.join("Packages"), b"fake rpm database file")?;
+
+        // Create a mock rpm script that returns uboot-images package data
+        let mock_rpm_dir = TempDir::new()?;
+        let mock_rpm_script = mock_rpm_dir.path().join("rpm");
+
+        let mock_script_content = format!(
+            r#"#!/bin/bash
+# Mock rpm script for testing
+if [[ "$*" == *"-q"* ]] && [[ "$*" == *"-f"* ]]; then
+    # Return mock uboot-images package data in the expected format: nevra,buildtime
+    echo "uboot-images-2023.04-2.fc42.noarch,1681234567"
+    exit 0
+fi
+# For any other rpm command, just fail
+exit 1
+"#
+        );
+
+        fs::write(&mock_rpm_script, mock_script_content)?;
+
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            let mut perms = fs::metadata(&mock_rpm_script)?.permissions();
+            perms.set_mode(0o755);
+            fs::set_permissions(&mock_rpm_script, perms)?;
+        }
+
+        let original_path = std::env::var("PATH").unwrap_or_default();
+        let new_path = format!("{}:{}", mock_rpm_dir.path().display(), original_path);
+        std::env::set_var("PATH", &new_path);
+
+        // Test extend_payload
+        let efi_component = Efi::default();
+
+        let result = efi_component
+            .extend_payload(sysroot_path, &format!("{}/usr/share/uboot/rpi", src_path));
+
+        // validation beigins
+        std::env::set_var("PATH", &original_path);
+        match result {
+            Ok(Some(true)) => {
+                // Verify the files were copied to the right location
+                let firmware_base = temp_sysroot
+                    .path()
+                    .join("usr")
+                    .join("lib")
+                    .join("efi")
+                    .join("firmware");
+                assert!(
+                    firmware_base.exists(),
+                    "Firmware base directory should be created"
+                );
+
+                // Look for the uboot package directory (package name is extracted from first part)
+                // From "uboot-images-2023.04-2.fc42.noarch" -> package: "uboot", version: "2023.04-2"
+                let uboot_dir = firmware_base.join("uboot").join("2023.04-2");
+                assert!(
+                    uboot_dir.exists(),
+                    "Package directory uboot/2023.04-2 should be created"
+                );
+
+                // Files should be copied to the EFI subdirectory
+                let efi_dir = uboot_dir.join("EFI");
+                assert!(efi_dir.exists(), "EFI directory should be created");
+
+                // Verify that u-boot.bin was copied to EFI subdirectory
+                let copied_uboot_bin = efi_dir.join("u-boot.bin");
+                assert!(copied_uboot_bin.exists(), "u-boot.bin should be copied");
+                let uboot_content = fs::read_to_string(&copied_uboot_bin)?;
+                assert_eq!(
+                    uboot_content, "uboot binary content",
+                    "u-boot.bin content should be preserved"
+                );
+
+                // Verify that overlays directory and i2c.dtb were copied to EFI subdirectory
+                let copied_overlays_dir = efi_dir.join("overlays");
+                assert!(
+                    copied_overlays_dir.exists(),
+                    "overlays directory should be copied"
+                );
+
+                let copied_overlay_dtb = copied_overlays_dir.join("i2c.dtb");
+                assert!(copied_overlay_dtb.exists(), "i2c.dtb should be copied");
+                let overlay_content = fs::read_to_string(&copied_overlay_dtb)?;
+                assert_eq!(
+                    overlay_content, "device tree overlay content",
+                    "i2c.dtb content should be preserved"
+                );
+
+                // Verify the EFI.json metadata
+                let metadata_file = uboot_dir.join("EFI.json");
+                assert!(
+                    metadata_file.exists(),
+                    "EFI.json metadata file should be created"
+                );
+                let metadata_content = fs::read_to_string(&metadata_file)?;
+                let parsed: ContentMetadata = serde_json::from_str(&metadata_content)?;
+                assert!(
+                    parsed
+                        .version
+                        .contains("uboot-images-2023.04-2.fc42.noarch"),
+                    "Metadata should contain uboot package"
+                );
+
+                println!("extend_payload test completed successfully!");
+                println!("✓ Files copied to: {:?}", efi_dir);
+                println!("✓ u-boot.bin: {:?}", copied_uboot_bin);
+                println!("✓ overlays/i2c.dtb: {:?}", copied_overlay_dtb);
+                println!("✓ Metadata created: {:?}", metadata_file);
+                println!("✓ Package version: {}", parsed.version);
+            }
+            Ok(Some(false)) => {
+                panic!("extend_payload returned false - expected success");
+            }
+            Ok(None) => {
+                panic!("extend_payload returned None - expected success");
+            }
+            Err(e) => {
+                panic!("extend_payload failed when it should have succeeded: {}", e);
+            }
+        }
+
         Ok(())
     }
 }
+

src/model.rs

@@ -39,6 +39,9 @@ pub(crate) struct InstalledContent {
     pub(crate) filetree: Option<crate::filetree::FileTree>,
     /// The version this was originally adopted from
     pub(crate) adopted_from: Option<ContentMetadata>,
+    /// Nested map of supplemental firmware payloads.
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub(crate) firmware: BTreeMap<String, Box<InstalledContent>>,
 }
 
 /// Will be serialized into /boot/bootupd-state.json