wip

Author: jmarrero

crates/lib/src/cli.rs

@@ -416,6 +416,11 @@ pub(crate) enum ImageOpts {
         /// this will make the image accessible via e.g. `podman run localhost/bootc` and for builds.
         target: Option<String>,
     },
+    /// Re-pull the currently booted image into the bootc-owned container storage.
+    ///
+    /// This onboards the system to the unified storage path so that future
+    /// upgrade/switch operations can read from the bootc storage directly.
+    SetUnified,
     /// Copy a container image from the default `containers-storage:` to the bootc-owned container storage.
     PullFromDefaultStorage {
         /// The image to pull
@@ -1367,6 +1372,9 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
             ImageOpts::CopyToStorage { source, target } => {
                 crate::image::push_entrypoint(source.as_deref(), target.as_deref()).await
             }
+            ImageOpts::SetUnified => {
+                crate::image::set_unified_entrypoint().await
+            }
             ImageOpts::PullFromDefaultStorage { image } => {
                 let sysroot = get_storage().await?;
                 sysroot

crates/lib/src/image.rs

@@ -181,3 +181,51 @@ pub(crate) async fn imgcmd_entrypoint(
     cmd.args(args);
     cmd.run_capture_stderr()
 }
+
+/// Re-pull the currently booted image into the bootc-owned container storage.
+///
+/// This onboards the system to unified storage for host images so that
+/// upgrade/switch can use the unified path automatically when the image is present.
+#[context("Setting unified storage for booted image")]
+pub(crate) async fn set_unified_entrypoint() -> Result<()> {
+    let sysroot = crate::cli::get_storage().await?;
+    let ostree = sysroot.get_ostree()?;
+    let repo = &ostree.repo();
+
+    // Discover the currently booted image reference
+    let (_booted_deployment, _deployments, host) =
+        crate::status::get_status_require_booted(ostree)?;
+    let imgref = host
+        .spec
+        .image
+        .as_ref()
+        .ok_or_else(|| anyhow::anyhow!("No image source specified in host spec"))?;
+
+    // Canonicalize for pull display only, but we want to preserve original pullspec
+    let imgref_display = imgref.clone().canonicalize()?;
+
+    // Pull the image from its original source into bootc storage using LBI machinery
+    let imgstore = sysroot.get_ensure_imgstore()?;
+    let img_string = format!("{:#}", imgref);
+    println!(
+        "Re-pulling booted image into bootc storage via unified path: {}",
+        imgref_display
+    );
+    imgstore
+        .pull(&img_string, crate::podstorage::PullMode::Always)
+        .await?;
+
+    // Optionally verify we can import from containers-storage by preparing in a temp importer
+    // without actually importing into the main repo; this is a lightweight validation.
+    let containers_storage_imgref = crate::spec::ImageReference {
+        transport: "containers-storage".to_string(),
+        image: imgref.image.clone(),
+        signature: imgref.signature.clone(),
+    };
+    let ostree_imgref = ostree_ext::container::OstreeImageReference::from(containers_storage_imgref);
+    let _ = ostree_ext::container::store::ImageImporter::new(repo, &ostree_imgref, Default::default())
+        .await?;
+
+    println!("Unified storage set for current image. Future upgrade/switch will use it automatically.");
+    Ok(())
+}

crates/lib/src/install.rs

@@ -172,7 +172,7 @@ pub(crate) struct InstallTargetOpts {
     /// When enabled, this uses bootc's container storage (/usr/lib/bootc/storage) to pull
     /// the image first, then imports it from there. This is the same approach used for
     /// logically bound images.
-    #[clap(long)]
+    #[clap(long = "experimental-unified-storage")]
     #[serde(default)]
     pub(crate) unified_storage_exp: bool,
 }