mod api; mod command; mod config; mod fail2ban; mod firewall; mod logs; mod network; mod privileged; mod services; mod system; mod wireguard; use anyhow::{Context, Result}; use axum_server::{tls_rustls::RustlsConfig, Handle}; use config::Config; use std::{env, path::PathBuf, time::Duration}; use tracing_subscriber::EnvFilter; #[tokio::main(flavor = "multi_thread", worker_threads = 2)] async fn main() -> Result<()> { let arguments = parse_args()?; if arguments.privileged_helper { return privileged::serve_once(&arguments.config_path); } if let Some(transaction) = arguments.firewall_rollback { return privileged::rollback_firewall(&arguments.config_path, &transaction); } let config_path = arguments.config_path; let config = Config::load(&config_path)?; tracing_subscriber::fmt() .with_env_filter( EnvFilter::try_new(&config.logging.level).context("invalid logging filter")?, ) .compact() .init(); let state = api::AppState::load(config.clone())?; let app = api::router(state); let handle = Handle::new(); let shutdown_handle = handle.clone(); tokio::spawn(async move { wait_for_shutdown().await; tracing::info!("shutdown signal received"); shutdown_handle.graceful_shutdown(Some(Duration::from_secs(10))); }); tracing::info!(listen = %config.server.listen, tls = config.tls.enabled, version = env!("CARGO_PKG_VERSION"), "vps-agent started"); if config.tls.enabled { let tls = RustlsConfig::from_pem_file(&config.tls.certificate_file, &config.tls.private_key_file) .await .context("load TLS certificate/key")?; axum_server::bind_rustls(config.server.listen, tls) .handle(handle) .serve(app.into_make_service()) .await?; } else { axum_server::bind(config.server.listen) .handle(handle) .serve(app.into_make_service()) .await?; } Ok(()) } struct Arguments { config_path: PathBuf, privileged_helper: bool, firewall_rollback: Option, } fn parse_args() -> Result { let mut args = env::args().skip(1); let mut config = PathBuf::from("/etc/vps-agent/config.toml"); let mut privileged_helper = false; let mut firewall_rollback = None; while let Some(argument) = args.next() { match argument.as_str() { "--config" => { config = args .next() .map(PathBuf::from) .context("--config needs a path")? } "--privileged-helper" => privileged_helper = true, "--firewall-rollback" => { firewall_rollback = Some(args.next().context("--firewall-rollback needs an id")?) } "--version" | "-V" => { println!("vps-agent {}", env!("CARGO_PKG_VERSION")); std::process::exit(0); } "--help" | "-h" => { println!("Usage: vps-agent [--config PATH] [--version]"); std::process::exit(0); } _ => anyhow::bail!("unknown argument: {argument}"), } } Ok(Arguments { config_path: config, privileged_helper, firewall_rollback, }) } async fn wait_for_shutdown() { #[cfg(unix)] { use tokio::signal::unix::{signal, SignalKind}; let mut terminate = signal(SignalKind::terminate()).expect("install SIGTERM handler"); tokio::select! { _ = tokio::signal::ctrl_c() => {}, _ = terminate.recv() => {} } } #[cfg(not(unix))] let _ = tokio::signal::ctrl_c().await; }