deb: change ui/ux of pkh deb

src/deb/ephemeral.rs

@@ -1,4 +1,5 @@
 use crate::context::{self, Context, ContextConfig};
+use crate::ui::deb::{DebUi, Phase};
 use directories::ProjectDirs;
 use std::error::Error;
 use std::fs;
@@ -28,6 +29,7 @@ impl EphemeralContextGuard {
         series: &str,
         arch: Option<&str>,
         base_ctx: Arc<Context>,
+        ui: Option<Arc<DebUi>>,
     ) -> Result<Self, Box<dyn Error>> {
         let current_context_name = context::manager().current_name();
 
@@ -43,7 +45,8 @@ impl EphemeralContextGuard {
         );
 
         // Download and extract the chroot tarball
-        Self::download_and_extract_chroot(series, arch, &chroot_path, base_ctx.clone()).await?;
+        Self::download_and_extract_chroot(series, arch, &chroot_path, base_ctx.clone(), &ui)
+            .await?;
 
         // Switch to an ephemeral context to build the package in the chroot
         context::manager().set_current_ephemeral(Context::new(ContextConfig::Unshare {
@@ -64,6 +67,7 @@ impl EphemeralContextGuard {
         arch: Option<&str>,
         chroot_path: &PathBuf,
         ctx: Arc<context::Context>,
+        ui: &Option<Arc<DebUi>>,
     ) -> Result<(), Box<dyn Error>> {
         // Clone ctx for use in create_device_nodes after download_chroot_tarball consumes it
         let ctx_for_devices = ctx.clone();
@@ -119,7 +123,10 @@ impl EphemeralContextGuard {
                 series,
                 arch
             );
-            Self::download_chroot_tarball(series, arch, &tarball_path, ctx).await?;
+            if let Some(u) = ui {
+                u.phase(Phase::PreparingChroot);
+            }
+            Self::download_chroot_tarball(series, arch, &tarball_path, ctx, ui).await?;
         } else {
             log::debug!(
                 "Using cached chroot tarball for {} (arch: {:?})",
@@ -130,10 +137,16 @@ impl EphemeralContextGuard {
 
         // Extract tarball to chroot directory
         log::debug!("Extracting chroot tarball to {}...", chroot_path.display());
-        Self::extract_tarball(&tarball_path, chroot_path)?;
+        if let Some(u) = ui {
+            u.phase(Phase::ExtractingChroot);
+        }
+        Self::extract_tarball(&tarball_path, chroot_path, ui.as_deref())?;
 
         // Create device nodes in the chroot
         log::debug!("Creating device nodes in chroot...");
+        if let Some(u) = ui {
+            u.phase(Phase::FinalizingChroot);
+        }
         Self::create_device_nodes(chroot_path, ctx_for_devices.clone())?;
 
         // Bind mount /proc from host into chroot (before entering unshare namespace)
@@ -149,6 +162,7 @@ impl EphemeralContextGuard {
         arch: Option<&str>,
         tarball_path: &Path,
         ctx: Arc<context::Context>,
+        ui: &Option<Arc<DebUi>>,
     ) -> Result<(), Box<dyn Error>> {
         // Create a lock file to make sure that noone tries to use the file while it's not fully downloaded
         let lockfile_path = tarball_path.with_extension("lock");
@@ -182,6 +196,10 @@ impl EphemeralContextGuard {
         cmd.arg(series)
             .arg(tarball_path.to_string_lossy().to_string());
 
+        if let Some(u) = ui {
+            cmd.capture(u.sink());
+        }
+
         let status = cmd.status()?;
 
         if !status.success() {
@@ -216,6 +234,7 @@ impl EphemeralContextGuard {
     fn extract_tarball(
         tarball_path: &PathBuf,
         chroot_path: &PathBuf,
+        ui: Option<&DebUi>,
     ) -> Result<(), Box<dyn Error>> {
         // Create the chroot directory
         fs::create_dir_all(chroot_path)?;
@@ -225,8 +244,23 @@ impl EphemeralContextGuard {
         let xz_decoder = XzDecoder::new(tarball_file);
         let mut archive = Archive::new(xz_decoder);
 
-        // Extract all files to the chroot directory
-        archive.unpack(chroot_path)?;
+        // Extract entries one by one so progress can be reported (a full
+        // second decompression pass just to count entries upfront would be
+        // too expensive for multi-hundred-MB chroot tarballs)
+        let mut count = 0usize;
+        for entry in archive.entries()? {
+            let mut entry = entry?;
+            entry.unpack_in(chroot_path)?;
+            count += 1;
+            if count.is_multiple_of(100)
+                && let Some(u) = ui
+            {
+                u.progress_message(&format!("Extracting chroot… ({count} files)"));
+            }
+        }
+        if let Some(u) = ui {
+            u.progress_message(&format!("Extracting chroot… ({count} files)"));
+        }
 
         Ok(())
     }