evobench_tools/run/

config.rs

use std::{
    borrow::Cow,
    collections::{BTreeMap, BTreeSet},
    fmt::{Debug, Display},
    path::{Path, PathBuf},
    str::FromStr,
    sync::Arc,
};

use anyhow::{Context, Result, anyhow, bail};
use chj_unix_util::daemon::DaemonPaths;
use chrono::{DateTime, Local};
use cj_path_util::path_util::AppendToPath;
use kstring::KString;

use crate::{
    config_file::{ConfigFile, DefaultConfigPath, ron_to_string_pretty},
    date_and_time::time_ranges::{DateTimeRange, LocalNaiveTimeRange},
    info,
    io_utils::{bash::bash_string_from_cmd, div::create_dir_if_not_exists},
    run::{env_vars::AllowableCustomEnvVar, key::CustomParameters},
    run_with_pre_exec::{BashSettings, BashSettingsLevel, RunWithPreExec, join_pre_exec_bash_code},
    serde_types::{
        allowed_env_var::AllowedEnvVar,
        date_and_time::LocalNaiveTime,
        git_branch_name::GitBranchName,
        git_url::GitUrl,
        priority::Priority,
        proper_dirname::ProperDirname,
        proper_filename::ProperFilename,
        regex::SerializableRegex,
        tilde_path::TildePath,
        val_or_ref::{ValOrRef, ValOrRefTarget},
    },
    util::grep_diff::LogExtract,
    utillib::arc::CloneArc,
};

use super::{
    benchmarking_job::BenchmarkingJobSettingsOpts, custom_parameter::AllowedCustomParameter,
    global_app_state_dir::GlobalAppStateDir, working_directory_pool::WorkingDirectoryPoolOpts,
};

#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub enum ScheduleCondition {
    /// Run jobs in this queue once right away
    Immediately {
        /// A description of the situation during which jobs in this
        /// queue are executed; all jobs of the same context (and same
        /// key) are grouped together and evaluated to "summary-" file
        /// names with this string appended. Meant to reflect
        /// conditions that might influence the results;
        /// e.g. "immediate" or "night".
        situation: ProperFilename,
    },

    /// Run jobs in this queue between the given times on every day
    /// (except when one of the times is not valid or ambiguous on a
    /// given day due to DST changes). Jobs started before the end of
    /// the window are finished, though.
    LocalNaiveTimeWindow {
        /// The priority of this queue--it is added to the priority of
        /// jobs in this queue. By default, 1.5 is used.
        priority: Option<Priority>,
        /// A description of the situation during which jobs in this
        /// queue are executed; all jobs of the same context (and same
        /// key) are grouped together and evaluated to "summary-" file
        /// names with this string appended. Meant to reflect
        /// conditions that might influence the results;
        /// e.g. "immediate" or "night".
        situation: ProperFilename,
        /// A command and arguments, run with "stop" at the `from`
        /// time and with "start" when done / at the `to` time.
        stop_start: Option<Vec<String>>,
        /// If true, run the `BenchmarkingJob`s in this queue until
        /// their own `count` reaches zero or the time window runs out
        /// (each job is rescheduled to the end of the queue after a
        /// run, meaning the jobs are alternating). If false, each job
        /// is run once and then moved to the next queue.
        repeatedly: bool,
        /// If true, when time runs out, move all remaining jobs to
        /// the next queue; if false, the jobs remain and are
        /// scheduled again in the same time window on the next day.
        move_when_time_window_ends: bool,
        /// Times in the time zone that the daemon is running with (to
        /// change that, set `TZ` env var to area/city, or the default
        /// time zone via dpkg-reconfigure).
        from: LocalNaiveTime,
        to: LocalNaiveTime,
    },

    /// A queue that is never run and never emptied, to add to the end
    /// of the queue pipeline to take up jobs that have been expelled
    /// from the second last queue, for informational purposes.
    Inactive,
}

