#[path = "cli/args.rs"]
mod args;
#[path = "cli/auth.rs"]
mod command_auth;
#[path = "cli/error.rs"]
mod error;
#[path = "cli/item.rs"]
mod item;
#[path = "cli/output.rs"]
mod output;
#[path = "cli/request.rs"]
mod request;
#[path = "cli/session.rs"]
mod session;
use std::{
io::{IsTerminal as _, Write as _},
process::ExitCode,
time::Duration,
};
use clap::{Parser as _, error::ErrorKind};
use crate::{args::Args, error::Result, output::Output};
fn main() -> ExitCode {
let args = match Args::try_parse() {
Ok(args) => args,
Err(error) => {
let success = matches!(
error.kind(),
ErrorKind::DisplayHelp
| ErrorKind::DisplayVersion
| ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
);
let _ = error.print();
return if success {
ExitCode::SUCCESS
} else {
ExitCode::FAILURE
};
}
};
let runtime = match tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
{
Ok(runtime) => runtime,
Err(_) => {
print_error("the HTTP runtime could not be started");
return ExitCode::FAILURE;
}
};
let exit = runtime.block_on(run(args));
runtime.shutdown_timeout(Duration::from_millis(100));
exit
}
async fn run(args: Args) -> ExitCode {
match execute(args).await {
Ok(code) => ExitCode::from(code),
Err(error) if error.is_broken_pipe() => ExitCode::SUCCESS,
Err(error) => {
print_error(&error.to_string());
ExitCode::from(error.exit_code())
}
}
}
async fn execute(args: Args) -> Result<u8> {
let stdin_is_terminal = std::io::stdin().is_terminal();
let output = Output::new(
args.headers,
args.body,
args.output.clone(),
std::io::stdout().is_terminal(),
args.download,
args.continue_download,
args.stream,
);
let target = args.target()?;
let mut session = session::Session::open(&args, &target.url).await?;
let outcome = request::execute(&args, stdin_is_terminal, &mut session).await?;
session.save().await?;
match outcome {
request::Outcome::Request(request) => {
output::write_request(request).await?;
Ok(0)
}
request::Outcome::Response(response) => {
let exit = output::status_exit(response.status(), args.check_status || args.download);
output::write(response, &output).await?;
Ok(exit)
}
}
}
fn print_error(message: &str) {
let _ = writeln!(std::io::stderr().lock(), "tez: {message}");
}
#[cfg(test)]
mod tests {
#[test]
fn cli_errors_are_redacted_by_construction() {
let error = crate::error::Error::usage("request item is malformed");
assert_eq!(error.to_string(), "request item is malformed");
assert!(!format!("{error:?}").contains("secret"));
}
}