what2watch/src/main.rs

use std::net::SocketAddr;

use rand::{thread_rng, RngCore};
use tokio::signal;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use what2watch::get_db_pool;

fn main() {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "what2watch=debug,axum::routing=info".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();

    let pool = get_db_pool();

    let rt = tokio::runtime::Builder::new_multi_thread()
        .enable_all()
        .build()
        .unwrap();

    let secret = {
        let mut bytes = [0u8; 64];
        let mut rng = thread_rng();
        rng.fill_bytes(&mut bytes);
        bytes
    };

    let app = rt.block_on(what2watch::app(pool.clone(), &secret));

    rt.block_on(async {
        let addr: SocketAddr = ([0, 0, 0, 0], 3000).into();
        tracing::debug!("binding to {addr:?}");

        axum::Server::bind(&addr)
            .serve(app)
            .with_graceful_shutdown(shutdown_signal())
            .await
            .unwrap_or_default();
    });

    rt.block_on(pool.close());
}

async fn shutdown_signal() {
    let ctrl_c = async {
        signal::ctrl_c()
            .await
            .expect("failed to install Ctrl+C handler");
    };

    #[cfg(unix)]
    let terminate = async {
        signal::unix::signal(signal::unix::SignalKind::terminate())
            .expect("failed to install signal handler")
            .recv()
            .await;
    };

    tokio::select! {
        _ = ctrl_c => {},
        _ = terminate => {},
    }

    println!(" signal received, starting graceful shutdown");
}