microsandbox 0.7.4

`microsandbox` is the core library for the microsandbox project.
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

#[test]
fn creation_futures_remain_small_for_concurrent_callers() {
    let future = microsandbox::Sandbox::builder("stack-probe").create();
    let detached = microsandbox::Sandbox::builder("stack-probe").create_detached();
    for bytes in [
        std::mem::size_of_val(&future),
        std::mem::size_of_val(&detached),
    ] {
        assert!(
            bytes < 16 * 1024,
            "create state must not inflate every caller's async stack: {bytes} bytes"
        );
    }
}

#[test]
#[cfg(feature = "local")]
fn rust_root_compat_exports_stay_available() {
    // Compile-time tripwire for public root exports restored after the
    // backend-routing refactor. The function items are not invoked.
    let _ = microsandbox::Image::get;
    let _ = microsandbox::Image::list;
    let _ = microsandbox::Image::inspect;
    let _ = microsandbox::Image::remove;
    let _ = microsandbox::Image::prune;
    let _ = microsandbox::all_sandbox_metrics;

    let _: Option<microsandbox::ImagePruneReport> = None;
    let _: Option<microsandbox::SandboxMetrics> = None;
}

#[test]
#[cfg(feature = "local")]
fn rust_config_and_runtime_setup_surface_stays_available() {
    let _ = microsandbox::setup::resolve_runtime;
    let _ = microsandbox::setup::install_runtime;
    let _ = microsandbox::setup::ensure_runtime;
    let _: Option<microsandbox::setup::ResolvedRuntime> = None;
    let _: Option<microsandbox::setup::InstallOptions> = None;
    let _ = microsandbox::config::config;
    let _ = microsandbox::config::resolve_msb_path;
    let _ = microsandbox::config::resolve_libkrunfw_path;
    let _ = microsandbox::config::GlobalConfig::resolve_msb_path;
    let _ = microsandbox::config::GlobalConfig::resolve_libkrunfw_path;

    #[allow(deprecated)]
    let _: Option<microsandbox::config::LocalConfig> = None;
}

#[cfg(feature = "ssh")]
#[test]
fn rust_ssh_compat_export_stays_available() {
    let _: Option<microsandbox::SandboxSshOps> = None;
}

#[test]
fn rust_identity_and_generated_patch_surface_is_backend_neutral() {
    use microsandbox::sandbox::{DestroyOptions, RestartOptions, SandboxHandle, SandboxId};

    let _: Option<SandboxId> = None;
    let _ = SandboxHandle::id;
    let _ = SandboxHandle::connect_or_start;
    let _ = SandboxHandle::wait_for_status;
    let _ = SandboxHandle::restart;
    let _ = SandboxHandle::destroy;
    let _ = (RestartOptions::default(), DestroyOptions::default());
    let _ = microsandbox::SandboxConfigPatch::new().spec(
        microsandbox::SandboxSpecPatch::new()
            .resources(microsandbox::SandboxResourcesPatch::new().cpus(2)),
    );
}

#[allow(dead_code)]
async fn rust_sandbox_fs_handle_api_stays_available(
    fs: &microsandbox::sandbox::SandboxFsOps<'_>,
    entry: microsandbox::sandbox::FsEntry,
    metadata: microsandbox::sandbox::FsMetadata,
) -> microsandbox::MicrosandboxResult<()> {
    use microsandbox::sandbox::{FsHandle, FsOpenOptions, FsSetAttrs};

    let _: Option<FsHandle> = None;
    let file = fs.open_file("/tmp/file", FsOpenOptions::default()).await?;
    let dir = fs.open_dir("/tmp").await?;

    let _ = fs.read_handle(file, 0, None).await?;
    let mut read_stream = fs.read_handle_stream(file, 0, Some(1)).await?;
    let _ = read_stream.recv().await?;

    fs.write_handle(file, 0, b"hello").await?;
    let write_stream = fs.write_handle_stream(file, 0, None).await?;
    write_stream.close().await?;

    let _ = fs.read_dir_handle(dir, None).await?;
    let _ = fs.read_dir(dir, None).await?;

    let _ = fs.stat_handle(file).await?;
    let _ = fs.fstat(file).await?;
    fs.set_stat_handle(file, FsSetAttrs::default()).await?;
    fs.fset_stat(file, FsSetAttrs::default()).await?;

    let _ = fs.real_path(".").await?;
    fs.remove_empty_dir("/tmp/empty").await?;
    fs.close_handle(file).await?;
    fs.close_handle(dir).await?;

    let _ = (entry.uid, entry.gid, entry.accessed);
    let _ = (metadata.uid, metadata.gid, metadata.accessed);

    Ok(())
}