cli: add support for soft-reboots

Co-authored-by: Colin Walters <walters@verbum.org>

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

Author: jmarrero

crates/lib/src/cli.rs

@@ -542,7 +542,7 @@ pub(crate) enum Opt {
         Note on Rollbacks and the `/etc` Directory:
 
         When you perform a rollback (e.g., with `bootc rollback`), any
-        changes made to files in the `/etc` directory won’t carry over
+        changes made to files in the `/etc` directory won't carry over
         to the rolled-back deployment.  The `/etc` files will revert
         to their state from that previous deployment instead.
 
@@ -721,6 +721,40 @@ pub(crate) fn require_root(is_container: bool) -> Result<()> {
     Ok(())
 }
 
+/// Check if a deployment can perform a soft reboot
+fn can_perform_soft_reboot(deployment: Option<&crate::spec::BootEntry>) -> bool {
+    deployment.map(|d| d.soft_reboot_capable).unwrap_or(false)
+}
+
+/// Prepare and execute a soft reboot for the given deployment
+#[context("Preparing soft reboot")]
+fn prepare_soft_reboot(
+    sysroot: &crate::store::Storage,
+    deployment: &ostree::Deployment,
+) -> Result<()> {
+    let cancellable = ostree::gio::Cancellable::NONE;
+    sysroot
+        .sysroot
+        .deployment_set_soft_reboot(deployment, false, cancellable)
+        .context("Failed to prepare soft-reboot")?;
+    Ok(())
+}
+
+/// Perform a soft reboot for a staged deployment
+#[context("Soft reboot staged deployment")]
+fn soft_reboot_staged(sysroot: &crate::store::Storage) -> Result<()> {
+    println!("Staged deployment is soft-reboot capable, performing soft-reboot...");
+
+    let deployments_list = sysroot.deployments();
+    let staged_deployment = deployments_list
+        .iter()
+        .find(|d| d.is_staged())
+        .ok_or_else(|| anyhow::anyhow!("Failed to find staged deployment"))?;
+
+    prepare_soft_reboot(sysroot, staged_deployment)?;
+    Ok(())
+}
+
 /// A few process changes that need to be made for writing.
 /// IMPORTANT: This may end up re-executing the current process,
 /// so anything that happens before this should be idempotent.
@@ -841,6 +875,9 @@ async fn upgrade(opts: UpgradeOpts) -> Result<()> {
             println!("Staged update present, not changed.");
 
             if opts.apply {
+                if can_perform_soft_reboot(host.status.staged.as_ref()) {
+                    soft_reboot_staged(sysroot)?;
+                }
                 crate::reboot::reboot()?;
             }
         } else if booted_unchanged {
@@ -937,6 +974,12 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
     sysroot.update_mtime()?;
 
     if opts.apply {
+        // Get updated status to check for soft-reboot capability
+        let updated_host = crate::status::get_status(sysroot, Some(&booted_deployment))?.1;
+
+        if can_perform_soft_reboot(updated_host.status.staged.as_ref()) {
+            soft_reboot_staged(sysroot)?;
+        }
         crate::reboot::reboot()?;
     }
 
@@ -950,6 +993,20 @@ async fn rollback(opts: RollbackOpts) -> Result<()> {
     crate::deploy::rollback(sysroot).await?;
 
     if opts.apply {
+        // Get status before rollback to check soft-reboot capability
+        let host = crate::status::get_status_require_booted(sysroot)?.2;
+
+        if can_perform_soft_reboot(host.status.rollback.as_ref()) {
+            println!("Rollback deployment is soft-reboot capable, performing soft-reboot...");
+
+            let deployments_list = sysroot.deployments();
+            let target_deployment = deployments_list
+                .first()
+                .ok_or_else(|| anyhow::anyhow!("No deployments found after rollback"))?;
+
+            prepare_soft_reboot(sysroot, target_deployment)?;
+        }
+
         crate::reboot::reboot()?;
     }
 

crates/lib/src/deploy.rs

@@ -577,10 +577,6 @@ async fn deploy(
                 &opts,
                 Some(cancellable),
             )?;
-            tracing::debug!(
-                "Soft reboot capable: {:?}",
-                sysroot.deployment_can_soft_reboot(&d)
-            );
             Ok(d.index())
         }),
     )

crates/lib/src/spec.rs

