mod asndata;
mod irr;
mod peeringdb;
mod refresh;
mod tls;
use asndata::Task;
use clap::{Parser, Subcommand};
use std::process::exit;
#[derive(Parser)]
#[command(
name = "pg_inserter",
version,
about = "Bulk-load BGP reference data into PostgreSQL"
)]
struct Cli {
#[command(subcommand)]
command: Commands,
#[arg(long, env = "DATABASE_URL", global = true)]
database_url: Option<String>,
}
#[derive(Subcommand, Clone, Copy, PartialEq, Eq)]
enum Commands {
Asnames,
As2org,
Population,
Hegemony,
Delegated,
Allocations,
Asndata,
Peeringdb,
Irr,
}
#[tokio::main]
async fn main() {
tracing_subscriber::fmt().with_ansi(false).init();
dotenvy::dotenv().ok();
let cli = Cli::parse();
let Some(database_url) = cli.database_url else {
eprintln!(
"DATABASE_URL is not set; pass --database-url or set the DATABASE_URL environment variable"
);
exit(10);
};
if let Err(message) = tls::ConnectionSettings::parse(&database_url) {
eprintln!("invalid DATABASE_URL: {message}");
exit(10);
}
let mut exit_code = 0;
if cli.command == Commands::Peeringdb {
let data_as_of = chrono::Utc::now();
let tables = match tokio::task::spawn_blocking({
let data_as_of = data_as_of.to_rfc3339();
move || peeringdb::load_all(&data_as_of)
})
.await
{
Ok(Ok(tables)) => tables,
Ok(Err(e)) => {
eprintln!("peeringdb: data load failed: {e}");
refresh::record_family_error_run(
"peeringdb",
"peeringdb.net",
&database_url,
&format!("data load failed: {e}"),
)
.await;
exit(11);
}
Err(e) => {
eprintln!("peeringdb: data loader task failed: {e}");
refresh::record_family_error_run(
"peeringdb",
"peeringdb.net",
&database_url,
&format!("data loader task failed: {e}"),
)
.await;
exit(11);
}
};
if let Err(code) = refresh::run_tables(tables, data_as_of, &database_url).await {
exit_code = code;
}
} else if cli.command == Commands::Irr {
if let Err(code) = irr::run(&database_url).await {
exit_code = code;
}
} else {
let tasks: &[Task] = match cli.command {
Commands::Asnames => &[Task::Asnames],
Commands::As2org => &[Task::As2org],
Commands::Population => &[Task::Population],
Commands::Hegemony => &[Task::Hegemony],
Commands::Delegated => &[Task::Delegated],
Commands::Allocations => &[Task::Allocations],
Commands::Asndata => asndata::ALL_TASKS,
Commands::Peeringdb | Commands::Irr => unreachable!(),
};
for task in tasks {
let spec = task.spec();
let load = task.load_fn();
if let Err(code) = refresh::run_task(spec, load, &database_url).await {
exit_code = code;
}
}
}
if exit_code != 0 {
exit(exit_code);
}
}