rustcracker 1.1.1+deprecated

A crate for communicating with firecracker for the development of PKU-cloud.
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

use rustcracker::{
    config::{HypervisorConfig, JailerConfig, MicroVMConfig},
    models::*,
};
use std::{env, sync::LazyLock};

#[allow(unused)]
const JAILER_CONFIG: LazyLock<JailerConfig> = LazyLock::new(|| JailerConfig {
    gid: env::var("JAILER_GID").ok().and_then(|s| s.parse().ok()),
    uid: env::var("JAILER_UID").ok().and_then(|s| s.parse().ok()),
    numa_node: None,
    exec_file: env::var("FRCK_BIN").ok(),
    jailer_bin: env::var("JAILER_BIN").ok(),
    chroot_base_dir: env::var("CHROOT_BASE_DIR").ok(),
    daemonize: Some(false),
});

#[allow(unused)]
const HYPERVISOR_NOJAILER_CONFIG: LazyLock<HypervisorConfig> = LazyLock::new(|| {
    HypervisorConfig {
        id: env::var("ID")
            .ok()
            .and_then(|s| Some(s + &uuid::Uuid::new_v4().to_string())),
        poll_status_secs: 20,
        launch_timeout: 5,
        using_jailer: Some(false),
        frck_bin: env::var("FRCK_BIN").ok(),
        jailer_bin: env::var("JAILER_BIN").ok(),
        jailer_config: None,
        frck_export_path: env::var("FRCK_EXPORT_PATH").ok(),
        socket_path: env::var("SOCKET_PATH").ok(),
        socket_retry: env::var("SOCKET_RETRY")
            .unwrap_or("3".to_string())
            .parse()
            .unwrap(),
        lock_path: env::var("LOCK_PATH").ok(),
        log_path: env::var("LOG_PATH").ok(),
        log_clear: Some(false),
        metrics_path: env::var("METRICS_PATH").ok(),
        metrics_clear: Some(false),
        network_clear: None,
        seccomp_level: None,
        // stdout_to: env::var("STDOUT_TO").ok(),
        // stderr_to: env::var("STDERR_TO").ok(),
        clear_jailer: env::var("CLEAR_JAILER")
            .ok()
            .and_then(|s| s.to_lowercase().parse().ok()),
    }
});

#[allow(unused)]
const HYPERVISOR_WITHJAILER_CONFIG: LazyLock<HypervisorConfig> =
    LazyLock::new(|| HypervisorConfig {
        id: env::var("ID")
            .ok()
            .and_then(|s| Some(s + &uuid::Uuid::new_v4().to_string())),
        poll_status_secs: 20,
        launch_timeout: 5,
        using_jailer: Some(true),
        frck_bin: env::var("FRCK_BIN").ok(),
        jailer_bin: env::var("JAILER_BIN").ok(),
        jailer_config: Some(JAILER_CONFIG.clone()),
        frck_export_path: env::var("FRCK_EXPORT_PATH").ok(),
        socket_path: env::var("SOCKET_PATH").ok(),
        socket_retry: env::var("SOCKET_RETRY")
            .unwrap_or("3".to_string())
            .parse()
            .unwrap(),
        lock_path: env::var("LOCK_PATH").ok(),
        log_path: env::var("LOG_PATH").ok(),
        log_clear: Some(false),
        metrics_path: env::var("METRICS_PATH").ok(),
        metrics_clear: Some(false),
        network_clear: None,
        seccomp_level: None,
        clear_jailer: env::var("CLEAR_JAILER")
            .ok()
            .and_then(|s| s.to_lowercase().parse().ok()),
    });

#[allow(unused)]
const BOOT_SOURCE: LazyLock<BootSource> = LazyLock::new(|| BootSource {
    boot_args: Some("console=ttyS0 reboot=k panic=1 pci=off".to_string()),
    initrd_path: None,
    kernel_image_path: env::var("KERNEL_IMAGE_PATH").expect("kernel image path not found"),
});

#[allow(unused)]
const ROOTFS: LazyLock<Drive> = LazyLock::new(|| Drive {
    drive_id: "rootfs".to_string(),
    partuuid: None,
    is_root_device: true,
    cache_type: None,
    is_read_only: false,
    path_on_host: env::var("ROOTFS_PATH").expect("must set rootfs"),
    rate_limiter: None,
    io_engine: None,
    socket: None,
});

#[allow(unused)]
const MICROVM_CONFIG: LazyLock<MicroVMConfig> = LazyLock::new(|| MicroVMConfig {
    logger: Some(Logger {
        level: None,
        log_path: "firecracker.log".to_string(),
        show_level: None,
        show_log_origin: None,
        module: None,
    }),
    metrics: None,
    boot_source: Some(BOOT_SOURCE.clone()),
    drives: Some(vec![ROOTFS.clone()]),
    network_interfaces: Some(vec![NetworkInterface {
        iface_id: "eth0".to_string(),
        guest_mac: None,
        host_dev_name: "tap0".to_string(),
        rx_rate_limiter: None,
        tx_rate_limiter: None,
    }]),
    vsock_devices: None,
    cpu_config: None,
    machine_config: Some(MachineConfiguration {
        cpu_template: None,
        ht_enabled: Some(false),
        mem_size_mib: 256,
        track_dirty_pages: None,
        vcpu_count: 4,
        huge_pages: None,
    }),
    vmid: Some("1234qwer".to_string()),
    net_ns: None,
    mmds_config: None,
    balloon: Some(Balloon {
        amount_mib: 64,
        deflate_on_oom: true,
        stats_polling_interval_s: None,
    }),
    entropy_device: None,
    init_metadata: Some("Hello there!".to_string()),
});