Gate composefs-native behind composefs-backend flag

Refactor to use `#[cfg(feature = "composefs-backend")]` to gate
composefs native features behind the flag.

Gate the following features
- `--composefs-native` and its corresponding cli args
- Installing/Switching/Upgrading/RollingBack of composefs native system
- Create separate install, rollback functions for ostree for a bit
  cleaner of a setup

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

Author: Johan-Liebert1

crates/lib/src/bootc_composefs/status.rs

@@ -1,17 +1,17 @@
-use std::io::Read;
+use std::{io::Read, sync::OnceLock};
 
 use anyhow::{Context, Result};
+use bootc_kernel_cmdline::Cmdline;
 use fn_error_context::context;
 
 use crate::{
     bootc_composefs::boot::BootType,
-    composefs_consts::{BOOT_LOADER_ENTRIES, USER_CFG},
+    composefs_consts::{BOOT_LOADER_ENTRIES, COMPOSEFS_CMDLINE, USER_CFG},
     parsers::{
         bls_config::{parse_bls_config, BLSConfig},
         grub_menuconfig::{parse_grub_menuentry_file, MenuEntry},
     },
     spec::{BootEntry, BootOrder, Host, HostSpec, ImageReference, ImageStatus},
-    status::composefs_booted,
 };
 
 use std::str::FromStr;
@@ -35,6 +35,49 @@ use crate::composefs_consts::{
 use crate::install::EFIVARFS;
 use crate::spec::Bootloader;
 
+/// A parsed composefs command line
+pub(crate) struct ComposefsCmdline {
+    #[allow(dead_code)]
+    pub insecure: bool,
+    pub digest: Box<str>,
+}
+
+impl ComposefsCmdline {
+    pub(crate) fn new(s: &str) -> Self {
+        let (insecure, digest_str) = s
+            .strip_prefix('?')
+            .map(|v| (true, v))
+            .unwrap_or_else(|| (false, s));
+        ComposefsCmdline {
+            insecure,
+            digest: digest_str.into(),
+        }
+    }
+}
+
+impl std::fmt::Display for ComposefsCmdline {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let insecure = if self.insecure { "?" } else { "" };
+        write!(f, "{}={}{}", COMPOSEFS_CMDLINE, insecure, self.digest)
+    }
+}
+
+/// Detect if we have composefs=<digest> in /proc/cmdline
+pub(crate) fn composefs_booted() -> Result<Option<&'static ComposefsCmdline>> {
+    static CACHED_DIGEST_VALUE: OnceLock<Option<ComposefsCmdline>> = OnceLock::new();
+    if let Some(v) = CACHED_DIGEST_VALUE.get() {
+        return Ok(v.as_ref());
+    }
+    let cmdline = Cmdline::from_proc()?;
+    let Some(kv) = cmdline.find_str(COMPOSEFS_CMDLINE) else {
+        return Ok(None);
+    };
+    let Some(v) = kv.value else { return Ok(None) };
+    let v = ComposefsCmdline::new(v);
+    let r = CACHED_DIGEST_VALUE.get_or_init(|| Some(v));
+    Ok(r.as_ref())
+}
+
 // Need str to store lifetime
 pub(crate) fn get_sorted_uki_boot_entries<'a>(
     boot_dir: &Dir,
