Clean up install options + metadata

This makes it easier to handle caching as we add
new things to install opts (though that shouldn't
happen often).

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

Author: cgwalters

crates/kit/src/cache_metadata.rs

@@ -8,6 +8,7 @@
 //! - A SHA256 hash of all build inputs for cache validation
 //! - The container image digest for visibility and tracking
 
+use crate::install_options::InstallOptions;
 use cap_std_ext::cap_std::{self, fs::Dir};
 use cap_std_ext::dirext::CapStdExtDirExt;
 use color_eyre::{eyre::Context, Result};
@@ -35,6 +36,9 @@ struct CacheInputs {
     /// Root filesystem size if specified
     root_size: Option<String>,
 
+    /// Whether to use composefs-native storage
+    composefs_native: bool,
+
     /// Kernel arguments used during installation
     kernel_args: Vec<String>,
 
@@ -54,6 +58,9 @@ pub struct DiskImageMetadata {
     /// Root filesystem size if specified
     pub root_size: Option<String>,
 
+    /// Whether to use composefs-native storage
+    pub composefs_native: bool,
+
     /// Kernel arguments used during installation
     pub kernel_args: Vec<String>,
 
@@ -62,23 +69,13 @@ pub struct DiskImageMetadata {
 }
 
 impl DiskImageMetadata {
-    /// Create new metadata for a disk image
-    pub fn new(digest: &str) -> Self {
-        Self {
-            version: 1,
-            digest: digest.to_owned(),
-            filesystem: None,
-            root_size: None,
-            kernel_args: Default::default(),
-        }
-    }
-
     /// Generate SHA256 hash of all build inputs
     fn compute_cache_hash(&self) -> String {
         let inputs = CacheInputs {
             image_digest: self.digest.clone(),
             filesystem: self.filesystem.clone(),
             root_size: self.root_size.clone(),
+            composefs_native: self.composefs_native,
             kernel_args: self.kernel_args.clone(),
             version: self.version,
         };
@@ -154,12 +151,25 @@ impl DiskImageMetadata {
     }
 }
 
+impl DiskImageMetadata {
+    /// Create new metadata from InstallOptions and image digest
+    pub fn from(options: &InstallOptions, image: &str, kernel_args: &[String]) -> Self {
+        Self {
+            version: 1,
+            digest: image.to_owned(),
+            filesystem: options.filesystem.clone(),
+            root_size: options.root_size.clone(),
+            kernel_args: kernel_args.to_vec(),
+            composefs_native: options.composefs_native,
+        }
+    }
+}
+
 /// Check if a cached disk image can be reused by comparing cache hashes
 pub fn check_cached_disk(
     path: &Path,
     image_digest: &str,
-    filesystem: Option<&str>,
-    root_size: Option<&str>,
+    install_options: &InstallOptions,
     kernel_args: &[String],
 ) -> Result<bool> {
     if !path.exists() {
@@ -168,10 +178,7 @@ pub fn check_cached_disk(
     }
 
     // Create metadata for the current request to compute expected hash
-    let mut expected_meta = DiskImageMetadata::new(image_digest);
-    expected_meta.filesystem = filesystem.map(ToOwned::to_owned);
-    expected_meta.root_size = root_size.map(ToOwned::to_owned);
-    expected_meta.kernel_args = Vec::from(kernel_args);
+    let expected_meta = DiskImageMetadata::from(install_options, image_digest, kernel_args);
     let expected_hash = expected_meta.compute_cache_hash();
 
     // Read the cache hash from the disk image
@@ -221,15 +228,29 @@ mod tests {
 
     #[test]
     fn test_cache_hash_generation() {
-        let mut metadata1 = DiskImageMetadata::new("sha256:abc123");
-        metadata1.filesystem = Some("ext4".to_string());
-        metadata1.root_size = Some("20G".to_string());
-        metadata1.kernel_args = vec!["console=ttyS0".to_string()];
+        let install_options1 = InstallOptions {
+            filesystem: Some("ext4".to_string()),
+            root_size: Some("20G".to_string()),
+            storage_path: None,
+            composefs_native: false,
+        };
+        let metadata1 = DiskImageMetadata::from(
+            &install_options1,
+            "sha256:abc123",
+            &["console=ttyS0".to_string()],
+        );
 
-        let mut metadata2 = DiskImageMetadata::new("sha256:abc123");
-        metadata2.filesystem = Some("ext4".to_string());
-        metadata2.root_size = Some("20G".to_string());
-        metadata2.kernel_args = vec!["console=ttyS0".to_string()];
+        let install_options2 = InstallOptions {
+            filesystem: Some("ext4".to_string()),
+            root_size: Some("20G".to_string()),
+            storage_path: None,
+            composefs_native: false,
+        };
+        let metadata2 = DiskImageMetadata::from(
+            &install_options2,
+            "sha256:abc123",
+            &["console=ttyS0".to_string()],
+        );
 
         // Same inputs should generate same hash
         assert_eq!(
@@ -238,21 +259,35 @@ mod tests {
         );
 
         // Different inputs should generate different hashes
-        let mut metadata3 = DiskImageMetadata::new("sha256:xyz789");
-        metadata3.filesystem = Some("ext4".to_string());
-        metadata3.root_size = Some("20G".to_string());
-        metadata3.kernel_args = vec!["console=ttyS0".to_string()];
+        let install_options3 = InstallOptions {
+            filesystem: Some("ext4".to_string()),
+            root_size: Some("20G".to_string()),
+            storage_path: None,
+            composefs_native: false,
+        };
+        let metadata3 = DiskImageMetadata::from(
+            &install_options3,
+            "sha256:xyz789",
+            &["console=ttyS0".to_string()],
+        );
 
         assert_ne!(
             metadata1.compute_cache_hash(),
             metadata3.compute_cache_hash()
         );
 
         // Different filesystem should generate different hash
-        let mut metadata4 = DiskImageMetadata::new("sha256:abc123");
-        metadata4.filesystem = Some("xfs".to_string());
-        metadata4.root_size = Some("20G".to_string());
-        metadata4.kernel_args = vec!["console=ttyS0".to_string()];
+        let install_options4 = InstallOptions {
+            filesystem: Some("xfs".to_string()),
+            root_size: Some("20G".to_string()),
+            storage_path: None,
+            composefs_native: false,
+        };
+        let metadata4 = DiskImageMetadata::from(
+            &install_options4,
+            "sha256:abc123",
+            &["console=ttyS0".to_string()],
+        );
 
         assert_ne!(
             metadata1.compute_cache_hash(),
@@ -267,6 +302,7 @@ mod tests {
             filesystem: Some("ext4".to_string()),
             root_size: Some("20G".to_string()),
             kernel_args: vec!["console=ttyS0".to_string()],
+            composefs_native: false,
             version: 1,
         };
 

crates/kit/src/libvirt/run.rs

@@ -13,6 +13,7 @@ use tracing::{debug, info};
 
 use crate::common_opts::MemoryOpts;
 use crate::domain_list::DomainLister;
+use crate::install_options::InstallOptions;
 use crate::libvirt::domain::VirtiofsFilesystem;
 use crate::utils::parse_memory_to_mb;
 use crate::xml_utils;
@@ -38,9 +39,9 @@ pub struct LibvirtRunOpts {
     #[clap(long, default_value = "20G")]
     pub disk_size: String,
 
-    /// Root filesystem type for installation
-    #[clap(long, default_value = "ext4")]
-    pub filesystem: String,
+    /// Installation options (filesystem, root-size, etc.)
+    #[clap(flatten)]
+    pub install: InstallOptions,
 
     /// Port mapping from host to VM
     #[clap(long = "port", short = 'p', action = clap::ArgAction::Append)]
@@ -79,7 +80,6 @@ pub struct LibvirtRunOpts {
 pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRunOpts) -> Result<()> {
     use crate::cache_metadata;
     use crate::images;
-    use crate::install_options::InstallOptions;
     use crate::run_ephemeral::CommonVmOpts;
     use crate::to_disk::ToDiskOpts;
 
@@ -118,9 +118,8 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRunOpts) -
         &vm_name,
         &opts.image,
         &image_digest,
-        &opts.filesystem,
-        None, // root_size
-        &[],  // kernel_args
+        &opts.install,
+        &[], // kernel_args
         connect_uri,
     )
     .with_context(|| "Failed to find or create disk path")?;
@@ -129,9 +128,8 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRunOpts) -
     let cached = cache_metadata::check_cached_disk(
         disk_path.as_std_path(),
         &image_digest,
-        Some(&opts.filesystem),
-        None, // root_size
-        &[],  // kernel_args
+        &opts.install,
+        &[], // kernel_args
     )?;
 
     if cached {
@@ -145,10 +143,7 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRunOpts) -
             target_disk: disk_path.clone(),
             disk_size: Some(opts.disk_size.clone()),
             format: crate::to_disk::Format::Raw, // Default to raw format
-            install: InstallOptions {
-                filesystem: Some(opts.filesystem.clone()),
-                ..Default::default()
-            },
+            install: opts.install.clone(),
             common: CommonVmOpts {
                 memory: opts.memory.clone(),
                 vcpus: Some(opts.cpus),
@@ -313,8 +308,7 @@ fn find_or_create_cached_disk(
     vm_name: &str,
     source_image: &str,
     image_digest: &str,
-    filesystem: &str,
-    root_size: Option<&str>,
+    install_options: &InstallOptions,
     kernel_args: &[String],
     connect_uri: Option<&String>,
 ) -> Result<Utf8PathBuf> {
@@ -361,8 +355,7 @@ fn find_or_create_cached_disk(
                     if cache_metadata::check_cached_disk(
                         path.as_std_path(),
                         image_digest,
-                        Some(filesystem),
-                        root_size,
+                        install_options,
                         kernel_args,
                     )? {
                         info!("Found matching cached disk image: {:?}", path);
@@ -555,7 +548,13 @@ fn create_libvirt_domain_from_disk(
         .with_metadata("bootc:memory-mb", &opts.memory.to_string())
         .with_metadata("bootc:vcpus", &opts.cpus.to_string())
         .with_metadata("bootc:disk-size-gb", &opts.disk_size.to_string())
-        .with_metadata("bootc:filesystem", &opts.filesystem)
+        .with_metadata(
+            "bootc:filesystem",
+            opts.install
+                .filesystem
+                .as_ref()
+                .unwrap_or(&"ext4".to_string()),
+        )
         .with_metadata("bootc:network", &opts.network)
         .with_metadata("bootc:ssh-generated", "true")
         .with_metadata("bootc:ssh-private-key-base64", &private_key_base64)

crates/kit/src/to_disk.rs

@@ -262,8 +262,7 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
         let matches = crate::cache_metadata::check_cached_disk(
             opts.target_disk.as_std_path(),
             &image_digest,
-            opts.install.filesystem.as_deref(),
-            opts.install.root_size.as_deref(),
+            &opts.install,
             &opts.common.kernel_args,
         )?;
 
@@ -417,8 +416,7 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
             let write_result = write_disk_metadata(
                 &opts.source_image,
                 &opts.target_disk,
-                opts.install.filesystem.as_deref(),
-                opts.install.root_size.as_deref(),
+                &opts.install,
                 &opts.common.kernel_args,
                 &opts.format,
             );
@@ -439,8 +437,7 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
 fn write_disk_metadata(
     source_image: &str,
     target_disk: &Utf8PathBuf,
-    filesystem: Option<&str>,
-    root_size: Option<&str>,
+    install_options: &InstallOptions,
     kernel_args: &[String],
     format: &Format,
 ) -> Result<()> {
@@ -451,11 +448,8 @@ fn write_disk_metadata(
     let inspect = images::inspect(source_image)?;
     let digest = inspect.digest.to_string();
 
-    // Prepare metadata
-    let mut metadata = DiskImageMetadata::new(&digest);
-    metadata.filesystem = filesystem.map(|s| s.to_owned());
-    metadata.root_size = root_size.map(|s| s.to_string());
-    metadata.kernel_args = kernel_args.to_vec();
+    // Prepare metadata using the new helper method
+    let metadata = DiskImageMetadata::from(install_options, &digest, kernel_args);
 
     // Write metadata using rustix fsetxattr
     let file = std::fs::OpenOptions::new()