116 lines
3.7 KiB
Rust
116 lines
3.7 KiB
Rust
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<String>,
|
|
}
|
|
|
|
fn parse_args() -> Result<Arguments> {
|
|
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;
|
|
}
|