install: add progress-fd for install

Co-authored-by: Colin Walters <walters@verbum.org>
Assisted by: Claude Code
Signed-off-by: Joseph Marrero Corchado <jmarrero@redhat.com>

Author: jmarrero

crates/lib/src/cli.rs

@@ -34,13 +34,14 @@ use crate::spec::ImageReference;
 use crate::utils::sigpolicy_from_opt;
 
 /// Shared progress options
-#[derive(Debug, Parser, PartialEq, Eq)]
+#[derive(Debug, Parser, PartialEq, Eq, Clone, Serialize, Deserialize)]
 pub(crate) struct ProgressOptions {
     /// File descriptor number which must refer to an open pipe (anonymous or named).
     ///
     /// Interactive progress will be written to this file descriptor as "JSON lines"
     /// format, where each value is separated by a newline.
     #[clap(long, hide = true)]
+    #[serde(default)]
     pub(crate) progress_fd: Option<RawProgressFd>,
 }
 
@@ -1422,4 +1423,86 @@ mod tests {
         ]));
         assert_eq!(args.as_slice(), ["container", "image", "pull"]);
     }
+
+    #[test]
+    fn test_progress_fd_install_parsing() {
+        // Test install to-disk with progress-fd
+        let opts = Opt::try_parse_from([
+            "bootc",
+            "install",
+            "to-disk",
+            "--progress-fd",
+            "3",
+            "/dev/sda",
+        ])
+        .unwrap();
+
+        if let Opt::Install(crate::cli::InstallOpts::ToDisk(install_opts)) = opts {
+            assert_eq!(install_opts.progress.progress_fd.unwrap().get_raw_fd(), 3);
+        } else {
+            panic!("Expected install to-disk command");
+        }
+
+        // Test install to-filesystem with progress-fd
+        let opts = Opt::try_parse_from([
+            "bootc",
+            "install",
+            "to-filesystem",
+            "--progress-fd",
+            "4",
+            "/mnt/root",
+        ])
+        .unwrap();
+
+        if let Opt::Install(crate::cli::InstallOpts::ToFilesystem(install_opts)) = opts {
+            assert_eq!(install_opts.progress.progress_fd.unwrap().get_raw_fd(), 4);
+        } else {
+            panic!("Expected install to-filesystem command");
+        }
+
+        // Test install to-existing-root with progress-fd
+        let opts =
+            Opt::try_parse_from(["bootc", "install", "to-existing-root", "--progress-fd", "5"])
+                .unwrap();
+
+        if let Opt::Install(crate::cli::InstallOpts::ToExistingRoot(install_opts)) = opts {
+            assert_eq!(install_opts.progress.progress_fd.unwrap().get_raw_fd(), 5);
+        } else {
+            panic!("Expected install to-existing-root command");
+        }
+    }
+
+    #[test]
+    fn test_progress_fd_validation() {
+        // Test that invalid FD values are rejected
+        let result = Opt::try_parse_from([
+            "bootc",
+            "install",
+            "to-disk",
+            "--progress-fd",
+            "1",
+            "/dev/sda",
+        ]);
+        assert!(result.is_err());
+
+        let result = Opt::try_parse_from([
+            "bootc",
+            "install",
+            "to-disk",
+            "--progress-fd",
+            "2",
+            "/dev/sda",
+        ]);
+        assert!(result.is_err());
+
+        let result = Opt::try_parse_from([
+            "bootc",
+            "install",
+            "to-disk",
+            "--progress-fd",
+            "invalid",
+            "/dev/sda",
+        ]);
+        assert!(result.is_err());
+    }
 }

crates/lib/src/install.rs

@@ -53,6 +53,7 @@ use serde::{Deserialize, Serialize};
 #[cfg(feature = "install-to-disk")]
 use self::baseline::InstallBlockDeviceOpts;
 use crate::boundimage::{BoundImage, ResolvedBoundImage};
+use crate::cli::ProgressOptions;
 use crate::containerenv::ContainerExecutionInfo;
 use crate::deploy::{prepare_for_pull, pull_from_prepared, PreparedImportMeta, PreparedPullResult};
 use crate::lsm;
