supermachine 0.7.108

#[cfg(any(
    all(target_os = "linux", target_arch = "x86_64"),
    all(target_os = "macos", target_arch = "aarch64")
))]
mod supported {
    //! Restore from a self-contained snapshot bundle dir.
    //!
    //! Pair with `supermachine bundle --into DIR --image NAME`:
    //!
    //! ```sh
    //! supermachine bundle --into /tmp/my-bundles --image nginx:1.27-alpine
    //! cargo supermachine build --release --example bundle_load
    //! target/release/examples/bundle_load /tmp/my-bundles/nginx_1_27-alpine
    //! ```
    //!
    //! The point: the bundle dir is self-contained — kernel, snapshot,
    //! layers, all relative paths inside it. An embedder ships this
    //! inside `MyApp.app/Contents/Resources/<name>/` and calls
    //! `Image::from_snapshot` against it. No supermachine install on
    //! the end-user's machine.
    //!
    //! This example doesn't need `cargo install supermachine` to run
    //! the bundle — it just needs the bundle dir.

    use std::io::{Read, Write};
    use std::time::Instant;

    use supermachine::{Image, Vm, VmConfig};

    pub(super) fn main() -> Result<(), Box<dyn std::error::Error>> {
        let bundle_dir = std::env::args()
            .nth(1)
            .ok_or("usage: bundle_load <BUNDLE_DIR>")?;

        let t0 = Instant::now();
        let image = Image::from_snapshot(&bundle_dir)?;
        eprintln!("loaded {bundle_dir} in {:?}", t0.elapsed());
        eprintln!(
            "  memory={} MiB  vcpus={}  layers={}",
            image.memory_mib(),
            image.vcpus(),
            image.snapshot_path().display(),
        );

        let t1 = Instant::now();
        let vm = Vm::start(&image, &VmConfig::new())?;
        eprintln!("vm started in {:?}", t1.elapsed());

        let mut sock = vm.connect()?;
        sock.write_all(b"GET / HTTP/1.1\r\nHost: workload\r\nConnection: close\r\n\r\n")?;
        let mut response = Vec::new();
        sock.read_to_end(&mut response)?;
        let preview = String::from_utf8_lossy(&response);
        for line in preview.lines().take(4) {
            eprintln!("  {line}");
        }

        vm.stop()?;
        eprintln!("done in {:?}", t0.elapsed());
        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(())
}