impl Display for ScheduleCondition {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ScheduleCondition::Immediately { situation } => {
                write!(f, "Immediately {:?}", situation.as_str())
            }
            ScheduleCondition::LocalNaiveTimeWindow {
                priority: _,
                situation,
                stop_start,
                repeatedly,
                move_when_time_window_ends,
                from,
                to,
            } => {
                let rep = if *repeatedly { "repeatedly" } else { "once" };
                let mov = if *move_when_time_window_ends {
                    "move"
                } else {
                    "stay"
                };
                let cmd = if let Some(st) = stop_start {
                    bash_string_from_cmd(st)
                } else {
                    "-".into()
                };
                let pri: f64 = self
                    .priority()
                    .expect("LocalNaiveTimeWindow *does* have priority field")
                    .into();
                write!(
                    f,
                    "LocalNaiveTimeWindow {:?} {from} - {to} pri={pri}: {rep}, {mov}, \"{cmd}\"",
                    situation.as_str()
                )
            }
            ScheduleCondition::Inactive => f.write_str("Inactive"),
        }
    }
}

impl ScheduleCondition {
    pub const TIMED_QUEUE_DEFAULT_PRIORITY: Priority = Priority::new_unchecked(1.5);

    /// Whether this queue will never run its jobs
    pub fn is_inactive(&self) -> bool {
        match self {
            ScheduleCondition::Inactive => true,
            _ => false,
        }
    }

    pub fn time_range(&self) -> Option<(LocalNaiveTime, LocalNaiveTime)> {
        match self {
            ScheduleCondition::Immediately { situation: _ } => None,
            ScheduleCondition::LocalNaiveTimeWindow {
                priority: _,
                situation: _,
                stop_start: _,
                repeatedly: _,
                move_when_time_window_ends: _,
                from,
                to,
            } => Some((from.clone(), to.clone())),
            ScheduleCondition::Inactive => None,
        }
    }

    pub fn stop_start(&self) -> Option<&[String]> {
        match self {
            ScheduleCondition::Immediately { situation: _ } => None,
            ScheduleCondition::LocalNaiveTimeWindow {
                priority: _,
                situation: _,
                stop_start,
                repeatedly: _,
                move_when_time_window_ends: _,
                from: _,
                to: _,
            } => stop_start.as_deref(),
            ScheduleCondition::Inactive => None,
        }
    }

    /// Returns true if the condition offers that flag *and* it is true
    pub fn move_when_time_window_ends(&self) -> bool {
        match self {
            ScheduleCondition::Immediately { situation: _ } => false,
            ScheduleCondition::LocalNaiveTimeWindow {
                priority: _,
                situation: _,
                stop_start: _,
                repeatedly: _,
                move_when_time_window_ends,
                from: _,
                to: _,
            } => *move_when_time_window_ends,
            ScheduleCondition::Inactive => false,
        }
    }

    pub fn situation(&self) -> Option<&ProperFilename> {
        match self {
            ScheduleCondition::Immediately { situation } => Some(situation),
            ScheduleCondition::LocalNaiveTimeWindow {
                priority: _,
                situation,
                stop_start: _,
                repeatedly: _,
                move_when_time_window_ends: _,
                from: _,
                to: _,
            } => Some(situation),
            ScheduleCondition::Inactive => None,
        }
    }

    pub fn priority(&self) -> Option<Priority> {
        match self {
            ScheduleCondition::Immediately { situation: _ } => Some(Priority::default()),
            ScheduleCondition::LocalNaiveTimeWindow {
                priority,
                situation: _,
                stop_start: _,
                repeatedly: _,
                move_when_time_window_ends: _,
                from: _,
                to: _,
            } => Some(priority.unwrap_or(Self::TIMED_QUEUE_DEFAULT_PRIORITY)),
            ScheduleCondition::Inactive => None,
        }
    }

