lavina/src/main.rs

mod core;
mod prelude;
mod projections;
mod protos;
mod util;

use std::future::Future;

use figment::providers::Format;
use figment::{providers::Toml, Figment};
use prometheus::Registry as MetricsRegistry;
use serde::Deserialize;

use crate::core::player::PlayerRegistry;
use crate::core::room::RoomRegistry;
use crate::prelude::*;

#[derive(Deserialize, Debug)]
struct ServerConfig {
    telemetry: util::telemetry::ServerConfig,
    irc: projections::irc::ServerConfig,
}

fn load_config() -> Result<ServerConfig> {
    let raw_config = Figment::new().merge(Toml::file("config.toml"));
    let config: ServerConfig = raw_config.extract()?;
    Ok(config)
}

#[tokio::main]
async fn main() -> Result<()> {
    set_up_logging()?;
    let sleep = ctrl_c()?;
    let config = load_config()?;

    tracing::info!("Booting up");
    tracing::info!("Loaded config: {config:?}");
    let ServerConfig {
        telemetry: telemetry_config,
        irc: irc_config,
    } = config;
    let metrics = MetricsRegistry::new();
    let rooms = RoomRegistry::empty();
    let players = PlayerRegistry::empty(rooms.clone());
    let telemetry_terminator = util::telemetry::launch(telemetry_config, metrics.clone()).await?;
    let irc = projections::irc::launch(irc_config, players, metrics.clone()).await?;
    tracing::info!("Started");

    sleep.await;

    tracing::info!("Begin shutdown");
    irc.terminate().await?;
    telemetry_terminator.terminate().await?;
    tracing::info!("Shutdown complete");
    Ok(())
}

fn ctrl_c() -> Result<impl Future<Output = ()>> {
    use tokio::signal::unix::*;
    let chan = signal(SignalKind::interrupt())?;
    async fn recv(mut chan: Signal) {
        let _ = chan.recv().await;
    }
    Ok(recv(chan))
}

fn set_up_logging() -> Result<()> {
    tracing_subscriber::fmt::init();
    Ok(())
}