main.rs

mod app;
pub mod c_wrapper;
mod cmd;
mod config;
mod error;
mod listen;
mod mpris;
mod routes;

pub use app::*;
pub use config::*;
pub use error::*;
pub use listen::*;

use anyhow::{Context, Result};
use cmd::SubCommand;
use lektor_utils::*;
use std::sync::atomic::{AtomicU64, Ordering};
use tokio::{signal, sync::oneshot::Receiver};

fn main() -> Result<()> {
    logger::init(Some(log::Level::Debug)).expect("failed to install logger");
    let config = lektor_utils::config::get_or_write_default_config::<LektorConfig>("lektord")?;
    let args = <cmd::Args as clap::Parser>::parse();
    lektor_utils::logger::level(config.log);
    if args.verbose != 0 {
        lektor_utils::logger::level_int(args.verbose);
    }

    match args.action.unwrap_or_default() {
        SubCommand::Config { show: true, .. } => {
            println!("{config}");
            Ok(())
        }

        SubCommand::Config {
            edit: Some(args), ..
        } => match &args[..] {
            [name, value] => config.edit(name, value),
            args => unreachable!("{args:#?}"),
        },

        SubCommand::Start => {
            log::info!("starting the lektord daemon");
            tokio::runtime::Builder::new_multi_thread()
                .worker_threads(config.workers) // Thread count from the config file.
                .thread_name_fn(|| {
                    static COUNT: AtomicU64 = AtomicU64::new(0);
                    format!("lektord-{}", COUNT.fetch_add(1, Ordering::SeqCst))
                })
                .enable_all()
                .thread_stack_size(3 * 1024 * 1024) // 3Mio for each thread, should be enaugh
                .build()?
                .block_on(async move {
                    lektor_utils::config::write_config_async("lektord", config.clone()).await?; // Write to apply changes...
                    let addrs = AddrIncomingCombined::from_iter(&config.listen).err()?;
                    let (app, shutdown) = app(config)
                        .await
                        .with_context(|| "failed to build service")?;
                    hyper::Server::builder(addrs)
                        .serve(app.into_make_service())
                        .with_graceful_shutdown(shutdown_signal(shutdown))
                        .await?;
                    Ok(())
                })
        }

        args => unreachable!("{args:?}"),
    }
}

/// Gracefull ctrl+c handling.
async fn shutdown_signal(shutdown: Receiver<()>) {
    let shutdown = async {
        let _ = shutdown.await;
        log::info!("shutdown signal!")
    };
    let ctrl_c = async {
        signal::ctrl_c()
            .await
            .expect("failed to install Ctrl+C handler");
        log::info!("ctrl+c signal!")
    };

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

    #[cfg(not(unix))]
    let terminate = std::future::pending::<()>();

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

    log::info!("received termination signal shutting down, try to unregister the state from the player module");
    if let Err(err) = c_wrapper::close_player_module().await {
        log::error!("{err}")
    }
    log::info!("will now call exit(EXIT_SUCCESS)");
    std::process::exit(0);
}