93 lines
2.8 KiB
Rust
93 lines
2.8 KiB
Rust
use axum::{serve, Router};
|
|
use notify::{Config, RecommendedWatcher, RecursiveMode, Watcher};
|
|
use std::{path::PathBuf, str::FromStr, sync::OnceLock};
|
|
use tokio::sync::mpsc::channel;
|
|
use tower_http::services::ServeDir;
|
|
use tower_livereload::{LiveReloadLayer, Reloader};
|
|
pub use tracing::{debug, error, info, warn};
|
|
|
|
type Berr = Box<dyn std::error::Error>;
|
|
type Besult<T> = Result<T, Berr>;
|
|
|
|
mod observe {
|
|
pub fn setup_logging() {
|
|
color_eyre::install().expect("Failed to install color_eyre");
|
|
|
|
let filter = tracing_subscriber::EnvFilter::builder()
|
|
.with_default_directive(<tracing_subscriber::filter::Directive>::from(
|
|
tracing::level_filters::LevelFilter::TRACE,
|
|
))
|
|
.parse_lossy("info,lyrs=trace");
|
|
|
|
tracing_subscriber::fmt().with_env_filter(filter).init();
|
|
}
|
|
}
|
|
|
|
fn static_file_dir() -> &'static PathBuf {
|
|
static STATIC_FILE_DIR: OnceLock<PathBuf> = OnceLock::new();
|
|
STATIC_FILE_DIR.get_or_init(|| PathBuf::from_str("static").unwrap())
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Besult<()> {
|
|
// load configuration?
|
|
observe::setup_logging();
|
|
|
|
// pulling the watcher into main's scope lets it live until the program dies
|
|
let (rl_layer, _watcher) = live_reload_layer()?;
|
|
|
|
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
|
|
info!("Listening on {listener:#?}");
|
|
let router = Router::new()
|
|
.nest_service("/static", ServeDir::new(static_file_dir()))
|
|
.layer(rl_layer);
|
|
|
|
Ok(serve(listener, router).await?)
|
|
}
|
|
|
|
fn live_reload_layer() -> Besult<(LiveReloadLayer, RecommendedWatcher)> {
|
|
let rl_layer = LiveReloadLayer::new();
|
|
let rl = rl_layer.reloader();
|
|
let watcher = static_file_watcher(rl)?;
|
|
Ok((rl_layer, watcher))
|
|
}
|
|
|
|
fn static_file_watcher(
|
|
reloader: Reloader,
|
|
) -> Result<RecommendedWatcher, Box<dyn std::error::Error>> {
|
|
info!("Creating async watcher...");
|
|
|
|
let (tx, mut rx) = channel(1);
|
|
|
|
info!("Creating watcher...");
|
|
// watcher needs to move out of scope to live long enough to watch
|
|
let mut watcher = RecommendedWatcher::new(
|
|
move |res| {
|
|
info!("Res from watcher: {res:#?}");
|
|
futures::executor::block_on(async {
|
|
tx.send(res).await.unwrap();
|
|
})
|
|
},
|
|
Config::default(),
|
|
)?;
|
|
info!("Created watcher");
|
|
|
|
watcher.watch(static_file_dir(), RecursiveMode::Recursive)?;
|
|
|
|
tokio::spawn(async move {
|
|
info!("Recieving...");
|
|
while let Some(res) = rx.recv().await {
|
|
info!("Recieved! {res:#?}");
|
|
match res {
|
|
Ok(event) => {
|
|
info!("fs event: {event:#?}");
|
|
reloader.reload()
|
|
}
|
|
Err(e) => println!("watch error: {:?}", e),
|
|
}
|
|
}
|
|
});
|
|
|
|
Ok(watcher)
|
|
}
|