storage: Refactor BootedStorage::new to return Option

Change `BootedStorage::new()` to return `Result<Option<Self>>` instead
of taking a `prep_for_write` boolean parameter. This makes the API more
idiomatic and clearer about when the system is not booted via bootc.

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

Author: cgwalters

crates/lib/src/cli.rs

@@ -8,7 +8,7 @@ use std::os::unix::process::CommandExt;
 use std::process::Command;
 use std::sync::Arc;
 
-use anyhow::{ensure, Context, Result};
+use anyhow::{anyhow, ensure, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
 use cap_std_ext::cap_std;
 use cap_std_ext::cap_std::fs::Dir;
@@ -24,7 +24,6 @@ use ostree_ext::composefs::fsverity;
 use ostree_ext::composefs::fsverity::FsVerityHashValue;
 use ostree_ext::composefs::splitstream::SplitStreamWriter;
 use ostree_ext::container as ostree_container;
-use ostree_ext::container_utils::ostree_booted;
 use ostree_ext::containers_image_proxy::ImageProxyConfig;
 use ostree_ext::keyfileext::KeyFileExt;
 use ostree_ext::ostree;
@@ -713,17 +712,14 @@ pub(crate) fn ensure_self_unshared_mount_namespace() -> Result<()> {
 }
 
 /// Load global storage state, expecting that we're booted into a bootc system.
+/// This prepares the process for write operations (re-exec, mount namespace, etc).
 #[context("Initializing storage")]
 pub(crate) async fn get_storage() -> Result<crate::store::BootedStorage> {
-    BootedStorage::new(true).await
-}
-
-/// Load global storage state, but do not internally call `prepare_for_write` for ostree booted
-/// systems
-/// We do this to keep the `bootc status` output unchanged
-#[context("Initializing locked storage")]
-pub(crate) async fn get_storage_unlocked() -> Result<crate::store::BootedStorage> {
-    BootedStorage::new(false).await
+    prepare_for_write()?;
+    let r = BootedStorage::new()
+        .await?
+        .ok_or_else(|| anyhow!("System not booted via bootc"))?;
+    Ok(r)
 }
 
 #[context("Querying root privilege")]

crates/lib/src/status.rs

@@ -18,12 +18,12 @@ use ostree_ext::sysroot::SysrootLock;
 
 use ostree_ext::ostree;
 
-use crate::cli::get_storage_unlocked;
 use crate::cli::OutputFormat;
 use crate::spec::BootEntryComposefs;
 use crate::spec::ImageStatus;
 use crate::spec::{BootEntry, BootOrder, Host, HostSpec, HostStatus, HostType};
 use crate::spec::{ImageReference, ImageSignature};
+use crate::store::BootedStorage;
 use crate::store::BootedStorageKind;
 use crate::store::CachedImageStatus;
 
@@ -369,13 +369,9 @@ pub(crate) fn get_status(
 }
 
 async fn get_host() -> Result<Host> {
-    let storage = match get_storage_unlocked().await {
-        Ok(storage) => storage,
-        Err(_) => {
-            // If storage initialization fails (e.g., in container environments),
-            // return a default host indicating the system is not deployed via bootc
-            return Ok(Host::default());
-        }
+    let Some(storage) = BootedStorage::new().await? else {
+        // If we're not booted, then return a default.
+        return Ok(Host::default());
     };
 
     let host = match storage.kind() {

crates/lib/src/store/mod.rs

@@ -26,12 +26,12 @@ use cap_std_ext::cap_std::fs::{Dir, DirBuilder, DirBuilderExt as _};
 use cap_std_ext::dirext::CapStdExtDirExt;
 use fn_error_context::context;
 
+use ostree_ext::container_utils::ostree_booted;
 use ostree_ext::sysroot::SysrootLock;
 use ostree_ext::{gio, ostree};
 use rustix::fs::Mode;
 
 use crate::bootc_composefs::status::{composefs_booted, ComposefsCmdline};
-use crate::cli::prepare_for_write;
 use crate::lsm;
 use crate::podstorage::CStorage;
 use crate::spec::ImageStatus;
@@ -109,14 +109,18 @@ impl BootedStorage {
     ///
     /// This detects whether the system is booted via composefs or ostree
     /// and initializes the appropriate storage backend.
-    pub(crate) async fn new(prep_for_write: bool) -> Result<Self> {
+    ///
+    /// Note: For write operations, callers should call `prepare_for_write()`
+    /// before calling this function to ensure the process is in the correct
+    /// mount namespace.
+    pub(crate) async fn new() -> Result<Option<Self>> {
         let physical_root = Dir::open_ambient_dir("/sysroot", cap_std::ambient_authority())
             .context("Opening /sysroot")?;
 
         let run =
             Dir::open_ambient_dir("/run", cap_std::ambient_authority()).context("Opening /run")?;
 
-        if let Some(cmdline) = composefs_booted()? {
+        let r = if let Some(cmdline) = composefs_booted()? {
             let mut composefs = ComposefsRepository::open_path(&physical_root, COMPOSEFS)?;
             if cmdline.insecure {
                 composefs.set_insecure(true);
@@ -131,27 +135,26 @@ impl BootedStorage {
                 imgstore: Default::default(),
             };
 
-            return Ok(Self { storage });
-        }
-
-        if prep_for_write {
-            prepare_for_write()?;
-        }
+            Some(Self { storage })
+        } else if ostree_booted()? {
+            let sysroot = ostree::Sysroot::new_default();
+            sysroot.set_mount_namespace_in_use();
+            let sysroot = ostree_ext::sysroot::SysrootLock::new_from_sysroot(&sysroot).await?;
+            sysroot.load(gio::Cancellable::NONE)?;
 
-        let sysroot = ostree::Sysroot::new_default();
-        sysroot.set_mount_namespace_in_use();
-        let sysroot = ostree_ext::sysroot::SysrootLock::new_from_sysroot(&sysroot).await?;
-        sysroot.load(gio::Cancellable::NONE)?;
+            let storage = Storage {
+                physical_root,
+                run,
+                ostree: OnceCell::from(sysroot),
+                composefs: Default::default(),
+                imgstore: Default::default(),
+            };
 
-        let storage = Storage {
-            physical_root,
-            run,
-            ostree: OnceCell::from(sysroot),
-            composefs: Default::default(),
-            imgstore: Default::default(),
+            Some(Self { storage })
+        } else {
+            None
         };
-
-        Ok(Self { storage })
+        Ok(r)
     }
 
     /// Determine the boot storage backend kind.