85 lines
2.9 KiB
Rust
85 lines
2.9 KiB
Rust
use std::path::{Path, PathBuf};
|
|
use std::{env, io};
|
|
|
|
use axum::body::Body;
|
|
use axum::http::Request;
|
|
use listenfd::ListenFd;
|
|
use notify::Watcher;
|
|
use thiserror::Error;
|
|
use tokio::net::TcpListener;
|
|
use tower_livereload::predicate::Predicate;
|
|
use tower_livereload::LiveReloadLayer;
|
|
|
|
use ::app::get_router;
|
|
|
|
#[derive(Error, Debug)]
|
|
pub enum AppError {
|
|
#[error("Unable to bind to TCP listener")]
|
|
TCPListener(#[from] std::io::Error),
|
|
#[error("Error with the notify watcher")]
|
|
NotifyWatcher(#[from] notify::Error),
|
|
#[error("Missing environment variable {var}")]
|
|
MissingEnvVar { var: &'static str },
|
|
}
|
|
|
|
/// Nous filtrons les requêtes de `htmx` pour ne pas inclure le script _JS_ qui gère le rechargement
|
|
/// Voir https://github.com/leotaku/tower-livereload/pull/3
|
|
#[derive(Copy, Clone)]
|
|
struct NotHtmxPredicate;
|
|
impl<T> Predicate<Request<T>> for NotHtmxPredicate {
|
|
fn check(&mut self, req: &Request<T>) -> bool {
|
|
!(req.headers().contains_key("hx-request"))
|
|
}
|
|
}
|
|
|
|
const DEFAULT_LISTENER: &str = "localhost:3000";
|
|
async fn get_tcp_listener() -> Result<TcpListener, io::Error> {
|
|
let mut listenfd = ListenFd::from_env();
|
|
|
|
match listenfd.take_tcp_listener(0)? {
|
|
// if we are given a tcp listener on listen fd 0, we use that one
|
|
Some(listener) => {
|
|
listener.set_nonblocking(true)?;
|
|
Ok(TcpListener::from_std(listener)?)
|
|
}
|
|
// otherwise fall back to local listening
|
|
None => Ok(TcpListener::bind(DEFAULT_LISTENER).await?),
|
|
}
|
|
}
|
|
|
|
fn get_livereload_layer(
|
|
templates_paths: Vec<PathBuf>,
|
|
) -> Result<LiveReloadLayer<NotHtmxPredicate>, notify::Error> {
|
|
let livereload = LiveReloadLayer::new();
|
|
let reloader = livereload.reloader();
|
|
let mut watcher = notify::recommended_watcher(move |_| reloader.reload())?;
|
|
for templates_path in templates_paths {
|
|
watcher.watch(templates_path.as_path(), notify::RecursiveMode::Recursive)?;
|
|
}
|
|
Ok(livereload.request_predicate::<Body, NotHtmxPredicate>(NotHtmxPredicate))
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), AppError> {
|
|
let manifest_dir = env::var("CARGO_MANIFEST_DIR").map_err(|_| AppError::MissingEnvVar {
|
|
var: "CARGO_MANIFEST_DIR",
|
|
})?;
|
|
let assets_path = Path::new(&manifest_dir).join("assets");
|
|
let templates_paths = vec![
|
|
Path::new(&manifest_dir).join("src/pages"),
|
|
Path::new(&manifest_dir).join("src/components"),
|
|
];
|
|
|
|
let livereload_layer =
|
|
get_livereload_layer(templates_paths).map_err(AppError::NotifyWatcher)?;
|
|
let router = get_router(assets_path).await.layer(livereload_layer);
|
|
|
|
let listener: TcpListener = get_tcp_listener().await.map_err(AppError::TCPListener)?;
|
|
let local_addr = listener.local_addr().map_err(AppError::TCPListener)?;
|
|
println!("Listening on: http://{}", local_addr);
|
|
|
|
// Run the server with the router
|
|
axum::serve(listener, router.into_make_service()).await?;
|
|
Ok(())
|
|
}
|