store: Drop deref for ostree repo

The goal here is to make all three types of storage effectively
equal peers.

Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

crates/lib/src/bootc_kargs.rs

@@ -116,7 +116,8 @@ pub(crate) fn get_kargs(
     fetched: &ImageState,
 ) -> Result<Vec<String>> {
     let cancellable = gio::Cancellable::NONE;
-    let repo = &sysroot.repo();
+    let ostree = sysroot.get_ostree()?;
+    let repo = &ostree.repo();
     let mut kargs = vec![];
     let sys_arch = std::env::consts::ARCH;
 
@@ -129,7 +130,7 @@ pub(crate) fn get_kargs(
     };
 
     // Get the kargs in kargs.d of the merge
-    let merge_root = &crate::utils::deployment_fd(sysroot, merge_deployment)?;
+    let merge_root = &crate::utils::deployment_fd(ostree, merge_deployment)?;
     let existing_kargs = get_kargs_in_root(merge_root, sys_arch)?;
 
     // Get the kargs in kargs.d of the pending image

crates/lib/src/boundimage.rs

@@ -39,7 +39,7 @@ pub(crate) struct ResolvedBoundImage {
 
 /// Given a deployment, pull all container images it references.
 pub(crate) async fn pull_bound_images(sysroot: &Storage, deployment: &Deployment) -> Result<()> {
-    let bound_images = query_bound_images_for_deployment(sysroot, deployment)?;
+    let bound_images = query_bound_images_for_deployment(sysroot.get_ostree()?, deployment)?;
     pull_images(sysroot, bound_images).await
 }
 

crates/lib/src/cli.rs

@@ -782,9 +782,9 @@ fn prepare_for_write() -> Result<()> {
 #[context("Upgrading")]
 async fn upgrade(opts: UpgradeOpts) -> Result<()> {
     let sysroot = &get_storage().await?;
-    let repo = &sysroot.repo();
-    let (booted_deployment, _deployments, host) =
-        crate::status::get_status_require_booted(sysroot)?;
+    let ostree = sysroot.get_ostree()?;
+    let repo = &ostree.repo();
+    let (booted_deployment, _deployments, host) = crate::status::get_status_require_booted(ostree)?;
     let imgref = host.spec.image.as_ref();
     let prog: ProgressWriter = opts.progress.try_into()?;
 
@@ -922,9 +922,9 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
     let cancellable = gio::Cancellable::NONE;
 
     let sysroot = &get_storage().await?;
-    let repo = &sysroot.repo();
-    let (booted_deployment, _deployments, host) =
-        crate::status::get_status_require_booted(sysroot)?;
+    let ostree = sysroot.get_ostree()?;
+    let repo = &ostree.repo();
+    let (booted_deployment, _deployments, host) = crate::status::get_status_require_booted(ostree)?;
 
     let new_spec = {
         let mut new_spec = host.spec.clone();
@@ -980,10 +980,10 @@ async fn rollback(opts: RollbackOpts) -> Result<()> {
 #[context("Editing spec")]
 async fn edit(opts: EditOpts) -> Result<()> {
     let sysroot = &get_storage().await?;
-    let repo = &sysroot.repo();
+    let ostree = sysroot.get_ostree()?;
+    let repo = &ostree.repo();
 
-    let (booted_deployment, _deployments, host) =
-        crate::status::get_status_require_booted(sysroot)?;
+    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)?

crates/lib/src/deploy.rs

@@ -304,10 +304,11 @@ async fn handle_layer_progress_print(
 /// Gather all bound images in all deployments, then prune the image store,
 /// using the gathered images as the roots (that will not be GC'd).
 pub(crate) async fn prune_container_store(sysroot: &Storage) -> Result<()> {
-    let deployments = sysroot.deployments();
+    let ostree = sysroot.get_ostree()?;
+    let deployments = ostree.deployments();
     let mut all_bound_images = Vec::new();
     for deployment in deployments {
-        let bound = crate::boundimage::query_bound_images_for_deployment(sysroot, &deployment)?;
+        let bound = crate::boundimage::query_bound_images_for_deployment(ostree, &deployment)?;
         all_bound_images.extend(bound.into_iter());
     }
     // Convert to a hashset of just the image names
@@ -463,11 +464,11 @@ pub(crate) async fn cleanup(sysroot: &Storage) -> Result<()> {
     let bound_prune = prune_container_store(sysroot);
 
     // We create clones (just atomic reference bumps) here to move to the thread.
-    let repo = sysroot.repo();
-    let sysroot = sysroot.get_ostree_cloned()?;
+    let ostree = sysroot.get_ostree_cloned()?;
+    let repo = ostree.repo();
     let repo_prune =
         ostree_ext::tokio_util::spawn_blocking_cancellable_flatten(move |cancellable| {
-            let locked_sysroot = &SysrootLock::from_assumed_locked(&sysroot);
+            let locked_sysroot = &SysrootLock::from_assumed_locked(&ostree);
             let cancellable = Some(cancellable);
             let repo = &repo;
             let txn = repo.auto_transaction(cancellable)?;
@@ -488,7 +489,7 @@ pub(crate) async fn cleanup(sysroot: &Storage) -> Result<()> {
 
             // Then, for each deployment which is derived (e.g. has configmaps) we synthesize
             // a base ref to ensure that it's not GC'd.
-            for (i, deployment) in sysroot.deployments().into_iter().enumerate() {
+            for (i, deployment) in ostree.deployments().into_iter().enumerate() {
                 let commit = deployment.csum();
                 if let Some(base) = get_base_commit(repo, &commit)? {
                     repo.transaction_set_refspec(&format!("{BASE_IMAGE_PREFIX}/{i}"), Some(&base));
@@ -582,7 +583,8 @@ async fn deploy(
     )
     .await?;
     // SAFETY: We must have a staged deployment
-    let staged = sysroot.staged_deployment().unwrap();
+    let ostree = sysroot.get_ostree()?;
+    let staged = ostree.staged_deployment().unwrap();
     assert_eq!(staged.index(), r);
     Ok(staged)
 }
@@ -608,6 +610,7 @@ pub(crate) async fn stage(
     spec: &RequiredHostSpec<'_>,
     prog: ProgressWriter,
 ) -> Result<()> {
+    let ostree = sysroot.get_ostree()?;
     let mut subtask = SubTaskStep {
         subtask: "merging".into(),
         description: "Merging Image".into(),
@@ -629,7 +632,7 @@ pub(crate) async fn stage(
             .collect(),
     })
     .await;
-    let merge_deployment = sysroot.merge_deployment(Some(stateroot));
+    let merge_deployment = ostree.merge_deployment(Some(stateroot));
 
     subtask.completed = true;
     subtasks.push(subtask.clone());
@@ -740,15 +743,18 @@ pub(crate) async fn stage(
 /// Implementation of rollback functionality
 pub(crate) async fn rollback(sysroot: &Storage) -> Result<()> {
     const ROLLBACK_JOURNAL_ID: &str = "26f3b1eb24464d12aa5e7b544a6b5468";
-    let repo = &sysroot.repo();
-    let (booted_deployment, deployments, host) = crate::status::get_status_require_booted(sysroot)?;
+    let ostree = sysroot.get_ostree()?;
+    let (booted_deployment, 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 ostree = sysroot.get_ostree()?;
+    let repo = &ostree.repo();
+
     // Just to be sure
     host.spec.verify_transition(&new_spec)?;
 
@@ -788,7 +794,7 @@ pub(crate) async fn rollback(sysroot: &Storage) -> Result<()> {
         .chain(deployments.other)
         .collect::<Vec<_>>();
     tracing::debug!("Writing new deployments: {new_deployments:?}");
-    sysroot.write_deployments(&new_deployments, gio::Cancellable::NONE)?;
+    ostree.write_deployments(&new_deployments, gio::Cancellable::NONE)?;
     if reverting {
         println!("Next boot: current deployment");
     } else {

crates/lib/src/fsck.rs

@@ -106,8 +106,9 @@ static CHECK_RESOLVCONF: FsckCheck =
 /// But at the current time fsck is an experimental feature that we should only be running
 /// in our CI.
 fn check_resolvconf(storage: &Storage) -> FsckResult {
+    let ostree = storage.get_ostree()?;
     // For now we only check the booted deployment.
-    if storage.booted_deployment().is_none() {
+    if ostree.booted_deployment().is_none() {
         return fsck_ok();
     }
     // Read usr/etc/resolv.conf directly.
@@ -240,7 +241,8 @@ fn check_fsverity(storage: &Storage) -> Pin<Box<dyn Future<Output = FsckResult>
 }
 
 async fn check_fsverity_inner(storage: &Storage) -> FsckResult {
-    let repo = &storage.repo();
+    let ostree = storage.get_ostree()?;
+    let repo = &ostree.repo();
     let verity_state = ostree_ext::fsverity::is_verity_enabled(repo)?;
     tracing::debug!(
         "verity: expected={:?} found={:?}",
@@ -249,7 +251,7 @@ async fn check_fsverity_inner(storage: &Storage) -> FsckResult {
     );
 
     let verity_found_state =
-        verity_state_of_all_objects(&storage.repo(), verity_state.desired == Tristate::Enabled)
+        verity_state_of_all_objects(&ostree.repo(), verity_state.desired == Tristate::Enabled)
             .await?;
     let Some((missing, rest)) = collect_until(
         verity_found_state.missing.iter(),

crates/lib/src/image.rs

@@ -42,7 +42,8 @@ struct ImageOutput {
 
 #[context("Listing host images")]
 fn list_host_images(sysroot: &crate::store::Storage) -> Result<Vec<ImageOutput>> {
-    let repo = sysroot.repo();
+    let ostree = sysroot.get_ostree()?;
+    let repo = ostree.repo();
     let images = ostree_ext::container::store::list_images(&repo).context("Querying images")?;
 
     Ok(images
@@ -129,8 +130,8 @@ pub(crate) async fn list_entrypoint(
 pub(crate) async fn push_entrypoint(source: Option<&str>, target: Option<&str>) -> Result<()> {
     let transport = Transport::ContainerStorage;
     let sysroot = crate::cli::get_storage().await?;
-
-    let repo = &sysroot.repo();
+    let ostree = sysroot.get_ostree()?;
+    let repo = &ostree.repo();
 
     // If the target isn't specified, push to containers-storage + our default image
     let target = if let Some(target) = target {
@@ -150,7 +151,7 @@ pub(crate) async fn push_entrypoint(source: Option<&str>, target: Option<&str>)
     let source = if let Some(source) = source {
         ImageReference::try_from(source).context("Parsing source image")?
     } else {
-        let status = crate::status::get_status_require_booted(&sysroot)?;
+        let status = crate::status::get_status_require_booted(&ostree)?;
         // SAFETY: We know it's booted
         let booted = status.2.status.booted.unwrap();
         let booted_image = booted.image.unwrap().image;

crates/lib/src/install.rs

@@ -1342,9 +1342,10 @@ async fn install_with_sysroot(
     has_ostree: bool,
     imgstore: &crate::imgstorage::Storage,
 ) -> Result<()> {
+    let ostree = sysroot.get_ostree()?;
     // And actually set up the container in that root, returning a deployment and
     // the aleph state (see below).
-    let (deployment, aleph) = install_container(state, rootfs, &sysroot, has_ostree).await?;
+    let (deployment, aleph) = install_container(state, rootfs, ostree, has_ostree).await?;
     // Write the aleph data that captures the system state at the time of provisioning for aid in future debugging.
     rootfs
         .physical_root
@@ -1353,7 +1354,7 @@ async fn install_with_sysroot(
         })
         .context("Writing aleph version")?;
 
-    let deployment_path = sysroot.deployment_dirpath(&deployment);
+    let deployment_path = ostree.deployment_dirpath(&deployment);
 
     if cfg!(target_arch = "s390x") {
         // TODO: Integrate s390x support into install_via_bootupd
@@ -1472,9 +1473,10 @@ async fn install_to_filesystem_impl(
             &imgstore,
         )
         .await?;
+        let ostree = sysroot.get_ostree()?;
 
         if matches!(cleanup, Cleanup::TriggerOnNextBoot) {
-            let sysroot_dir = crate::utils::sysroot_dir(&sysroot)?;
+            let sysroot_dir = crate::utils::sysroot_dir(ostree)?;
             tracing::debug!("Writing {DESTRUCTIVE_CLEANUP}");
             sysroot_dir.atomic_write(format!("etc/{}", DESTRUCTIVE_CLEANUP), b"")?;
         }

crates/lib/src/status.rs

@@ -22,7 +22,7 @@ use crate::cli::OutputFormat;
 use crate::spec::ImageStatus;
 use crate::spec::{BootEntry, BootOrder, Host, HostSpec, HostStatus, HostType};
 use crate::spec::{ImageReference, ImageSignature};
-use crate::store::{CachedImageStatus, Storage};
+use crate::store::CachedImageStatus;
 
 impl From<ostree_container::SignatureSource> for ImageSignature {
     fn from(sig: ostree_container::SignatureSource) -> Self {
@@ -161,7 +161,7 @@ fn imagestatus(
 /// Given an OSTree deployment, parse out metadata into our spec.
 #[context("Reading deployment metadata")]
 fn boot_entry_from_deployment(
-    sysroot: &Storage,
+    sysroot: &SysrootLock,
     deployment: &ostree::Deployment,
 ) -> Result<BootEntry> {
     let (
@@ -223,7 +223,7 @@ impl BootEntry {
 
 /// A variant of [`get_status`] that requires a booted deployment.
 pub(crate) fn get_status_require_booted(
-    sysroot: &Storage,
+    sysroot: &SysrootLock,
 ) -> Result<(ostree::Deployment, Deployments, Host)> {
     let booted_deployment = sysroot.require_booted_deployment()?;
     let (deployments, host) = get_status(sysroot, Some(&booted_deployment))?;
@@ -234,7 +234,7 @@ pub(crate) fn get_status_require_booted(
 /// a more native Rust structure.
 #[context("Computing status")]
 pub(crate) fn get_status(
-    sysroot: &Storage,
+    sysroot: &SysrootLock,
     booted_deployment: Option<&ostree::Deployment>,
 ) -> Result<(Deployments, Host)> {
     let stateroot = booted_deployment.as_ref().map(|d| d.osname());
@@ -340,8 +340,9 @@ pub(crate) async fn status(opts: super::cli::StatusOpts) -> Result<()> {
         Default::default()
     } else {
         let sysroot = super::cli::get_storage().await?;
-        let booted_deployment = sysroot.booted_deployment();
-        let (_deployments, host) = get_status(&sysroot, booted_deployment.as_ref())?;
+        let ostree = sysroot.get_ostree()?;
+        let booted_deployment = ostree.booted_deployment();
+        let (_deployments, host) = get_status(&ostree, booted_deployment.as_ref())?;
         host
     };
 

crates/lib/src/store/mod.rs

@@ -1,5 +1,22 @@
+//! The [`Store`] holds references to three different types of
+//! storage:
+//!
+//! # OSTree
+//!
+//! The default backend for the bootable container store; this
+//! lives in `/ostree` in the physical root.
+//!
+//! # containers-storage:
+//!
+//! Later, bootc gained support for Logically Bound Images.
+//! This is a `containers-storage:` instance that lives
+//! in `/ostree/bootc/storage`
+//!
+//! # composefs
+//!
+//! This lives in `/composefs` in the physical root.
+
 use std::cell::OnceCell;
-use std::ops::Deref;
 use std::sync::Arc;
 
 use anyhow::{Context, Result};
@@ -9,6 +26,7 @@ use cap_std_ext::dirext::CapStdExtDirExt;
 use fn_error_context::context;
 
 use composefs;
+use ostree_ext::ostree;
 use ostree_ext::sysroot::SysrootLock;
 use rustix::fs::Mode;
 
@@ -31,6 +49,8 @@ pub const COMPOSEFS_MODE: Mode = Mode::from_raw_mode(0o700);
 /// system root
 pub(crate) const BOOTC_ROOT: &str = "ostree/bootc";
 
+/// A reference to a physical filesystem root, plus
+/// accessors for the different types of container storage.
 pub(crate) struct Storage {
     /// Directory holding the physical root
     pub physical_root: Dir,
@@ -52,14 +72,6 @@ pub(crate) struct CachedImageStatus {
     pub cached_update: Option<ImageStatus>,
 }
 
-impl Deref for Storage {
-    type Target = SysrootLock;
-
-    fn deref(&self) -> &Self::Target {
-        &self.ostree
-    }
-}
-
 impl Storage {
     pub fn new(sysroot: SysrootLock, run: &Dir) -> Result<Self> {
         let run = run.try_clone()?;