feat(efi::install)install from extend-payload-path

Added additional flow in efi::install to read from the path
created by extend_payload_to_esp command and install to /boot/efi

Author: say-paul

src/bios.rs

@@ -3,6 +3,7 @@ use camino::Utf8PathBuf;
 use openat_ext::OpenatDirExt;
 #[cfg(target_arch = "powerpc64")]
 use std::borrow::Cow;
+use std::collections::BTreeMap;
 use std::io::prelude::*;
 use std::path::Path;
 use std::process::Command;
@@ -121,6 +122,7 @@ impl Component for Bios {
             meta,
             filetree: None,
             adopted_from: None,
+            firmware: BTreeMap::new(),
         })
     }
 
@@ -235,6 +237,7 @@ impl Component for Bios {
             meta: update.clone(),
             filetree: None,
             adopted_from: Some(meta.version),
+            firmware: BTreeMap::new(),
         }))
     }
 
@@ -257,6 +260,7 @@ impl Component for Bios {
             meta: updatemeta,
             filetree: None,
             adopted_from,
+            firmware: BTreeMap::new(),
         })
     }
 

src/efi.rs

@@ -5,6 +5,7 @@
  */
 
 use std::cell::RefCell;
+use std::collections::BTreeMap;
 use std::os::unix::io::AsRawFd;
 use std::path::{Path, PathBuf};
 use std::process::Command;
@@ -328,6 +329,7 @@ impl Component for Efi {
             meta: updatemeta.clone(),
             filetree: Some(updatef),
             adopted_from: Some(meta.version),
+            firmware: BTreeMap::new(),
         }))
     }
 
@@ -372,15 +374,70 @@ impl Component for Efi {
             .arg(destpath)
             .current_dir(format!("/proc/self/fd/{}", src_root.as_raw_fd()))
             .run()?;
+
+        let mut found_firmware = BTreeMap::new();
+        // Scan and install supplemental firmware
+        let firmware_base_dir_path = Path::new("usr/lib/efi/firmware");
+        if src_root.exists(firmware_base_dir_path)? {
+            let firmware_base_dir = src_root.sub_dir(firmware_base_dir_path)?;
+            for pkg_entry in firmware_base_dir.list_dir(".")?.flatten() {
+                if firmware_base_dir.get_file_type(&pkg_entry)? != openat::SimpleType::Dir {
+                    continue;
+                }
+                let pkg_name = pkg_entry.file_name().to_string_lossy().to_string();
+                let pkg_dir = firmware_base_dir.sub_dir(pkg_entry.file_name())?;
+
+                let mut versions: Vec<_> = pkg_dir.list_dir(".")?.filter_map(Result::ok).collect();
+                versions.sort_by_key(|e| e.file_name().to_owned());
+
+                if let Some(ver_entry) = versions.pop() {
+                    let ver_dir = pkg_dir.sub_dir(ver_entry.file_name())?;
+                    let meta_path = Path::new("EFI.json");
+
+                    if ver_dir.exists(meta_path)? {
+                        log::debug!(
+                            "Found supplemental firmware: {}/{}",
+                            pkg_name,
+                            ver_entry.file_name().to_string_lossy()
+                        );
+                        let firmware_meta: ContentMetadata =
+                            serde_json::from_reader(ver_dir.open_file(meta_path)?)?;
+                        let payload_src_dir = ver_dir.sub_dir("EFI")?;
+                        let firmware_filetree =
+                            crate::filetree::FileTree::new_from_dir(&payload_src_dir)?;
+                        // copy all by applying a diff with a empty filetree
+                        let empty_filetree = filetree::FileTree {
+                            children: Default::default(),
+                        };
+                        let diff = empty_filetree.diff(&firmware_filetree)?;
+                        filetree::apply_diff(&payload_src_dir, destd, &diff, None)
+                            .context("applying supplemental firmware")?;
+
+                        found_firmware.insert(
+                            pkg_name.clone(),
+                            Box::new(InstalledContent {
+                                meta: firmware_meta,
+                                filetree: Some(firmware_filetree),
+                                adopted_from: None,
+                                firmware: BTreeMap::new(),
+                            }),
+                        );
+                    }
+                }
+            }
+        }
+
         if update_firmware {
-            if let Some(vendordir) = self.get_efi_vendor(&src_root)? {
+            if let Some(vendordir) = self.get_efi_vendor(src_root)? {
                 self.update_firmware(device, destd, &vendordir)?
             }
         }
+
         Ok(InstalledContent {
             meta,
             filetree: Some(ft),
             adopted_from: None,
+            firmware: found_firmware,
         })
     }
 
@@ -424,6 +481,7 @@ impl Component for Efi {
             meta: updatemeta,
             filetree: Some(updatef),
             adopted_from,
+            firmware: BTreeMap::new(),
         })
     }
 
