sprawling-runtime 0.0.10

One run of a sprawling resident, from dispatch to freeze: turns, tools, replay and the sandbox that executes code.
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
// Copyright (c) 2026 2youg1 and the sprawling contributors

//! Confirmed resource deletion (`crates/runtime/spec/Tools/Exec/Container.lean`, D52).

use std::path::PathBuf;
use std::process::Command;

use kernel::AxError;
use serde::{Deserialize, Serialize};

use super::{ContainerEngine, ContainerRuntime, control, denied};

#[derive(Clone, Copy)]
pub(super) enum Confirmation {
    Absence,
    Deletion,
}

#[derive(Clone, Serialize, Deserialize)]
pub(super) struct Cleanup {
    pub(super) program: PathBuf,
    engine: ContainerEngine,
    pub(super) name: String,
    pub(super) copy: PathBuf,
}

impl Cleanup {
    pub(super) fn registered(runtime: &ContainerRuntime, name: String, copy: PathBuf) -> Self {
        Self {
            program: runtime.program.clone(),
            engine: runtime.engine,
            name,
            copy,
        }
    }

    pub(super) fn remove(&self, confirmation: Confirmation) -> Result<(), AxError> {
        let mut remove = Command::new(&self.program);
        remove.args(["rm", "--force", "--volumes"]);
        match self.engine {
            ContainerEngine::Docker => {}
            ContainerEngine::Podman => {
                remove.args(["--time", "0"]);
            }
        }
        remove.arg(&self.name);
        let removed = control::output(&mut remove, control::Wait::Bounded)?;
        if !removed.status.success() {
            if matches!(confirmation, Confirmation::Deletion) {
                return Err(denied(
                    "remove a possibly late-created container",
                    &self.name,
                ));
            }
            let mut inventory = Command::new(&self.program);
            inventory.args(["container", "ls", "--all", "--format", "{{.Names}}"]);
            let names = control::checked(&mut inventory)?;
            let names = std::str::from_utf8(&names)
                .map_err(|err| denied("confirm container removal", err))?;
            if names.lines().any(|name| name.trim() == self.name) {
                return Err(denied(
                    "remove the owned container",
                    format!(
                        "{}: {}",
                        self.name,
                        String::from_utf8_lossy(&removed.stderr).trim()
                    ),
                ));
            }
        }
        Ok(())
    }

    pub(super) fn release_copy(&self) -> Result<(), AxError> {
        match std::fs::remove_dir_all(&self.copy) {
            Ok(()) => Ok(()),
            Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(()),
            Err(err) => Err(denied("release the container copy", err)),
        }
    }
}