xtask: Introduce composefs variant

This is the Non UKI version, i.e. version with Type1 bootloader entries

Signed-off-by: Pragyan Poudyal <pragyanpoudyal41999@gmail.com>

Author: Johan-Liebert1

crates/tests-integration/src/container.rs

@@ -52,8 +52,8 @@ pub(crate) fn test_bootc_container_inspect() -> Result<()> {
         .expect("kernel.unified should be a boolean");
     if let Some(variant) = std::env::var("BOOTC_variant").ok() {
         match variant.as_str() {
-            "ostree" => {
-                assert!(!unified, "Expected unified=false for ostree variant");
+            v @ "ostree" | v @ "composefs" => {
+                assert!(!unified, "Expected unified=false for variant {v}");
                 // For traditional kernels, version should look like a uname (contains digits)
                 assert!(
                     version.chars().any(|c| c.is_ascii_digit()),
@@ -159,7 +159,7 @@ fn test_variant_base_crosscheck() -> Result<()> {
         // TODO add this to `bootc status` or so?
         let boot_efi = Utf8Path::new("/boot/EFI");
         match variant.as_str() {
-            "ostree" => {
+            "composefs" | "ostree" => {
                 assert!(!boot_efi.try_exists()?);
             }
             "composefs-sealeduki-sdboot" => {

crates/xtask/src/tmt.rs

@@ -29,6 +29,8 @@ const ENV_BOOTC_UPGRADE_IMAGE: &str = "BOOTC_upgrade_image";
 // Distro identifiers
 const DISTRO_CENTOS_9: &str = "centos-9";
 
+const COMPOSEFS_KERNEL_ARGS: [&str; 1] = ["--karg=enforcing=0"];
+
 // Import the argument types from xtask.rs
 use crate::{RunTmtArgs, TmtProvisionArgs};
 
@@ -430,6 +432,19 @@ pub(crate) fn run_tmt(sh: &Shell, args: &RunTmtArgs) -> Result<()> {
                     opts.push("--filesystem=xfs".to_string());
                 }
             }
+
+            if args.composefs_backend {
+                // TODO(Johan-Liebert1): Filesystem should be a parameter and we should test
+                // insecure with xfs
+                opts.push("--filesystem=ext4".into());
+                opts.push("--composefs-backend".into());
+                opts.extend(COMPOSEFS_KERNEL_ARGS.map(|x| x.into()));
+            }
+
+            if let Some(b) = &args.bootloader {
+                opts.push(format!("--bootloader={b}"));
+            }
+
             opts
         };
 

crates/xtask/src/xtask.rs

@@ -5,13 +5,14 @@
 //! end up as a lot of nontrivial bash code.
 
 use std::borrow::Cow;
+use std::fmt::Display;
 use std::fs::File;
 use std::io::{BufRead, BufReader, BufWriter, Write};
 use std::process::Command;
 
 use anyhow::{Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
-use clap::{Args, Parser, Subcommand};
+use clap::{Args, Parser, Subcommand, ValueEnum};
 use fn_error_context::context;
 use xshell::{Shell, cmd};
 
@@ -76,6 +77,25 @@ pub(crate) struct LocalRustDepsArgs {
     pub(crate) format: String,
 }
 
+/// Bootloader passed as --bootloader param for composefs builds
+// TODO: Find a better way to share this Enum between this and crates/lib
+#[derive(Debug, Clone, ValueEnum)]
+pub enum Bootloader {
+    /// grub as bootloader
+    Grub,
+    /// systemd-boot as bootloader
+    Systemd,
+}
+
+impl Display for Bootloader {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Bootloader::Grub => f.write_str("grub"),
+            Bootloader::Systemd => f.write_str("systemd"),
+        }
+    }
+}
+
 /// Arguments for run-tmt command
 #[derive(Debug, Args)]
 pub(crate) struct RunTmtArgs {
@@ -101,6 +121,12 @@ pub(crate) struct RunTmtArgs {
     /// Preserve VMs after test completion (useful for debugging)
     #[arg(long)]
     pub(crate) preserve_vm: bool,
+
+    #[arg(long)]
+    pub(crate) composefs_backend: bool,
+
+    #[arg(long, requires = "composefs_backend")]
+    pub(crate) bootloader: Option<Bootloader>,
 }
 
 /// Arguments for tmt-provision command