git-next/src/server/mod.rs

mod actors;
mod config;
pub mod gitforge;
pub mod types;

use actix::prelude::*;

use kxio::network::Network;

use std::path::PathBuf;

use tracing::{error, info, level_filters::LevelFilter};

use crate::{
    filesystem::FileSystem,
    server::{
        actors::webhook,
        config::{ForgeConfig, ForgeName, RepoAlias, ServerStorage, Webhook},
    },
};

use self::{actors::repo::RepoActor, config::ServerRepoConfig};

pub fn init(fs: FileSystem) {
    let file_name = "git-next-server.toml";
    let path = PathBuf::from(file_name);
    if fs.file_exists(&path) {
        eprintln!(
            "The configuration file already exists at {} - not overwritting it.",
            file_name
        );
    } else {
        match fs.write_file(file_name, include_str!("../../server-default.toml")) {
            Ok(_) => println!("Created a default configuration file at {}", file_name),
            Err(e) => {
                eprintln!("Failed to write to the configuration file: {}", e)
            }
        }
    }
}

pub async fn start(fs: FileSystem, net: Network) {
    let Ok(_) = init_logging() else {
        eprintln!("Failed to initialize logging.");
        return;
    };
    info!("Starting Server...");
    let server_config = match config::ServerConfig::load(&fs) {
        Ok(server_config) => server_config,
        Err(err) => {
            error!("Failed to load config file. Error: {}", err);
            return;
        }
    };

    let webhook_router = webhook::WebhookRouter::new().start();
    let webhook = server_config.webhook();
    let server_storage = server_config.storage();

    server_config
        .forges()
        .flat_map(|(forge_name, forge)| {
            create_forge_repos(forge, forge_name, server_storage, webhook, &net)
        })
        .map(start_actor)
        .map(|(alias, addr)| webhook::AddWebhookRecipient(alias, addr.recipient()))
        .for_each(|msg| webhook_router.do_send(msg));
    let webhook_server = webhook::WebhookActor::new(webhook_router.recipient()).start();
    let _ = actix_rt::signal::ctrl_c().await;
    info!("Ctrl-C received, shutting down...");
    drop(webhook_server);
}

fn create_forge_repos(
    forge: &ForgeConfig,
    forge_name: ForgeName,
    server_storage: &ServerStorage,
    webhook: &Webhook,
    net: &Network,
) -> Vec<(ForgeName, RepoAlias, RepoActor)> {
    let forge = forge.clone();
    let span = tracing::info_span!("Forge", %forge_name, %forge);
    let _guard = span.enter();
    info!("Creating Forge");
    forge
        .repos()
        .map(create_actor(
            forge_name,
            forge.clone(),
            server_storage,
            webhook,
            net,
        ))
        .collect::<Vec<_>>()
}

fn create_actor(
    forge_name: ForgeName,
    forge: config::ForgeConfig,
    server_storage: &ServerStorage,
    webhook: &Webhook,
    net: &Network,
) -> impl Fn((RepoAlias, &ServerRepoConfig)) -> (ForgeName, RepoAlias, RepoActor) {
    let server_storage = server_storage.clone();
    let webhook = webhook.clone();
    let net = net.clone();
    move |(repo_name, server_repo_config)| {
        let span = tracing::info_span!("Repo", %repo_name, %server_repo_config);
        let _guard = span.enter();
        info!("Creating Repo");
        let actor = actors::repo::RepoActor::new(
            config::RepoDetails::new(
                &repo_name,
                server_repo_config,
                &forge_name,
                &forge,
                &server_storage,
            ),
            webhook.clone(),
            net.clone(),
        );
        info!("Created Repo");
        (forge_name.clone(), repo_name, actor)
    }
}

fn start_actor(
    actor: (ForgeName, RepoAlias, actors::repo::RepoActor),
) -> (RepoAlias, Addr<actors::repo::RepoActor>) {
    let (forge_name, repo_alias, actor) = actor;
    let span = tracing::info_span!("Forge/Repo", %forge_name, %repo_alias);
    let _guard = span.enter();
    info!("Starting");
    let addr = actor.start();
    addr.do_send(actors::repo::CloneRepo);
    info!("Started");
    (repo_alias, addr)
}

pub fn init_logging() -> Result<(), tracing::subscriber::SetGlobalDefaultError> {
    use tracing_subscriber::prelude::*;

    let subscriber = tracing_subscriber::fmt::layer()
        // NOTE: set RUSTLOG in ${root}/.cargo/config
        .with_target(false)
        .with_file(true)
        .with_line_number(true)
        .with_filter(LevelFilter::INFO);
    tracing_subscriber::registry()
        .with(console_subscriber::ConsoleLayer::builder().spawn())
        .with(subscriber)
        .init();
    Ok(())
}