evobench_util/

evobench-util.rs

use std::{ffi::OsString, path::PathBuf, sync::Arc};

use ahtml::arc_util::IntoArc;
use anyhow::{Result, bail};
use cj_path_util::path_util::AppendToPath;
use clap::Parser;

use evobench_tools::{
    ctx,
    git::GitHash,
    info,
    run::{
        config::{RunConfig, RunConfigBundle},
        global_app_state_dir::GlobalAppStateDir,
        output_directory::{
            html_files::regenerate_index_files,
            post_process::compress_file_as,
            structure::{KeyDir, OutputSubdir, RunDir, SubDirs},
        },
        working_directory_pool::WorkingDirectoryPoolBaseDir,
    },
    serde_types::proper_dirname::ProperDirname,
    util::grep_diff::GrepDiffRegion,
    utillib::{
        get_terminal_width::get_terminal_width,
        into_arc_path::IntoArcPath,
        logging::{LogLevelOpts, set_log_level},
    },
};

#[derive(clap::Parser, Debug)]
#[clap(next_line_help = true)]
#[clap(term_width = get_terminal_width(4))]
/// Utilities for working with evobench
struct Opts {
    #[clap(flatten)]
    log_level: LogLevelOpts,

    // XX should wrap that help text (COPYPASTE) in a wrapper for flatten
    /// Override the path to the config file (default: the paths
    /// `~/.evobench.*` where a single one exists where the `*` is
    /// the suffix for one of the supported config file formats (run
    /// `config-formats` to get the list), and if those are missing,
    /// use compiled-in default config values)
    #[clap(long)]
    config: Option<PathBuf>,

    /// The subcommand to run. Use `--help` after the sub-command to
    /// get a list of the allowed options there.
    #[clap(subcommand)]
    subcommand: SubCommand,
}

#[derive(clap::Subcommand, Debug)]
enum SubCommand {
    /// Extract time differences between pairs of lines in log files
    /// from benchmarking runs--not the evobench.log files, but files
    /// with captured stdout/stderr, in the working directory pool
    /// directory (like `$n.output_of_benchmarking_command_at_*`).
    GrepDiff {
        /// Filter for commit id
        #[clap(long, short)]
        commit: Option<GitHash>,

        /// Filter for target name
        #[clap(long, short)]
        target: Option<ProperDirname>,

        /// Filter for custom parameters (environment variables); you
        /// can provide multiple separated by '/',
        /// e.g. "FOO=1/BAR=hi"; not all of them need to be provided,
        /// the filter checks for existance and equality on those
        /// variables that are provided. NOTE: does not verify correct
        /// syntax of the variable names and values (currently no
        /// configuration is read, thus the info is not available)
        /// except for the basic acceptance rules for custom env var
        /// names.
        #[clap(long, short)]
        params: Option<String>,

        /// The regex to match a log line that starts a timed region
        regex_start: String,

        /// The regex to match a log line that ends a timed region
        regex_end: String,

        /// Override the path to the config file (default: the paths
        /// `~/.evobench.*` where a single one exists where the `*` is
        /// the suffix for one of the supported config file formats (run
        /// `config-formats` to get the list), and if those are missing,
        /// use compiled-in default config values)
        logfiles: Vec<PathBuf>,
    },

    /// Do the same "single" post-processing on a single benchmark
    /// results as `evobench daemon` does--useful in case new
    /// features were added or the configuration was changed.
    PostProcessSingle {
        /// Skip (re)generation of the normal evobench.log Excel and
        /// flamegraph stats.
        #[clap(long)]
        no_stats: bool,

        /// The path to a directory for an individual run, i.e. ending
        /// in a directory name that is a timestamp
        run_dir: PathBuf,
    },

    /// Do the same "summary" post-processing on a set of benchmark
    /// results as `evobench daemon` does--useful in case new
    /// features were added or the configuration was changed.
    PostProcessSummary {
        /// Run `post-process-single` on all sub-directories for the
        /// individual runs for this 'key', too.
        #[clap(long)]
        single: bool,

        /// Skip (re)generation of the normal evobench.log Excel and
        /// flamegraph stats. (Only relevant when `--single` is
        /// given.)
        #[clap(long)]
        no_single_stats: bool,

        /// Skip (re)generation of the normal evobench.log Excel and
        /// flamegraph summary stats.
        #[clap(long)]
        no_summary_stats: bool,

        /// The path to a directory for a particular 'key', i.e. a set
        /// of individual runs: ending in a directory name that is a
        /// commit id
        key_dir: PathBuf,
    },

    /// Development commands; these are meant for app development, not
    /// for users. Only use when you know what you're doing. .
    Dev {
        #[clap(subcommand)]
        subcommand: DevSubCommand,
    },
}

#[derive(clap::Subcommand, Debug)]
enum DevSubCommand {
    /// Regenerate index files
    RegenerateIndexFiles,

