mod cli;
mod deployment;
mod error;
mod git;
mod inventory;
mod logs;
mod process;
mod ssh;
mod status;
mod store_path;
mod update;
mod verification;
use std::{path::PathBuf, process::ExitCode};
use clap::Parser;
use display_full_error::DisplayFullErrorExt;
use tokio_util::sync::CancellationToken;
use tracing_subscriber::{EnvFilter, filter::LevelFilter};
use crate::{
cli::{Cli, Command},
error::Error,
inventory::Inventory,
logs::LogSession,
process::ProcessContext,
};
async fn run(cli: Cli, processes: &ProcessContext<'_>) -> Result<(), Error> {
let inventory = Inventory::load(&cli.inventory).map_err(Error::Inventory)?;
match cli.command {
Command::Status(args) => {
let inventory = inventory.select(&args.ids).map_err(Error::Inventory)?;
deployment::status(inventory, args.update, processes).await
}
Command::Deploy(args) => {
let inventory = inventory
.select(&args.workflow.ids)
.map_err(Error::Inventory)?;
let options = deployment::DeployOptions {
update_flakes: args.update_flakes(),
commit_flakes: args.commit_flakes(),
approved: args.yes,
host: deployment::HostOptions {
include_verifier: !args.skip_verifier,
rollback: !args.no_rollback,
keep_generations: (!args.no_gc).then_some(args.keep_generations),
},
};
deployment::deploy(inventory, options, processes).await
}
Command::Verify(args) => {
let inventory = inventory.select(&args.ids).map_err(Error::Inventory)?;
verification::verify(inventory, processes).await
}
}
}
fn report(result: Result<(), Error>, logs: Result<Option<PathBuf>, Error>) -> ExitCode {
let succeeded = result.is_ok() && logs.is_ok();
if let Err(error) = result {
eprintln!("error: {}", error.display_full());
}
let path = match logs {
Ok(path) => path,
Err(error) => {
eprintln!("error: {}", error.display_full());
None
}
};
println!("status: {}", if succeeded { "succeeded" } else { "failed" });
if let Some(path) = path {
println!("logs: {}", path.display());
}
if succeeded {
ExitCode::SUCCESS
} else {
ExitCode::FAILURE
}
}
#[tokio::main]
async fn main() -> ExitCode {
let cli = Cli::parse();
let logs = match LogSession::start(cli.logs, cli.logs_dir.as_deref()) {
Ok(logs) => logs,
Err(error) => return report(Err(Error::Log(error)), Ok(None)),
};
if let Some(writer) = logs.writer() {
let filter = EnvFilter::builder()
.with_default_directive(LevelFilter::INFO.into())
.from_env_lossy();
let subscriber = tracing_subscriber::fmt()
.compact()
.with_ansi(false)
.with_env_filter(filter)
.with_target(false)
.with_writer(writer)
.finish();
if let Err(source) = tracing::subscriber::set_global_default(subscriber) {
let error = Error::InstallTracing { source };
let error_message = error.display_full().to_string();
return report(
Err(error),
logs.finish(Some(&error_message)).map_err(Error::Log),
);
}
logs.record_start(&cli.inventory);
}
let result = {
let cancellation = CancellationToken::new();
let processes = ProcessContext::new(&logs, cancellation.clone());
let workflow = run(cli, &processes);
tokio::pin!(workflow);
tokio::select! {
result = &mut workflow => result,
signal = tokio::signal::ctrl_c() => {
match signal {
Ok(()) => cancellation.cancel(),
Err(source) => eprintln!("error: failed to listen for interruption: {source}"),
}
workflow.await
}
}
};
let error_message = result
.as_ref()
.err()
.map(|error| error.display_full().to_string());
let log_directory = logs.finish(error_message.as_deref()).map_err(Error::Log);
report(result, log_directory)
}