rust-embed 8.12.0

Rust Custom Derive Macro which loads files into the rust binary at compile time during release and loads the file from the fs during dev
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

use axum::{
  extract::Path,
  http::{HeaderMap, StatusCode},
  response::{Html, IntoResponse, Response},
  routing::{get, Router},
};
use rust_embed::Embed;
use std::net::SocketAddr;

#[derive(Embed)]
#[folder = "examples/public/"]
#[compression = "zstd"]
struct Asset;

#[tokio::main]
async fn main() {
  let app = Router::new()
    .route("/", get(index_handler))
    .route("/index.html", get(index_handler))
    .route("/dist/{*file}", get(static_handler))
    .fallback_service(get(not_found));

  let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
  println!("listening on {}", addr);
  let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
  axum::serve(listener, app.into_make_service()).await.unwrap();
}

async fn index_handler(headers: HeaderMap) -> impl IntoResponse {
  serve_asset("index.html", &headers)
}

async fn static_handler(Path(path): Path<String>, headers: HeaderMap) -> impl IntoResponse {
  serve_asset(&path, &headers)
}

async fn not_found() -> Html<&'static str> {
  Html("<h1>404</h1><p>Not Found</p>")
}

#[cfg_attr(not(feature = "compression"), allow(unused_variables, reason = "headers for compression path only"))]
fn serve_asset(path: &str, headers: &HeaderMap) -> Response {
  #[cfg(feature = "compression")]
  if let Some(compressed) = Asset::compressed(path) {
    let encoding = compressed.content_encoding();
    let accept = headers.get(axum::http::header::ACCEPT_ENCODING).and_then(|v| v.to_str().ok()).unwrap_or("");
    if accept.contains(encoding) {
      return (
        [
          #[cfg(feature = "mime-guess")]
          (axum::http::header::CONTENT_TYPE, compressed.metadata.mimetype()),
          (axum::http::header::CONTENT_ENCODING, encoding),
        ],
        compressed.data.compressed().to_vec(),
      )
        .into_response();
    }
  }

  match Asset::get(path) {
    Some(content) => (
      #[cfg(feature = "mime-guess")]
      [(axum::http::header::CONTENT_TYPE, content.metadata.mimetype())],
      content.data,
    )
      .into_response(),
    None => (StatusCode::NOT_FOUND, "404 Not Found").into_response(),
  }
}