firepilot 1.2.0

Interface to work with Firecracker microVMs
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

use std::path::PathBuf;

use crate::builder::{assert_not_none, Builder, BuilderError};
use firepilot_models::models::Drive;

#[derive(Debug)]
pub struct DriveBuilder {
    pub drive_id: Option<String>,
    pub path_on_host: Option<PathBuf>,
    pub is_root_device: bool,
    pub is_read_only: bool,
}

impl DriveBuilder {
    pub fn new() -> DriveBuilder {
        DriveBuilder {
            drive_id: None,
            path_on_host: None,
            is_root_device: false,
            is_read_only: false,
        }
    }

    pub fn with_drive_id(mut self, drive_id: String) -> DriveBuilder {
        self.drive_id = Some(drive_id);
        self
    }

    pub fn with_path_on_host(mut self, path_on_host: PathBuf) -> DriveBuilder {
        self.path_on_host = Some(path_on_host);
        self
    }

    pub fn as_root_device(mut self) -> DriveBuilder {
        self.is_root_device = true;
        self
    }

    pub fn as_read_only(mut self) -> DriveBuilder {
        self.is_read_only = true;
        self
    }
}

impl Builder<Drive> for DriveBuilder {
    fn try_build(self) -> Result<Drive, BuilderError> {
        assert_not_none(stringify!(self.drive_id), &self.drive_id)?;
        assert_not_none(stringify!(self.path_on_host), &self.path_on_host)?;
        Ok(Drive {
            drive_id: self.drive_id.unwrap(),
            // FIXME: This is a hack to convert PathBuf to String
            path_on_host: self
                .path_on_host
                .unwrap()
                .into_os_string()
                .into_string()
                .unwrap(),
            is_root_device: self.is_root_device,
            is_read_only: self.is_read_only,
            cache_type: None,
            partuuid: None,
            rate_limiter: None,
            io_engine: None,
        })
    }
}

#[cfg(test)]
mod tests {
    use crate::builder::{Builder, BuilderError};

    #[test]
    fn drive_full() {
        let drive = crate::builder::drive::DriveBuilder::new()
            .with_drive_id("rootfs".to_string())
            .with_path_on_host("/path/to/rootfs".into())
            .as_root_device()
            .as_read_only()
            .try_build();
        assert_eq!(drive.is_ok(), true);
    }

    #[test]
    fn drive_incomplete_path_host() {
        let drive = crate::builder::drive::DriveBuilder::new()
            .with_drive_id("rootfs".to_string())
            .try_build();
        assert_eq!(drive.is_err(), true);
        assert_eq!(
            drive.err().unwrap(),
            BuilderError::MissingRequiredField(stringify!(self.path_on_host).to_string())
        );
    }

    #[test]
    fn drive_incomplete_drive_id() {
        let drive = crate::builder::drive::DriveBuilder::new()
            .with_path_on_host("/path/to/rootfs".into())
            .try_build();
        assert_eq!(drive.is_err(), true);
        assert_eq!(
            drive.err().unwrap(),
            BuilderError::MissingRequiredField(stringify!(self.drive_id).to_string())
        );
    }
}