#![forbid(unsafe_code)]
#![deny(missing_docs)]
#![deny(rustdoc::broken_intra_doc_links)]
#![deny(rustdoc::invalid_codeblock_attributes)]
#![deny(clippy::pedantic)]
pub mod cli;
pub mod commands;
pub mod config;
pub mod conn;
pub mod datamove;
pub mod dispatch;
pub mod error;
pub mod exec;
pub mod history;
pub mod i18n;
pub mod introspect;
pub mod obs;
pub mod output;
pub mod runtime;
pub mod serverinfo;
pub mod settings;
pub mod sql;
pub mod types;
use clap::Parser;
use error::{ExitNumber, Failure};
use std::io::Write;
pub const ENCRYPTED_CHANNEL_AVAILABLE: bool = cfg!(feature = "tls");
pub fn run<O: Write, E: Write>(
argv: Vec<std::ffi::OsString>,
out: &mut O,
err: &mut E,
) -> ExitNumber {
if let Some(requested) = requested_language(&argv) {
let _ = i18n::install(Some(&requested), None);
}
let cli = match cli::Cli::try_parse_from(argv) {
Ok(parsed) => parsed,
Err(parse_error) => return render_parse_outcome(&parse_error, out, err),
};
let _guard = match install_auxiliary_channel(&cli, err) {
Ok(guard) => guard,
Err(failure) => {
let _ = error::render::write_failure(err, &failure);
return failure.exit_number();
}
};
let floor = settings::protocol_floor(cli.globals.diagnostics.config_dir.as_deref());
if let Err(failure) = conn::provider::install(floor) {
let _ = error::render::write_failure(err, &failure);
return failure.exit_number();
}
match dispatch(&cli, out) {
Ok(number) => number,
Err(failure) => {
let _ = error::render::write_failure(err, &failure);
failure.exit_number()
}
}
}
fn install_auxiliary_channel<E: Write>(
cli: &cli::Cli,
err: &mut E,
) -> error::Result<Option<tracing_appender::non_blocking::WorkerGuard>> {
let Ok(config) = config::Config::load(cli.globals.diagnostics.config_dir.as_deref()) else {
return Ok(None);
};
let settings = obs::settings::resolve(&config, &cli.globals)?;
match obs::install(&settings) {
Ok(guard) => Ok(guard),
Err(failure) if failure.code() == "log.already_installed" => Ok(None),
Err(failure) => {
let _ = error::render::write_failure(err, &failure);
Ok(None)
}
}
}
fn requested_language(argv: &[std::ffi::OsString]) -> Option<String> {
let mut items = argv.iter();
while let Some(item) = items.next() {
let Some(text) = item.to_str() else { continue };
if text == "--" {
break;
}
if text == "--lang" {
return items
.next()
.and_then(|value| value.to_str())
.map(str::to_owned);
}
if let Some(value) = text.strip_prefix("--lang=") {
return Some(value.to_owned());
}
}
None
}
fn render_parse_outcome<O: Write, E: Write>(
parse_error: &clap::Error,
out: &mut O,
err: &mut E,
) -> ExitNumber {
use clap::error::ErrorKind;
if matches!(
parse_error.kind(),
ErrorKind::DisplayHelp
| ErrorKind::DisplayVersion
| ErrorKind::DisplayHelpOnMissingArgumentOrSubcommand
) {
let _ = write!(out, "{parse_error}");
return ExitNumber::Success;
}
let failure = Failure::usage(
"usage.invalid_arguments",
"the arguments given do not match the accepted form",
)
.with_hint("run with --help to see the accepted form")
.with_cause(parse_error.to_string());
let _ = error::render::write_failure(err, &failure);
ExitNumber::Usage
}
fn dispatch<O: Write>(cli: &cli::Cli, out: &mut O) -> error::Result<ExitNumber> {
let mut counted = output::Counted::new(out);
let outcome = match dispatch::build_runtime() {
Ok(runtime) => runtime.block_on(dispatch::under_signals(async |shutdown| {
served(cli, &mut counted, shutdown).await
})),
Err(failure) => Err(failure),
};
i18n::report::response_volume(counted.bytes(), counted.lines());
outcome
}
async fn served<O: Write>(
cli: &cli::Cli,
out: &mut O,
shutdown: &runtime::Shutdown,
) -> error::Result<ExitNumber> {
let config_dir = cli.globals.diagnostics.config_dir.as_deref();
let config = match config::Config::load(config_dir) {
Ok(config) => config,
Err(unreadable) if dispatch::diagnoses_the_settings(&cli.command) => {
config::Config::with_nothing_stored(config_dir).map_err(|_| unreadable)?
}
Err(unreadable) => return Err(unreadable),
};
let format = output_shape(cli, &config)?;
cli.globals.refuse_a_profile_over_a_flow(format)?;
let pipeline = cli.globals.pipeline(&config)?;
let Some(path) = cli.globals.output.output.clone() else {
let Some(envelope) = dispatch::serve(cli, out, shutdown).await? else {
return Ok(ExitNumber::Success);
};
let shaped = signed(cli, pipeline.apply(envelope)?)?;
output::format::for_format(format).write_envelope(out, &shaped)?;
return Ok(ExitNumber::Success);
};
let mut staged = output::destination::staged(&path)?;
let served = dispatch::serve(cli, &mut staged, shutdown).await?;
let command = match served {
None => cli.command.published_name(),
Some(envelope) => {
let shaped = signed(cli, pipeline.apply(envelope)?)?;
match shaped.raw_document() {
Some(document) => staged
.write_all(document.as_bytes())
.map_err(|cause| unwritable(&path, &cause))?,
None => output::format::for_format(format).write_envelope(&mut staged, &shaped)?,
}
shaped.command
}
};
let report = staged.finish()?;
let receipt = output::Envelope::new(command, serde_json::to_value(&report).unwrap_or_default());
output::format::for_format(format).write_envelope(out, &receipt)?;
Ok(ExitNumber::Success)
}
fn unwritable(path: &std::path::Path, cause: &std::io::Error) -> error::Failure {
error::Failure::config(
"output.destination_unwritable",
"the destination stopped accepting the answer",
)
.with_detail("detail", path.display().to_string())
.with_cause(cause.to_string())
}
pub fn output_shape(
cli: &cli::Cli,
config: &config::Config,
) -> error::Result<cli::globals::OutputFormat> {
use cli::globals::OutputFormat;
if let Some(asked) = cli.globals.output.output_format {
return Ok(asked);
}
Ok(match settings::word(config, "output.format")?.as_str() {
"ndjson" => OutputFormat::Ndjson,
"tsv" => OutputFormat::Tsv,
"text" => OutputFormat::Text,
_ => OutputFormat::Json,
})
}
fn signed(cli: &cli::Cli, envelope: output::Envelope) -> error::Result<output::Envelope> {
if !cli.globals.output.checksum {
return Ok(envelope);
}
if envelope
.applied
.as_ref()
.is_some_and(|applied| applied.output_truncated)
{
return Err(Failure::limit(
"limit.signature_over_a_cut_answer",
"the answer was cut to fit the volume ceiling, so it cannot be signed",
)
.with_hint("raise --max-output-bytes, or drop --checksum"));
}
let signature = match envelope.payload_array_key() {
Some(key) => output::checksum::of_rows(&rows_of(&envelope, key)),
None => output::checksum::of_bytes(
serde_json::to_vec(&envelope.data)
.unwrap_or_default()
.as_slice(),
),
};
let gathered = envelope
.applied
.clone()
.unwrap_or_default()
.also_gathered_for_the_signature();
Ok(envelope.with_applied(gathered).with_checksum(signature))
}
fn rows_of(envelope: &output::Envelope, key: &str) -> Vec<output::Row> {
envelope.data[key]
.as_array()
.map(|rows| {
rows.iter()
.map(|row| serde_json::from_value(row.clone()).unwrap_or_default())
.collect()
})
.unwrap_or_default()
}
#[cfg(test)]
mod tests {
use super::*;
fn invoke(args: &[&str]) -> (ExitNumber, String, String) {
let command_line: Vec<std::ffi::OsString> = std::iter::once("mariadb-cli")
.chain(args.iter().copied())
.map(Into::into)
.collect();
let (mut out, mut err) = (Vec::new(), Vec::new());
let number = run(command_line, &mut out, &mut err);
(
number,
String::from_utf8(out).expect("utf8 out"),
String::from_utf8(err).expect("utf8 err"),
)
}
#[test]
fn help_is_a_success_and_never_a_failure() {
let (number, out, err) = invoke(&["--help"]);
assert_eq!(number, ExitNumber::Success);
assert!(!out.is_empty(), "help belongs on the primary channel");
assert!(err.is_empty(), "help is not a failure");
}
#[test]
fn a_bad_argument_is_a_usage_failure_on_the_auxiliary_channel() {
let (number, out, err) = invoke(&["--no-such-flag"]);
assert_eq!(number, ExitNumber::Usage);
assert!(
out.is_empty(),
"a failure never reaches the primary channel"
);
let parsed: serde_json::Value =
serde_json::from_str(err.trim_end()).expect("structured failure");
assert_eq!(parsed["error"]["category"], "usage");
assert_eq!(parsed["error"]["exit"], 2);
assert_eq!(parsed["error"]["retryable"], false);
}
#[test]
fn a_malformed_filter_is_refused_before_any_work() {
let (number, _, err) = invoke(&["--filter", "broken", "meta", "version"]);
assert_eq!(number, ExitNumber::Usage);
assert!(err.contains("filter.no_operator"));
}
#[test]
fn the_primary_channel_carries_one_parseable_line() {
let (number, out, err) = invoke(&["meta", "version"]);
assert_eq!(number, ExitNumber::Success);
assert!(
err.is_empty(),
"a clean run says nothing on the auxiliary channel"
);
let parsed: serde_json::Value =
serde_json::from_str(out.trim_end()).expect("one json line");
assert_eq!(parsed["command"], "meta version");
}
#[test]
fn the_same_invocation_produces_the_same_bytes() {
let first = invoke(&["meta", "commands"]).1;
let second = invoke(&["meta", "commands"]).1;
assert_eq!(first, second, "the answer must be byte-for-byte stable");
}
#[test]
fn the_output_pipeline_serves_every_command_without_command_side_code() {
let (number, out, _) = invoke(&["--count-only", "meta", "commands"]);
assert_eq!(number, ExitNumber::Success);
let parsed: serde_json::Value =
serde_json::from_str(out.trim_end()).expect("one json line");
assert!(parsed["data"]["count"].is_number());
}
}