hennery 0.3.0

Self-hosted cockpit for ACP coding agents
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

//! Check 2 (distribution spec ยง1.1): whether this machine can run a host's
//! managed runtime. What its C library is, and what stops the runtime, are
//! the host's own (`hennery_host::runtime::glibc`): the host refuses to
//! install a set where this check fails it. What is read is gathered apart
//! from how it is judged, so the judging is tested on fixtures.

use super::{Check, Doctor, Finding, Verdict};
use hennery_host::runtime::glibc::{self, Said};
pub use hennery_host::runtime::glibc::{Libc, major_minor};
// The parsers' fixture tests live with the doctor's.
#[cfg(test)]
pub use hennery_host::runtime::glibc::{parse_getconf, parse_loader};
use hennery_host::runtime::install;
use hennery_host::runtime::manifest::Platform;

/// The oldest Linux kernel Node 24 supports.
pub const MIN_KERNEL: (u32, u32) = (4, 18);

/// What check 2 reads of the machine.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Facts {
    /// `<os>-<arch>`, as Rust names them.
    pub name: String,
    /// The managed runtime's platform, if it supports this one.
    pub platform: Option<Platform>,
    /// glibc's loader, and whether it is there (Linux only).
    pub loader: Option<(&'static str, bool)>,
    /// `/etc/NIXOS` is there.
    pub nixos: bool,
    pub libc: Libc,
    /// The kernel's release, as `uname` gives it (Linux only).
    pub kernel: Option<String>,
}

/// Read the facts of the machine: its files under `cx.root`, its programs
/// through `doctor.run`.
pub fn gather(doctor: &Doctor) -> Facts {
    let root = &doctor.cx.root;
    let platform = Platform::current();
    let nixos = root.join("etc/NIXOS").exists();
    let loader = platform
        .and_then(install::glibc_loader)
        .map(|path| (path, root.join(path.trim_start_matches('/')).exists()));
    let libc = match loader {
        Some((path, true)) => libc_behind(doctor, path, nixos),
        _ => Libc::Unknown,
    };
    Facts {
        name: format!("{}-{}", std::env::consts::OS, std::env::consts::ARCH),
        platform,
        loader,
        nixos,
        libc,
        kernel: if cfg!(target_os = "linux") {
            kernel_release()
        } else {
            None
        },
    }
}

/// What the loader at `path` says it is, else what `/usr/bin/getconf`
/// says (not on NixOS; decision 5).
pub fn libc_behind(doctor: &Doctor, path: &str, nixos: bool) -> Libc {
    let root = &doctor.cx.root;
    let run = |program: &std::path::Path, args: &[&str]| {
        (doctor.run)(program, args).map(|ran| Said {
            ok: ran.ok,
            stdout: ran.stdout,
            stderr: ran.stderr,
        })
    };
    glibc::libc_behind(
        &root.join(path.trim_start_matches('/')),
        &root.join("usr/bin/getconf"),
        nixos,
        &run,
    )
}

/// `uname(2)`'s release.
fn kernel_release() -> Option<String> {
    // SAFETY: uname(2) into a zeroed local struct of the right type.
    let mut name: libc::utsname = unsafe { std::mem::zeroed() };
    if unsafe { libc::uname(&mut name) } != 0 {
        return None;
    }
    // SAFETY: on success `release` is a NUL-terminated string in `name`.
    let release = unsafe { std::ffi::CStr::from_ptr(name.release.as_ptr()) };
    Some(release.to_string_lossy().into_owned())
}

/// Check 2.
pub fn platform(doctor: &Doctor) -> Finding {
    let strict = doctor.dirs.host.is_some() && !doctor.agents_given();
    Finding::Checked(judge(&gather(doctor), strict))
}

/// Check 2's verdict on `facts`. What stops a managed runtime fails only
/// where a host needs one (`strict`): elsewhere, with no host here or with
/// agents given by `--agent`, it is a warning about this machine.
pub fn judge(facts: &Facts, strict: bool) -> Check {
    let mut verdict = Verdict::default();
    let bad = |verdict: &mut Verdict, summary: String, fix: &str| {
        if strict {
            verdict.fail(summary, fix);
        } else {
            verdict.warn(format!("{summary}: no managed runtime can run here"), fix);
        }
    };
    match facts.platform {
        None => bad(
            &mut verdict,
            format!("hennery's managed runtime does not support {}", facts.name),
            "run hosts on macOS on Apple silicon or on Linux (x86-64, arm64) with glibc; this machine can run the collector",
        ),
        Some(Platform::DarwinArm64) => verdict.ok("macOS on Apple silicon"),
        Some(platform) => {
            match (glibc::refusal(facts.loader, facts.nixos, facts.libc), facts.libc) {
                (Some((summary, fix)), _) => bad(&mut verdict, summary, fix),
                (None, Libc::Glibc(major, minor)) => {
                    verdict.ok(format!("{} with glibc {major}.{minor}", platform.key()))
                }
                (None, _) => verdict.warn(
                    format!("{}: glibc's version is unknown", platform.key()),
                    "check that glibc is 2.28 or later (`ldd --version`)",
                ),
            }
            match facts.kernel.as_deref().map(|k| (k, major_minor(k))) {
                Some((release, Some(version))) if version < MIN_KERNEL => bad(
                    &mut verdict,
                    format!("Linux {release} is older than 4.18"),
                    "upgrade the kernel to 4.18 or later",
                ),
                Some((release, Some(_))) => verdict.ok(format!("Linux {release}")),
                _ => verdict.warn(
                    "the kernel's release is unknown",
                    "check that `uname -r` says 4.18 or later",
                ),
            }
        }
    }
    verdict.check(2, "platform")
}