clawft-kernel 0.8.3

WeftOS kernel: boot sequence, process table, service registry, and health subsystem
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

//! A scripted [`ProbeHost`] for probe tests: canned tool output, files,
//! directories and paths, so any machine can be simulated.

use std::collections::{BTreeMap, BTreeSet};
use std::path::PathBuf;

use super::host::ProbeHost;

#[derive(Debug, Default, Clone)]
pub struct FakeHost {
    pub os: String,
    pub arch: String,
    pub tools: BTreeSet<String>,
    /// Key: `"tool arg1 arg2"`.
    pub outputs: BTreeMap<String, String>,
    pub files: BTreeMap<String, String>,
    pub dirs: BTreeMap<String, Vec<String>>,
    pub paths: BTreeSet<String>,
    /// Every `run` command, in order (shared across clones).
    pub log: std::sync::Arc<std::sync::Mutex<Vec<String>>>,
}

impl FakeHost {
    pub fn new(os: &str, arch: &str) -> Self {
        Self {
            os: os.into(),
            arch: arch.into(),
            ..Self::default()
        }
    }
    pub fn tool(mut self, t: &str) -> Self {
        self.tools.insert(t.into());
        self
    }
    /// Register `cmd` (`"tool arg ..."`) with its stdout; also installs the tool.
    pub fn out(mut self, cmd: &str, stdout: &str) -> Self {
        let tool = cmd.split(' ').next().unwrap().to_string();
        self.tools.insert(tool);
        self.outputs.insert(cmd.into(), stdout.into());
        self
    }
    pub fn file(mut self, path: &str, body: &str) -> Self {
        self.files.insert(path.into(), body.into());
        self.paths.insert(path.into());
        self
    }
    pub fn dir(mut self, path: &str, names: &[&str]) -> Self {
        self.dirs
            .insert(path.into(), names.iter().map(|s| s.to_string()).collect());
        self
    }
    pub fn path(mut self, p: &str) -> Self {
        self.paths.insert(p.into());
        self
    }
}

impl ProbeHost for FakeHost {
    fn os(&self) -> String {
        self.os.clone()
    }
    fn arch(&self) -> String {
        self.arch.clone()
    }
    fn which(&self, tool: &str) -> Option<PathBuf> {
        self.tools
            .contains(tool)
            .then(|| PathBuf::from(format!("/fake/bin/{tool}")))
    }
    fn run(&self, tool: &str, args: &[&str]) -> Option<String> {
        if !self.tools.contains(tool) {
            return None;
        }
        let key = std::iter::once(tool)
            .chain(args.iter().copied())
            .collect::<Vec<_>>()
            .join(" ");
        self.log.lock().unwrap().push(key.clone());
        self.outputs.get(&key).cloned()
    }
    fn run_all(&self, tool: &str, args: &[&str]) -> Option<String> {
        self.run(tool, args)
    }
    fn read_file(&self, path: &str) -> Option<String> {
        self.files.get(path).cloned()
    }
    fn list_dir(&self, path: &str) -> Option<Vec<String>> {
        self.dirs.get(path).cloned()
    }
    fn exists(&self, path: &str) -> bool {
        self.paths.contains(path) || self.dirs.contains_key(path)
    }
}