@@ -465,72 +523,71 @@ impl Component for Efi {
     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");
 
-        // Fetch version and release from the source input using query_files
         let src_input_path = Path::new(src_input);
-        let meta_from_src = packagesystem::query_files(sysroot_path, [src_input_path])
+        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 (no package name found in '{}').",
-                meta_from_src.version
-            ))?;
+        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 {
-            // Successfully extracted package name, version, and release
-            let actual_pkg_name = parts[0];
-            let version_part = parts[parts.len() - 2]; // version, e.g., "1.0"
-            let release_part = parts[parts.len() - 1]
-                .split('.')
-                .next()
-                .unwrap_or(parts[parts.len() - 1]); // release, e.g., "1" from "1.el8.noarch"
             (
-                actual_pkg_name.to_string(),
-                format!("{}-{}", version_part, release_part),
+                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 matadata_path = dest_efidir_base.join(&pkg_name).join(&version_release_str);
-        std::fs::create_dir_all(&matadata_path)?;
-
-        let final_dest_path = matadata_path.join("EFI");
+        let final_dest_path = dest_efidir_base.join(&pkg_name).join(&version_release_str);
         std::fs::create_dir_all(&final_dest_path)?;
 
         // Copy the payload files
         let src_metadata = std::fs::metadata(src_input_path)?;
         if src_metadata.is_dir() {
-            log::debug!(
-                "Copying contents of directory {:?} to {:?}",
-                src_input,
-                &final_dest_efi_path
-            );
             Command::new("cp")
                 .args([
                     "-rp",
                     &format!("{}/.", src_input),
-                    final_dest_efi_path.to_str().unwrap(),
+                    final_dest_path.to_str().unwrap(),
                 ])
                 .run()
                 .with_context(|| {
                     format!(
                         "Failed to copy contents of {:?} to {:?}",
-                        src_input, &final_dest_efi_path
+                        src_input, &final_dest_path
                     )
                 })?;
-        } else if src_metadata.is_file() {
-            log::debug!("Copying file {:?} to {:?}", src_input, &final_dest_efi_path);
+        } else {
             Command::new("cp")
                 .args(["-p", src_input, final_dest_path.to_str().unwrap()])
                 .run()?;
         }
 
         // Create the metadata file for the firmware
-        let firmware_meta_path = matadata_path.join("EFI.json");
+        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);

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

src/model_legacy.rs

@@ -30,6 +30,8 @@ pub(crate) struct InstalledContent01 {
     pub(crate) meta: ContentMetadata01,
     /// File tree
     pub(crate) filetree: Option<crate::filetree::FileTree>,
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub(crate) firmware: BTreeMap<String, Box<InstalledContent01>>,
 }
 
 /// Will be serialized into /boot/bootupd-state.json
@@ -59,6 +61,11 @@ impl InstalledContent01 {
             meta: self.meta.upconvert(),
             filetree: self.filetree,
             adopted_from: None,
+            firmware: self
+                .firmware
+                .into_iter()
+                .map(|(k, v)| (k, Box::new(v.upconvert())))
+                .collect(),
         }
     }
 }