@@ -176,6 +176,9 @@ pub struct BootEntry {
     pub incompatible: bool,
     /// Whether this entry will be subject to garbage collection
     pub pinned: bool,
+    /// This is true if (relative to the booted system) this is a possible target for a soft reboot
+    #[serde(default)]
+    pub soft_reboot_capable: bool,
     /// The container storage backend
     #[serde(default)]
     pub store: Option<Store>,
@@ -517,6 +520,7 @@ mod tests {
                 image: None,
                 cached_update: None,
                 incompatible: false,
+                soft_reboot_capable: false,
                 pinned: false,
                 store: None,
                 ostree: None,

crates/lib/src/status.rs

@@ -144,10 +144,14 @@ fn boot_entry_from_deployment(
         (None, CachedImageStatus::default(), false)
     };
 
+    let soft_reboot_capable =
+        ostree_ext::systemd_has_soft_reboot() && sysroot.deployment_can_soft_reboot(deployment);
+
     let r = BootEntry {
         image,
         cached_update,
         incompatible,
+        soft_reboot_capable,
         store,
         pinned: deployment.is_pinned(),
         ostree: Some(crate::spec::BootEntryOstree {
@@ -228,17 +232,17 @@ pub(crate) fn get_status(
         other,
     };
 
-    let staged = deployments
-        .staged
+    let booted = booted_deployment
         .as_ref()
         .map(|d| boot_entry_from_deployment(sysroot, d))
         .transpose()
-        .context("Staged deployment")?;
-    let booted = booted_deployment
+        .context("Booted deployment")?;
+    let staged = deployments
+        .staged
         .as_ref()
         .map(|d| boot_entry_from_deployment(sysroot, d))
         .transpose()
-        .context("Booted deployment")?;
+        .context("Staged deployment")?;
     let rollback = deployments
         .rollback
         .as_ref()

crates/ostree-ext/src/lib.rs

@@ -78,3 +78,12 @@ pub mod prelude {
 pub mod fixture;
 #[cfg(feature = "internal-testing-api")]
 pub mod integrationtest;
+
+/// Check if the system has the soft reboot target, which signals
+/// systemd support for soft reboots.
+pub fn systemd_has_soft_reboot() -> bool {
+    const UNIT: &str = "/usr/lib/systemd/system/soft-reboot.target";
+    use std::sync::OnceLock;
+    static EXISTS: OnceLock<bool> = OnceLock::new();
+    *EXISTS.get_or_init(|| std::path::Path::new(UNIT).exists())
+}

tmt/plans/integration.fmf

@@ -37,6 +37,14 @@ execute:
         - /tmt/tests/bootc-install-provision
         - /tmt/tests/test-21-logically-bound-switch
 
+/test-21-soft-reboot:
+  summary: Soft reboot support
+  discover:
+    how: fmf
+    test:
+        - /tmt/tests/bootc-install-provision
+        - /tmt/tests/test-21-soft-reboot
+
 /test-22-logically-bound-install:
   summary: Execute logically bound images tests for switching images
   environment+:

tmt/tests/booted/test-soft-reboot.nu

@@ -0,0 +1,55 @@
+# Verify that soft reboot works (on by default)
+use std assert
+use tap.nu
+
+let soft_reboot_capable = "/usr/lib/systemd/system/soft-reboot.target" | path exists
+if not $soft_reboot_capable {
+    echo "Skipping, system is not soft reboot capable"
+    return
+}
+
+# This code runs on *each* boot.
+# Here we just capture information.
+bootc status
+let st = bootc status --json | from json
+let booted = $st.status.booted.image
+
+# Run on the first boot
+def initial_build [] {
+    tap begin "local image push + pull + upgrade"
+
+    let td = mktemp -d
+    cd $td
+
+    bootc image copy-to-storage
+
+    # A simple derived container that adds a file, but also injects some kargs
+    "FROM localhost/bootc
+RUN echo test content > /usr/share/testfile-for-soft-reboot.txt
+" | save Dockerfile
+    # Build it
+    podman build -t localhost/bootc-derived .
+
+    bootc switch --transport containers-storage localhost/bootc-derived
+    let st = bootc status --json | from json
+    assert ($st.status.staged.soft_reboot_capable) == true
+
+    # And reboot into it
+    tmt-reboot
+}
+
+# The second boot; verify we're in the derived image
+def second_boot [] {
+    assert ("/usr/share/testfile-for-soft-reboot.txt" | path exists)
+
+    assert equal (systemctl show -P SoftRebootsCount) "1"
+}
+
+def main [] {
+    # See https://tmt.readthedocs.io/en/stable/stories/features.html#reboot-during-test
+    match $env.TMT_REBOOT_COUNT? {
+        null | "0" => initial_build,
+        "1" => second_boot,
+        $o => { error make { msg: $"Invalid TMT_REBOOT_COUNT ($o)" } },
+    }
+}