storage: Conditionally call prepare_for_write

For ostree systems, before making any changes to the repo/boot entries
we call `prepare_for_write`. Before this we were calling it
unconditionally even if the command was `bootc status`, which was
causing test failures.

We pass in a flag now to `BootedStorage::new` which will conditionally
call `prepare_for_write`. We also need this to make sure we keep the API
more or less similar to what we had before

Signed-off-by: Pragyan Poudyal <[email protected]>

Author: Johan-Liebert1

crates/lib/src/cli.rs

@@ -715,7 +715,15 @@ pub(crate) fn ensure_self_unshared_mount_namespace() -> Result<()> {
 /// Load global storage state, expecting that we're booted into a bootc system.
 #[context("Initializing storage")]
 pub(crate) async fn get_storage() -> Result<crate::store::BootedStorage> {
-    BootedStorage::new().await
+    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
 }
 
 #[context("Querying root privilege")]

crates/lib/src/status.rs

@@ -18,11 +18,13 @@ 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::BootedStorageKind;
 use crate::store::CachedImageStatus;
 
 impl From<ostree_container::SignatureSource> for ImageSignature {
@@ -367,15 +369,29 @@ pub(crate) fn get_status(
 }
 
 async fn get_host() -> Result<Host> {
-    let storage = super::cli::get_storage().await?;
-
-    let host = match storage.kind()? {
-        crate::store::BootedStorageKind::Ostree(booted_ostree) => {
-            let (_deployments, host) = get_status(&booted_ostree)?;
-            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());
         }
-        crate::store::BootedStorageKind::Composefs(booted_cfs) => {
-            crate::bootc_composefs::status::get_composefs_status(&storage, &booted_cfs).await?
+    };
+
+    let host = match storage.kind() {
+        Ok(kind) => match kind {
+            BootedStorageKind::Ostree(booted_ostree) => {
+                let (_deployments, host) = get_status(&booted_ostree)?;
+                host
+            }
+            BootedStorageKind::Composefs(booted_cfs) => {
+                crate::bootc_composefs::status::get_composefs_status(&storage, &booted_cfs).await?
+            }
+        },
+        Err(_) => {
+            // If determining storage kind fails (e.g., no booted deployment),
+            // return a default host indicating the system is not deployed via bootc
+            Host::default()
         }
     };
 

crates/lib/src/store/mod.rs

@@ -109,7 +109,7 @@ impl BootedStorage {
     ///
     /// This detects whether the system is booted via composefs or ostree
     /// and initializes the appropriate storage backend.
-    pub(crate) async fn new() -> Result<Self> {
+    pub(crate) async fn new(prep_for_write: bool) -> Result<Self> {
         let physical_root = Dir::open_ambient_dir("/sysroot", cap_std::ambient_authority())
             .context("Opening /sysroot")?;
 
@@ -134,7 +134,9 @@ impl BootedStorage {
             return Ok(Self { storage });
         }
 
-        prepare_for_write()?;
+        if prep_for_write {
+            prepare_for_write()?;
+        }
 
         let sysroot = ostree::Sysroot::new_default();
         sysroot.set_mount_namespace_in_use();