cli/composefs: Show staged/rollback deployments

Store the staged deployment at `/run/composefs/staged-deployment`
similar to how it's done in ostree

Signed-off-by: Pragyan Poudyal <[email protected]>

Author: Johan-Liebert1

lib/src/cli.rs

@@ -831,7 +831,7 @@ async fn upgrade_composefs(_opts: UpgradeOpts) -> Result<()> {
         BootType::Uki => setup_composefs_uki_boot(BootSetupType::Upgrade, repo, &id, entry),
     }?;
 
-    write_composefs_state(&Utf8PathBuf::from("/sysroot"), id, imgref)?;
+    write_composefs_state(&Utf8PathBuf::from("/sysroot"), id, imgref, true)?;
 
     Ok(())
 }

lib/src/install.rs

@@ -15,7 +15,7 @@ pub(crate) mod osconfig;
 
 use std::collections::HashMap;
 use std::fs::create_dir_all;
-use std::io::{Seek, SeekFrom, Write};
+use std::io::Write;
 use std::os::fd::{AsFd, AsRawFd};
 use std::os::unix::fs::symlink;
 use std::os::unix::process::CommandExt;
@@ -1779,19 +1779,26 @@ fn setup_composefs_boot(root_setup: &RootSetup, state: &State, image_id: &str) -
             transport: state.source.imageref.transport.to_string(),
             signature: None,
         },
+        false,
     )?;
 
     Ok(())
 }
 
+pub(crate) const COMPOSEFS_TRANSIENT_STATE_DIR: &str = "/run/composefs";
+pub(crate) const COMPOSEFS_STAGED_DEPLOYMENT_PATH: &str = "/run/composefs/staged-deployment";
+/// Relative to /sysroot
+pub(crate) const STATE_DIR_RELATIVE: &str = "state/deploy";
+
 /// Creates and populates /sysroot/state/deploy/image_id
 #[context("Writing composefs state")]
 pub(crate) fn write_composefs_state(
     root_path: &Utf8PathBuf,
     deployment_id: Sha256HashValue,
     imgref: &ImageReference,
+    staged: bool,
 ) -> Result<()> {
-    let state_path = root_path.join(format!("state/deploy/{}", deployment_id.to_hex()));
+    let state_path = root_path.join(format!("{STATE_DIR_RELATIVE}/{}", deployment_id.to_hex()));
 
     create_dir_all(state_path.join("etc/upper"))?;
     create_dir_all(state_path.join("etc/work"))?;
@@ -1821,6 +1828,19 @@ pub(crate) fn write_composefs_state(
         .write(config.to_string().as_bytes())
         .context("Falied to write to .origin file")?;
 
+    if staged {
+        std::fs::create_dir_all(COMPOSEFS_TRANSIENT_STATE_DIR)
+            .with_context(|| format!("Creating {COMPOSEFS_TRANSIENT_STATE_DIR}"))?;
+
+        let mut file = std::fs::OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(COMPOSEFS_STAGED_DEPLOYMENT_PATH)
+            .context("Opening staged-deployment file")?;
+
+        file.write_all(deployment_id.to_hex().as_bytes())?;
+    }
+
     Ok(())
 }
 

lib/src/status.rs

@@ -23,6 +23,7 @@ use ostree_ext::ostree;
 use tokio::io::AsyncReadExt;
 
 use crate::cli::OutputFormat;
+use crate::install::{COMPOSEFS_STAGED_DEPLOYMENT_PATH, STATE_DIR_RELATIVE};
 use crate::spec::ImageStatus;
 use crate::spec::{BootEntry, BootOrder, Host, HostSpec, HostStatus, HostType};
 use crate::spec::{ImageReference, ImageSignature};
@@ -389,8 +390,8 @@ pub(crate) async fn composefs_deployment_status() -> Result<Host> {
     let sysroot = cap_std::fs::Dir::open_ambient_dir("/sysroot", cap_std::ambient_authority())
         .context("Opening sysroot")?;
     let deployments = sysroot
-        .read_dir("state/deploy")
-        .context("Reading sysroot state/deploy")?;
+        .read_dir(STATE_DIR_RELATIVE)
+        .with_context(|| format!("Reading sysroot {STATE_DIR_RELATIVE}"))?;
 
     let host_spec = HostSpec {
         image: None,
@@ -399,6 +400,17 @@ pub(crate) async fn composefs_deployment_status() -> Result<Host> {
 
     let mut host = Host::new(host_spec);
 
+    let staged_deployment_id = match std::fs::File::open(COMPOSEFS_STAGED_DEPLOYMENT_PATH) {
+        Ok(mut f) => {
+            let mut s = String::new();
+            f.read_to_string(&mut s)?;
+
+            Ok(Some(s))
+        }
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(e) => Err(e),
+    }?;
+
     for depl in deployments {
         let depl = depl?;
 
@@ -422,6 +434,15 @@ pub(crate) async fn composefs_deployment_status() -> Result<Host> {
             host.status.booted = Some(boot_entry);
             continue;
         }
+
+        if let Some(staged_deployment_id) = &staged_deployment_id {
+            if depl_file_name == staged_deployment_id.trim() {
+                host.status.staged = Some(boot_entry);
+                continue;
+            }
+        }
+
+        host.status.rollback = Some(boot_entry);
     }
 
     Ok(host)