arcbox-computer-runtime 0.10.1

Sandbox orchestration over nested microVMs behind the arcbox-vm-driver port: boot, exec, files, checkpoints, warm pools. The in-sandbox init is arcbox-vm-agent; the wire vocabulary is arcbox-vm-proto.
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

//! Reachability, and the two projections over every leaf.

use super::harness::{LEAVES, explore, ordinal};
use crate::sandbox::ComputerState;
use crate::sandbox::record::PersistPhase;

#[test]
fn every_leaf_is_reachable_by_driving_events() {
    let mut seen = [false; LEAVES];
    for node in explore() {
        seen[ordinal(node.state)] = true;
    }
    assert!(
        seen.iter().all(|reached| *reached),
        "unreachable leaves: {:?}",
        seen.iter()
            .enumerate()
            .filter(|(_, reached)| !**reached)
            .map(|(index, _)| index)
            .collect::<Vec<_>>()
    );
}

#[test]
fn every_leaf_projects_onto_a_public_state() {
    // An arm nobody projects is how a state becomes invisible to callers, so
    // this asserts the whole table rather than sampling it. `gating` is the
    // one leaf with two answers: the boot's own `cmd` claims the workload
    // slot before READY, and from there a caller reads `Running` — which is
    // what stops an Inspect-polling client from stealing that slot.
    let expected: [&[ComputerState]; LEAVES] = [
        &[ComputerState::Starting],                         // provisioning
        &[ComputerState::Starting],                         // staging
        &[ComputerState::Starting],                         // booting
        &[ComputerState::Starting],                         // restoring
        &[ComputerState::Starting, ComputerState::Running], // gating
        &[ComputerState::Ready],                            // ready
        &[ComputerState::Running],                          // running
        &[ComputerState::Ready],                            // checkpointing
        &[ComputerState::Pausing],                          // capturing
        &[ComputerState::Pausing],                          // releasing
        &[ComputerState::Paused],                           // paused
        &[ComputerState::Starting],                         // resuming
        &[ComputerState::Stopping],                         // stopping
        &[ComputerState::Stopped],                          // stopped
        &[ComputerState::Failed],                           // failed
        &[ComputerState::Stopping],                         // removing
        &[ComputerState::Stopped],                          // gone
        &[ComputerState::Ready],                            // detached
    ];
    for node in explore() {
        let public = node.state.to_public();
        assert!(
            expected[ordinal(node.state)].contains(&public),
            "{:?} projects {public}",
            node.state
        );
    }
}

#[test]
fn every_leaf_projects_onto_a_durable_phase() {
    use PersistPhase as P;
    // Indexed by `ordinal`. `gating` is the one leaf two paths reach on
    // different phases, so it carries the discriminator and lists both; the
    // walk below pins which one each path actually holds.
    let expected: [&[Option<P>]; LEAVES] = [
        &[Some(P::Creating)],                 // provisioning: the reserved intent
        &[Some(P::Starting)],                 // staging
        &[Some(P::Starting)],                 // booting
        &[Some(P::Creating)],                 // restoring: commits Ready in one hop
        &[Some(P::Starting), Some(P::Ready)], // gating
        &[Some(P::Ready)],                    // ready
        &[Some(P::Ready)],                    // running: the hot path writes nothing
        &[Some(P::Ready)],                    // checkpointing
        &[Some(P::Pausing)],                  // capturing
        &[Some(P::Pausing)],                  // releasing
        &[Some(P::Paused)],                   // paused
        &[Some(P::Resuming)],                 // resuming
        &[Some(P::Stopping)],                 // stopping
        &[Some(P::Stopped)],                  // stopped
        &[Some(P::Failed)],                   // failed
        &[Some(P::Removing)],                 // removing
        &[None],                              // gone: the record is forgotten
        &[Some(P::Ready)],                    // detached: a handover writes nothing
    ];
    for node in explore() {
        let durable = node.state.durable();
        assert!(
            expected[ordinal(node.state)].contains(&durable),
            "{:?} projects {durable:?}",
            node.state
        );
    }
}

#[test]
fn the_durable_projection_is_the_phase_actually_in_effect() {
    for node in explore() {
        assert_eq!(
            node.state.durable(),
            node.phase,
            "{:?} reached via {:?}",
            node.state,
            node.path
        );
    }
}