cli: Refactor switch/rollback/edit to use BootedOstree

Apply the same pattern used in upgrade() to switch, rollback, and edit
commands. This eliminates redundant composefs_booted() calls from the
main CLI code paths by consistently using storage.kind() for dispatch.

Changes:
- Split switch/rollback/edit into dispatcher + _ostree() helper functions
- Update get_status_require_booted() to return BootedOstree instead of
  separate deployment/sysroot components
- Update soft_reboot_rollback() to accept &BootedOstree
- Update deploy::rollback() and install_reset() for new types
- All command verbs now follow consistent pattern:
  storage.kind()? → match BootedStorageKind → call helper with &BootedOstree

This change eliminates all composefs_booted() calls from crates/lib/src/cli.rs
main code paths, passing boot context data down from BootedStorage instead.

Assisted-by: Claude Code (Sonnet 4.5)
Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

crates/lib/src/cli.rs

@@ -827,15 +827,15 @@ fn soft_reboot_staged(sysroot: &SysrootLock) -> Result<()> {
 
 /// Perform a soft reboot for a rollback deployment
 #[context("Soft reboot rollback deployment")]
-fn soft_reboot_rollback(sysroot: &SysrootLock) -> Result<()> {
+fn soft_reboot_rollback(booted_ostree: &BootedOstree<'_>) -> Result<()> {
     println!("Rollback deployment is soft-reboot capable, preparing for soft-reboot...");
 
-    let deployments_list = sysroot.deployments();
+    let deployments_list = booted_ostree.sysroot.deployments();
     let target_deployment = deployments_list
         .first()
         .ok_or_else(|| anyhow::anyhow!("No rollback deployment found!"))?;
 
-    prepare_soft_reboot(sysroot, target_deployment)
+    prepare_soft_reboot(booted_ostree.sysroot, target_deployment)
 }
 
 /// A few process changes that need to be made for writing.
@@ -996,34 +996,19 @@ pub(crate) fn imgref_for_switch(opts: &SwitchOpts) -> Result<ImageReference> {
     return Ok(target);
 }
 
-/// Implementation of the `bootc switch` CLI command.
-#[context("Switching")]
-async fn switch(opts: SwitchOpts) -> Result<()> {
+/// Implementation of the `bootc switch` CLI command for ostree backend.
+#[context("Switching (ostree)")]
+async fn switch_ostree(
+    opts: SwitchOpts,
+    storage: &Storage,
+    booted_ostree: &BootedOstree<'_>,
+) -> Result<()> {
     let target = imgref_for_switch(&opts)?;
-
     let prog: ProgressWriter = opts.progress.try_into()?;
-
-    // If we're doing an in-place mutation, we shortcut most of the rest of the work here
-    if opts.mutate_in_place {
-        let deployid = {
-            // Clone to pass into helper thread
-            let target = target.clone();
-            let root = cap_std::fs::Dir::open_ambient_dir("/", cap_std::ambient_authority())?;
-            tokio::task::spawn_blocking(move || {
-                crate::deploy::switch_origin_inplace(&root, &target)
-            })
-            .await??
-        };
-        println!("Updated {deployid} to pull from {target}");
-        return Ok(());
-    }
-
     let cancellable = gio::Cancellable::NONE;
 
-    let storage = &get_storage().await?;
-    let ostree = storage.get_ostree()?;
-    let repo = &ostree.repo();
-    let (booted_deployment, _deployments, host) = crate::status::get_status_require_booted(ostree)?;
+    let repo = &booted_ostree.repo();
+    let (_, host) = crate::status::get_status(booted_ostree)?;
 
     let new_spec = {
         let mut new_spec = host.spec.clone();
@@ -1061,7 +1046,7 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
 
     if !opts.retain {
         // By default, we prune the previous ostree ref so it will go away after later upgrades
-        if let Some(booted_origin) = booted_deployment.origin() {
+        if let Some(booted_origin) = booted_ostree.deployment.origin() {
             if let Some(ostree_ref) = booted_origin.optional_string("origin", "refspec")? {
                 let (remote, ostree_ref) =
                     ostree::parse_refspec(&ostree_ref).context("Failed to parse ostree ref")?;
@@ -1070,7 +1055,7 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
         }
     }
 
-    let stateroot = booted_deployment.osname();
+    let stateroot = booted_ostree.stateroot();
     let from = MergeState::from_stateroot(storage, &stateroot)?;
     crate::deploy::stage(storage, from, &fetched, &new_spec, prog.clone()).await?;
 
@@ -1079,12 +1064,8 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
     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 booted_ostree = BootedOstree {
-            sysroot: ostree,
-            deployment: booted_deployment.clone(),
-        };
-        let updated_host = crate::status::get_status(&booted_ostree)?.1;
-        handle_staged_soft_reboot(&booted_ostree, opts.soft_reboot, &updated_host)?;
+        let updated_host = crate::status::get_status(booted_ostree)?.1;
+        handle_staged_soft_reboot(booted_ostree, opts.soft_reboot, &updated_host)?;
     }
 
     if opts.apply {
@@ -1094,36 +1075,85 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
     Ok(())
 }
 
-/// Implementation of the `bootc rollback` CLI command.
-#[context("Rollback")]
-async fn rollback(opts: &RollbackOpts) -> Result<()> {
+/// Implementation of the `bootc switch` CLI command.
+#[context("Switching")]
+async fn switch(opts: SwitchOpts) -> Result<()> {
     let storage = &get_storage().await?;
-    let ostree = storage.get_ostree()?;
+    match storage.kind()? {
+        BootedStorageKind::Ostree(booted_ostree) => {
+            // If we're doing an in-place mutation, we shortcut most of the rest of the work here
+            if opts.mutate_in_place {
+                let target = imgref_for_switch(&opts)?;
+                let deployid = {
+                    // Clone to pass into helper thread
+                    let target = target.clone();
+                    let root =
+                        cap_std::fs::Dir::open_ambient_dir("/", cap_std::ambient_authority())?;
+                    tokio::task::spawn_blocking(move || {
+                        crate::deploy::switch_origin_inplace(&root, &target)
+                    })
+                    .await??
+                };
+                println!("Updated {deployid} to pull from {target}");
+                return Ok(());
+            }
+            switch_ostree(opts, storage, &booted_ostree).await
+        }
+        BootedStorageKind::Composefs(_) => {
+            if opts.mutate_in_place {
+                anyhow::bail!("--mutate-in-place is not yet supported for composefs backend");
+            }
+            switch_composefs(opts).await
+        }
+    }
+}
+
+/// Implementation of the `bootc rollback` CLI command for ostree backend.
+#[context("Rollback (ostree)")]
+async fn rollback_ostree(
+    opts: &RollbackOpts,
+    storage: &Storage,
+    booted_ostree: &BootedOstree<'_>,
+) -> Result<()> {
     crate::deploy::rollback(storage).await?;
 
     if opts.soft_reboot.is_some() {
         // Get status of rollback deployment to check soft-reboot capability
-        let host = crate::status::get_status_require_booted(ostree)?.2;
+        let host = crate::status::get_status(booted_ostree)?.1;
 
         handle_soft_reboot(
             opts.soft_reboot,
             host.status.rollback.as_ref(),
             "rollback",
-            || soft_reboot_rollback(ostree),
+            || soft_reboot_rollback(booted_ostree),
         )?;
     }
 
     Ok(())
 }
 
-/// Implementation of the `bootc edit` CLI command.
-#[context("Editing spec")]
-async fn edit(opts: EditOpts) -> Result<()> {
+/// Implementation of the `bootc rollback` CLI command.
+#[context("Rollback")]
+async fn rollback(opts: &RollbackOpts) -> Result<()> {
     let storage = &get_storage().await?;
-    let ostree = storage.get_ostree()?;
-    let repo = &ostree.repo();
+    match storage.kind()? {
+        BootedStorageKind::Ostree(booted_ostree) => {
+            rollback_ostree(opts, storage, &booted_ostree).await
+        }
+        BootedStorageKind::Composefs(_) => composefs_rollback().await,
+    }
+}
+
+/// Implementation of the `bootc edit` CLI command for ostree backend.
+#[context("Editing spec (ostree)")]
+async fn edit_ostree(
+    opts: EditOpts,
+    storage: &Storage,
+    booted_ostree: &BootedOstree<'_>,
+) -> Result<()> {
+    let repo = &booted_ostree.repo();
+    let (_, host) = crate::status::get_status(booted_ostree)?;
 
-    let (booted_deployment, _deployments, host) = crate::status::get_status_require_booted(ostree)?;
     let new_host: Host = if let Some(filename) = opts.filename {
         let mut r = std::io::BufReader::new(std::fs::File::open(filename)?);
         serde_yaml::from_reader(&mut r)?
@@ -1154,7 +1184,7 @@ async fn edit(opts: EditOpts) -> Result<()> {
 
     // TODO gc old layers here
 
-    let stateroot = booted_deployment.osname();
+    let stateroot = booted_ostree.stateroot();
     let from = MergeState::from_stateroot(storage, &stateroot)?;
     crate::deploy::stage(storage, from, &fetched, &new_spec, prog.clone()).await?;
 
@@ -1163,6 +1193,20 @@ async fn edit(opts: EditOpts) -> Result<()> {
     Ok(())
 }
 
+/// Implementation of the `bootc edit` CLI command.
+#[context("Editing spec")]
+async fn edit(opts: EditOpts) -> Result<()> {
+    let storage = &get_storage().await?;
+    match storage.kind()? {
+        BootedStorageKind::Ostree(booted_ostree) => {
+            edit_ostree(opts, storage, &booted_ostree).await
+        }
+        BootedStorageKind::Composefs(_) => {
+            anyhow::bail!("Edit is not yet supported for composefs backend")
+        }
+    }
+}
+
 /// Implementation of `bootc usroverlay`
 async fn usroverlay() -> Result<()> {
     // This is just a pass-through today.  At some point we may make this a libostree API
@@ -1268,24 +1312,12 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
                 }
             }
         }
-        Opt::Switch(opts) => {
-            let storage = &get_storage().await?;
-            match storage.kind()? {
-                BootedStorageKind::Ostree(_) => switch(opts).await,
-                BootedStorageKind::Composefs(_) => switch_composefs(opts).await,
-            }
-        }
+        Opt::Switch(opts) => switch(opts).await,
         Opt::Rollback(opts) => {
-            let storage = &get_storage().await?;
-            match storage.kind()? {
-                BootedStorageKind::Ostree(_) => rollback(&opts).await?,
-                BootedStorageKind::Composefs(_) => composefs_rollback().await?,
-            }
-
+            rollback(&opts).await?;
             if opts.apply {
                 crate::reboot::reboot()?;
             }
-
             Ok(())
         }
         Opt::Edit(opts) => edit(opts).await,

crates/lib/src/deploy.rs

@@ -835,15 +835,15 @@ fn write_reboot_required(image: &str) -> Result<()> {
 pub(crate) async fn rollback(sysroot: &Storage) -> Result<()> {
     const ROLLBACK_JOURNAL_ID: &str = "26f3b1eb24464d12aa5e7b544a6b5468";
     let ostree = sysroot.get_ostree()?;
-    let (booted_deployment, deployments, host) = crate::status::get_status_require_booted(ostree)?;
+    let (booted_ostree, deployments, host) = crate::status::get_status_require_booted(ostree)?;
 
     let new_spec = {
         let mut new_spec = host.spec.clone();
         new_spec.boot_order = new_spec.boot_order.swap();
         new_spec
     };
 
-    let repo = &ostree.repo();
+    let repo = &booted_ostree.repo();
 
     // Just to be sure
     host.spec.verify_transition(&new_spec)?;
@@ -882,16 +882,18 @@ pub(crate) async fn rollback(sysroot: &Storage) -> Result<()> {
     // SAFETY: If there's a rollback status, then there's a deployment
     let rollback_deployment = deployments.rollback.expect("rollback deployment");
     let new_deployments = if reverting {
-        [booted_deployment, rollback_deployment]
+        [booted_ostree.deployment, rollback_deployment]
     } else {
-        [rollback_deployment, booted_deployment]
+        [rollback_deployment, booted_ostree.deployment]
     };
     let new_deployments = new_deployments
         .into_iter()
         .chain(deployments.other)
         .collect::<Vec<_>>();
     tracing::debug!("Writing new deployments: {new_deployments:?}");
-    ostree.write_deployments(&new_deployments, gio::Cancellable::NONE)?;
+    booted_ostree
+        .sysroot
+        .write_deployments(&new_deployments, gio::Cancellable::NONE)?;
     if reverting {
         println!("Next boot: current deployment");
     } else {

crates/lib/src/install.rs

@@ -2265,7 +2265,7 @@ pub(crate) async fn install_reset(opts: InstallResetOpts) -> Result<()> {
     let sysroot = &crate::cli::get_storage().await?;
     let ostree = sysroot.get_ostree()?;
     let repo = &ostree.repo();
-    let (booted_deployment, _deployments, host) = crate::status::get_status_require_booted(ostree)?;
+    let (booted_ostree, _deployments, host) = crate::status::get_status_require_booted(ostree)?;
 
     let stateroots = list_stateroots(ostree)?;
     let target_stateroot = if let Some(s) = opts.stateroot {
@@ -2276,7 +2276,7 @@ pub(crate) async fn install_reset(opts: InstallResetOpts) -> Result<()> {
         r.name
     };
 
-    let booted_stateroot = booted_deployment.osname();
+    let booted_stateroot = booted_ostree.stateroot();
     assert!(booted_stateroot.as_str() != target_stateroot);
     let (fetched, spec) = if let Some(target) = opts.target_opts.imageref()? {
         let mut new_spec = host.spec;
@@ -2307,7 +2307,8 @@ pub(crate) async fn install_reset(opts: InstallResetOpts) -> Result<()> {
     let root_kargs = if opts.no_root_kargs {
         Vec::new()
     } else {
-        let bootcfg = booted_deployment
+        let bootcfg = booted_ostree
+            .deployment
             .bootconfig()
             .ok_or_else(|| anyhow!("Missing bootcfg for booted deployment"))?;
         if let Some(options) = bootcfg.get("options") {

crates/lib/src/status.rs

@@ -259,14 +259,14 @@ impl BootEntry {
 /// A variant of [`get_status`] that requires a booted deployment.
 pub(crate) fn get_status_require_booted(
     sysroot: &SysrootLock,
-) -> Result<(ostree::Deployment, Deployments, Host)> {
+) -> Result<(crate::store::BootedOstree<'_>, Deployments, Host)> {
     let booted_deployment = sysroot.require_booted_deployment()?;
     let booted_ostree = crate::store::BootedOstree {
         sysroot,
-        deployment: booted_deployment.clone(),
+        deployment: booted_deployment,
     };
     let (deployments, host) = get_status(&booted_ostree)?;
-    Ok((booted_deployment, deployments, host))
+    Ok((booted_ostree, deployments, host))
 }
 
 /// Gather the ostree deployment objects, but also extract metadata from them into