virtx 0.1.2

Run tasks in disposable Linux VMs from your own code, with a filesystem you compose.
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

//! The name a method goes by on the wire, shared by [`Call`](super::Call),
//! [`Notification`](super::Notification) and [`Response`](super::Response).

use std::fmt;

use serde::{Deserialize, Serialize};

/// Which method a request called, and its response answers.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Method {
    Version,
    BuildImage,
    RemoveImage,
    ListImages,
    Init,
    Exec,
    Read,
    Write,
    Snapshot,
    Start,
    Stop,
    Quit,
}

impl Method {
    /// The name as it appears in a `method` member.
    pub fn as_str(&self) -> &'static str {
        match self {
            Method::Version => "version",
            Method::BuildImage => "build_image",
            Method::RemoveImage => "remove_image",
            Method::ListImages => "list_images",
            Method::Snapshot => "snapshot",
            Method::Init => "init",
            Method::Exec => "exec",
            Method::Read => "read",
            Method::Write => "write",
            Method::Start => "start",
            Method::Stop => "stop",
            Method::Quit => "quit",
        }
    }

    /// Whether nothing answers this method.
    ///
    /// A property of the method, not the message.
    pub fn is_notification(&self) -> bool {
        matches!(self, Method::Start | Method::Stop | Method::Quit)
    }

    pub fn parse(name: &str) -> Option<Method> {
        Some(match name {
            "version" => Method::Version,
            "build_image" => Method::BuildImage,
            "remove_image" => Method::RemoveImage,
            "list_images" => Method::ListImages,
            "snapshot" => Method::Snapshot,
            "init" => Method::Init,
            "exec" => Method::Exec,
            "read" => Method::Read,
            "write" => Method::Write,
            "start" => Method::Start,
            "stop" => Method::Stop,
            "quit" => Method::Quit,
            _ => return None,
        })
    }
}

impl fmt::Display for Method {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(self.as_str())
    }
}