hvctrl 0.1.0

A hypervisor controller library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// Copyright takubokudori.
// This source code is licensed under the MIT or Apache-2.0 license.
#![allow(dead_code)]
use hvctrl::{types::*, vmerr};
use std::time::Duration;

pub fn test_vm(cmd: &mut impl VmCmd) {
    cmd.list_vms().unwrap();
    let x = cmd.set_vm_by_name("hvctrlDoesNotExistVmName");
    if x != vmerr!(ErrorKind::VmNotFound)
        && x != vmerr!(ErrorKind::UnsupportedCommand)
    {
        panic!("Unexpected response: {:?}", x);
    }
    let x = cmd.set_vm_by_path(r"C:\hvctrl\does\not\exist\vm.vmx");
    if x != vmerr!(ErrorKind::VmNotFound)
        && x != vmerr!(ErrorKind::UnsupportedCommand)
    {
        panic!("Unexpected response: {:?}", x);
    }
    let x = cmd.set_vm_by_id("0HVCTRL1DOES2NOT3EXIST4VM5ID4649");
    if x != vmerr!(ErrorKind::VmNotFound)
        && x != vmerr!(ErrorKind::UnsupportedCommand)
    {
        panic!("Unexpected response: {:?}", x);
    }
}

fn is_invalid_state_running<T>(x: VmResult<T>) -> bool {
    match x {
        Ok(_) => panic!("The function succeeded unexpectedly"),
        Err(x) => match x.is_invalid_state_running() {
            Some(x) => x,
            None => panic!("Unexpected error: {}", x.to_string()),
        },
    }
}

fn assert_ok_stop(cmd: &impl PowerCmd, timeout: Duration) {
    let status = cmd.stop(timeout);
    if status == Ok(()) {
        assert_eq!(Ok(false), cmd.is_running());
    } else if status == vmerr!(ErrorKind::Timeout) {
        assert_eq!(Ok(true), cmd.is_running());
    } else if let Err(x) = status {
        panic!("Unexpected error: {}", x.to_string());
    }
}

fn assert_ok_reboot(cmd: &impl PowerCmd, timeout: Duration) {
    let status = cmd.reboot(timeout);
    if status == Ok(()) {
        assert_eq!(Ok(true), cmd.is_running());
    } else if status == vmerr!(ErrorKind::Timeout) {
        assert_eq!(Ok(true), cmd.is_running());
    } else if let Err(x) = status {
        panic!("Unexpected error: {}", x.to_string());
    }
}

/// At first, make sure that a VM is not running.
pub fn test_power(cmd: &impl PowerCmd) {
    let timeout = Duration::from_secs(3);
    assert_eq!(Ok(false), cmd.is_running());
    assert!(!is_invalid_state_running(cmd.hard_stop()));
    assert!(!is_invalid_state_running(cmd.stop(timeout)));
    assert!(!is_invalid_state_running(cmd.hard_reboot()));
    assert!(!is_invalid_state_running(cmd.reboot(timeout)));

    assert_eq!(Ok(()), cmd.start());
    assert!(is_invalid_state_running(cmd.start()));
    assert_eq!(Ok(true), cmd.is_running());
    assert!(is_invalid_state_running(cmd.start()));
    assert_eq!(Ok(()), cmd.suspend());
    assert_eq!(Ok(false), cmd.is_running());
    assert!(!is_invalid_state_running(cmd.suspend()));
    assert_eq!(Ok(()), cmd.resume());
    assert_eq!(Ok(true), cmd.is_running());
    assert!(is_invalid_state_running(cmd.resume()));
    assert_eq!(Ok(()), cmd.hard_stop());
    assert_eq!(Ok(false), cmd.is_running());

    assert_eq!(Ok(()), cmd.start());
    assert_eq!(Ok(true), cmd.is_running());
    assert_ok_reboot(cmd, timeout);
    let _ = cmd.hard_stop();
    assert_eq!(Ok(false), cmd.is_running());
    assert_eq!(Ok(()), cmd.start());
    assert_eq!(Ok(true), cmd.is_running());
    assert_ok_stop(cmd, timeout);
    let _ = cmd.hard_stop();
    assert_eq!(Ok(false), cmd.is_running());
}

/// At first, make sure that the snapshot named `hvctrl_test_snapshot` does not exist.
pub fn test_snapshot_cmd<T: SnapshotCmd>(cmd: &T) {
    const SN_NAME: &str = "hvctrl_test_snapshot";
    fn is_snapshot_exists(v: &[Snapshot], name: &str) -> bool {
        v.iter()
            .any(|x| x.name.as_ref().map_or(false, |n| n == name))
    }
    let v = cmd
        .list_snapshots()
        .expect("Failed to get the list of snapshots");
    // check the snapshot doesn't exist.
    assert!(!is_snapshot_exists(&v, SN_NAME));
    assert_eq!(
        vmerr!(ErrorKind::SnapshotNotFound),
        cmd.delete_snapshot(SN_NAME)
    );
    assert_eq!(
        vmerr!(ErrorKind::SnapshotNotFound),
        cmd.revert_snapshot(SN_NAME)
    );

    // take a snapshot and check `revert` and `delete`.
    assert_eq!(Ok(()), cmd.take_snapshot(SN_NAME));
    assert_eq!(Ok(()), cmd.revert_snapshot(SN_NAME));
    assert_eq!(Ok(()), cmd.delete_snapshot(SN_NAME));
    assert_eq!(
        vmerr!(ErrorKind::SnapshotNotFound),
        cmd.delete_snapshot(SN_NAME)
    );
    assert_eq!(
        vmerr!(ErrorKind::SnapshotNotFound),
        cmd.revert_snapshot(SN_NAME)
    );
}