feat: libvirt domain xml progress

src/host/libvirt.rs

@@ -5,12 +5,20 @@ use crate::host::{
 use crate::settings::QemuConfig;
 use crate::status::{VmRunningState, VmState};
 use crate::KB;
-use anyhow::{Context, Result};
+use anyhow::{bail, ensure, Context, Result};
 use chrono::Utc;
-use lnvps_db::{async_trait, Vm, VmOsImage};
+use lnvps_db::{async_trait, LNVpsDb, Vm, VmOsImage};
+use log::info;
+use rand::random;
+use serde::{Deserialize, Serialize};
+use std::str::FromStr;
+use std::sync::Arc;
+use uuid::Uuid;
 use virt::connect::Connect;
 use virt::domain::Domain;
-use virt::sys::{virDomainCreate, VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE};
+use virt::sys::{
+    virDomainCreate, VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE, VIR_DOMAIN_START_VALIDATE,
+};
 
 #[derive(Debug)]
 pub struct LibVirtHost {
@@ -25,6 +33,94 @@ impl LibVirtHost {
             qemu,
         })
     }
+
+    pub fn import_disk_image(&self, vm: &Vm, image: &VmOsImage) -> Result<()> {
+        // https://libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolUpload
+        // https://libvirt.org/html/libvirt-libvirt-storage.html#virStorageVolResize
+        Ok(())
+    }
+
+    pub fn create_domain_xml(&self, cfg: &FullVmInfo) -> Result<DomainXML> {
+        let storage = self
+            .connection
+            .list_all_storage_pools(VIR_CONNECT_LIST_STORAGE_POOLS_ACTIVE)?;
+
+        // check the storage disk exists, we don't need anything else from it for now
+        let _storage_disk = if let Some(d) = storage
+            .iter()
+            .find(|s| s.get_name().map(|n| n == cfg.disk.name).unwrap_or(false))
+        {
+            d
+        } else {
+            bail!(
+                "Disk \"{}\" not found on host! Available pools: {}",
+                cfg.disk.name,
+                storage
+                    .iter()
+                    .filter_map(|s| s.get_name().ok())
+                    .collect::<Vec<_>>()
+                    .join(",")
+            );
+        };
+
+        let resources = cfg.resources()?;
+        let mut devices = vec![];
+        // primary disk
+        devices.push(DomainDevice::Disk(Disk {
+            kind: DiskType::File,
+            device: DiskDevice::Disk,
+            source: DiskSource {
+                file: Some(format!("{}:vm-{}-disk0", cfg.disk.name, cfg.vm.id)),
+                ..Default::default()
+            },
+            target: DiskTarget {
+                dev: "vda".to_string(),
+                bus: Some(DiskBus::VirtIO),
+            },
+        }));
+        devices.push(DomainDevice::Interface(NetworkInterface {
+            kind: NetworkKind::Bridge,
+            mac: Some(NetworkMac {
+                address: cfg.vm.mac_address.clone(),
+            }),
+            source: Some(NetworkSource {
+                bridge: Some(self.qemu.bridge.clone()),
+            }),
+            target: None,
+            vlan: cfg.host.vlan_id.map(|v| NetworkVlan {
+                tags: vec![NetworkVlanTag { id: v as u32 }],
+            }),
+        }));
+        Ok(DomainXML {
+            kind: DomainType::KVM,
+            id: Some(cfg.vm.id),
+            name: Some(format!("VM{}", cfg.vm.id)),
+            uuid: None,
+            title: None,
+            description: None,
+            os: DomainOs {
+                kind: DomainOsType {
+                    kind: DomainOsTypeKind::Hvm,
+                    arch: Some(DomainOsArch::from_str(&self.qemu.arch)?),
+                    machine: Some(DomainOsMachine::from_str(&self.qemu.machine)?),
+                },
+                firmware: Some(DomainOsFirmware::EFI),
+                loader: Some(DomainOsLoader {
+                    read_only: None,
+                    kind: None,
+                    secure: Some(true),
+                    stateless: None,
+                    format: None,
+                }),
+                boot: DomainOsBoot {
+                    dev: DomainOsBootDev::HardDrive,
+                },
+            },
+            vcpu: resources.cpu,
+            memory: resources.memory,
+            devices: DomainDevices { contents: devices },
+        })
+    }
 }
 
 #[async_trait]
@@ -52,11 +148,17 @@ impl VmHostClient for LibVirtHost {
     }
 
     async fn download_os_image(&self, image: &VmOsImage) -> Result<()> {
+        // TODO: download ISO images to host (somehow, ssh?)
         Ok(())
     }
 