@@ -336,6 +379,17 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn test_composefs_parsing() {
+        const DIGEST: &str = "8b7df143d91c716ecfa5fc1730022f6b421b05cedee8fd52b1fc65a96030ad52";
+        let v = ComposefsCmdline::new(DIGEST);
+        assert!(!v.insecure);
+        assert_eq!(v.digest.as_ref(), DIGEST);
+        let v = ComposefsCmdline::new(&format!("?{}", DIGEST));
+        assert!(v.insecure);
+        assert_eq!(v.digest.as_ref(), DIGEST);
+    }
+
     #[test]
     fn test_sorted_bls_boot_entries() -> Result<()> {
         let tempdir = cap_std_ext::cap_tempfile::tempdir(cap_std::ambient_authority())?;

crates/lib/src/cli.rs

@@ -29,15 +29,16 @@ use ostree_ext::sysroot::SysrootLock;
 use schemars::schema_for;
 use serde::{Deserialize, Serialize};
 
-use crate::bootc_composefs::rollback::composefs_rollback;
-use crate::bootc_composefs::switch::switch_composefs;
-use crate::bootc_composefs::update::upgrade_composefs;
+#[cfg(feature = "composefs-backend")]
+use crate::bootc_composefs::{
+    rollback::composefs_rollback, status::composefs_booted, switch::switch_composefs,
+    update::upgrade_composefs,
+};
 use crate::deploy::RequiredHostSpec;
 use crate::lints;
 use crate::progress_jsonl::{ProgressWriter, RawProgressFd};
 use crate::spec::Host;
 use crate::spec::ImageReference;
-use crate::status::composefs_booted;
 use crate::utils::sigpolicy_from_opt;
 
 /// Shared progress options
@@ -1141,29 +1142,21 @@ async fn switch(opts: SwitchOpts) -> Result<()> {
 
 /// Implementation of the `bootc rollback` CLI command.
 #[context("Rollback")]
-async fn rollback(opts: RollbackOpts) -> Result<()> {
-    if composefs_booted()?.is_some() {
-        composefs_rollback().await?
-    } else {
-        let sysroot = &get_storage().await?;
-        let ostree = sysroot.get_ostree()?;
-        crate::deploy::rollback(sysroot).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;
-
-            handle_soft_reboot(
-                opts.soft_reboot,
-                host.status.rollback.as_ref(),
-                "rollback",
-                || soft_reboot_rollback(ostree),
-            )?;
-        }
-    };
+async fn rollback(opts: &RollbackOpts) -> Result<()> {
+    let sysroot = &get_storage().await?;
+    let ostree = sysroot.get_ostree()?;
+    crate::deploy::rollback(sysroot).await?;
 
-    if opts.apply {
-        crate::reboot::reboot()?;
+    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;
+
+        handle_soft_reboot(
+            opts.soft_reboot,
+            host.status.rollback.as_ref(),
+            "rollback",
+            || soft_reboot_rollback(ostree),
+        )?;
     }
 
     Ok(())
@@ -1310,20 +1303,44 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
     let root = &Dir::open_ambient_dir("/", cap_std::ambient_authority())?;
     match opt {
         Opt::Upgrade(opts) => {
+            #[cfg(feature = "composefs-backend")]
             if composefs_booted()?.is_some() {
                 upgrade_composefs(opts).await
             } else {
                 upgrade(opts).await
             }
+
+            #[cfg(not(feature = "composefs-backend"))]
+            upgrade(opts).await
         }
         Opt::Switch(opts) => {
+            #[cfg(feature = "composefs-backend")]
             if composefs_booted()?.is_some() {
                 switch_composefs(opts).await
             } else {
                 switch(opts).await
             }
+
+            #[cfg(not(feature = "composefs-backend"))]
+            switch(opts).await
+        }
+        Opt::Rollback(opts) => {
+            #[cfg(feature = "composefs-backend")]
+            if composefs_booted()?.is_some() {
+                composefs_rollback().await?
+            } else {
+                rollback(&opts).await?
+            }
+
+            #[cfg(not(feature = "composefs-backend"))]
+            rollback(&opts).await?;
+
+            if opts.apply {
+                crate::reboot::reboot()?;
+            }
+
+            Ok(())
         }
-        Opt::Rollback(opts) => rollback(opts).await,
         Opt::Edit(opts) => edit(opts).await,
         Opt::UsrOverlay => usroverlay().await,
         Opt::Container(opts) => match opts {

crates/lib/src/composefs_consts.rs

@@ -1,3 +1,5 @@
+#![allow(dead_code)]
+
 /// composefs= paramter in kernel cmdline
 pub const COMPOSEFS_CMDLINE: &str = "composefs";