composefs-backend: Rename 'composefs-native' to 'composefs-backend'

We were using composefs-native and composefs-backend interchangeably.
Replace all instances of `composefs-native` with `composefs-backend`

Move all composefs-backend options to a single struct so that we can
test for boolean instead of testing for Some/None for composefs-backend
options

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

Author: Johan-Liebert1

crates/lib/src/bootc_composefs/boot.rs

@@ -353,14 +353,11 @@ pub(crate) fn setup_composefs_bls_boot(
             // root_setup.kargs has [root=UUID=<UUID>, "rw"]
             let mut cmdline_options = String::from(root_setup.kargs.join(" "));
 
-            match &state.composefs_options {
-                Some(opt) if opt.insecure => {
-                    cmdline_options.push_str(&format!(" {COMPOSEFS_CMDLINE}=?{id_hex}"));
-                }
-                None | Some(..) => {
-                    cmdline_options.push_str(&format!(" {COMPOSEFS_CMDLINE}={id_hex}"));
-                }
-            };
+            if state.composefs_options.insecure {
+                cmdline_options.push_str(&format!(" {COMPOSEFS_CMDLINE}=?{id_hex}"));
+            } else {
+                cmdline_options.push_str(&format!(" {COMPOSEFS_CMDLINE}={id_hex}"));
+            }
 
             // Locate ESP partition device
             let esp_part = root_setup
@@ -375,11 +372,7 @@ pub(crate) fn setup_composefs_bls_boot(
                 esp_part.node.clone(),
                 cmdline_options,
                 fs,
-                state
-                    .composefs_options
-                    .as_ref()
-                    .map(|opts| opts.bootloader.clone())
-                    .unwrap_or(Bootloader::default()),
+                state.composefs_options.bootloader.clone(),
             )
         }
 
@@ -828,10 +821,6 @@ pub(crate) fn setup_composefs_uki_boot(
                 }
             }
 
-            let Some(cfs_opts) = &state.composefs_options else {
-                anyhow::bail!("ComposeFS options not found");
-            };
-
             let esp_part = root_setup
                 .device_info
                 .partitions
@@ -842,9 +831,9 @@ pub(crate) fn setup_composefs_uki_boot(
             (
                 root_setup.physical_root_path.clone(),
                 esp_part.node.clone(),
-                cfs_opts.bootloader.clone(),
-                cfs_opts.insecure,
-                cfs_opts.uki_addon.as_ref(),
+                state.composefs_options.bootloader.clone(),
+                state.composefs_options.insecure,
+                state.composefs_options.uki_addon.as_ref(),
             )
         }
 

crates/lib/src/bootc_composefs/finalize.rs

@@ -39,7 +39,7 @@ pub(crate) async fn get_etc_diff() -> Result<()> {
     Ok(())
 }
 
