feat: Add KubeVirt common-instancetypes support

Add support for KubeVirt common-instancetypes to provide standardized
VM sizing. Basically it's annoying to have to specify cpus and memory
separately always since they're often *related*, and that's
the whole idea of the generic instance type.

We only expose the U1 (Universal) series instancetype
definitions from kubevirt/common-instancetypes because we're not
a true cloud.

Both `bcvk ephemeral run` and `bcvk libvirt run` now accept an
`--itype` flag that overrides `--vcpus` and `--memory` settings,
making it easier to create consistently-sized VMs across different
environments.

For libvirt VMs, the instance type is stored in domain metadata as
`bootc:instance-type` for reference.

Assisted-by: Claude Code (Sonnet 4.5)
Signed-off-by: Colin Walters <[email protected]>

Author: cgwalters

crates/integration-tests/src/tests/libvirt_verb.rs

@@ -363,6 +363,97 @@ fn test_libvirt_ssh_integration() -> Result<()> {
     Ok(())
 }
 
+#[distributed_slice(INTEGRATION_TESTS)]
+static TEST_LIBVIRT_RUN_WITH_INSTANCETYPE: IntegrationTest = IntegrationTest::new(
+    "test_libvirt_run_with_instancetype",
+    test_libvirt_run_with_instancetype,
+);
+
+/// Test libvirt run with instancetype
+fn test_libvirt_run_with_instancetype() -> Result<()> {
+    let test_image = get_test_image();
+
+    // Generate unique domain name for this test
+    let domain_name = format!(
+        "test-itype-{}",
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    );
+
+    println!(
+        "Testing libvirt run with instancetype for domain: {}",
+        domain_name
+    );
+
+    // Cleanup any existing domain with this name
+    cleanup_domain(&domain_name);
+
+    // Create domain with instancetype
+    println!("Creating libvirt domain with instancetype u1.small...");
+    let create_output = run_bcvk(&[
+        "libvirt",
+        "run",
+        "--name",
+        &domain_name,
+        "--label",
+        LIBVIRT_INTEGRATION_TEST_LABEL,
+        "--itype",
+        "u1.small",
+        "--filesystem",
+        "ext4",
+        &test_image,
+    ])
+    .expect("Failed to run libvirt run");
+
+    println!("Create stdout: {}", create_output.stdout);
+    println!("Create stderr: {}", create_output.stderr);
+
+    if !create_output.success() {
+        cleanup_domain(&domain_name);
+        panic!(
+            "Failed to create domain with instancetype: {}",
+            create_output.stderr
+        );
+    }
+
+    println!("Successfully created domain: {}", domain_name);
+
+    // Inspect the domain to verify instancetype was set
+    let inspect_output =
+        run_bcvk(&["libvirt", "inspect", &domain_name]).expect("Failed to run libvirt inspect");
+
+    let inspect_stdout = inspect_output.stdout;
+    println!("Inspect output: {}", inspect_stdout);
+
+    // Parse XML to verify memory and vcpus match u1.small (1 vcpu, 2048 MB)
+    let dom = parse_xml_dom(&inspect_stdout).expect("Failed to parse domain XML");
+
+    // Check vCPUs (should be 1 for u1.small)
+    let vcpu_node = dom.find("vcpu").expect("vcpu element not found");
+    let vcpus: u32 = vcpu_node.text.parse().expect("Failed to parse vcpu count");
+    assert_eq!(vcpus, 1, "u1.small should have 1 vCPU, got {}", vcpus);
+    println!("✓ vCPUs correctly set to: {}", vcpus);
+
+    // Check memory (should be 2048 MB = 2097152 KB for u1.small)
+    let memory_node = dom.find("memory").expect("memory element not found");
+    let memory_kb: u64 = memory_node.text.parse().expect("Failed to parse memory");
+    let memory_mb = memory_kb / 1024;
+    assert_eq!(
+        memory_mb, 2048,
+        "u1.small should have 2048 MB, got {} MB",
+        memory_mb
+    );
+    println!("✓ Memory correctly set to: {} MB", memory_mb);
+
+    // Cleanup domain
+    cleanup_domain(&domain_name);
+
+    println!("✓ libvirt run with instancetype test passed");
+    Ok(())
+}
+
 /// Helper function to cleanup domain
 fn cleanup_domain(domain_name: &str) {
     println!("Cleaning up domain: {}", domain_name);

crates/integration-tests/src/tests/run_ephemeral.rs

@@ -228,3 +228,63 @@ fn test_run_ephemeral_container_ssh_access() -> Result<()> {
     assert!(ssh_output.stdout.contains("SSH_TEST_SUCCESS"));
     Ok(())
 }
+
+#[distributed_slice(INTEGRATION_TESTS)]
+static TEST_RUN_EPHEMERAL_WITH_INSTANCETYPE: IntegrationTest = IntegrationTest::new(
+    "run_ephemeral_with_instancetype",
+    test_run_ephemeral_with_instancetype,
+);
+
+fn test_run_ephemeral_with_instancetype() -> Result<()> {
+    let output = run_bcvk(&[
+        "ephemeral",
+        "run",
+        "--rm",
+        "--label",
+        INTEGRATION_TEST_LABEL,
+        "--itype",
+        "u1.nano",
+        "--karg",
+        "systemd.unit=poweroff.target",
+        &get_test_image(),
+    ])?;
+
+    output.assert_success("ephemeral run with instance type u1.nano");
+    Ok(())
+}
+
+#[distributed_slice(INTEGRATION_TESTS)]
+static TEST_RUN_EPHEMERAL_INSTANCETYPE_INVALID: IntegrationTest = IntegrationTest::new(
+    "run_ephemeral_instancetype_invalid",
+    test_run_ephemeral_instancetype_invalid,
+);
+
+fn test_run_ephemeral_instancetype_invalid() -> Result<()> {
+    let output = run_bcvk(&[
+        "ephemeral",
+        "run",
+        "--rm",
+        "--label",
+        INTEGRATION_TEST_LABEL,
+        "--itype",
+        "invalid.type",
+        "--karg",
+        "systemd.unit=poweroff.target",
+        &get_test_image(),
+    ])?;
+
+    // Should fail with invalid instance type
+    assert!(
+        !output.success(),
+        "Expected failure with invalid instance type, but succeeded"
+    );
+
+    // Error message should mention the invalid type
+    assert!(
+        output.stderr.contains("invalid.type") || output.stderr.contains("Unknown instance type"),
+        "Error message should mention invalid instance type: {}",
+        output.stderr
+    );
+
+    Ok(())
+}

crates/kit/src/instancetypes.rs

@@ -0,0 +1,200 @@
+//! KubeVirt common-instancetypes support
+//!
+//! This module vendors the KubeVirt common-instancetypes definitions,
+//! specifically the U series (Universal/General Purpose) instance types.
+//! These provide standardized VM sizing with predefined vCPU and memory
+//! configurations.
+//!
+//! Instance types follow the format: u1.{size}
+//! Examples: u1.nano, u1.micro, u1.small, u1.medium, u1.large, etc.
+//!
+//! Source: https://github.com/kubevirt/common-instancetypes
+
+/// Instance type variants with associated vCPU and memory specifications
+///
+/// Source: https://github.com/kubevirt/common-instancetypes/blob/main/instancetypes/u/1/sizes.yaml
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    serde::Serialize,
+    serde::Deserialize,
+    strum::Display,
+    strum::EnumString,
+)]
+#[non_exhaustive]
+pub enum InstanceType {
+    /// u1.nano - 1 vCPU, 512 MiB memory
+    #[strum(serialize = "u1.nano")]
+    U1Nano,
+    /// u1.micro - 1 vCPU, 1 GiB memory
+    #[strum(serialize = "u1.micro")]
+    U1Micro,
+    /// u1.small - 1 vCPU, 2 GiB memory
+    #[strum(serialize = "u1.small")]
+    U1Small,
+    /// u1.medium - 1 vCPU, 4 GiB memory
+    #[strum(serialize = "u1.medium")]
+    U1Medium,
+    /// u1.2xmedium - 2 vCPU, 4 GiB memory
+    #[strum(serialize = "u1.2xmedium")]
+    U1TwoXMedium,
+    /// u1.large - 2 vCPU, 8 GiB memory
+    #[strum(serialize = "u1.large")]
+    U1Large,
+    /// u1.xlarge - 4 vCPU, 16 GiB memory
+    #[strum(serialize = "u1.xlarge")]
+    U1XLarge,
+    /// u1.2xlarge - 8 vCPU, 32 GiB memory
+    #[strum(serialize = "u1.2xlarge")]
+    U1TwoXLarge,
+    /// u1.4xlarge - 16 vCPU, 64 GiB memory
+    #[strum(serialize = "u1.4xlarge")]
+    U1FourXLarge,
+    /// u1.8xlarge - 32 vCPU, 128 GiB memory
+    #[strum(serialize = "u1.8xlarge")]
+    U1EightXLarge,
+}
+
+impl InstanceType {
+    /// Get the number of vCPUs for this instance type
+    pub const fn vcpus(self) -> u32 {
+        match self {
+            Self::U1Nano => 1,
+            Self::U1Micro => 1,
+            Self::U1Small => 1,
+            Self::U1Medium => 1,
+            Self::U1TwoXMedium => 2,
+            Self::U1Large => 2,
+            Self::U1XLarge => 4,
+            Self::U1TwoXLarge => 8,
+            Self::U1FourXLarge => 16,
+            Self::U1EightXLarge => 32,
+        }
+    }
+
+    /// Get the memory in megabytes for this instance type
+    pub const fn memory_mb(self) -> u32 {
+        match self {
+            Self::U1Nano => 512,
+            Self::U1Micro => 1024,
+            Self::U1Small => 2048,
+            Self::U1Medium => 4096,
+            Self::U1TwoXMedium => 4096,
+            Self::U1Large => 8192,
+            Self::U1XLarge => 16384,
+            Self::U1TwoXLarge => 32768,
+            Self::U1FourXLarge => 65536,
+            Self::U1EightXLarge => 131072,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::str::FromStr;
+
+    #[test]
+    fn test_parse_valid_instancetype() {
+        let itype = InstanceType::from_str("u1.nano").unwrap();
+        assert_eq!(itype, InstanceType::U1Nano);
+        assert_eq!(itype.vcpus(), 1);
+        assert_eq!(itype.memory_mb(), 512);
+    }
+
+    #[test]
+    fn test_parse_all_variants() {
+        assert_eq!(
+            InstanceType::from_str("u1.nano").unwrap(),
+            InstanceType::U1Nano
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.micro").unwrap(),
+            InstanceType::U1Micro
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.small").unwrap(),
+            InstanceType::U1Small
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.medium").unwrap(),
+            InstanceType::U1Medium
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.2xmedium").unwrap(),
+            InstanceType::U1TwoXMedium
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.large").unwrap(),
+            InstanceType::U1Large
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.xlarge").unwrap(),
+            InstanceType::U1XLarge
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.2xlarge").unwrap(),
+            InstanceType::U1TwoXLarge
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.4xlarge").unwrap(),
+            InstanceType::U1FourXLarge
+        );
+        assert_eq!(
+            InstanceType::from_str("u1.8xlarge").unwrap(),
+            InstanceType::U1EightXLarge
+        );
+    }
+
+    #[test]
+    fn test_parse_invalid_instancetype() {
+        let result = InstanceType::from_str("invalid");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_display() {
+        assert_eq!(InstanceType::U1Nano.to_string(), "u1.nano");
+        assert_eq!(InstanceType::U1Small.to_string(), "u1.small");
+        assert_eq!(InstanceType::U1EightXLarge.to_string(), "u1.8xlarge");
+    }
+
+    #[test]
+    fn test_vcpus() {
+        assert_eq!(InstanceType::U1Nano.vcpus(), 1);
+        assert_eq!(InstanceType::U1TwoXMedium.vcpus(), 2);
+        assert_eq!(InstanceType::U1XLarge.vcpus(), 4);
+        assert_eq!(InstanceType::U1EightXLarge.vcpus(), 32);
+    }
+
+    #[test]
+    fn test_memory_mb() {
+        assert_eq!(InstanceType::U1Nano.memory_mb(), 512);
+        assert_eq!(InstanceType::U1Small.memory_mb(), 2048);
+        assert_eq!(InstanceType::U1Large.memory_mb(), 8192);
+        assert_eq!(InstanceType::U1EightXLarge.memory_mb(), 131072);
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        for variant in [
+            InstanceType::U1Nano,
+            InstanceType::U1Micro,
+            InstanceType::U1Small,
+            InstanceType::U1Medium,
+            InstanceType::U1TwoXMedium,
+            InstanceType::U1Large,
+            InstanceType::U1XLarge,
+            InstanceType::U1TwoXLarge,
+            InstanceType::U1FourXLarge,
+            InstanceType::U1EightXLarge,
+        ] {
+            let s = variant.to_string();
+            let parsed = InstanceType::from_str(&s).unwrap();
+            assert_eq!(parsed, variant);
+        }
+    }
+}