mxsh 0.2.0

Embeddable POSIX-style shell parser and runtime
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

#![cfg(all(feature = "runtime", feature = "test-support"))]

use std::io;
use std::path::{Path, PathBuf};

use mxsh::runtime::Runtime;
use mxsh::runtime::fd::FileDescriptor;
use mxsh::runtime::process::{
    ExternalCommand, ProcessEvent, ProcessHandle, RuntimeSignal, SpawnMode, SpawnStdio,
};
use mxsh::runtime::testing::{DeterministicRuntime, InMemoryRuntime};

fn fork_runtime<R: Runtime + Sized>(runtime: &R) -> R {
    runtime.fork().expect("runtime fork should succeed")
}

fn resolve_program<R: Runtime>(runtime: &R, program: &str) -> PathBuf {
    runtime
        .resolve_command_path(program, "/usr/bin:/bin", Path::new("/"))
        .expect("runtime path resolution should succeed")
}

fn run_command<R: Runtime>(runtime: &mut R, command: ExternalCommand) -> i32 {
    let child = runtime
        .spawn_external_command(&command, SpawnStdio::default(), &[], SpawnMode::Foreground)
        .expect("runtime spawn should succeed");
    runtime.wait_child(child.handle)
}

fn signal_process<R: Runtime>(runtime: &mut R) {
    runtime
        .signal_process_group(ProcessHandle::new(1), RuntimeSignal::Continue)
        .expect("runtime signaling should succeed");
}

fn claim_and_release_foreground<R: Runtime>(runtime: &mut R) {
    let guard = runtime
        .claim_foreground(ProcessHandle::new(1), FileDescriptor::STDIN)
        .expect("foreground claim should succeed");
    runtime
        .release_foreground(guard)
        .expect("foreground release should succeed");
}

fn exec_is_explicit<R: Runtime>(runtime: &R) -> io::ErrorKind {
    runtime
        .exec_replace("echo", &["echo".to_string()], &[], Path::new("/"))
        .expect_err("in-memory runtime should not support exec")
        .kind()
}

#[test]
fn public_runtime_capabilities_are_composable() {
    let mut runtime = InMemoryRuntime::new();
    runtime.register_command("emit", |_argv, _env, _cwd, _stdio| 7);

    let forked = fork_runtime(&runtime);
    assert_eq!(resolve_program(&forked, "emit"), PathBuf::from("emit"));

    let status = run_command(
        &mut runtime,
        ExternalCommand {
            program: "emit".to_string(),
            argv: vec!["emit".to_string()],
            env: Vec::new(),
            cwd: PathBuf::from("/"),
            create_process_group: false,
            join_process_group: None,
            passed_fds: Vec::new(),
            signal_plan: Default::default(),
        },
    );
    assert_eq!(status, 7);

    signal_process(&mut runtime);
    claim_and_release_foreground(&mut runtime);
    assert_eq!(exec_is_explicit(&runtime), io::ErrorKind::Unsupported);
}

#[test]
fn deterministic_runtime_fork_does_not_clone_queued_spawns() {
    let mut runtime = DeterministicRuntime::new();
    runtime.push_spawn(Some(42), [], [ProcessEvent::Exited(0)]);

    let mut forked = runtime.fork().expect("runtime fork should succeed");
    let err = forked
        .spawn_external_command(
            &ExternalCommand {
                program: "echo".to_string(),
                argv: vec!["echo".to_string()],
                env: Vec::new(),
                cwd: PathBuf::from("/"),
                create_process_group: false,
                join_process_group: None,
                passed_fds: Vec::new(),
                signal_plan: Default::default(),
            },
            SpawnStdio::default(),
            &[],
            SpawnMode::Foreground,
        )
        .expect_err("forked runtime should start with no queued spawns");
    assert_eq!(err.kind(), io::ErrorKind::NotFound);
}