my-ci 0.0.5

Minimalist Local CICD
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

use std::collections::HashMap;
use std::io::Read;
use std::sync::OnceLock;

use axum::body::Body;
use axum::http::{HeaderValue, StatusCode, Uri, header};
use axum::response::{IntoResponse, Response};
use bytes::Bytes;
use tracing::{debug, warn};

const ARCHIVE: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/ui-dist.tar.gz"));

static ASSETS: OnceLock<HashMap<String, Bytes>> = OnceLock::new();

pub fn has_assets() -> bool {
    !assets().is_empty()
}

fn assets() -> &'static HashMap<String, Bytes> {
    ASSETS.get_or_init(unpack)
}

fn unpack() -> HashMap<String, Bytes> {
    let mut out: HashMap<String, Bytes> = HashMap::new();
    if ARCHIVE.is_empty() {
        return out;
    }

    let decoder = flate2::read::GzDecoder::new(ARCHIVE);
    let mut archive = tar::Archive::new(decoder);
    let entries = match archive.entries() {
        Ok(entries) => entries,
        Err(err) => {
            warn!(error = %err, "failed to read embedded UI archive");
            return out;
        }
    };

    for entry in entries {
        let mut entry = match entry {
            Ok(entry) => entry,
            Err(err) => {
                warn!(error = %err, "skipping malformed UI archive entry");
                continue;
            }
        };
        if !entry.header().entry_type().is_file() {
            continue;
        }
        let raw_path = match entry.path() {
            Ok(path) => path.to_string_lossy().into_owned(),
            Err(err) => {
                warn!(error = %err, "skipping UI archive entry with bad path");
                continue;
            }
        };
        let mut buf = Vec::with_capacity(entry.size() as usize);
        if let Err(err) = entry.read_to_end(&mut buf) {
            warn!(error = %err, path = %raw_path, "failed to read UI archive entry");
            continue;
        }
        let key = normalize(&raw_path);
        out.insert(key, Bytes::from(buf));
    }

    debug!(file_count = out.len(), "unpacked embedded UI archive");
    out
}

fn normalize(path: &str) -> String {
    path.trim_start_matches("./")
        .trim_start_matches('/')
        .to_string()
}

pub async fn fallback(uri: Uri) -> Response {
    let map = assets();
    let raw = uri.path().trim_start_matches('/');
    let lookup = if raw.is_empty() { "index.html" } else { raw };

    if let Some(body) = map.get(lookup) {
        return ok_response(lookup, body.clone());
    }
    // SPA fallback: serve index.html for unknown paths so client-side routing works.
    if let Some(body) = map.get("index.html") {
        return ok_response("index.html", body.clone());
    }
    (
        StatusCode::NOT_FOUND,
        "UI assets not embedded in this build",
    )
        .into_response()
}

fn ok_response(path: &str, body: Bytes) -> Response {
    let mut response = Response::new(Body::from(body));
    response.headers_mut().insert(
        header::CONTENT_TYPE,
        HeaderValue::from_static(guess_mime(path)),
    );
    response
}

fn guess_mime(path: &str) -> &'static str {
    let ext = path.rsplit('.').next().unwrap_or("");
    match ext {
        "html" | "htm" => "text/html; charset=utf-8",
        "css" => "text/css; charset=utf-8",
        "js" | "mjs" => "application/javascript; charset=utf-8",
        "json" | "map" => "application/json; charset=utf-8",
        "wasm" => "application/wasm",
        "woff" => "font/woff",
        "woff2" => "font/woff2",
        "ttf" => "font/ttf",
        "otf" => "font/otf",
        "svg" => "image/svg+xml",
        "png" => "image/png",
        "jpg" | "jpeg" => "image/jpeg",
        "gif" => "image/gif",
        "ico" => "image/x-icon",
        "txt" => "text/plain; charset=utf-8",
        _ => "application/octet-stream",
    }
}