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 <walters@verbum.org>

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,100 @@ 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<()> {
+    // Test u1.nano: 1 vCPU, 512 MiB memory
+    let output = run_bcvk(&[
+        "ephemeral",
+        "run",
+        "--rm",
+        "--label",
+        INTEGRATION_TEST_LABEL,
+        "--itype",
+        "u1.nano",
+        "--execute",
+        "/bin/sh -c 'echo CPUs:$(grep -c ^processor /proc/cpuinfo); echo MemTotal:$(grep MemTotal /proc/meminfo | awk \"{print \\$2}\")'",
+        &get_test_image(),
+    ])?;
+
+    output.assert_success("ephemeral run with instance type u1.nano");
+
+    // Verify vCPUs (should be 1)
+    assert!(
+        output.stdout.contains("CPUs:1"),
+        "Expected 1 vCPU for u1.nano, output: {}",
+        output.stdout
+    );
+
+    // Verify memory (should be ~512 MiB = ~524288 kB, allow some tolerance for kernel overhead)
+    // MemTotal is typically slightly less than allocated due to kernel reservations
+    let memtotal_line = output
+        .stdout
+        .lines()
+        .find(|line| line.contains("MemTotal:"))
+        .expect("MemTotal line not found in output");
+
+    let memtotal_kb: u32 = memtotal_line
+        .split(':')
+        .nth(1)
+        .expect("Could not parse MemTotal")
+        .trim()
+        .parse()
+        .expect("Could not parse MemTotal as number");
+
+    // Allow 10% tolerance for kernel overhead (512 MiB = 524288 kB)
+    let expected_kb = 512 * 1024;
+    let lower_bound = expected_kb * 9 / 10; // 90% of expected
+    let upper_bound = expected_kb * 11 / 10; // 110% of expected
+
+    assert!(
+        memtotal_kb >= lower_bound && memtotal_kb <= upper_bound,
+        "Expected memory around {} kB for u1.nano, got {} kB",
+        expected_kb,
+        memtotal_kb
+    );
+
+    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,146 @@
+//! 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,
+    strum::EnumIter,
+)]
+#[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;
+    use strum::IntoEnumIterator;
+
+    #[test]
+    fn test_properties() {
+        for variant in InstanceType::iter() {
+            let (expected_vcpus, expected_memory_mb) = match variant {
+                InstanceType::U1Nano => (1, 512),
+                InstanceType::U1Micro => (1, 1024),
+                InstanceType::U1Small => (1, 2048),
+                InstanceType::U1Medium => (1, 4096),
+                InstanceType::U1TwoXMedium => (2, 4096),
+                InstanceType::U1Large => (2, 8192),
+                InstanceType::U1XLarge => (4, 16384),
+                InstanceType::U1TwoXLarge => (8, 32768),
+                InstanceType::U1FourXLarge => (16, 65536),
+                InstanceType::U1EightXLarge => (32, 131072),
+            };
+            assert_eq!(
+                variant.vcpus(),
+                expected_vcpus,
+                "Mismatch in vcpus for {:?}",
+                variant
+            );
+            assert_eq!(
+                variant.memory_mb(),
+                expected_memory_mb,
+                "Mismatch in memory_mb for {:?}",
+                variant
+            );
+        }
+    }
+
+    #[test]
+    fn test_parse_invalid_instancetype() {
+        let result = InstanceType::from_str("invalid");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_roundtrip() {
+        for variant in InstanceType::iter() {
+            let s = variant.to_string();
+            let parsed = InstanceType::from_str(&s).unwrap();
+            assert_eq!(parsed, variant);
+        }
+    }
+}