    /// Returns an optional time window (given if runnable due to
    /// being in this time window) if runnable
    pub fn is_runnable_at(
        &self,
        reference_time: DateTime<Local>,
    ) -> Option<Option<DateTimeRange<Local>>> {
        match self {
            ScheduleCondition::Immediately { situation: _ } => Some(None),
            ScheduleCondition::LocalNaiveTimeWindow {
                priority: _,
                situation: _,
                stop_start: _,
                repeatedly: _,
                move_when_time_window_ends: _,
                from,
                to,
            } => {
                let ltr = LocalNaiveTimeRange {
                    from: *from,
                    to: *to,
                };
                let dtr: Option<DateTimeRange<Local>> = ltr.after_datetime(&reference_time, true);
                if let Some(dtr) = dtr {
                    if dtr.contains(&reference_time) {
                        Some(Some(dtr))
                    } else {
                        None
                    }
                } else {
                    info!("times in {ltr} do not resolve for {reference_time}");
                    None
                }
            }
            ScheduleCondition::Inactive => None,
        }
    }
}

#[derive(Debug, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QueuesConfig {
    /// If not given, `~/.evobench/queues/` is used. Also used for
    /// locking the `run` action of evobench, to ensure only one
    /// benchmarking job is executed at the same time--if you
    /// configure multiple such directories then you don't have this
    /// guarantee any more. Supports `~/`
    /// for specifying the home directory.
    pub run_queues_basedir: Option<TildePath<PathBuf>>,

    /// The queues to use (file names, without '/'), and their
    /// scheduled execution condition
    pub pipeline: Vec<(ProperFilename, ScheduleCondition)>,

    /// The queue where to put jobs when they run out of
    /// `error_budget` (if `None` is given, the jobs will be dropped--
    /// silently unless verbose flag is given). Should be of
    /// scheduling type Inactive (or perhaps a future messaging
    /// queue).
    pub erroneous_jobs_queue: Option<(ProperFilename, ScheduleCondition)>,

    /// The queue where to put jobs when they are finished
    /// successfully (if `None` is given, the jobs will be dropped--
    /// silently unless verbose flag is given).
    pub done_jobs_queue: Option<(ProperFilename, ScheduleCondition)>,

    /// How many jobs to show in the extra queues
    /// (`erroneous_jobs_queue` and `done_jobs_queue`) when no `--all`
    /// option is given
    pub view_jobs_max_len: usize,
}

impl QueuesConfig {
    pub fn run_queues_basedir(
        &self,
        create_if_not_exists: bool,
        global_app_state_dir: &GlobalAppStateDir,
    ) -> Result<PathBuf> {
        if let Some(base_dir) = &self.run_queues_basedir {
            let base_dir = base_dir.resolve()?;
            if create_if_not_exists {
                create_dir_if_not_exists(&base_dir, "queues base directory")?;
            }
            Ok(base_dir)
        } else {
            global_app_state_dir.run_queues_basedir()
        }
    }
}

#[derive(serde::Serialize, serde::Deserialize, Debug)]
#[serde(deny_unknown_fields)]
#[serde(rename = "RemoteRepository")]
pub struct RemoteRepositoryOpts {
    /// The Git repository to clone the target project from
    pub url: GitUrl,

    /// The remote branches to track
    pub remote_branch_names_for_poll:
        BTreeMap<GitBranchName, ValOrRef<JobTemplateListsField, Vec<JobTemplateOpts>>>,
}

pub struct RemoteRepository {
    pub url: GitUrl,
    pub remote_branch_names_for_poll: BTreeMap<GitBranchName, Arc<[JobTemplate]>>,
}

