cli: add support for soft-reboots

Co-authored-by: Colin Walters <[email protected]>

Signed-off-by: Joseph Marrero Corchado <[email protected]>

Author: jmarrero

lib/src/cli.rs

@@ -26,11 +26,11 @@ use schemars::schema_for;
 use serde::{Deserialize, Serialize};
 
 use crate::deploy::RequiredHostSpec;
-use crate::lints;
 use crate::progress_jsonl::{ProgressWriter, RawProgressFd};
 use crate::spec::Host;
 use crate::spec::ImageReference;
 use crate::utils::sigpolicy_from_opt;
+use crate::{lints, reboot};
 
 /// Shared progress options
 #[derive(Debug, Parser, PartialEq, Eq)]
@@ -536,7 +536,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.
 
@@ -835,6 +835,31 @@ async fn upgrade(opts: UpgradeOpts) -> Result<()> {
             println!("Staged update present, not changed.");
 
             if opts.apply {
+                // Check if we can do a soft-reboot instead of a full reboot
+                let can_soft_reboot = host
+                    .status
+                    .staged
+                    .as_ref()
+                    .map(|s| s.soft_reboot_capable)
+                    .unwrap_or(false);
+
+                if can_soft_reboot {
+                    println!("Staged deployment is soft-reboot capable, performing soft-reboot...");
+
+                    // Find the staged deployment
+                    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 the soft-reboot using native ostree bindings
+                    let cancellable = ostree::gio::Cancellable::NONE;
+                    sysroot
+                        .sysroot
+                        .deployment_prepare_next_root(staged_deployment, false, cancellable)
+                        .context("Failed to prepare soft-reboot")?;
+                }
                 crate::reboot::reboot()?;
             }
         } else if booted_unchanged {
@@ -931,6 +956,33 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
     sysroot.update_mtime()?;
 
     if opts.apply {
+        // Get updated status to check for soft-reboot capability
+        let (_updated_deployments, updated_host) =
+            crate::status::get_status(sysroot, Some(&booted_deployment))?;
+        let can_soft_reboot = updated_host
+            .status
+            .staged
+            .as_ref()
+            .map(|s| s.soft_reboot_capable)
+            .unwrap_or(false);
+
+        if can_soft_reboot {
+            println!("Staged deployment is soft-reboot capable, performing soft-reboot...");
+
+            // Find the staged deployment
+            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 the soft-reboot using native ostree bindings
+            let cancellable = ostree::gio::Cancellable::NONE;
+            sysroot
+                .sysroot
+                .deployment_prepare_next_root(staged_deployment, false, cancellable)
+                .context("Failed to prepare soft-reboot")?;
+        }
         crate::reboot::reboot()?;
     }
 
@@ -941,10 +993,40 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
 #[context("Rollback")]
 async fn rollback(opts: RollbackOpts) -> Result<()> {
     let sysroot = &get_storage().await?;
-    crate::deploy::rollback(sysroot).await?;
 
     if opts.apply {
+        // Get status before rollback to check soft-reboot capability
+        let (_booted_deployment, _deployments, host) =
+            crate::status::get_status_require_booted(sysroot)?;
+        let can_soft_reboot = host
+            .status
+            .rollback
+            .as_ref()
+            .map(|r| r.soft_reboot_capable)
+            .unwrap_or(false);
+
+        // Perform the rollback
+        crate::deploy::rollback(sysroot).await?;
+
+        if can_soft_reboot {
+            println!("Rollback deployment is soft-reboot capable, performing soft-reboot...");
+
+            // For rollback, get the current first deployment after rollback
+            let deployments_list = sysroot.deployments();
+            let target_deployment = deployments_list
+                .first()
+                .ok_or_else(|| anyhow::anyhow!("No deployments found after rollback"))?;
+
+            // Prepare the soft-reboot using native ostree bindings
+            let cancellable = ostree::gio::Cancellable::NONE;
+            sysroot
+                .sysroot
+                .deployment_prepare_next_root(target_deployment, false, cancellable)
+                .context("Failed to prepare soft-reboot")?;
+        }
         crate::reboot::reboot()?;
+    } else {
+        crate::deploy::rollback(sysroot).await?;
     }
 
     Ok(())

lib/src/reboot.rs

@@ -13,7 +13,9 @@ pub(crate) fn reboot() -> anyhow::Result<()> {
     // Flush output streams
     let _ = std::io::stdout().flush();
     let _ = std::io::stderr().flush();
-    Task::new("Rebooting system", "reboot").run()?;
+    Task::new("Rebooting system", "systemd-run")
+        .args(["reboot"])
+        .run()?;
     tracing::debug!("Initiated reboot, sleeping forever...");
     loop {
         std::thread::park();

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,

lib/src/status.rs

@@ -144,10 +144,13 @@ fn boot_entry_from_deployment(
         (None, CachedImageStatus::default(), false)
     };
 
+    let soft_reboot_capable = sysroot.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 +231,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()