cloud-hypervisor-command-builder 0.38.0-beta.2

Type safe command line builder for cloud-hypervisor
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

use bytesize::ByteSize;
use std::path::PathBuf;

use cloud_hypervisor_command_builder::to_command::ToCommand;
use cloud_hypervisor_command_builder::{
    BalloonBuilder, CloudHypervisorInstance, Console, CpusBuilder, DebugConsole, DeviceBuilder,
    DiskBuilder, FsBuilder, MemoryBuilder, MemoryHotplugMethod, OnOff, PathOrFileDescriptorOption,
    PlatformBuilder, Rng, SecComp, Serial, SgxEpc, UserDeviceBuilder, VdpaBuilder, Vsock,
};

#[test]
fn full_command_line() {
    let mut ch = CloudHypervisorInstance::new(PathBuf::from("/cloud-hypervisor"));

    let cpus = CpusBuilder::default().build().unwrap();
    ch.cpus(cpus);

    let platform = PlatformBuilder::default()
        .num_pci_segments(10)
        .iommu_segments(8)
        .serial_number("some_serial")
        .uuid("uuid")
        .oem_strings(vec!["oem_string".to_string()])
        .build()
        .unwrap();
    ch.platform(platform);

    ch.memory(
        MemoryBuilder::default()
            .size(ByteSize::gb(4))
            .mergeable(OnOff::On)
            .shared(OnOff::Off)
            .hugepages(OnOff::On)
            .hugepage_size(ByteSize::mb(2))
            .hotplug_method(MemoryHotplugMethod::VirtioMem)
            .hotplug_size(ByteSize::mb(64))
            .hotplugged_size(ByteSize::mb(24))
            .prefault(OnOff::Off)
            .thp(OnOff::On)
            .build()
            .unwrap(),
    );

    ch.firmware(PathBuf::from("/firmware"));
    ch.kernel(PathBuf::from("/kernel"));
    ch.initramfs(PathBuf::from("/initramfs"));
    ch.cmdline("--whatever".to_string());

    let disk0 = DiskBuilder::default()
        .path(PathBuf::from("/dev/disk0"))
        .build()
        .unwrap();
    ch.disk(disk0);
    let disk1 = DiskBuilder::default()
        .path(PathBuf::from("/dev/disk1"))
        .id("1")
        .build()
        .unwrap();
    ch.disk(disk1);

    ch.rng(Rng::Src(PathBuf::from("/dev/urandom")));

    ch.balloon(
        BalloonBuilder::default()
            .size(ByteSize::mb(100))
            .deflate_on_oom(OnOff::On)
            .free_page_reporting(OnOff::Off)
            .build()
            .unwrap(),
    );

    ch.fs(FsBuilder::default().build().unwrap());
    ch.serial(Serial::Null);
    ch.console(Console::Pty);

    ch.device(
        DeviceBuilder::default()
            .path(PathBuf::from("/dev/something"))
            .iommu(OnOff::Off)
            .id("dev_id_1".to_string())
            .pci_segment("pci1".to_string())
            .build()
            .unwrap(),
    );

    ch.user_device(UserDeviceBuilder::default().build().unwrap());

    ch.pvpanic(true);

    ch.watchdog(true);

    ch.log_file(PathBuf::from("/ch.log"));
    ch.api_socket(PathOrFileDescriptorOption::Path(PathBuf::from(
        "/api.socket",
    )));
    ch.event_monitor(PathOrFileDescriptorOption::Fd(3));

    ch.seccomp(SecComp::Log);

    ch.tpm(PathBuf::from("/tpm"));

    ch.vsock(Vsock {
        cid: None,
        socket: Some(PathBuf::from("/dev/vsock")),
        iommu: None,
        id: None,
        pci_segment: None,
    });

    ch.vdpa(
        VdpaBuilder::default()
            .path(PathBuf::from("/dev/vdpa1"))
            .num_queues(1usize)
            .iommu(OnOff::On)
            .id("id1")
            .pci_segment("01")
            .build()
            .unwrap(),
    );

    ch.vdpa(
        VdpaBuilder::default()
            .path(PathBuf::from("/dev/vdpa2"))
            .build()
            .unwrap(),
    );

    ch.sgx_epc(SgxEpc {
        id: None,
        size: None,
        prefault: None,
    });

    ch.debug_console(DebugConsole {
        console_type: None,
        iobase: None,
    });

    ch.v();
    ch.v();

    let expected = [
        "/cloud-hypervisor",
        "--platform", "num_pci_segments=10,iommu_segments=8,serial_number=some_serial,uuid=uuid,oem_strings=[oem_string]",
        "--memory", "size=4000000000,mergeable=on,shared=off,hugepages=on,hugepage_size=2000000,hotplug_method=virtio-mem,hotplug_size=64000000,hotplugged_size=24000000,prefault=off,thp=on",
        "--firmware", "/firmware",
        "--kernel", "/kernel",
        "--initramfs", "/initramfs",
        "--cmdline", "--whatever",
        "--disk", "path=/dev/disk0", "path=/dev/disk1,id=1",
        "--rng", "src=/dev/urandom",
        "--balloon", "size=100000000,deflate_on_oom=on,free_page_reporting=off",
        "--serial", "null",
        "--console", "pty",
        "--device", "path=/dev/something,iommu=off,id=dev_id_1,pci_segment=pci1",
        "--vsock", "socket=/dev/vsock",
        "--vdpa", "path=/dev/vdpa1,num_queues=1,iommu=on,id=id1,pci_segment=01", "path=/dev/vdpa2",
        "--pvpanic",
        "--watchdog",
        "--log-file", "/ch.log",
        "--api-socket", "path=/api.socket",
        "--event-monitor", "fd=3",
        "--seccomp", "log",
        "--tpm", "/tpm",
        "-v", "-v",
    ];

    assert_eq!(ch.to_command(), expected);
    assert_eq!(ch.to_single_command(), expected.join(" "));
}