    /// List the contents of a folder, structurally
    ListOutputDir { dir_path: PathBuf },
}

fn post_process_single(run_dir: &RunDir, run_config: &RunConfig, no_stats: bool) -> Result<()> {
    let target = run_dir.parent().parent().target_name();
    let standard_log_path = run_dir.standard_log_path();
    if !standard_log_path.exists() {
        info!(
            "missing {standard_log_path:?} -- try to find and move it \
             from the working directory pool dir"
        );

        let date_time_with_offset_str = run_dir.timestamp().as_str();

        // (Is this too involved?)
        let global_app_state_dir = GlobalAppStateDir::new()?;
        let pool_base_dir = WorkingDirectoryPoolBaseDir::new(
            run_config.working_directory_pool.base_dir.clone(),
            &|| global_app_state_dir.working_directory_pool_base(),
        )?;
        let pool_base_dir_path = pool_base_dir.path();
        // /involved

        let found_log_file_name = {
            let mut file_names: Vec<OsString> = pool_base_dir_path
                .read_dir()
                .map_err(ctx!("reading dir {pool_base_dir_path:?}"))?
                .map(|entry| -> Result<_> {
                    let entry = entry?;
                    let file_name = entry.file_name();
                    if file_name
                        .to_string_lossy()
                        .contains(date_time_with_offset_str)
                    {
                        Ok(Some(file_name))
                    } else {
                        Ok(None)
                    }
                })
                .filter_map(|v| v.transpose())
                .collect::<Result<_>>()?;
            match file_names.len() {
                1 => file_names.pop().expect("seen"),
                0 => bail!(
                    "can't find standard log at {standard_log_path:?} and finding \
                     {date_time_with_offset_str:?} in {pool_base_dir_path:?} was unsuccessful"
                ),
                _ => bail!(
                    "got more than one match for {date_time_with_offset_str:?} in \
                     {pool_base_dir_path:?}"
                ),
            }
        };

        let found_log_file_path = pool_base_dir_path.append(&found_log_file_name);
        info!("found file {found_log_file_path:?}");

        compress_file_as(&found_log_file_path, standard_log_path.clone(), false)?;
        std::fs::remove_file(&found_log_file_path)?;
        info!("deleted moved file {found_log_file_path:?}");
    }
    run_dir.post_process_single(
        None,
        || Ok(()),
        &target,
        &standard_log_path,
        run_config,
        no_stats,
    )?;
    Ok(())
}

fn main() -> Result<()> {
    let Opts {
        config,
        log_level,
        subcommand,
    } = Opts::parse();

    set_log_level(log_level.try_into()?);

    let get_config = {
        move || -> Result<RunConfigBundle> {
            let config = config.map(Into::into);
            Ok(RunConfigBundle::load(
                config,
                |msg| bail!("can't load config: {msg}"),
                GlobalAppStateDir::new()?,
            )?)
        }
    };

    match subcommand {
        SubCommand::GrepDiff {
            regex_start,
            regex_end,
            logfiles,
            commit,
            target,
            params,
        } => {
            let grep_diff_region = GrepDiffRegion::from_strings(&regex_start, &regex_end)?;
            grep_diff_region.grep_diff(logfiles, commit, target, params)?;
        }
        SubCommand::PostProcessSingle { run_dir, no_stats } => {
            let run_config_bundle = get_config()?;
            let conf = &run_config_bundle.shareable.run_config;

            let run_dir = RunDir::try_from(run_dir.into_arc_path())?;

            post_process_single(&run_dir, conf, no_stats)?;
        }
        SubCommand::PostProcessSummary {
            single,
            key_dir,
            no_single_stats,
            no_summary_stats,
        } => {
            let run_config_bundle = get_config()?;
            let conf = &run_config_bundle.shareable.run_config;

            let key_dir: Arc<_> = KeyDir::try_from(key_dir.into_arc_path())?.into();

            if single {
                for run_dir in key_dir.sub_dirs()? {
                    let run_dir = run_dir?;
                    post_process_single(&run_dir, conf, no_single_stats)?;
                }
            }

            key_dir.generate_summaries_for_key_dir(no_summary_stats)?;
        }
        SubCommand::Dev { subcommand } => match subcommand {
            DevSubCommand::RegenerateIndexFiles => {
                let run_config_bundle = get_config()?;
                regenerate_index_files(&run_config_bundle.shareable, None, None)?;
            }
            DevSubCommand::ListOutputDir { dir_path } => {
                let dir_path = dir_path.into_arc_path();
                let output_subdir = OutputSubdir::try_from(dir_path)?;
                println!(
                    "Listing for {} at {:?}:",
                    output_subdir.type_name(),
                    output_subdir.to_path()
                );
                for subdir in output_subdir.into_arc().sub_dirs()? {
                    let subdir = subdir?;
                    println!("{} at {:?}", subdir.type_name(), subdir.to_path());
                }
            }
        },
    }

    Ok(())
}