-    async fn generate_mac(&self, vm: &Vm) -> Result<String> {
-        Ok("ff:ff:ff:ff:ff:ff".to_string())
+    async fn generate_mac(&self, _vm: &Vm) -> Result<String> {
+        Ok(format!(
+            "52:54:00:{}:{}:{}",
+            hex::encode([random::<u8>()]),
+            hex::encode([random::<u8>()]),
+            hex::encode([random::<u8>()])
+        ))
     }
 
     async fn start_vm(&self, vm: &Vm) -> Result<()> {
@@ -72,6 +174,10 @@ impl VmHostClient for LibVirtHost {
     }
 
     async fn create_vm(&self, cfg: &FullVmInfo) -> Result<()> {
+        let domain = self.create_domain_xml(cfg)?;
+        let xml = quick_xml::se::to_string(&domain)?;
+        let domain = Domain::create_xml(&self.connection, &xml, VIR_DOMAIN_START_VALIDATE)?;
+
         Ok(())
     }
 
@@ -113,3 +219,439 @@ impl VmHostClient for LibVirtHost {
         todo!()
     }
 }
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "domain")]
+struct DomainXML {
+    #[serde(rename = "@type")]
+    pub kind: DomainType,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@id")]
+    pub id: Option<u64>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub name: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub uuid: Option<Uuid>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub title: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
+    pub os: DomainOs,
+    pub vcpu: u16,
+    pub memory: u64,
+    pub devices: DomainDevices,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "devices")]
+struct DomainDevices {
+    #[serde(rename = "$value")]
+    pub contents: Vec<DomainDevice>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainType {
+    #[default]
+    KVM,
+    XEN,
+    HVF,
+    QEMU,
+    LXC,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "os")]
+struct DomainOs {
+    #[serde(rename = "type")]
+    pub kind: DomainOsType,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@firmware")]
+    pub firmware: Option<DomainOsFirmware>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub loader: Option<DomainOsLoader>,
+    pub boot: DomainOsBoot,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainOsFirmware {
+    #[default]
+    EFI,
+    BIOS,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+struct DomainOsType {
+    #[serde(rename = "$text")]
+    pub kind: DomainOsTypeKind,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@arch")]
+    pub arch: Option<DomainOsArch>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@machine")]
+    pub machine: Option<DomainOsMachine>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainOsTypeKind {
+    #[default]
+    Hvm,
+    Xen,
+    Linux,
+    XenPvh,
+    Exe,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainOsMachine {
+    #[default]
+    Q35,
+    PC,
+}
+
+impl FromStr for DomainOsMachine {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "q35" => Ok(DomainOsMachine::Q35),
+            "pc" => Ok(DomainOsMachine::PC),
+            v => bail!("Unknown machine type {}", v),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainOsArch {
+    #[default]
+    X86_64,
+    I686,
+}
+
+impl FromStr for DomainOsArch {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "x86_64" => Ok(Self::X86_64),
+            "i686" => Ok(Self::I686),
+            v => bail!("unsupported arch {}", v),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "loader")]
+struct DomainOsLoader {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@readonly")]
+    pub read_only: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@type")]
+    pub kind: Option<DomainOsLoaderType>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@secure")]
+    pub secure: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@stateless")]
+    pub stateless: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@format")]
+    pub format: Option<DomainOsLoaderFormat>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainOsLoaderType {
+    #[default]
+    ROM,
+    PFlash,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainOsLoaderFormat {
+    Raw,
+    #[default]
+    QCow2,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+struct DomainOsBoot {
+    #[serde(rename = "@dev")]
+    pub dev: DomainOsBootDev,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DomainOsBootDev {
+    #[serde(rename = "fd")]
+    Floppy,
+    #[serde(rename = "hd")]
+    #[default]
+    HardDrive,
+    CdRom,
+    Network,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "vcpu")]
+struct DomainVCPU {
+    #[serde(rename = "$text")]
+    pub count: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+enum DomainDevice {
+    #[serde(rename = "disk")]
+    Disk(Disk),
+    #[serde(rename = "interface")]
+    Interface(NetworkInterface),
+    #[serde(other)]
+    Other,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "interface")]
+struct NetworkInterface {
+    #[serde(rename = "@type")]
+    pub kind: NetworkKind,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mac: Option<NetworkMac>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<NetworkSource>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<NetworkTarget>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub vlan: Option<NetworkVlan>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "vlan")]
+struct NetworkVlan {
+    #[serde(rename = "tag")]
+    pub tags: Vec<NetworkVlanTag>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "tag")]
+struct NetworkVlanTag {
+    #[serde(rename = "@id")]
+    pub id: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum NetworkKind {
+    Network,
+    #[default]
+    Bridge,
+    User,
+    Ethernet,
+    Direct,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename = "mac")]
+struct NetworkMac {
+    #[serde(rename = "@address")]
+    pub address: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename = "source")]
+struct NetworkSource {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@bridge")]
+    pub bridge: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename = "target")]
+struct NetworkTarget {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@dev")]
+    pub dev: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename = "disk")]
+struct Disk {
+    #[serde(rename = "@type")]
+    pub kind: DiskType,
+    #[serde(rename = "@device")]
+    pub device: DiskDevice,
+    pub source: DiskSource,
+    pub target: DiskTarget,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DiskType {
+    #[default]
+    File,
+    Block,
+    Dir,
+    Network,
+    Volume,
+    Nvme,
+    VHostUser,
+    VHostVdpa,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DiskDevice {
+    Floppy,
+    #[default]
+    Disk,
+    CdRom,
+    Lun,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "source")]
+struct DiskSource {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@file")]
+    pub file: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@dir")]
+    pub dir: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename = "target")]
+struct DiskTarget {
+    /// Device name (hint)
+    #[serde(rename = "@dev")]
+    pub dev: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "@bus")]
+    pub bus: Option<DiskBus>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Default, Clone)]
+#[serde(rename_all = "lowercase")]
+enum DiskBus {
+    #[default]
+    IDE,
+    SCSI,
+    VirtIO,
+    XEN,
+    USB,
+    SATA,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::host::tests::mock_full_vm;
+
+    fn cfg() -> FullVmInfo {
+        let mut cfg = mock_full_vm();
+        // adjust mock data for libvirt test driver
+        cfg.disk.name = "default-pool".to_string();
+
+        cfg
+    }
+
+    #[test]
+    fn test_xml_os() -> Result<()> {
+        let tag = "<os firmware=\"efi\"><type>hvm</type><boot dev=\"hd\"/></os>";
+
+        let test = DomainOs {
+            kind: DomainOsType {
+                kind: DomainOsTypeKind::Hvm,
+                arch: None,
+                machine: None,
+            },
+            firmware: Some(DomainOsFirmware::EFI),
+            loader: None,
+            boot: DomainOsBoot {
+                dev: DomainOsBootDev::HardDrive,
+            },
+        };
+
+        let xml = quick_xml::se::to_string(&test)?;
+        assert_eq!(tag, xml);
+        Ok(())
+    }
+
+    #[test]
+    fn text_xml_disk() -> Result<()> {
+        let tag = "<disk type=\"file\" device=\"disk\"><source file=\"/var/lib/libvirt/images/disk.qcow2\"/><target dev=\"vda\" bus=\"virtio\"/></disk>";
+
+        let test = Disk {
+            kind: DiskType::File,
+            device: DiskDevice::Disk,
+            source: DiskSource {
+                file: Some("/var/lib/libvirt/images/disk.qcow2".to_string()),
+                ..Default::default()
+            },
+            target: DiskTarget {
+                dev: "vda".to_string(),
+                bus: Some(DiskBus::VirtIO),
+            },
+        };
+        let xml = quick_xml::se::to_string(&test)?;
+        assert_eq!(tag, xml);
+        Ok(())
+    }
+
+    #[test]
+    fn text_config_to_domain() -> Result<()> {
+        let cfg = cfg();
+        let template = cfg.template.clone().unwrap();
+
+        let q_cfg = QemuConfig {
+            machine: "q35".to_string(),
+            os_type: "l26".to_string(),
+            bridge: "vmbr0".to_string(),
+            cpu: "kvm64".to_string(),
+            kvm: true,
+            arch: "x86_64".to_string(),
+        };
+        let host = LibVirtHost::new("test:///default", q_cfg)?;
+        let xml = host.create_domain_xml(&cfg)?;
+
+        let res = cfg.resources()?;
+        assert_eq!(xml.vcpu, res.cpu);
+        assert_eq!(xml.memory, res.memory);
+
+        let xml = quick_xml::se::to_string(&xml)?;
+        println!("{}", xml);
+
+        let output = r#"<domain type="kvm" id="1"><name>VM1</name><os firmware="efi"><type arch="x86_64" machine="q35">hvm</type><loader secure="true"/><boot dev="hd"/></os><vcpu>2</vcpu><memory>2147483648</memory><devices><disk type="file" device="disk"><source file="default-pool:vm-1-disk0"/><target dev="vda" bus="virtio"/></disk><interface type="bridge"><mac address="ff:ff:ff:ff:ff:fe"/><source bridge="vmbr0"/><vlan><tag id="100"/></vlan></interface></devices></domain>"#;
+        assert_eq!(xml, output);
+
+        Ok(())
+    }
+
+    #[ignore]
+    #[tokio::test]
+    async fn text_vm_lifecycle() -> Result<()> {
+        let cfg = cfg();
+        let template = cfg.template.clone().unwrap();
+
+        let q_cfg = QemuConfig {
+            machine: "q35".to_string(),
+            os_type: "l26".to_string(),
+            bridge: "vmbr0".to_string(),
+            cpu: "kvm64".to_string(),
+            kvm: true,
+            arch: "x86_64".to_string(),
+        };
+        let host = LibVirtHost::new("test:///default", q_cfg)?;
+        println!("{:?}", host.get_info().await?);
+        host.create_vm(&cfg).await?;
+
+        Ok(())
+    }
+}