( )⚙ D10090 rhg: Make configuration available as early as possible in main()

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10090

rhg: Make configuration available as early as possible in main()
ClosedPublic

Authored by SimonSapin on Mar 2 2021, 2:58 PM.

Details

Reviewers
Alphare
pulkit
Group Reviewers
hg-reviewers
Commits
rHG7284b524b441: rhg: Make configuration available as early as possible in main()

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

SimonSapin created this revision.Mar 2 2021, 2:58 PM
Alphare accepted this revision.Mar 5 2021, 3:21 AM
pulkit accepted this revision.Mar 10 2021, 1:30 PM
This revision is now accepted and ready to land.Mar 10 2021, 1:30 PM

Revision Contents
Changeset List

Diff 26024

rust/rhg/src/blackbox.rs

} }
impl<'a> Blackbox<'a> { impl<'a> Blackbox<'a> {
pub fn new( pub fn new(
invocation: &'a CliInvocation<'a>, invocation: &'a CliInvocation<'a>,
process_start_time: &'a ProcessStartTime, process_start_time: &'a ProcessStartTime,
) -> Result<Self, HgError> { ) -> Result<Self, HgError> {
let configured = if let Ok(repo) = invocation.repo { let configured = if let Ok(repo) = invocation.repo {
let config = invocation.config(); if invocation.config.get(b"extensions", b"blackbox").is_none() {
if config.get(b"extensions", b"blackbox").is_none() {
// The extension is not enabled // The extension is not enabled
None None
} else { } else {
Some(ConfiguredBlackbox { Some(ConfiguredBlackbox {
repo, repo,
max_size: config max_size: invocation
.config
.get_byte_size(b"blackbox", b"maxsize")? .get_byte_size(b"blackbox", b"maxsize")?
.unwrap_or(DEFAULT_MAX_SIZE), .unwrap_or(DEFAULT_MAX_SIZE),
max_files: config max_files: invocation
.config
.get_u32(b"blackbox", b"maxfiles")? .get_u32(b"blackbox", b"maxfiles")?
.unwrap_or(DEFAULT_MAX_FILES), .unwrap_or(DEFAULT_MAX_FILES),
date_format: config date_format: invocation
.config
.get_str(b"blackbox", b"date-format")? .get_str(b"blackbox", b"date-format")?
.unwrap_or(DEFAULT_DATE_FORMAT), .unwrap_or(DEFAULT_DATE_FORMAT),
}) })
} }
} else { } else {
// Without a local repository there’s no `.hg/blackbox.log` to // Without a local repository there’s no `.hg/blackbox.log` to
// write to. // write to.
None None

rust/rhg/src/commands/config.rs

let (section, name) = invocation let (section, name) = invocation
.subcommand_args .subcommand_args
.value_of("name") .value_of("name")
.expect("missing required CLI argument") .expect("missing required CLI argument")
.as_bytes() .as_bytes()
.split_2(b'.') .split_2(b'.')
.ok_or_else(|| HgError::abort(""))?; .ok_or_else(|| HgError::abort(""))?;
let value = invocation.config().get(section, name).unwrap_or(b""); let value = invocation.config.get(section, name).unwrap_or(b"");
invocation.ui.write_stdout(&format_bytes!(b"{}\n", value))?; invocation.ui.write_stdout(&format_bytes!(b"{}\n", value))?;
Ok(()) Ok(())
} }

rust/rhg/src/main.rs

extern crate log; extern crate log;
use crate::ui::Ui; use crate::ui::Ui;
use clap::App; use clap::App;
use clap::AppSettings; use clap::AppSettings;
use clap::Arg; use clap::Arg;
use clap::ArgMatches; use clap::ArgMatches;
use format_bytes::format_bytes; use format_bytes::format_bytes;
use hg::config::Config; use hg::config::Config;
use hg::repo::{Repo, RepoError}; use hg::repo::{Repo, RepoError};
use std::path::{Path, PathBuf}; use hg::utils::files::{get_bytes_from_os_str, get_path_from_bytes};
use hg::utils::SliceExt;
use std::ffi::OsString;
use std::path::PathBuf;
mod blackbox; mod blackbox;
mod error; mod error;
mod exitcode; mod exitcode;
mod ui; mod ui;
use error::CommandError; use error::CommandError;
fn main_with_result( fn main_with_result(
ui: &ui::Ui,
process_start_time: &blackbox::ProcessStartTime, process_start_time: &blackbox::ProcessStartTime,
ui: &ui::Ui,
repo: Result<&Repo, &NoRepoInCwdError>,
config: &Config,
) -> Result<(), CommandError> { ) -> Result<(), CommandError> {
env_logger::init();
let app = App::new("rhg") let app = App::new("rhg")
.global_setting(AppSettings::AllowInvalidUtf8) .global_setting(AppSettings::AllowInvalidUtf8)
.setting(AppSettings::SubcommandRequired) .setting(AppSettings::SubcommandRequired)
.setting(AppSettings::VersionlessSubcommands) .setting(AppSettings::VersionlessSubcommands)
.arg( .arg(
Arg::with_name("repository") Arg::with_name("repository")
.help("repository root directory") .help("repository root directory")
.short("-R") .short("-R")
let matches = app.clone().get_matches_safe()?; let matches = app.clone().get_matches_safe()?;
let (subcommand_name, subcommand_matches) = matches.subcommand(); let (subcommand_name, subcommand_matches) = matches.subcommand();
let run = subcommand_run_fn(subcommand_name) let run = subcommand_run_fn(subcommand_name)
.expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired"); .expect("unknown subcommand name from clap despite AppSettings::SubcommandRequired");
let subcommand_args = subcommand_matches let subcommand_args = subcommand_matches
.expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired"); .expect("no subcommand arguments from clap despite AppSettings::SubcommandRequired");
let config_args = matches
.values_of_os("config")
// Turn `Option::None` into an empty iterator:
.into_iter()
.flatten()
.map(hg::utils::files::get_bytes_from_os_str);
let non_repo_config = &hg::config::Config::load(config_args)?;
let repo_path = matches.value_of_os("repository").map(Path::new);
let repo = match Repo::find(non_repo_config, repo_path) {
Ok(repo) => Ok(repo),
Err(RepoError::NotFound { at }) if repo_path.is_none() => {
// Not finding a repo is not fatal yet, if `-R` was not given
Err(NoRepoInCwdError { cwd: at })
}
Err(error) => return Err(error.into()),
};
let invocation = CliInvocation { let invocation = CliInvocation {
ui, ui,
subcommand_args, subcommand_args,
non_repo_config, config,
repo: repo.as_ref(), repo,
}; };
let blackbox = blackbox::Blackbox::new(&invocation, process_start_time)?; let blackbox = blackbox::Blackbox::new(&invocation, process_start_time)?;
blackbox.log_command_start(); blackbox.log_command_start();
let result = run(&invocation); let result = run(&invocation);
blackbox.log_command_end(exit_code(&result)); blackbox.log_command_end(exit_code(&result));
result result
} }
fn main() { fn main() {
// Run this first, before we find out if the blackbox extension is even // Run this first, before we find out if the blackbox extension is even
// enabled, in order to include everything in-between in the duration // enabled, in order to include everything in-between in the duration
// measurements. Reading config files can be slow if they’re on NFS. // measurements. Reading config files can be slow if they’re on NFS.
let process_start_time = blackbox::ProcessStartTime::now(); let process_start_time = blackbox::ProcessStartTime::now();
env_logger::init();
let ui = ui::Ui::new(); let ui = ui::Ui::new();
let result = main_with_result(&ui, &process_start_time); let early_args = EarlyArgs::parse(std::env::args_os());
if let Err(CommandError::Abort { message }) = &result { let non_repo_config = Config::load(early_args.config)
if !message.is_empty() { .unwrap_or_else(|error| exit(&ui, Err(error.into())));
// Ignore errors when writing to stderr, we’re already exiting
// with failure code so there’s not much more we can do. let repo_path = early_args.repo.as_deref().map(get_path_from_bytes);
let _ = ui.write_stderr(&format_bytes!(b"abort: {}\n", message)); let repo_result = match Repo::find(&non_repo_config, repo_path) {
} Ok(repo) => Ok(repo),
Err(RepoError::NotFound { at }) if repo_path.is_none() => {
// Not finding a repo is not fatal yet, if `-R` was not given
Err(NoRepoInCwdError { cwd: at })
} }
std::process::exit(exit_code(&result)) Err(error) => exit(&ui, Err(error.into())),
};
let config = if let Ok(repo) = &repo_result {
repo.config()
} else {
&non_repo_config
};
let result = main_with_result(
&process_start_time,
&ui,
repo_result.as_ref(),
config,
);
exit(&ui, result)
} }
fn exit_code(result: &Result<(), CommandError>) -> i32 { fn exit_code(result: &Result<(), CommandError>) -> i32 {
match result { match result {
Ok(()) => exitcode::OK, Ok(()) => exitcode::OK,
Err(CommandError::Abort { .. }) => exitcode::ABORT, Err(CommandError::Abort { .. }) => exitcode::ABORT,
// Exit with a specific code and no error message to let a potential // Exit with a specific code and no error message to let a potential
// wrapper script fallback to Python-based Mercurial. // wrapper script fallback to Python-based Mercurial.
Err(CommandError::Unimplemented) => exitcode::UNIMPLEMENTED, Err(CommandError::Unimplemented) => exitcode::UNIMPLEMENTED,
} }
} }
fn exit(ui: &Ui, result: Result<(), CommandError>) -> ! {
if let Err(CommandError::Abort { message }) = &result {
if !message.is_empty() {
// Ignore errors when writing to stderr, we’re already exiting
// with failure code so there’s not much more we can do.
let _ = ui.write_stderr(&format_bytes!(b"abort: {}\n", message));
}
}
std::process::exit(exit_code(&result))
}
macro_rules! subcommands { macro_rules! subcommands {
($( $command: ident )+) => { ($( $command: ident )+) => {
mod commands { mod commands {
$( $(
pub mod $command; pub mod $command;
)+ )+
} }
debugrequirements debugrequirements
files files
root root
config config
} }
pub struct CliInvocation<'a> { pub struct CliInvocation<'a> {
ui: &'a Ui, ui: &'a Ui,
subcommand_args: &'a ArgMatches<'a>, subcommand_args: &'a ArgMatches<'a>,
non_repo_config: &'a Config, config: &'a Config,
/// References inside `Result` is a bit peculiar but allow /// References inside `Result` is a bit peculiar but allow
/// `invocation.repo?` to work out with `&CliInvocation` since this /// `invocation.repo?` to work out with `&CliInvocation` since this
/// `Result` type is `Copy`. /// `Result` type is `Copy`.
repo: Result<&'a Repo, &'a NoRepoInCwdError>, repo: Result<&'a Repo, &'a NoRepoInCwdError>,
} }
struct NoRepoInCwdError { struct NoRepoInCwdError {
cwd: PathBuf, cwd: PathBuf,
} }
impl CliInvocation<'_> { /// CLI arguments to be parsed "early" in order to be able to read
fn config(&self) -> &Config { /// configuration before using Clap. Ideally we would also use Clap for this,
if let Ok(repo) = self.repo { /// see <https://github.com/clap-rs/clap/discussions/2366>.
repo.config() ///
} else { /// These arguments are still declared when we do use Clap later, so that Clap
self.non_repo_config /// does not return an error for their presence.
struct EarlyArgs {
/// Values of all `--config` arguments. (Possibly none)
config: Vec<Vec<u8>>,
/// Value of the `-R` or `--repository` argument, if any.
repo: Option<Vec<u8>>,
}
impl EarlyArgs {
fn parse(args: impl IntoIterator<Item = OsString>) -> Self {
let mut args = args.into_iter().map(get_bytes_from_os_str);
let mut config = Vec::new();
let mut repo = None;
// Use `while let` instead of `for` so that we can also call
// `args.next()` inside the loop.
while let Some(arg) = args.next() {
if arg == b"--config" {
if let Some(value) = args.next() {
config.push(value)
}
} else if let Some(value) = arg.drop_prefix(b"--config=") {
config.push(value.to_owned())
}
if arg == b"--repository" || arg == b"-R" {
if let Some(value) = args.next() {
repo = Some(value)
}
} else if let Some(value) = arg.drop_prefix(b"--repository=") {
repo = Some(value.to_owned())
} else if let Some(value) = arg.drop_prefix(b"-R") {
repo = Some(value.to_owned())
}
} }
Self { config, repo }
} }
} }