bashkit 0.20.1

Awesomely fast virtual sandbox with bash and file system
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Tests for background execution with & and wait
//!
//! Covers: cmd &, cmd & cmd2, wait, wait $pid, $!, multiple background jobs,
//! background jobs writing to VFS.

use bashkit::Bash;

/// Basic background execution: cmd & should succeed
#[tokio::test]
async fn background_basic() {
    let mut bash = Bash::new();
    let result = bash.exec("echo hello &\nwait").await.unwrap();
    assert_eq!(result.exit_code, 0);
}

/// Background writes to VFS, foreground waits then reads
#[tokio::test]
async fn background_writes_to_vfs() {
    let mut bash = Bash::new();
    let result = bash
        .exec("echo content > /tmp/bg_out.txt &\nwait\ncat /tmp/bg_out.txt")
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "content");
}

/// Multiple background jobs
#[tokio::test]
async fn multiple_background_jobs() {
    let mut bash = Bash::new();
    let result = bash
        .exec(
            r#"
echo a > /tmp/a.txt &
echo b > /tmp/b.txt &
echo c > /tmp/c.txt &
wait
cat /tmp/a.txt
cat /tmp/b.txt
cat /tmp/c.txt
"#,
        )
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert!(result.stdout.contains("a"));
    assert!(result.stdout.contains("b"));
    assert!(result.stdout.contains("c"));
}

/// $! is set after background command
#[tokio::test]
async fn background_sets_last_pid() {
    let mut bash = Bash::new();
    let result = bash.exec("sleep 0 &\necho $!").await.unwrap();
    assert_eq!(result.exit_code, 0);
    // $! should be a non-empty numeric value
    let pid = result.stdout.trim();
    assert!(!pid.is_empty(), "$! should be set after background command");
    assert!(
        pid.parse::<usize>().is_ok(),
        "$! should be numeric, got: {pid}"
    );
}

/// wait with specific PID
#[tokio::test]
async fn wait_specific_pid() {
    let mut bash = Bash::new();
    let result = bash
        .exec(
            r#"
echo done > /tmp/wait_pid.txt &
pid=$!
wait $pid
cat /tmp/wait_pid.txt
"#,
        )
        .await
        .unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "done");
}

/// Background command exit code via wait
#[tokio::test]
async fn background_exit_code_via_wait() {
    let mut bash = Bash::new();
    let result = bash.exec("false &\nwait $!\necho $?").await.unwrap();
    // `wait $pid` returns the job's status; bare `wait` returns 0 (bash).
    assert_eq!(result.stdout.trim(), "1");
}

/// cmd1 & cmd2 — cmd2 runs in foreground while cmd1 is backgrounded
#[tokio::test]
async fn background_and_foreground() {
    let mut bash = Bash::new();
    let result = bash.exec("echo bg > /tmp/bg.txt & echo fg").await.unwrap();
    assert_eq!(result.exit_code, 0);
    assert!(result.stdout.contains("fg"));
}

/// Completed background jobs should not accumulate across exec() calls.
#[tokio::test]
async fn background_jobs_do_not_leak_across_exec_calls() {
    let mut bash = Bash::new();
    for _ in 0..20 {
        bash.exec("false &").await.unwrap();
    }

    let result = bash.exec("wait\necho $?").await.unwrap();
    assert_eq!(result.exit_code, 0);
    assert_eq!(result.stdout.trim(), "0");
}

/// TM-DOS-122: live background jobs are capped by `max_background_jobs`.
#[tokio::test]
async fn background_job_limit() {
    let limits = bashkit::ExecutionLimits::new().max_background_jobs(2);
    let mut bash = Bash::builder().limits(limits).build();
    let result = bash
        .exec("sleep 5 & sleep 5 & sleep 5 & echo rc=$?; kill %1 %2; wait")
        .await
        .unwrap();
    assert!(result.stdout.contains("rc=1"), "stdout: {}", result.stdout);
    assert!(
        result.stderr.contains("Resource temporarily unavailable"),
        "stderr: {}",
        result.stderr
    );
}

/// TM-DOS-122: a fork bomb terminates. Nested `&` shares the session-wide
/// job cap and counts as subshell nesting (TM-DOS-092). Runs on a big-stack
/// thread: unoptimized builds use far more stack per nesting level.
#[test]
fn background_fork_bomb_is_bounded() {
    let handle = std::thread::Builder::new()
        .stack_size(64 * 1024 * 1024)
        .spawn(|| {
            let rt = tokio::runtime::Builder::new_current_thread()
                .enable_all()
                .build()
                .unwrap();
            rt.block_on(async {
                let limits = bashkit::ExecutionLimits::new()
                    .max_background_jobs(8)
                    .max_subshell_depth(4);
                let mut bash = Bash::builder().limits(limits).build();
                let run = bash.exec("f() { f & f & }; f; wait; echo survived");
                tokio::time::timeout(std::time::Duration::from_secs(30), run)
                    .await
                    .expect("fork bomb must terminate")
                    .unwrap()
            })
        })
        .unwrap();
    let result = handle.join().unwrap();
    assert!(
        result.stdout.contains("survived"),
        "stdout: {}",
        result.stdout
    );
    assert!(result.stderr.contains("Resource temporarily unavailable"));
}