hypervisor: extract some functions out of image module

Author: delan

monitor/hypervisor/src/impl_libvirt.rs

@@ -1,15 +1,19 @@
 use core::str;
 use std::{
-    fs::{create_dir_all, rename},
+    collections::BTreeSet,
+    fs::{create_dir_all, read_dir, rename},
     net::Ipv4Addr,
     path::Path,
+    time::Duration,
 };
 
-use cmd_lib::{run_fun, spawn_with_output};
-use jane_eyre::eyre;
-use settings::TOML;
+use cmd_lib::{run_cmd, run_fun, spawn_with_output};
+use jane_eyre::eyre::{self, OptionExt, bail};
+use settings::{TOML, profile::Profile};
 use shell::log_output_as_trace;
-use tracing::debug;
+use tracing::{debug, info};
+
+use crate::libvirt::{delete_template_or_rebuild_image_file, template_or_rebuild_images_path};
 
 pub fn list_template_guests() -> eyre::Result<Vec<String>> {
     // Output is not filtered by prefix, so we must filter it ourselves.
@@ -71,6 +75,66 @@ pub fn get_ipv4_address(guest_name: &str) -> Option<Ipv4Addr> {
         .or_else(|| virsh_domifaddr(guest_name, "agent"))
 }
 
+pub fn start_guest(guest_name: &str) -> eyre::Result<()> {
+    info!(?guest_name, "Starting guest");
+    run_cmd!(virsh start -- $guest_name)?;
+
+    Ok(())
+}
+
+pub fn wait_for_guest(guest_name: &str, timeout: Duration) -> eyre::Result<()> {
+    let timeout = timeout.as_secs();
+    info!("Waiting for guest to shut down (max {timeout} seconds)");
+    if !run_cmd!(time virsh event --timeout $timeout -- $guest_name lifecycle).is_ok() {
+        bail!("`virsh event` failed or timed out!");
+    }
+    for _ in 0..100 {
+        if run_fun!(virsh domstate -- $guest_name)?.trim_ascii() == "shut off" {
+            return Ok(());
+        }
+    }
+
+    bail!("Guest did not shut down as expected")
+}
+
+pub fn rename_guest(old_guest_name: &str, new_guest_name: &str) -> eyre::Result<()> {
+    run_cmd!(virsh domrename -- $old_guest_name $new_guest_name)?;
+    Ok(())
+}
+
+pub fn delete_guest(guest_name: &str) -> eyre::Result<()> {
+    if run_cmd!(virsh domstate -- $guest_name).is_ok() {
+        // FIXME make this idempotent in a less noisy way?
+        let _ = run_cmd!(virsh destroy -- $guest_name);
+        run_cmd!(virsh undefine --nvram -- $guest_name)?;
+    }
+
+    Ok(())
+}
+
+pub fn prune_base_image_files(
+    profile: &Profile,
+    keep_snapshots: BTreeSet<String>,
+) -> eyre::Result<()> {
+    let base_images_path = template_or_rebuild_images_path(profile);
+    info!(?base_images_path, "Pruning base image files");
+    create_dir_all(&base_images_path)?;
+
+    for entry in read_dir(&base_images_path)? {
+        let filename = entry?.file_name();
+        let filename = filename.to_str().ok_or_eyre("Unsupported path")?;
+        if let Some((_base, snapshot_name)) = filename.split_once("@") {
+            if !keep_snapshots.contains(snapshot_name) {
+                delete_template_or_rebuild_image_file(profile, filename);
+            }
+        } else {
+            delete_template_or_rebuild_image_file(profile, filename);
+        }
+    }
+
+    Ok(())
+}
+
 fn virsh_domifaddr(guest_name: &str, source: &str) -> Option<Ipv4Addr> {
     let output = run_fun!(virsh domifaddr --source $source $guest_name 2> /dev/null);
     match output {

monitor/hypervisor/src/lib.rs

@@ -1,9 +1,12 @@
+pub mod libvirt;
+
 #[cfg_attr(target_os = "linux", path = "impl_libvirt.rs")]
 mod platform;
 
-use std::{net::Ipv4Addr, path::Path};
+use std::{collections::BTreeSet, net::Ipv4Addr, path::Path, time::Duration};
 
 use jane_eyre::eyre;
+use settings::profile::Profile;
 
 pub fn list_template_guests() -> eyre::Result<Vec<String>> {
     self::platform::list_template_guests()
@@ -28,3 +31,26 @@ pub fn take_screenshot(guest_name: &str, output_path: &Path) -> eyre::Result<()>
 pub fn get_ipv4_address(guest_name: &str) -> Option<Ipv4Addr> {
     self::platform::get_ipv4_address(guest_name)
 }
+
+pub fn start_guest(guest_name: &str) -> eyre::Result<()> {
+    self::platform::start_guest(guest_name)
+}
+
+pub fn wait_for_guest(guest_name: &str, timeout: Duration) -> eyre::Result<()> {
+    self::platform::wait_for_guest(guest_name, timeout)
+}
+
+pub fn rename_guest(old_guest_name: &str, new_guest_name: &str) -> eyre::Result<()> {
+    self::platform::rename_guest(old_guest_name, new_guest_name)
+}
+
+pub fn delete_guest(guest_name: &str) -> eyre::Result<()> {
+    self::platform::delete_guest(guest_name)
+}
+
+pub fn prune_base_image_files(
+    profile: &Profile,
+    keep_snapshots: BTreeSet<String>,
+) -> eyre::Result<()> {
+    self::platform::prune_base_image_files(profile, keep_snapshots)
+}

monitor/hypervisor/src/libvirt.rs

@@ -0,0 +1,79 @@
+use std::{
+    ffi::OsStr,
+    fs::{create_dir_all, remove_file},
+    path::{Path, PathBuf},
+};
+
+use cmd_lib::run_cmd;
+use jane_eyre::eyre;
+use settings::profile::Profile;
+use tracing::{debug, info, warn};
+
+pub fn template_or_rebuild_images_path(profile: &Profile) -> PathBuf {
+    Path::new("/var/lib/libvirt/images/base").join(&profile.profile_name)
+}
+
+pub fn runner_images_path() -> PathBuf {
+    PathBuf::from("/var/lib/libvirt/images/runner")
+}
+
+pub fn delete_template_or_rebuild_image_file(profile: &Profile, filename: &str) {
+    let base_images_path = template_or_rebuild_images_path(profile);
+    let path = base_images_path.join(filename);
+    info!(?path, "Deleting");
+    if let Err(error) = remove_file(&path) {
+        warn!(?path, ?error, "Failed to delete");
+    }
+}
+
+pub fn create_template_or_rebuild_images_dir(profile: &Profile) -> eyre::Result<PathBuf> {
+    let base_images_path = template_or_rebuild_images_path(profile);
+    debug!(?base_images_path, "Creating base images subdirectory");
+    create_dir_all(&base_images_path)?;
+
+    Ok(base_images_path)
+}
+
+pub fn create_runner_images_dir() -> eyre::Result<PathBuf> {
+    let runner_images_path = runner_images_path();
+    debug!(?runner_images_path, "Creating runner images directory");
+    create_dir_all(&runner_images_path)?;
+
+    Ok(runner_images_path)
+}
+
+pub fn define_libvirt_guest(
+    profile_name: &str,
+    guest_name: &str,
+    guest_xml_path: impl AsRef<Path>,
+    args: &[&dyn AsRef<OsStr>],
+    cdrom_images: &[CdromImage],
+) -> eyre::Result<()> {
+    // This dance is needed to randomise the MAC address of the guest.
+    let guest_xml_path = guest_xml_path.as_ref();
+    let args = args.iter().map(|x| x.as_ref()).collect::<Vec<_>>();
+    run_cmd!(virsh define -- $guest_xml_path)?;
+    run_cmd!(virt-clone --preserve-data --check path_in_use=off -o $profile_name.init -n $guest_name $[args])?;
+    libvirt_change_media(guest_name, cdrom_images)?;
+    run_cmd!(virsh undefine -- $profile_name.init)?;
+
+    Ok(())
+}
+
+pub fn libvirt_change_media(guest_name: &str, cdrom_images: &[CdromImage]) -> eyre::Result<()> {
+    for CdromImage { target_dev, path } in cdrom_images {
+        run_cmd!(virsh change-media -- $guest_name $target_dev $path)?;
+    }
+
+    Ok(())
+}
+
+pub struct CdromImage<'path> {
+    pub target_dev: &'static str,
+    pub path: &'path str,
+}
+impl<'path> CdromImage<'path> {
+    pub fn new(target_dev: &'static str, path: &'path str) -> Self {
+        Self { target_dev, path }
+    }
+}