@@ -242,6 +243,10 @@ pub(crate) struct InstallToDiskOpts {
     #[clap(long)]
     #[serde(default)]
     pub(crate) via_loopback: bool,
+
+    #[clap(flatten)]
+    #[serde(flatten)]
+    pub(crate) progress: ProgressOptions,
 }
 
 #[derive(ValueEnum, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -317,6 +322,9 @@ pub(crate) struct InstallToFilesystemOpts {
 
     #[clap(flatten)]
     pub(crate) config_opts: InstallConfigOpts,
+
+    #[clap(flatten)]
+    pub(crate) progress: ProgressOptions,
 }
 
 #[derive(Debug, Clone, clap::Parser, PartialEq, Eq)]
@@ -348,6 +356,9 @@ pub(crate) struct InstallToExistingRootOpts {
     /// via e.g. `-v /:/target`.
     #[clap(default_value = ALONGSIDE_ROOT_MOUNT)]
     pub(crate) root_path: Utf8PathBuf,
+
+    #[clap(flatten)]
+    pub(crate) progress: ProgressOptions,
 }
 
 /// Global state captured from the container.
@@ -755,6 +766,7 @@ async fn install_container(
     root_setup: &RootSetup,
     sysroot: &ostree::Sysroot,
     has_ostree: bool,
+    prog: ProgressWriter,
 ) -> Result<(ostree::Deployment, InstallAleph)> {
     let sepolicy = state.load_policy()?;
     let sepolicy = sepolicy.as_ref();
@@ -793,15 +805,14 @@ async fn install_container(
     let repo = &sysroot.repo();
     repo.set_disable_fsync(true);
 
-    let pulled_image = match prepare_for_pull(repo, &spec_imgref, Some(&state.target_imgref))
-        .await?
-    {
-        PreparedPullResult::AlreadyPresent(existing) => existing,
-        PreparedPullResult::Ready(image_meta) => {
-            check_disk_space(root_setup.physical_root.as_fd(), &image_meta, &spec_imgref)?;
-            pull_from_prepared(&spec_imgref, false, ProgressWriter::default(), image_meta).await?
-        }
-    };
+    let pulled_image =
+        match prepare_for_pull(repo, &spec_imgref, Some(&state.target_imgref)).await? {
+            PreparedPullResult::AlreadyPresent(existing) => existing,
+            PreparedPullResult::Ready(image_meta) => {
+                check_disk_space(root_setup.physical_root.as_fd(), &image_meta, &spec_imgref)?;
+                pull_from_prepared(&spec_imgref, false, prog, image_meta).await?
+            }
+        };
 
     repo.set_disable_fsync(false);
 
@@ -1174,6 +1185,7 @@ async fn prepare_install(
     config_opts: InstallConfigOpts,
     source_opts: InstallSourceOpts,
     target_opts: InstallTargetOpts,
+    _prog: ProgressWriter,
 ) -> Result<Arc<State>> {
     tracing::trace!("Preparing install");
     let rootfs = cap_std::fs::Dir::open_ambient_dir("/", cap_std::ambient_authority())
@@ -1335,10 +1347,11 @@ async fn install_with_sysroot(
     bound_images: BoundImages,
     has_ostree: bool,
     imgstore: &crate::imgstorage::Storage,
+    prog: ProgressWriter,
 ) -> Result<()> {
     // And actually set up the container in that root, returning a deployment and
     // the aleph state (see below).
-    let (_deployment, aleph) = install_container(state, rootfs, &sysroot, has_ostree).await?;
+    let (_deployment, aleph) = install_container(state, rootfs, &sysroot, has_ostree, prog).await?;
     // Write the aleph data that captures the system state at the time of provisioning for aid in future debugging.
     rootfs
         .physical_root
@@ -1420,6 +1433,7 @@ async fn install_to_filesystem_impl(
     state: &State,
     rootfs: &mut RootSetup,
     cleanup: Cleanup,
+    prog: ProgressWriter,
 ) -> Result<()> {
     if matches!(state.selinux_state, SELinuxFinalState::ForceTargetDisabled) {
         rootfs.kargs.push("selinux=0".to_string());
@@ -1461,6 +1475,7 @@ async fn install_to_filesystem_impl(
             bound_images,
             has_ostree,
             &imgstore,
+            prog,
         )
         .await?;
 
@@ -1496,6 +1511,7 @@ fn installation_complete() {
 #[context("Installing to disk")]
 #[cfg(feature = "install-to-disk")]
 pub(crate) async fn install_to_disk(mut opts: InstallToDiskOpts) -> Result<()> {
+    let prog: ProgressWriter = opts.progress.try_into()?;
     let mut block_opts = opts.block_opts;
     let target_blockdev_meta = block_opts
         .device
@@ -1517,7 +1533,13 @@ pub(crate) async fn install_to_disk(mut opts: InstallToDiskOpts) -> Result<()> {
     } else if !target_blockdev_meta.file_type().is_block_device() {
         anyhow::bail!("Not a block device: {}", block_opts.device);
     }
-    let state = prepare_install(opts.config_opts, opts.source_opts, opts.target_opts).await?;
+    let state = prepare_install(
+        opts.config_opts,
+        opts.source_opts,
+        opts.target_opts,
+        prog.clone(),
+    )
+    .await?;
 
     // This is all blocking stuff
     let (mut rootfs, loopback) = {
@@ -1538,7 +1560,7 @@ pub(crate) async fn install_to_disk(mut opts: InstallToDiskOpts) -> Result<()> {
         (rootfs, loopback_dev)
     };
 
-    install_to_filesystem_impl(&state, &mut rootfs, Cleanup::Skip).await?;
+    install_to_filesystem_impl(&state, &mut rootfs, Cleanup::Skip, prog).await?;
 
     // Drop all data about the root except the bits we need to ensure any file descriptors etc. are closed.
     let (root_path, luksdev) = rootfs.into_storage();
@@ -1720,12 +1742,19 @@ pub(crate) async fn install_to_filesystem(
     targeting_host_root: bool,
     cleanup: Cleanup,
 ) -> Result<()> {
+    let prog: ProgressWriter = opts.progress.try_into()?;
     // Gather global state, destructuring the provided options.
     // IMPORTANT: We might re-execute the current process in this function (for SELinux among other things)
     // IMPORTANT: and hence anything that is done before MUST BE IDEMPOTENT.
     // IMPORTANT: In practice, we should only be gathering information before this point,
     // IMPORTANT: and not performing any mutations at all.
-    let state = prepare_install(opts.config_opts, opts.source_opts, opts.target_opts).await?;
+    let state = prepare_install(
+        opts.config_opts,
+        opts.source_opts,
+        opts.target_opts,
+        prog.clone(),
+    )
+    .await?;
     // And the last bit of state here is the fsopts, which we also destructure now.
     let mut fsopts = opts.filesystem_opts;
 
@@ -1924,7 +1953,7 @@ pub(crate) async fn install_to_filesystem(
         skip_finalize,
     };
 
-    install_to_filesystem_impl(&state, &mut rootfs, cleanup).await?;
+    install_to_filesystem_impl(&state, &mut rootfs, cleanup, prog).await?;
 
     // Drop all data about the root except the path to ensure any file descriptors etc. are closed.
     drop(rootfs);
@@ -1952,6 +1981,7 @@ pub(crate) async fn install_to_existing_root(opts: InstallToExistingRootOpts) ->
         source_opts: opts.source_opts,
         target_opts: opts.target_opts,
         config_opts: opts.config_opts,
+        progress: opts.progress,
     };
 
     install_to_filesystem(opts, true, cleanup).await

crates/lib/src/progress_jsonl.rs

@@ -4,7 +4,7 @@
 use anyhow::Result;
 use canon_json::CanonJsonSerialize;
 use schemars::JsonSchema;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 use std::borrow::Cow;
 use std::os::fd::{FromRawFd, OwnedFd, RawFd};
 use std::str::FromStr;
@@ -137,7 +137,7 @@ pub enum Event<'t> {
     },
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub(crate) struct RawProgressFd(RawFd);
 
 impl FromStr for RawProgressFd {
@@ -153,6 +153,13 @@ impl FromStr for RawProgressFd {
     }
 }
 
+impl RawProgressFd {
+    #[cfg(test)]
+    pub(crate) fn get_raw_fd(&self) -> RawFd {
+        self.0
+    }
+}
+
 #[derive(Debug)]
 struct ProgressWriterInner {
     /// true if we sent the initial Start message