supermachine 0.7.105

Run any OCI/Docker image as a hardware-isolated microVM on macOS HVF (Linux KVM and Windows WHP in progress). Single library API, zero flags for the common case, sub-100 ms cold-restore from snapshot.
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

#[cfg(any(
    all(target_os = "linux", target_arch = "x86_64"),
    all(target_os = "macos", target_arch = "aarch64")
))]
mod supported {
    //! Debug: try several timeout variants to see which actually
    //! short-circuit. NOT a polished example — just diagnosis.
    //!
    //! Run with `SUPERMACHINE_TIMEOUT_TRACE=1` to see watchdog fires.

    use std::time::Duration;

    use supermachine::{Image, VmConfig};

    fn variant(vm: &supermachine::Vm, label: &str, argv: &[&str]) {
        let argv_owned: Vec<String> = argv.iter().map(|s| s.to_string()).collect();
        let out = vm
            .exec_builder()
            .argv(argv_owned)
            .timeout(Duration::from_millis(500))
            .output();
        match out {
            Ok(o) => println!(
                "  {label:30} timed_out={} duration={:?} status={:?}",
                o.timed_out,
                o.duration,
                o.status.code()
            ),
            Err(e) => println!("  {label:30} ERR {e}"),
        }
    }

    pub(super) fn main() -> Result<(), Box<dyn std::error::Error>> {
        let snap = format!(
            "{}/.local/supermachine-snapshots/nginx_1_27-alpine",
            std::env::var("HOME").unwrap()
        );
        let image = Image::from_snapshot(&snap)?;
        let vm = image.start(&VmConfig::new())?;

        println!("=== timeout 500ms variants ===");
        // 1. Direct sleep — agent's pid_for_signal IS sleep's pid.
        variant(&vm, "sleep direct", &["sleep", "10"]);
        // 2. sh -c "sleep" — pid is sh, sh's child is sleep.
        variant(&vm, "sh -c sleep", &["sh", "-c", "sleep 10"]);
        // 3. sh -c sleep + post-print — same shape but provokes
        //    completion-after-kill.
        variant(
            &vm,
            "sh -c sleep+echo",
            &["sh", "-c", "sleep 10; echo never"],
        );
        // 4. Busy loop — no syscall to interrupt.
        variant(
            &vm,
            "busy loop",
            &[
                "sh",
                "-c",
                "i=0; while [ $i -lt 1000000000 ]; do i=$((i+1)); done; echo done",
            ],
        );
        // 5. tight read — should be SIGKILL'able.
        variant(
            &vm,
            "cat /dev/zero >/dev/null",
            &["sh", "-c", "cat /dev/zero > /dev/null"],
        );

        vm.stop()?;
        Ok(())
    }
}

#[cfg(any(
    all(target_os = "linux", target_arch = "x86_64"),
    all(target_os = "macos", target_arch = "aarch64")
))]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    supported::main()
}

#[cfg(not(any(
    all(target_os = "linux", target_arch = "x86_64"),
    all(target_os = "macos", target_arch = "aarch64")
)))]
fn main() -> Result<(), Box<dyn std::error::Error>> {
    eprintln!("this example requires a linux-x86_64 (KVM) or macos-aarch64 (HVF) host; unsupported on this platform");
    Ok(())
}