firewatch 0.1.0

Security alerts for Lightning nodes: checks your node against published advisories
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

//! Builds the advisories, the LND release table and the dashboard into the
//! binary, so an installed `firewatch` needs no files from this repo.
//!
//! Inside the workspace the data comes from the repo root (`advisories/`,
//! `releases/lnd.toml`, `dashboard/dist`). A packaged crate has no repo
//! around it, so it carries a copy in `data/` (see scripts/package-data.sh). The dashboard is optional: build
//! it first (`cd dashboard && npm run build`) or the binary serves the API only.

use std::fmt::Write as _;
use std::path::{Path, PathBuf};

fn main() {
    let manifest = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
    let root = manifest.join("../..");
    let packaged = manifest.join("data");
    let (advisories, releases, dashboard) = if !root.join("advisories").is_dir() {
        (
            packaged.join("advisories"),
            packaged.join("releases/lnd.toml"),
            packaged.join("dashboard"),
        )
    } else {
        (
            root.join("advisories"),
            root.join("releases/lnd.toml"),
            root.join("dashboard/dist"),
        )
    };
    for path in [&advisories, &releases, &dashboard] {
        println!("cargo:rerun-if-changed={}", path.display());
    }

    let mut out = String::new();

    let mut files = list(&advisories);
    files.retain(|p| p.extension().is_some_and(|e| e == "toml"));
    assert!(
        !files.is_empty(),
        "no advisories in {}",
        advisories.display()
    );
    out.push_str("pub static ADVISORIES: &[(&str, &str)] = &[\n");
    for file in &files {
        let name = file.file_name().unwrap().to_string_lossy();
        writeln!(out, "    ({name:?}, include_str!({:?})),", abs(file)).unwrap();
    }
    out.push_str("];\n\n");

    assert!(releases.is_file(), "missing {}", releases.display());
    writeln!(
        out,
        "pub static LND_RELEASES: &str = include_str!({:?});\n",
        abs(&releases)
    )
    .unwrap();

    out.push_str("pub static DASHBOARD: &[(&str, &[u8])] = &[\n");
    if dashboard.join("index.html").is_file() {
        for file in list(&dashboard) {
            let rel = file
                .strip_prefix(&dashboard)
                .unwrap()
                .to_string_lossy()
                .replace('\\', "/");
            writeln!(out, "    ({rel:?}, include_bytes!({:?})),", abs(&file)).unwrap();
        }
    } else {
        println!(
            "cargo:warning=no dashboard at {}: the binary will serve the API only (run `npm run build` in dashboard/)",
            dashboard.display()
        );
    }
    out.push_str("];\n");

    let dest = PathBuf::from(std::env::var("OUT_DIR").unwrap()).join("embedded.rs");
    std::fs::write(dest, out).unwrap();
}

/// Every file under `dir`, sorted, recursively.
fn list(dir: &Path) -> Vec<PathBuf> {
    let mut found = Vec::new();
    let Ok(entries) = std::fs::read_dir(dir) else {
        return found;
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.is_dir() {
            found.extend(list(&path));
        } else {
            found.push(path);
        }
    }
    found.sort();
    found
}

fn abs(path: &Path) -> String {
    path.canonicalize().unwrap().to_string_lossy().into_owned()
}