lyrs/src/main.rs

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)
}