impl RemoteRepositoryOpts {
    fn check(
        &self,
        job_template_lists: &BTreeMap<KString, Arc<[JobTemplate]>>,
        targets: &BTreeMap<ProperDirname, Arc<BenchmarkingTarget>>,
    ) -> Result<RemoteRepository> {
        let Self {
            url,
            remote_branch_names_for_poll,
        } = self;

        let remote_branch_names_for_poll = remote_branch_names_for_poll
            .iter()
            .map(|(branch_name, job_template_optss)| -> Result<_> {
                let job_templates: ValOrRef<JobTemplateListsField, Arc<[JobTemplate]>> =
                    job_template_optss.try_map(
                        |job_template_optss: &Vec<JobTemplateOpts>| -> Result<Arc<[JobTemplate]>> {
                            job_template_optss
                                .iter()
                                .map(|job_template_opts| job_template_opts.check(targets))
                                .collect()
                        },
                    )?;
                let job_templates = job_templates.value_with_backing(job_template_lists)?;
                Ok((branch_name.clone(), job_templates.clone_arc()))
            })
            .collect::<Result<_>>()?;

        Ok(RemoteRepository {
            url: url.clone(),
            remote_branch_names_for_poll,
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
#[serde(from = "Option<Arc<str>>", into = "Option<Arc<str>>")]
pub struct PreExecLevel2(Option<Arc<str>>);

impl From<Option<Arc<str>>> for PreExecLevel2 {
    fn from(value: Option<Arc<str>>) -> Self {
        Self(value)
    }
}

impl From<PreExecLevel2> for Option<Arc<str>> {
    fn from(value: PreExecLevel2) -> Self {
        value.0
    }
}

impl PreExecLevel2 {
    pub fn new(arg: Option<Arc<str>>) -> Self {
        Self(arg)
    }

    pub fn to_run_with_pre_exec(&self, conf: &RunConfig) -> RunWithPreExec<'static> {
        let code = join_pre_exec_bash_code(
            conf.target_pre_exec_bash_code.as_deref().unwrap_or(""),
            self.0.as_deref().unwrap_or(""),
        );
        RunWithPreExec {
            pre_exec_bash_code: code.into(),
            bash_settings: BashSettings {
                level: BashSettingsLevel::SetMEUPipefail,
                set_ifs: true,
            },
            bash_path: None,
        }
    }
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
/// What command to run on the target project to execute a
/// benchmarking run; the env variables configured in CustomParameters
/// are set when running this command.
pub struct BenchmarkingCommand {
    /// The name is matched on the `target_name` field in
    /// `JobTemplate`, and it is used as the first path segment below
    /// `output_base_dir` for storing the results. It will also be
    /// shown by `evobench list`.
    pub target_name: ProperDirname,

    /// Relative path to the subdirectory (provide "." for the top
    /// level of the working directory) where to run the command
    pub subdir: PathBuf,

    /// Name or path to the command to run, e.g. "make"
    pub command: String,

    /// Arguments to the command, e.g. "bench"
    pub arguments: Vec<String>,

    /// Bash shell code to run before executing this target. E.g. to
    /// source a Python virtual env or defining env variables. `set
    /// -meuo pipefail` and `IFS=` are enabled. Execution flow must
    /// leave at the end of the string. This is executed after code
    /// declared via the global `target_pre_exec_bash_code` field, if
    /// any. Note that this value (together with the other values in
    /// BenchmarkingCommand) is copied into the job, and
    /// `evobench wd enter` will use the copy from the time the
    /// job was started, not the current value here!
    pub pre_exec_bash_code: PreExecLevel2,
}

#[derive(Debug, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BenchmarkingTarget {
    pub benchmarking_command: Arc<BenchmarkingCommand>,

    /// Which custom environment variables are allowed, required, and
    /// of what type (format) they must be.
    pub allowed_custom_parameters:
        BTreeMap<AllowedEnvVar<AllowableCustomEnvVar>, AllowedCustomParameter>,

    /// Optional list of `LogExtract` declarations, to extract time
    /// spans from the stdout/stderr of the benchmark run. (Note: this
    /// is not and does not include the file optionally written by the
    /// target application to the path in the `BENCH_OUTPUT_LOG` env
    /// var!--Possible todo: offer something separate for that file?)
    pub log_extracts: Option<Vec<LogExtract>>,
}

#[derive(Debug, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename = "JobTemplate")]
pub struct JobTemplateOpts {
    priority: Priority,
    initial_boost: Priority,
    target_name: ProperDirname,
    // Using `String` for values--type checking is done in conversion
    // to `JobTemplate` (don't want to use another enum here that
    // would be required, and `allowed_custom_parameters` already have
    // the type, no *need* to specify it again, OK?)
    custom_parameters: BTreeMap<AllowedEnvVar<AllowableCustomEnvVar>, KString>,
}

pub struct JobTemplate {
    pub priority: Priority,
    pub initial_boost: Priority,
    pub command: Arc<BenchmarkingCommand>,
    pub custom_parameters: Arc<CustomParameters>,
}

impl JobTemplateOpts {
    pub fn check(
        &self,
        targets: &BTreeMap<ProperDirname, Arc<BenchmarkingTarget>>,
    ) -> Result<JobTemplate> {
        let Self {
            priority,
            initial_boost,
            target_name,
            custom_parameters,
        } = self;

        let target = targets
            .get(target_name)
            .ok_or_else(|| anyhow!("unknown target name {:?}", target_name.as_str()))?;

        let custom_parameters =
            CustomParameters::checked_from(custom_parameters, &target.allowed_custom_parameters)
                .with_context(|| {
                    let context = ron_to_string_pretty(self).expect("no serialisation errors");
                    anyhow!("processing {context}")
                })?;

        Ok(JobTemplate {
            priority: *priority,
            initial_boost: *initial_boost,
            command: target.benchmarking_command.clone_arc(),
            custom_parameters: custom_parameters.into(),
        })
    }
}

/// Settings for calling `evobench-eval`
#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct EvalSettings {
    /// Pass the --show-thread-number option to evobench-eval
    /// ("Include the internally-allocated thread number in call
    /// path strings in the output"). Only use if the application
    /// has a limited number of threads (i.e. uses fixed thread
    /// pools); if it allocates new threads all the time then this
    /// will blow up the resulting Excel files.
    pub show_thread_number: bool,
}

#[derive(Debug, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename = "DaemonPaths")]
pub struct DaemonPathsOpts {
    /// Where the lock/pid files should be written to (is created if missing).
    pub state_dir: Option<TildePath<PathBuf>>,
    /// Where the log files should be written to (is created if missing).
    pub log_dir: Option<TildePath<PathBuf>>,
}

impl DaemonPathsOpts {
    fn check(
        &self,
        global_app_state_dir: &GlobalAppStateDir,
        default_state_subdir: &str,
    ) -> Result<DaemonPaths> {
        let DaemonPathsOpts { state_dir, log_dir } = self;

        let state_dir: Arc<Path> = if let Some(path) = state_dir {
            path.resolve()?.into()
        } else {
            global_app_state_dir.subdir(default_state_subdir)?.into()
        };
        let log_dir = if let Some(path) = log_dir {
            path.resolve()?.into()
        } else {
            (&state_dir).append("logs").into()
        };
        Ok(DaemonPaths { state_dir, log_dir })
    }
}

#[derive(Debug, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename = "OutputDir")]
pub struct OutputDirOpts {
    /// The base of the directory hierarchy where the output files
    /// should be placed. Supports `~/` for specifying the home
    /// directory.
    pub path: Arc<TildePath<PathBuf>>,

    /// URL where the same path is served (optional). Used for
    /// `evobench list path url`.
    pub url: Option<Arc<str>>,
}

impl OutputDirOpts {
    fn resolve(&self) -> Result<OutputDir> {
        let Self { path, url } = self;
        let path = path.resolve()?.into();
        let url = url.clone();
        Ok(OutputDir { path, url })
    }
}

pub struct OutputDir {
    pub path: Arc<Path>,
    pub url: Option<Arc<str>>,
}

/// Direct representation of the evobench config file
// For why `Arc` is used, see `docs/hacking.md`
#[derive(Debug, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
#[serde(rename = "RunConfig")]
pub struct RunConfigOpts {
    pub queues: Arc<QueuesConfig>,

    pub working_directory_pool: Arc<WorkingDirectoryPoolOpts>,

    /// Bash shell code to run before executing any of the
    /// targets. E.g. to source a Python virtual env or defining env
    /// variables. `set -meuo pipefail` and `IFS=` are
    /// enabled. Execution flow must leave at the end of the string.
    pub target_pre_exec_bash_code: Option<Arc<str>>,

    /// What command to run on the target project to execute a
    /// benchmarking run; the env variables configured in
    /// CustomParameters are set when running this command.
    pub targets: Vec<Arc<BenchmarkingTarget>>,

    /// A set of named job template lists, referred to by name from
    /// `remote_branch_names_for_poll` or from the command line
    /// (`evobench insert templates`).  Each job template in a
    /// list generates a separate benchmark run for each commit that
    /// is inserted. The order defines in which order the jobs are
    /// inserted (which means the job generated from the first
    /// template is scheduled first, at least if priorities are the
    /// same). `priority` is added to whatever priority the inserter
    /// asks for, and `initial_boost` is added to the job for its
    /// first run only.
    pub job_template_lists: BTreeMap<KString, Vec<JobTemplateOpts>>,

    /// Each job receives a copy of these settings after expansion
    pub benchmarking_job_settings: Arc<BenchmarkingJobSettingsOpts>,

    /// Settings for calling `evobench-eval`
    pub eval_settings: Arc<EvalSettings>,

    /// Information on the remote repository of the target project
    pub remote_repository: RemoteRepositoryOpts,

    /// Where the output files should be placed.
    pub output_dir: OutputDirOpts,

    /// The paths for the `evobench run daemon`. The defaults are
    /// `~/.evobench/run_jobs_daemon` for the `state_dir` and
    /// the `logs` subdir below that for `logs_dir`.  The paths
    /// support `~/` notation.
    run_jobs_daemon: DaemonPathsOpts,

    /// The same as above for the `evobench poll daemon`, just
    /// with the `polling_daemon` subdir as the default.
    polling_daemon: DaemonPathsOpts,

    /// Optional directory holding directories whose name is taken
    /// from the (optional, depending on the configuration) `DATASET`
    /// custom variable (hacky to mis-use a custom variable for
    /// this?), inside which are directories named after git revision
    /// names (tags or commit ids), the latest which is an ancestor or
    /// the commit itself to be benchmarked,
    /// i.e. `$versioned_datasets_base_dir/$DATASET/$best_rev_name`. The
    /// resolved path (only when both this option and `DATASET` are
    /// provided) is stored in the `DATASET_DIR` env var when calling
    /// the benchmarking entry point of the client app. Supports `~/`
    /// for specifying the home directory.
    pub versioned_datasets_base_dir: Option<Arc<TildePath<PathBuf>>>,

    /// A regular expression matching those Git tags that should be
    /// passed to the target in the `COMMIT_TAGS` env variable (as
    /// comma-separated strings). By default, all tags are passed.
    pub commit_tags_regex: Option<SerializableRegex>,
}

#[derive(Debug)]
pub struct JobTemplateListsField;
impl ValOrRefTarget for JobTemplateListsField {
    fn target_desc() -> Cow<'static, str> {
        "`RunConfig.job_template_lists` field".into()
    }
}

impl DefaultConfigPath for RunConfigOpts {
    fn default_config_file_name_without_suffix() -> Result<Option<ProperFilename>> {
        Ok(Some("evobench".parse().map_err(|e| anyhow!("{e:#}"))?))
    }
}

/// Checked, produced from `RunConfigOpts`, for docs see there.
pub struct RunConfig {
    pub queues: Arc<QueuesConfig>,
    pub run_jobs_daemon: DaemonPaths,
    pub polling_daemon: DaemonPaths,
    pub working_directory_pool: Arc<WorkingDirectoryPoolOpts>,
    pub target_pre_exec_bash_code: Option<Arc<str>>,
    // targets: BTreeMap<ProperDirname, Arc<BenchmarkingTarget>>,
    pub job_template_lists: BTreeMap<KString, Arc<[JobTemplate]>>,
    pub benchmarking_job_settings: Arc<BenchmarkingJobSettingsOpts>,
    pub eval_settings: Arc<EvalSettings>,
    pub remote_repository: RemoteRepository,
    pub output_dir: OutputDir,
    pub versioned_datasets_base_dir: Option<Arc<Path>>,
    pub targets: BTreeMap<ProperDirname, Arc<BenchmarkingTarget>>,
    pub commit_tags_regex: SerializableRegex,
}

impl RunConfig {
    pub fn working_directory_change_signals_path(&self) -> PathBuf {
        (&self.run_jobs_daemon.state_dir).append("working_directory_change.signals")
    }
}

impl RunConfigOpts {
    /// Don't take ownership since RunConfigWithReload can't give it
    pub fn check(&self, global_app_state_dir: &GlobalAppStateDir) -> Result<RunConfig> {
        let RunConfigOpts {
            queues,
            working_directory_pool,
            target_pre_exec_bash_code,
            targets,
            job_template_lists,
            benchmarking_job_settings,
            eval_settings,
            remote_repository,
            output_dir,
            run_jobs_daemon,
            polling_daemon,
            versioned_datasets_base_dir,
            commit_tags_regex,
        } = self;

        let targets: BTreeMap<ProperDirname, Arc<BenchmarkingTarget>> = {
            let mut seen = BTreeSet::new();
            targets
                .iter()
                .map(|benchmarking_target| {
                    let name = &benchmarking_target.benchmarking_command.target_name;
                    if seen.contains(&name) {
                        bail!("duplicate `target_name` value {:?}", name.as_str())
                    }
                    seen.insert(name);
                    Ok((name.clone(), benchmarking_target.clone_arc()))
                })
                .collect::<Result<_>>()?
        };

        let job_template_lists: BTreeMap<KString, Arc<[JobTemplate]>> = job_template_lists
            .iter()
            .map(
                |(template_list_name, template_list)| -> Result<(KString, Arc<[JobTemplate]>)> {
                    Ok((
                        template_list_name.clone(),
                        template_list
                            .iter()
                            .map(|job_template_opts| job_template_opts.check(&targets))
                            .collect::<Result<_>>()?,
                    ))
                },
            )
            .collect::<Result<_>>()?;

        let remote_repository = remote_repository.check(&job_template_lists, &targets)?;

        let commit_tags_regex: SerializableRegex =
            if let Some(commit_tags_regex) = commit_tags_regex {
                (*commit_tags_regex).clone()
            } else {
                SerializableRegex::from_str(".*")?
            };

        Ok(RunConfig {
            queues: queues.clone_arc(),
            working_directory_pool: working_directory_pool.clone_arc(),
            target_pre_exec_bash_code: target_pre_exec_bash_code.clone(),
            job_template_lists,
            benchmarking_job_settings: benchmarking_job_settings.clone_arc(),
            eval_settings: eval_settings.clone_arc(),
            remote_repository,
            output_dir: output_dir.resolve()?,
            targets,
            versioned_datasets_base_dir: versioned_datasets_base_dir
                .as_ref()
                .map(|d| d.resolve())
                .transpose()?
                .map(Arc::<Path>::from),
            commit_tags_regex,
            run_jobs_daemon: run_jobs_daemon.check(global_app_state_dir, "run_jobs_daemon")?,
            polling_daemon: polling_daemon.check(global_app_state_dir, "polling_daemon")?,
        })
    }
}

/// Shareable across threads
#[derive(Clone)]
pub struct ShareableConfig {
    pub run_config: Arc<RunConfig>,
    pub global_app_state_dir: Arc<GlobalAppStateDir>,
}

/// Keep the original ConfigFile around so that we can check whether
/// it needs reloading (in `Daemon`, passed to daemon run procedures
/// via `DaemonCheckExit`). Also, need the `GlobalAppStateDir` for
/// further path operations, too.
pub struct RunConfigBundle {
    pub config_file: Arc<ConfigFile<RunConfigOpts>>,
    pub shareable: ShareableConfig,
}

impl RunConfigBundle {
    pub fn load(
        provided_path: Option<Arc<Path>>,
        or_else: impl FnOnce(&str) -> Result<RunConfigOpts>,
        global_app_state_dir: GlobalAppStateDir,
    ) -> Result<Self> {
        let config_file = Arc::new(ConfigFile::<RunConfigOpts>::load_config(
            provided_path,
            or_else,
        )?);
        let run_config = config_file.check(&global_app_state_dir)?.into();
        Ok(Self {
            config_file,
            shareable: ShareableConfig {
                run_config,
                global_app_state_dir: global_app_state_dir.into(),
            },
        })
    }
}