wip soft-reboot

Author: jmarrero

lib/src/cli.rs

@@ -26,7 +26,7 @@ use schemars::schema_for;
 use serde::{Deserialize, Serialize};
 
 use crate::deploy::RequiredHostSpec;
-use crate::lints;
+use crate::{lints, reboot};
 use crate::progress_jsonl::{ProgressWriter, RawProgressFd};
 use crate::spec::Host;
 use crate::spec::ImageReference;
@@ -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,7 +835,35 @@ async fn upgrade(opts: UpgradeOpts) -> Result<()> {
             println!("Staged update present, not changed.");
 
             if opts.apply {
-                crate::reboot::reboot()?;
+                // 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 index of the staged deployment  
+                    let deployments_list = sysroot.deployments();
+                    let staged_index = deployments_list
+                        .iter()
+                        .position(|d| d.is_staged())
+                        .ok_or_else(|| anyhow::anyhow!("Failed to find staged deployment index"))?;
+                    
+                    // Prepare the soft-reboot using ostree admin prepare-soft-reboot
+                    let mut cmd = std::process::Command::new("ostree");
+                    cmd.args(["admin", "prepare-soft-reboot", &staged_index.to_string()]);
+                    let status = cmd.status().context("Failed to run ostree admin prepare-soft-reboot")?;
+                    if !status.success() {
+                        anyhow::bail!("ostree admin prepare-soft-reboot failed");
+                    }
+                    
+                    // Perform the soft-reboot
+                    crate::reboot::soft_reboot()?;
+                } else {
+                    crate::reboot::reboot()?;
+                }
             }
         } else if booted_unchanged {
             println!("No update available.")
@@ -931,7 +959,36 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
     sysroot.update_mtime()?;
 
     if opts.apply {
-        crate::reboot::reboot()?;
+        // 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 index of the staged deployment  
+            let deployments_list = sysroot.deployments();
+            let staged_index = deployments_list
+                .iter()
+                .position(|d| d.is_staged())
+                .ok_or_else(|| anyhow::anyhow!("Failed to find staged deployment index"))?;
+            
+            // Prepare the soft-reboot using ostree admin prepare-soft-reboot
+            let mut cmd = std::process::Command::new("ostree");
+            cmd.args(["admin", "prepare-soft-reboot", &staged_index.to_string()]);
+            let status = cmd.status().context("Failed to run ostree admin prepare-soft-reboot")?;
+            if !status.success() {
+                anyhow::bail!("ostree admin prepare-soft-reboot failed");
+            }
+            
+                         // Perform the soft-reboot
+             crate::reboot::soft_reboot()?;
+        } else {
+            crate::reboot::reboot()?;
+        }
     }
 
     Ok(())
@@ -941,10 +998,39 @@ 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 {
-        crate::reboot::reboot()?;
+        // 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, the target deployment is at index 0 after the rollback operation
+            let target_index = 0;
+            
+            // Prepare the soft-reboot using ostree admin prepare-soft-reboot
+            let mut cmd = std::process::Command::new("ostree");
+            cmd.args(["admin", "prepare-soft-reboot", &target_index.to_string()]);
+            let status = cmd.status().context("Failed to run ostree admin prepare-soft-reboot")?;
+            if !status.success() {
+                anyhow::bail!("ostree admin prepare-soft-reboot failed");
+            }
+            
+            // Perform the soft-reboot
+            crate::reboot::soft_reboot()?;
+        } else {
+            crate::reboot::reboot()?;
+        }
+    } else {
+        crate::deploy::rollback(sysroot).await?;
     }
 
     Ok(())

lib/src/reboot.rs

@@ -6,16 +6,29 @@ use fn_error_context::context;
 
 use crate::task::Task;
 
-/// Initiate a system reboot.
+/// Common reboot implementation that handles flushing streams and running the reboot command.
 /// This function will only return in case of error.
-#[context("Initiating reboot")]
-pub(crate) fn reboot() -> anyhow::Result<()> {
+fn perform_reboot(task_name: &str, command: &str) -> anyhow::Result<()> {
     // Flush output streams
     let _ = std::io::stdout().flush();
     let _ = std::io::stderr().flush();
-    Task::new("Rebooting system", "reboot").run()?;
-    tracing::debug!("Initiated reboot, sleeping forever...");
+    Task::new(task_name, command).run()?;
+    tracing::debug!("Initiated {}, sleeping forever...", task_name.to_lowercase());
     loop {
         std::thread::park();
     }
 }
+
+/// Initiate a system reboot.
+/// This function will only return in case of error.
+#[context("Initiating reboot")]
+pub(crate) fn reboot() -> anyhow::Result<()> {
+    perform_reboot("Rebooting system", "reboot")
+}
+
+/// Initiate a soft reboot (userspace-only restart).
+/// This function will only return in case of error.
+#[context("Initiating soft reboot")]
+pub(crate) fn soft_reboot() -> anyhow::Result<()> {
+    perform_reboot("Performing soft-reboot", "systemctl soft-reboot")
+}

lib/src/status.rs

@@ -422,6 +422,11 @@ fn human_render_slot(
         writeln!(out, "yes")?;
     }
 
+    if entry.soft_reboot_capable {
+        write_row_name(&mut out, "Soft-reboot", prefix_len)?;
+        writeln!(out, "capable")?;
+    }
+
     tracing::debug!("pinned={}", entry.pinned);
 
     Ok(())
@@ -451,6 +456,11 @@ fn human_render_slot_ostree(
         writeln!(out, "yes")?;
     }
 
+    if entry.soft_reboot_capable {
+        write_row_name(&mut out, "Soft-reboot", prefix_len)?;
+        writeln!(out, "capable")?;
+    }
+
     tracing::debug!("pinned={}", entry.pinned);
     Ok(())
 }