fusible 0.20.1

Electronic linter: a fuse that blows to block firmware code generation
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

//! GLB of an authored body for `GET /api/bodies/<name>.glb`.
//!
//! Only files declared as a body `source:` in the manifest are read: the URL carries the
//! body name, never a path. GLB is served as is. STEP and STL are converted to GLB with
//! occt-wasm and cached by path, modification time, and size.

use std::io::Read;
use std::path::{Path, PathBuf};

use super::authored_cache::{cache_key, cached_conversion};
use crate::config::FusibleConfig;

const MAX_BYTES: u64 = 64 * 1024 * 1024;

/// Text that marks a conversion error as a timeout, which is reported as a 504.
pub(super) const TIMEOUT_MARK: &str = "timed out after";

/// Why a body GLB could not be served, with the HTTP status that reports it.
#[derive(Debug, PartialEq, Eq)]
pub(super) struct Failure {
    pub status: u16,
    pub message: String,
}

impl Failure {
    pub(super) fn new(status: u16, message: impl Into<String>) -> Self {
        Self {
            status,
            message: message.into(),
        }
    }
}

enum Kind {
    Glb,
    Convert(&'static str),
}

fn kind_of(path: &Path) -> Option<Kind> {
    match path.extension()?.to_str()?.to_ascii_lowercase().as_str() {
        "glb" => Some(Kind::Glb),
        "step" | "stp" => Some(Kind::Convert("step")),
        "stl" => Some(Kind::Convert("stl")),
        _ => None,
    }
}

fn source_of(cfg: &FusibleConfig, name: &str) -> Result<PathBuf, Failure> {
    let body = cfg
        .bodies
        .get(name)
        .ok_or_else(|| Failure::new(404, format!("unknown body `{name}`")))?;
    body.source.clone().ok_or_else(|| {
        let help = "generated bodies are served by /api/mechanical";
        Failure::new(404, format!("body `{name}` is not authored; {help}"))
    })
}

/// Returns the GLB bytes of the authored body `name`, converting and caching when needed.
///
/// `convert(source, format, output)` writes the GLB of a STEP or STL file to `output`.
pub(super) fn authored_glb(
    cfg: &FusibleConfig,
    name: &str,
    cache_dir: &Path,
    convert: impl Fn(&Path, &str, &Path) -> Result<(), String>,
) -> Result<Vec<u8>, Failure> {
    let source = source_of(cfg, name)?;
    let meta = std::fs::metadata(&source).map_err(|_| {
        Failure::new(
            404,
            format!("source file \"{}\" does not exist", source.display()),
        )
    })?;
    if meta.len() > MAX_BYTES {
        let limit = MAX_BYTES / (1024 * 1024);
        return Err(Failure::new(
            422,
            format!("source file is larger than {limit} MiB"),
        ));
    }
    let Some(kind) = kind_of(&source) else {
        let message = "unsupported source type; use .glb, .step, .stp, or .stl";
        return Err(Failure::new(422, message));
    };
    match kind {
        Kind::Glb => read_capped(&source),
        Kind::Convert(format) => {
            let key = cache_key(&source, &meta);
            cached_conversion(&source, format, &key, cache_dir, &convert)
        }
    }
}

/// Reads `path`, refusing more than [`MAX_BYTES`] even when the file grew after the size check.
fn read_capped(path: &Path) -> Result<Vec<u8>, Failure> {
    let io = |e: std::io::Error| Failure::new(500, e.to_string());
    let mut bytes = Vec::new();
    let file = std::fs::File::open(path).map_err(io)?;
    file.take(MAX_BYTES + 1)
        .read_to_end(&mut bytes)
        .map_err(io)?;
    if bytes.len() as u64 > MAX_BYTES {
        return Err(Failure::new(422, "source file is larger than 64 MiB"));
    }
    Ok(bytes)
}