wip --soft-reboot=required

Author: jmarrero

crates/lib/src/cli.rs

@@ -80,12 +80,12 @@ pub(crate) struct UpgradeOpts {
     #[clap(long, conflicts_with = "check")]
     pub(crate) apply: bool,
 
-    /// Queue a soft reboot after staging the deployment.
+    /// Configure soft reboot behavior.
     ///
-    /// This will prepare the system for a soft reboot instead of a full reboot,
-    /// which allows userspace to restart without rebooting the kernel.
-    #[clap(long, conflicts_with = "check")]
-    pub(crate) queue_soft_reboot: bool,
+    /// 'required' will fail if soft reboot is not available.
+    /// 'auto' will use soft reboot if available, otherwise fall back to regular reboot.
+    #[clap(long = "soft-reboot", conflicts_with = "check")]
+    pub(crate) soft_reboot: Option<SoftRebootMode>,
 
     #[clap(flatten)]
     pub(crate) progress: ProgressOptions,
@@ -106,12 +106,12 @@ pub(crate) struct SwitchOpts {
     #[clap(long)]
     pub(crate) apply: bool,
 
-    /// Queue a soft reboot after staging the deployment.
+    /// Configure soft reboot behavior.
     ///
-    /// This will prepare the system for a soft reboot instead of a full reboot,
-    /// which allows userspace to restart without rebooting the kernel.
-    #[clap(long)]
-    pub(crate) queue_soft_reboot: bool,
+    /// 'required' will fail if soft reboot is not available.
+    /// 'auto' will use soft reboot if available, otherwise fall back to regular reboot.
+    #[clap(long = "soft-reboot")]
+    pub(crate) soft_reboot: Option<SoftRebootMode>,
 
     /// The transport; e.g. oci, oci-archive, containers-storage.  Defaults to `registry`.
     #[clap(long, default_value = "registry")]
@@ -157,12 +157,12 @@ pub(crate) struct RollbackOpts {
     #[clap(long)]
     pub(crate) apply: bool,
 
-    /// Queue a soft reboot after performing the rollback.
+    /// Configure soft reboot behavior.
     ///
-    /// This will prepare the system for a soft reboot instead of a full reboot,
-    /// which allows userspace to restart without rebooting the kernel.
-    #[clap(long)]
-    pub(crate) queue_soft_reboot: bool,
+    /// 'required' will fail if soft reboot is not available.
+    /// 'auto' will use soft reboot if available, otherwise fall back to regular reboot.
+    #[clap(long = "soft-reboot")]
+    pub(crate) soft_reboot: Option<SoftRebootMode>,
 }
 
 /// Perform an edit operation
@@ -188,6 +188,15 @@ pub(crate) enum OutputFormat {
     Json,
 }
 
+#[derive(Debug, Clone, Copy, ValueEnum, PartialEq, Eq)]
+#[clap(rename_all = "lowercase")]
+pub(crate) enum SoftRebootMode {
+    /// Require a soft reboot; fail if not possible
+    Required,
+    /// Automatically use soft reboot if possible, otherwise use regular reboot
+    Auto,
+}
+
 /// Perform an status operation
 #[derive(Debug, Parser, PartialEq, Eq)]
 pub(crate) struct StatusOpts {
@@ -781,6 +790,42 @@ fn prepare_soft_reboot(
     Ok(())
 }
 
+/// Handle soft reboot based on the configured mode
+#[context("Handling soft reboot")]
+fn handle_soft_reboot<F>(
+    soft_reboot_mode: Option<SoftRebootMode>,
+    entry: Option<&crate::spec::BootEntry>,
+    deployment_type: &str,
+    execute_soft_reboot: F,
+) -> Result<()>
+where
+    F: FnOnce() -> Result<()>,
+{
+    let Some(mode) = soft_reboot_mode else {
+        return Ok(());
+    };
+
+    let can_soft_reboot = has_soft_reboot_capability(entry);
+    match mode {
+        SoftRebootMode::Required => {
+            if can_soft_reboot {
+                execute_soft_reboot()?;
+            } else {
+                anyhow::bail!(
+                    "Soft reboot was required but {} deployment is not soft-reboot capable",
+                    deployment_type
+                );
+            }
+        }
+        SoftRebootMode::Auto => {
+            if can_soft_reboot {
+                execute_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<()> {
@@ -914,11 +959,12 @@ async fn upgrade(opts: UpgradeOpts) -> Result<()> {
             .unwrap_or_default();
         if staged_unchanged {
             println!("Staged update present, not changed.");
-            if opts.queue_soft_reboot {
-                if has_soft_reboot_capability(host.status.staged.as_ref()) {
-                    soft_reboot_staged(sysroot)?;
-                }
-            }
+            handle_soft_reboot(
+                opts.soft_reboot,
+                host.status.staged.as_ref(),
+                "staged",
+                || soft_reboot_staged(sysroot),
+            )?;
             if opts.apply {
                 crate::reboot::reboot()?;
             }
@@ -940,13 +986,16 @@ async fn upgrade(opts: UpgradeOpts) -> Result<()> {
     if changed {
         sysroot.update_mtime()?;
 
-        if opts.queue_soft_reboot {
+        if opts.soft_reboot.is_some() {
             // At this point we have new staged deployment and the host definition has changed.
             // We need the updated host status before we check if we can prepare the soft-reboot.
             let updated_host = crate::status::get_status(sysroot, Some(&booted_deployment))?.1;
-            if has_soft_reboot_capability(updated_host.status.staged.as_ref()) {
-                soft_reboot_staged(sysroot)?;
-            }
+            handle_soft_reboot(
+                opts.soft_reboot,
+                updated_host.status.staged.as_ref(),
+                "staged",
+                || soft_reboot_staged(sysroot),
+            )?;
         }
 
         if opts.apply {
@@ -1024,13 +1073,16 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
 
     sysroot.update_mtime()?;
 
-    if opts.queue_soft_reboot {
+    if opts.soft_reboot.is_some() {
         // At this point we have staged the deployment and the host definition has changed.
         // We need the updated host status before we check if we can prepare the soft-reboot.
         let updated_host = crate::status::get_status(sysroot, Some(&booted_deployment))?.1;
-        if has_soft_reboot_capability(updated_host.status.staged.as_ref()) {
-            soft_reboot_staged(sysroot)?;
-        }
+        handle_soft_reboot(
+            opts.soft_reboot,
+            updated_host.status.staged.as_ref(),
+            "staged",
+            || soft_reboot_staged(sysroot),
+        )?;
     }
 
     if opts.apply {
@@ -1046,20 +1098,25 @@ async fn rollback(opts: RollbackOpts) -> Result<()> {
     let sysroot = &get_storage().await?;
     crate::deploy::rollback(sysroot).await?;
 
-    if opts.queue_soft_reboot {
+    if opts.soft_reboot.is_some() {
         // Get status of rollback deployment to check soft-reboot capability
         let host = crate::status::get_status_require_booted(sysroot)?.2;
 
-        if has_soft_reboot_capability(host.status.rollback.as_ref()) {
-            println!("Rollback deployment is soft-reboot capable, preparing for soft-reboot...");
-
-            let deployments_list = sysroot.deployments();
-            let target_deployment = deployments_list
-                .first()
-                .ok_or_else(|| anyhow::anyhow!("No rollback deployment found!"))?;
-
-            prepare_soft_reboot(sysroot, target_deployment)?;
-        }
+        handle_soft_reboot(
+            opts.soft_reboot,
+            host.status.rollback.as_ref(),
+            "rollback",
+            || {
+                println!(
+                    "Rollback deployment is soft-reboot capable, preparing for soft-reboot..."
+                );
+                let deployments_list = sysroot.deployments();
+                let target_deployment = deployments_list
+                    .first()
+                    .ok_or_else(|| anyhow::anyhow!("No rollback deployment found!"))?;
+                prepare_soft_reboot(sysroot, target_deployment)
+            },
+        )?;
     }
 
     if opts.apply {

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

@@ -30,7 +30,7 @@ RUN echo test content > /usr/share/testfile-for-soft-reboot.txt
 
     assert (not ("/run/nextroot" | path exists))
 
-    bootc switch --queue-soft-reboot --transport containers-storage localhost/bootc-derived
+    bootc switch --soft-reboot=auto --transport containers-storage localhost/bootc-derived
     let st = bootc status --json | from json
     assert $st.status.staged.softRebootCapable
 
@@ -58,7 +58,7 @@ RUN echo 'kargs = ["foo1=bar2"]' | tee /usr/lib/bootc/kargs.d/00-foo1bar2.toml >
     # Build it
     podman build -t localhost/bootc-derived .
 
-    bootc update --queue-soft-reboot
+    bootc upgrade --soft-reboot=auto
     let st = bootc status --json | from json
     # Should not be soft-reboot capable because of kargs diff
     assert (not $st.status.staged.softRebootCapable)