-pub(crate) async fn composefs_native_finalize() -> Result<()> {
+pub(crate) async fn composefs_backend_finalize() -> Result<()> {
     let host = composefs_deployment_status().await?;
 
     let booted_composefs = host.require_composefs_booted()?;

crates/lib/src/cli.rs

@@ -31,7 +31,7 @@ use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "composefs-backend")]
 use crate::bootc_composefs::{
-    finalize::{composefs_native_finalize, get_etc_diff},
+    finalize::{composefs_backend_finalize, get_etc_diff},
     rollback::composefs_rollback,
     state::composefs_usr_overlay,
     status::composefs_booted,
@@ -1544,7 +1544,7 @@ async fn run_from_opt(opt: Opt) -> Result<()> {
         },
 
         #[cfg(feature = "composefs-backend")]
-        Opt::ComposefsFinalizeStaged => composefs_native_finalize().await,
+        Opt::ComposefsFinalizeStaged => composefs_backend_finalize().await,
 
         #[cfg(feature = "composefs-backend")]
         Opt::ConfigDiff => get_etc_diff().await,

crates/lib/src/composefs_consts.rs

@@ -8,9 +8,9 @@ pub(crate) const COMPOSEFS_TRANSIENT_STATE_DIR: &str = "/run/composefs";
 /// File created in /run/composefs to record a staged-deployment
 pub(crate) const COMPOSEFS_STAGED_DEPLOYMENT_FNAME: &str = "staged-deployment";
 
-/// Absolute path to composefs-native state directory
+/// Absolute path to composefs-backend state directory
 pub(crate) const STATE_DIR_ABS: &str = "/sysroot/state/deploy";
-/// Relative path to composefs-native state directory. Relative to /sysroot
+/// Relative path to composefs-backend state directory. Relative to /sysroot
 pub(crate) const STATE_DIR_RELATIVE: &str = "state/deploy";
 /// Relative path to the shared 'var' directory. Relative to /sysroot
 pub(crate) const SHARED_VAR_PATH: &str = "state/os/default/var";

crates/lib/src/install.rs

@@ -249,10 +249,17 @@ pub(crate) struct InstallConfigOpts {
 
 #[derive(Debug, Clone, clap::Parser, Serialize, Deserialize, PartialEq, Eq)]
 pub(crate) struct InstallComposefsOpts {
+    /// If true, composefs backend is used, else ostree backend is used
+    #[clap(long, default_value_t)]
+    #[serde(default)]
+    pub(crate) composefs_backend: bool,
+
+    /// Make fs-verity validation optional in case the filesystem doesn't support it
     #[clap(long, default_value_t)]
     #[serde(default)]
     pub(crate) insecure: bool,
 
+    /// The bootloader to use.
     #[clap(long, default_value_t)]
     #[serde(default)]
     pub(crate) bootloader: Bootloader,
@@ -288,11 +295,6 @@ pub(crate) struct InstallToDiskOpts {
     #[serde(default)]
     pub(crate) via_loopback: bool,
 
-    #[clap(long)]
-    #[serde(default)]
-    #[cfg(feature = "composefs-backend")]
-    pub(crate) composefs_native: bool,
-
     #[clap(flatten)]
     #[serde(flatten)]
     #[cfg(feature = "composefs-backend")]
@@ -373,10 +375,6 @@ pub(crate) struct InstallToFilesystemOpts {
     #[clap(flatten)]
     pub(crate) config_opts: InstallConfigOpts,
 
-    #[clap(long)]
-    #[cfg(feature = "composefs-backend")]
-    pub(crate) composefs_native: bool,
-
     #[cfg(feature = "composefs-backend")]
     #[clap(flatten)]
     pub(crate) composefs_opts: InstallComposefsOpts,
@@ -446,9 +444,9 @@ pub(crate) struct State {
     pub(crate) container_root: Dir,
     pub(crate) tempdir: TempDir,
 
-    // If Some, then --composefs_native is passed
+    // If Some, then --composefs-backend is passed
     #[cfg(feature = "composefs-backend")]
-    pub(crate) composefs_options: Option<InstallComposefsOpts>,
+    pub(crate) composefs_options: InstallComposefsOpts,
 }
 
 impl State {
@@ -578,10 +576,10 @@ impl FromStr for MountSpec {
 #[cfg(all(feature = "install-to-disk", feature = "composefs-backend"))]
 impl InstallToDiskOpts {
     pub(crate) fn validate(&self) -> Result<()> {
-        if !self.composefs_native {
-            // Reject using --insecure without --composefs
+        if !self.composefs_opts.composefs_backend {
+            // Reject using --insecure without --composefs-backend
             if self.composefs_opts.insecure != false {
-                anyhow::bail!("--insecure must not be provided without --composefs");
+                anyhow::bail!("--insecure must not be provided without --composefs-backend");
             }
         }
 
@@ -1234,7 +1232,7 @@ async fn prepare_install(
     config_opts: InstallConfigOpts,
     source_opts: InstallSourceOpts,
     target_opts: InstallTargetOpts,
-    _composefs_opts: Option<InstallComposefsOpts>,
+    #[cfg(feature = "composefs-backend")] composefs_options: InstallComposefsOpts,
 ) -> Result<Arc<State>> {
     tracing::trace!("Preparing install");
     let rootfs = cap_std::fs::Dir::open_ambient_dir("/", cap_std::ambient_authority())
@@ -1380,7 +1378,7 @@ async fn prepare_install(
         tempdir,
         host_is_container,
         #[cfg(feature = "composefs-backend")]
-        composefs_options: _composefs_opts,
+        composefs_options,
     });
 
     Ok(state)
@@ -1545,7 +1543,7 @@ async fn install_to_filesystem_impl(
     }
 
     #[cfg(feature = "composefs-backend")]
-    if state.composefs_options.is_some() {
+    if state.composefs_options.composefs_backend {
         // Load a fd for the mounted target physical root
 
         let (id, verity) = initialize_composefs_repository(state, rootfs).await?;
@@ -1622,21 +1620,12 @@ pub(crate) async fn install_to_disk(mut opts: InstallToDiskOpts) -> Result<()> {
         anyhow::bail!("Not a block device: {}", block_opts.device);
     }
 
-    #[cfg(feature = "composefs-backend")]
-    let composefs_arg = if opts.composefs_native {
-        Some(opts.composefs_opts)
-    } else {
-        None
-    };
-
-    #[cfg(not(feature = "composefs-backend"))]
-    let composefs_arg = None;
-
     let state = prepare_install(
         opts.config_opts,
         opts.source_opts,
         opts.target_opts,
-        composefs_arg,
+        #[cfg(feature = "composefs-backend")]
+        opts.composefs_opts,
     )
     .await?;
 
@@ -1874,9 +1863,7 @@ pub(crate) async fn install_to_filesystem(
         opts.source_opts,
         opts.target_opts,
         #[cfg(feature = "composefs-backend")]
-        opts.composefs_native.then_some(opts.composefs_opts),
-        #[cfg(not(feature = "composefs-backend"))]
-        None,
+        opts.composefs_opts,
     )
     .await?;
 
@@ -2148,9 +2135,8 @@ pub(crate) async fn install_to_existing_root(opts: InstallToExistingRootOpts) ->
         target_opts: opts.target_opts,
         config_opts: opts.config_opts,
         #[cfg(feature = "composefs-backend")]
-        composefs_native: false,
-        #[cfg(feature = "composefs-backend")]
         composefs_opts: InstallComposefsOpts {
+            composefs_backend: true,
             insecure: false,
             bootloader: Bootloader::Grub,
             uki_addon: None,

crates/lib/src/spec.rs

@@ -164,12 +164,14 @@ pub struct BootEntryOstree {
 }
 
 /// Bootloader type to determine whether system was booted via Grub or Systemd
-#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
+#[derive(
+    clap::ValueEnum, Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema,
+)]
 pub enum Bootloader {
-    /// Booted via Grub
+    /// Use Grub as the booloader
     #[default]
     Grub,
-    /// Booted via Systemd
+    /// Use SystemdBoot as the bootloader
     Systemd,
 }
 

tmt/tests/examples/bootc-uki/install-grub.sh

@@ -19,7 +19,7 @@ podman run \
     --security-opt label=type:unconfined_t \
     "${IMAGE}" \
     bootc install to-disk \
-        --composefs-native \
+        --composefs-backend \
         --boot=uki \
         --source-imgref="containers-storage:${IMAGE}" \
         --target-imgref="${IMAGE}" \

tmt/tests/examples/bootc-uki/install-systemd-boot.sh

@@ -24,7 +24,7 @@ podman run \
     --security-opt label=type:unconfined_t \
     "${IMAGE}" \
     bootc install to-disk \
-        --composefs-native \
+        --composefs-backend \
         --boot=uki \
         --source-imgref="containers-storage:${IMAGE}" \
         --target-imgref="${IMAGE}" \