domani/src/main.rs

use clap::Parser;
use futures::stream::StreamExt;
use signal_hook_tokio::Signals;
use tokio::select;
use tokio::time;

use std::convert::Infallible;
use std::net::SocketAddr;
use std::path;
use std::str::FromStr;
use std::sync;

use domiply::origin::store::Store;

#[derive(Parser, Debug)]
#[command(version)]
#[command(about = "A domiply to another dimension")]
struct Cli {
    #[arg(long, default_value_t = SocketAddr::from_str("[::]:3030").unwrap(), env = "DOMIPLY_HTTP_LISTEN_ADDR")]
    http_listen_addr: SocketAddr,

    #[arg(long, required = true, env = "DOMIPLY_HTTP_DOMAIN")]
    http_domain: String,

    #[arg(long, required = true, env = "DOMIPLY_PASSPHRASE")]
    passphrase: String,

    #[arg(long, required = true, env = "DOMIPLY_ORIGIN_STORE_GIT_DIR_PATH")]
    origin_store_git_dir_path: path::PathBuf,

    #[arg(long, required = true, env = "DOMIPLY_DOMAIN_CHECKER_TARGET_A")]
    domain_checker_target_a: std::net::Ipv4Addr,

    #[arg(long, default_value_t = String::from("1.1.1.1:53"), env = "DOMIPLY_DOMAIN_CHECKER_RESOLVER_ADDR")]
    domain_checker_resolver_addr: String,

    #[arg(long, required = true, env = "DOMIPLY_DOMAIN_CONFIG_STORE_DIR_PATH")]
    domain_config_store_dir_path: path::PathBuf,
}

fn main() {
    let config = Cli::parse();

    let tokio_runtime = std::sync::Arc::new(
        tokio::runtime::Builder::new_multi_thread()
            .enable_all()
            .build()
            .unwrap(),
    );

    let canceller = tokio_runtime.block_on(async { tokio_util::sync::CancellationToken::new() });

    {
        let canceller = canceller.clone();
        tokio_runtime.spawn(async move {
            let mut signals =
                Signals::new(signal_hook::consts::TERM_SIGNALS).expect("initialized signals");

            if (signals.next().await).is_some() {
                println!("Gracefully shutting down...");
                canceller.cancel();
            }

            if (signals.next().await).is_some() {
                println!("Forcefully shutting down");
                std::process::exit(1);
            };
        });
    }

    let origin_store = domiply::origin::store::git::new(config.origin_store_git_dir_path)
        .expect("git origin store initialized");

    let origin_syncer_handler = {
        let origin_store = origin_store.clone();
        let canceller = canceller.clone();

        tokio_runtime.spawn(async move {
            let mut interval = time::interval(time::Duration::from_secs(20 * 60));
            interval.tick().await;

            loop {
                origin_store
                    .all_descrs()
                    .expect("got all_descrs iter")
                    .into_iter()
                    .for_each(|descr| {
                        if canceller.is_cancelled() {
                            return;
                        }

                        if let Err(err) = descr {
                            println!("failed iterating origins: {err}");
                            return;
                        }

                        let descr = descr.unwrap();

                        println!("syncing origin: {descr:?}");
                        if let Err(err) =
                            origin_store.sync(descr.clone(), domiply::origin::store::Limits {})
                        {
                            println!("error syncing origin {descr:?}: {err}");
                        }
                    });

                select! {
                _ = interval.tick() => continue,
                _ = canceller.cancelled() => return,
                }
            }
        })
    };

    let domain_checker = domiply::domain::checker::new(
        tokio_runtime.clone(),
        config.domain_checker_target_a,
        &config.domain_checker_resolver_addr,
    )
    .expect("domain checker initialized");

    let domain_config_store = domiply::domain::config::new(&config.domain_config_store_dir_path)
        .expect("domain config store initialized");

    let manager = domiply::domain::manager::new(origin_store, domain_config_store, domain_checker);
    let manager = sync::Arc::new(manager);

    let service = domiply::service::new(
        manager,
        config.domain_checker_target_a,
        config.passphrase,
        config.http_domain.clone(),
    );

    let service = sync::Arc::new(service);

    let make_service =
        hyper::service::make_service_fn(move |_conn: &hyper::server::conn::AddrStream| {
            let service = service.clone();

            // Create a `Service` for responding to the request.
            let service = hyper::service::service_fn(move |req| {
                domiply::service::handle_request(service.clone(), req)
            });

            // Return the service to hyper.
            async move { Ok::<_, Infallible>(service) }
        });

    let server_handler = {
        tokio_runtime.spawn(async move {
            let addr = config.http_listen_addr;

            println!("Listening on http://{}:{}", config.http_domain, addr.port());
            let server = hyper::Server::bind(&addr).serve(make_service);

            let graceful = server.with_graceful_shutdown(async {
                canceller.cancelled().await;
            });

            if let Err(e) = graceful.await {
                panic!("server error: {}", e);
            };
        })
    };

    tokio_runtime
        .block_on(async { futures::try_join!(origin_syncer_handler, server_handler) })
        .unwrap();

    println!("Graceful shutdown complete");
}