accent 0.1.3

Installer and updater for Accent CMS — downloads, verifies and installs signed Accent releases
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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221

//! Running a downloaded binary once before it is installed.
//!
//! Signature and checksum verification prove the archive is the one that
//! was published; nothing before this point proves the machine can start
//! what is inside it. This module answers that question with the one call
//! that matters, `accent --version`, and turns a refusal into a message
//! that tells an unsupported system apart from a broken release.

use std::path::Path;
use std::process::Command;

use anyhow::{anyhow, Result};

/// Runs a downloaded binary once, before it is installed.
///
/// Everything before this point proves the archive is the one that was
/// published; nothing proves this machine can start what is inside it. A
/// Linux release built against a newer glibc than the system has is the
/// case that made this necessary: the v0.25.0 binaries needed glibc 2.39 and
/// the dynamic loader refused them on Debian 12 and Ubuntu 22.04, while the
/// installers reported success over them. So `accent --version` is run on
/// the staged file. Success returns the line it printed; failure returns an
/// error that quotes the loader and, when the loader named a `GLIBC_x.y` the
/// system lacks, says which glibc the release needs and which one the
/// system has, so the user can tell an unsupported system from a broken
/// release. `report_url` is where the latter should go.
pub fn runs(binary: &Path, report_url: &str) -> Result<String> {
    let output = match Command::new(binary).arg("--version").output() {
        Ok(output) => output,
        Err(err) => {
            let mut msg = format!(
                "the downloaded binary cannot run on this system:\n  {}: {err}",
                binary.display()
            );
            // The loader itself is what is missing when exec fails with "not
            // found" on a file that exists: the ELF interpreter the binary
            // names (`/lib64/ld-linux-x86-64.so.2`) is glibc's, and a musl
            // system does not have it. Reaching this means the glibc build
            // was chosen on a musl host, which libc detection should have
            // prevented -- so it is a report, not a shrug.
            if cfg!(target_os = "linux")
                && err.kind() == std::io::ErrorKind::NotFound
                && binary.exists()
            {
                msg.push_str(&format!(
                    "\nThe binary asks for the glibc loader, which this system does not have \
                     (Alpine or another musl-based distribution). accentup selects the fully static \
                     musl build on such systems from {} onward; if this is one and you still got \
                     here, please report it via {report_url}",
                    crate::release::OLDEST_MUSL
                ));
            }
            return Err(anyhow!(msg));
        }
    };

    if output.status.success() {
        return Ok(String::from_utf8_lossy(&output.stdout).trim().to_string());
    }

    let stderr = String::from_utf8_lossy(&output.stderr);
    let mut msg = String::from("the downloaded binary cannot run on this system:");
    for line in stderr.lines().filter(|line| !line.trim().is_empty()) {
        msg.push_str("\n  ");
        msg.push_str(line);
    }
    if stderr.trim().is_empty() {
        msg.push_str(&format!(
            "\n  {} --version: {}",
            binary.display(),
            output.status
        ));
    }

    if let Some((major, minor)) = highest_glibc_need(&stderr) {
        let have = system_glibc().unwrap_or_else(|| "unknown".to_string());
        msg.push_str(&format!(
            "\nThis release needs glibc {major}.{minor} or newer; this system has glibc {have}.\n\
             The supported Linux versions are listed at https://accentcms.dev/download.\n\
             If this system is one of them, the release is at fault: please report it via {report_url}"
        ));
    }
    Err(anyhow!(msg))
}

/// The newest `GLIBC_x.y` a dynamic-loader complaint names, as `(x, y)`.
///
/// The loader prints one `version \`GLIBC_2.39' not found` line per missing
/// symbol version; the highest of them is the floor the binary really has.
/// `GLIBC_PRIVATE` and other non-numeric tags are ignored.
pub fn highest_glibc_need(loader_stderr: &str) -> Option<(u32, u32)> {
    loader_stderr
        .match_indices("GLIBC_")
        .filter_map(|(at, _)| {
            let rest = &loader_stderr[at + "GLIBC_".len()..];
            let version: String = rest
                .chars()
                .take_while(|c| c.is_ascii_digit() || *c == '.')
                .collect();
            let (major, minor) = version.split_once('.')?;
            let minor = minor.split('.').next()?;
            Some((major.parse().ok()?, minor.parse().ok()?))
        })
        .max()
}

