Make use of Default for ToDisk structs

This avoids lots of duplication when adding a new field.

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

Author: cgwalters

crates/kit/src/libvirt/run.rs

@@ -81,7 +81,7 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRunOpts) -
     use crate::cache_metadata;
     use crate::images;
     use crate::run_ephemeral::CommonVmOpts;
-    use crate::to_disk::ToDiskOpts;
+    use crate::to_disk::{ToDiskAdditionalOpts, ToDiskOpts};
 
     let connect_uri = global_opts.connect.as_ref();
     let lister = match connect_uri {
@@ -141,22 +141,17 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtRunOpts) -
         let to_disk_opts = ToDiskOpts {
             source_image: opts.image.clone(),
             target_disk: disk_path.clone(),
-            disk_size: Some(opts.disk_size.clone()),
-            format: crate::to_disk::Format::Raw, // Default to raw format
             install: opts.install.clone(),
-            install_log: None,
-            common: CommonVmOpts {
-                memory: opts.memory.clone(),
-                vcpus: Some(opts.cpus),
-                kernel_args: vec![],
-                net: None,
-                console: false,
-                debug: false,
-                virtio_serial_out: vec![],
-                execute: vec![],
-                ssh_keygen: true, // Enable SSH key generation
+            additional: ToDiskAdditionalOpts {
+                disk_size: Some(opts.disk_size.clone()),
+                common: CommonVmOpts {
+                    memory: opts.memory.clone(),
+                    vcpus: Some(opts.cpus),
+                    ssh_keygen: true, // Enable SSH key generation
+                    ..Default::default()
+                },
+                ..Default::default()
             },
-            label: vec![],
         };
 
         // Run the disk creation

crates/kit/src/libvirt/upload.rs

@@ -5,7 +5,7 @@
 
 use crate::common_opts::MemoryOpts;
 use crate::install_options::InstallOptions;
-use crate::to_disk::{run as to_disk, ToDiskOpts};
+use crate::to_disk::{run as to_disk, ToDiskAdditionalOpts, ToDiskOpts};
 use crate::{images, utils};
 use camino::Utf8PathBuf;
 use clap::Parser;
@@ -214,20 +214,16 @@ pub fn run(global_opts: &crate::libvirt::LibvirtOptions, opts: LibvirtUploadOpts
         source_image: opts.source_image.clone(),
         target_disk: temp_disk_path.clone(),
         install: opts.install.clone(),
-        format: crate::to_disk::Format::Raw, // Default to raw format
-        disk_size: Some(disk_size.to_string()),
-        label: Default::default(),
-        install_log: None,
-        common: crate::run_ephemeral::CommonVmOpts {
-            memory: opts.memory.clone(),
-            vcpus: opts.vcpus,
-            kernel_args: opts.karg.clone(),
-            net: Some("none".to_string()),
-            console: false,
-            debug: false,
-            virtio_serial_out: vec![],
-            execute: Default::default(),
-            ssh_keygen: false,
+        additional: ToDiskAdditionalOpts {
+            disk_size: Some(disk_size.to_string()),
+            common: crate::run_ephemeral::CommonVmOpts {
+                memory: opts.memory.clone(),
+                vcpus: opts.vcpus,
+                kernel_args: opts.karg.clone(),
+                net: Some("none".to_string()),
+                ..Default::default()
+            },
+            ..Default::default()
         },
     };
 

crates/kit/src/libvirt_upload_disk.rs

@@ -5,7 +5,7 @@
 
 use crate::common_opts::MemoryOpts;
 use crate::install_options::InstallOptions;
-use crate::to_disk::{run as to_disk, ToDiskOpts};
+use crate::to_disk::{run as to_disk, ToDiskAdditionalOpts, ToDiskOpts};
 use crate::xml_utils::{self, XmlWriter};
 use crate::{images, utils};
 use camino::Utf8Path;
@@ -285,20 +285,16 @@ pub fn run(opts: LibvirtUploadDiskOpts) -> Result<()> {
         source_image: opts.source_image.clone(),
         target_disk: temp_disk.clone(),
         install: opts.install.clone(),
-        disk_size: Some(disk_size.to_string()),
-        format: crate::to_disk::Format::Raw, // Default to raw format
-        label: Default::default(),
-        install_log: None,
-        common: crate::run_ephemeral::CommonVmOpts {
-            memory: opts.memory.clone(),
-            vcpus: opts.vcpus,
-            kernel_args: opts.karg.clone(),
-            net: Some("none".to_string()),
-            console: false,
-            debug: false,
-            virtio_serial_out: vec![],
-            execute: Default::default(),
-            ssh_keygen: false,
+        additional: ToDiskAdditionalOpts {
+            disk_size: Some(disk_size.to_string()),
+            common: crate::run_ephemeral::CommonVmOpts {
+                memory: opts.memory.clone(),
+                vcpus: opts.vcpus,
+                kernel_args: opts.karg.clone(),
+                net: Some("none".to_string()),
+                ..Default::default()
+            },
+            ..Default::default()
         },
     };
 

crates/kit/src/to_disk.rs

@@ -88,9 +88,10 @@ use indoc::indoc;
 use tracing::debug;
 
 /// Supported disk image formats
-#[derive(Debug, Clone, ValueEnum, PartialEq)]
+#[derive(Debug, Clone, ValueEnum, PartialEq, Default)]
 pub enum Format {
     /// Raw disk image format (default)
+    #[default]
     Raw,
     /// QEMU Copy On Write 2 format
     Qcow2,
@@ -112,21 +113,9 @@ impl std::fmt::Display for Format {
     }
 }
 
-/// Configuration options for installing a bootc container image to disk
-///
-/// See the module-level documentation for details on the installation architecture and workflow.
-#[derive(Debug, Parser)]
-pub struct ToDiskOpts {
-    /// Container image to install
-    pub source_image: String,
-
-    /// Target disk/device path
-    pub target_disk: Utf8PathBuf,
-
-    /// Installation options (filesystem, root-size, storage-path)
-    #[clap(flatten)]
-    pub install: InstallOptions,
-
+/// Additional configuration options for installing a bootc container image to disk
+#[derive(Debug, Parser, Default)]
+pub struct ToDiskAdditionalOpts {
     /// Disk size to create (e.g. 10G, 5120M, or plain number for bytes)
     #[clap(long)]
     pub disk_size: Option<String>,
@@ -150,6 +139,26 @@ pub struct ToDiskOpts {
     pub label: Vec<String>,
 }
 
+/// Configuration options for installing a bootc container image to disk
+///
+/// See the module-level documentation for details on the installation architecture and workflow.
+#[derive(Debug, Parser)]
+pub struct ToDiskOpts {
+    /// Container image to install
+    pub source_image: String,
+
+    /// Target disk/device path
+    pub target_disk: Utf8PathBuf,
+
+    /// Installation options (filesystem, root-size, storage-path)
+    #[clap(flatten)]
+    pub install: InstallOptions,
+
+    /// Additional installation options
+    #[clap(flatten)]
+    pub additional: ToDiskAdditionalOpts,
+}
+
 impl ToDiskOpts {
     /// Get the container image to use as the installation environment
     ///
@@ -189,6 +198,7 @@ impl ToDiskOpts {
             .to_string();
 
         let install_log = self
+            .additional
             .install_log
             .as_deref()
             .map(|v| shlex::try_quote(v))
@@ -232,7 +242,7 @@ impl ToDiskOpts {
     /// Returns explicit disk_size if provided (parsed from human-readable format),
     /// otherwise 2x the image size with a 4GB minimum.
     fn calculate_disk_size(&self) -> Result<u64> {
-        if let Some(ref size_str) = self.disk_size {
+        if let Some(ref size_str) = self.additional.disk_size {
             let parsed = utils::parse_size(size_str)?;
             debug!("Using explicit disk size: {} -> {} bytes", size_str, parsed);
             return Ok(parsed);
@@ -277,7 +287,7 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
             opts.target_disk.as_std_path(),
             &image_digest,
             &opts.install,
-            &opts.common.kernel_args,
+            &opts.additional.common.kernel_args,
         )?;
 
         if matches {
@@ -299,7 +309,7 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
     let storage_path = opts.get_storage_path()?;
 
     // Debug logging for installation configuration
-    if opts.common.debug {
+    if opts.additional.common.debug {
         debug!("Using container storage: {:?}", storage_path);
         debug!("Installing to target disk: {:?}", opts.target_disk);
         debug!("Filesystem: {:?}", opts.install.filesystem);
@@ -311,7 +321,7 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
     let disk_size = opts.calculate_disk_size()?;
 
     // Create disk image based on format
-    match opts.format {
+    match opts.additional.format {
         Format::Raw => {
             // Create sparse file - only allocates space as data is written
             let file = std::fs::File::create(&opts.target_disk)
@@ -352,7 +362,7 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
     let bootc_install_command = opts.generate_bootc_install_command()?;
 
     // Phase 4: Ephemeral VM configuration
-    let mut common_opts = opts.common.clone();
+    let mut common_opts = opts.additional.common.clone();
     // Enable SSH key generation for SSH-based installation
     common_opts.ssh_keygen = true;
 
@@ -370,22 +380,22 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
             rm: true,     // Clean up container after installation
             detach: true, // Run in detached mode for SSH approach
             tty,
-            label: opts.label,
+            label: opts.additional.label,
             ..Default::default()
         },
         // Workaround for https://github.com/containers/container-libs/issues/144#issuecomment-3300424410
         // Basically containers-libs allocates a tempfile for a whole serialization of a layer as a tarball
         // when fetching, so we need enough memory to do so.
         add_swap: Some(format!("{disk_size}")),
-        bind_mounts: Vec::new(),        // No additional bind mounts needed
-        ro_bind_mounts: Vec::new(),     // No additional ro bind mounts needed
-        systemd_units_dir: None,        // No custom systemd units
-        log_cmdline: opts.common.debug, // Log kernel command line if debug
-        bind_storage_ro: true,          // Mount host container storage read-only
+        bind_mounts: Vec::new(),    // No additional bind mounts needed
+        ro_bind_mounts: Vec::new(), // No additional ro bind mounts needed
+        systemd_units_dir: None,    // No custom systemd units
+        log_cmdline: opts.additional.common.debug, // Log kernel command line if debug
+        bind_storage_ro: true,      // Mount host container storage read-only
         mount_disk_files: vec![format!(
             "{}:output:{}",
             opts.target_disk,
-            opts.format.as_str()
+            opts.additional.format.as_str()
         )], // Attach target disk
     };
 
@@ -441,8 +451,8 @@ pub fn run(opts: ToDiskOpts) -> Result<()> {
                 &opts.source_image,
                 &opts.target_disk,
                 &opts.install,
-                &opts.common.kernel_args,
-                &opts.format,
+                &opts.additional.common.kernel_args,
+                &opts.additional.format,
             );
             if let Err(e) = write_result {
                 debug!("Failed to write metadata to disk image: {}", e);
@@ -505,15 +515,14 @@ mod tests {
         let opts = ToDiskOpts {
             source_image: "test:latest".to_string(),
             target_disk: "/tmp/test.img".into(),
-            label: Default::default(),
-            install_log: None,
             install: InstallOptions {
                 filesystem: Some("ext4".to_string()),
                 ..Default::default()
             },
-            disk_size: Some("10G".to_string()),
-            format: Format::Raw,
-            common: CommonVmOpts::default(),
+            additional: ToDiskAdditionalOpts {
+                disk_size: Some("10G".to_string()),
+                ..Default::default()
+            },
         };
 
         let size = opts.calculate_disk_size()?;
@@ -524,15 +533,14 @@ mod tests {
         let opts2 = ToDiskOpts {
             source_image: "test:latest".to_string(),
             target_disk: "/tmp/test.img".into(),
-            label: Default::default(),
-            install_log: None,
             install: InstallOptions {
                 filesystem: Some("ext4".to_string()),
                 ..Default::default()
             },
-            disk_size: Some("5120M".to_string()),
-            format: Format::Raw,
-            common: CommonVmOpts::default(),
+            additional: ToDiskAdditionalOpts {
+                disk_size: Some("5120M".to_string()),
+                ..Default::default()
+            },
         };
 
         let size2 = opts2.calculate_disk_size()?;