/// The glibc this system runs, as `getconf` reports it (`2.36`), when it is
/// a glibc system at all.
fn system_glibc() -> Option<String> {
    #[cfg(target_os = "linux")]
    {
        let output = Command::new("getconf")
            .arg("GNU_LIBC_VERSION")
            .output()
            .ok()
            .filter(|out| out.status.success())?;
        let text = String::from_utf8_lossy(&output.stdout);
        text.split_whitespace().nth(1).map(str::to_string)
    }
    #[cfg(not(target_os = "linux"))]
    {
        None
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[cfg(unix)]
    use crate::install::stub;

    #[test]
    fn the_highest_glibc_the_loader_names_is_the_floor() {
        let stderr = "accent: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.38' not found (required by accent)\n\
                      accent: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.39' not found (required by accent)\n\
                      accent: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.4' not found (required by accent)\n";
        assert_eq!(highest_glibc_need(stderr), Some((2, 39)));
        assert_eq!(
            highest_glibc_need("version `GLIBC_PRIVATE' not found"),
            None
        );
        assert_eq!(highest_glibc_need("Segmentation fault"), None);
        assert_eq!(highest_glibc_need(""), None);
    }

    #[cfg(unix)]
    #[test]
    fn a_binary_that_runs_reports_its_version_line() {
        let dir = tempfile::tempdir().unwrap();
        let bin = stub(
            dir.path(),
            "ok",
            "#!/bin/sh\necho 'accent 0.26.0 (abc1234)'\n",
        );
        assert_eq!(
            runs(&bin, "https://example.invalid").unwrap(),
            "accent 0.26.0 (abc1234)"
        );
    }

    #[cfg(unix)]
    #[test]
    fn a_loader_refusal_names_the_glibc_the_release_needs() {
        let dir = tempfile::tempdir().unwrap();
        let bin = stub(
            dir.path(),
            "refused",
            "#!/bin/sh\n\
             echo \"$0: /lib/x86_64-linux-gnu/libc.so.6: version \\`GLIBC_2.38' not found (required by $0)\" >&2\n\
             echo \"$0: /lib/x86_64-linux-gnu/libc.so.6: version \\`GLIBC_2.39' not found (required by $0)\" >&2\n\
             exit 127\n",
        );
        let text = runs(&bin, "https://example.invalid/discussions")
            .unwrap_err()
            .to_string();
        assert!(
            text.starts_with("the downloaded binary cannot run on this system:"),
            "{text}"
        );
        assert!(text.contains("GLIBC_2.39' not found"), "{text}");
        assert!(
            text.contains("This release needs glibc 2.39 or newer; this system has glibc "),
            "{text}"
        );
        assert!(text.contains("https://accentcms.dev/download"), "{text}");
        assert!(
            text.contains("report it via https://example.invalid/discussions"),
            "{text}"
        );
    }

    #[cfg(unix)]
    #[test]
    fn a_failure_without_glibc_in_it_is_quoted_without_a_diagnosis() {
        let dir = tempfile::tempdir().unwrap();
        let bin = stub(
            dir.path(),
            "crash",
            "#!/bin/sh\necho 'Illegal instruction' >&2\nexit 132\n",
        );
        let text = runs(&bin, "https://example.invalid")
            .unwrap_err()
            .to_string();
        assert!(text.contains("  Illegal instruction"), "{text}");
        assert!(!text.contains("needs glibc"), "{text}");
    }

    #[cfg(unix)]
    #[test]
    fn a_file_that_cannot_be_executed_at_all_is_an_error_not_a_panic() {
        let dir = tempfile::tempdir().unwrap();
        let bin = dir.path().join("missing");
        let text = runs(&bin, "https://example.invalid")
            .unwrap_err()
            .to_string();
        assert!(
            text.starts_with("the downloaded binary cannot run on this system:"),
            "{text}"
        );
    }
}