fn main()

in rd-agent/src/main.rs [1236:1371]

• 113 lines of code
• 21 McCabe index (conditional complexity)

fn main() {
    assert_eq!(*VERSION, *rd_agent_intf::VERSION);
    Args::set_help_body(std::str::from_utf8(include_bytes!("../README.md")).unwrap());

    setup_prog_state();
    unsafe {
        libc::umask(0o002);
    }

    let args_file = Args::init_args_and_logging().unwrap_or_else(|e| {
        error!("cfg: Failed to process args file ({:#})", &e);
        panic!();
    });

    if let Some(bandit) = args_file.data.bandit.as_ref() {
        bandit::bandit_main(bandit);
        return;
    }

    systemd::set_systemd_timeout(args_file.data.systemd_timeout);

    let mut cfg = Config::new(&args_file);

    if args_file.data.reset {
        reset_agent_states(&cfg);
    }

    if let Err(e) = update_index(&cfg) {
        error!("cfg: Failed to update {:?} ({:#})", &cfg.index_path, &e);
        panic!();
    }

    if let Err(e) = misc::prepare_misc_bins(&cfg, args_file.data.prepare) {
        error!("cfg: Failed to prepare misc support binaries ({:#})", &e);
        panic!();
    }

    if let Err(e) = side::prepare_side_bins(&cfg) {
        error!("cfg: Failed to prepare sideload binaries ({:#})", &e);
        panic!();
    }

    match cfg.side_linux_tar_path.as_deref() {
        Some("__SKIP__") => {}
        _ => {
            if let Err(e) = side::prepare_linux_tar(&cfg) {
                error!("cfg: Failed to prepare linux tarball ({:#})", &e);
                panic!();
            }
        }
    }

    let mut _iocost_sys_save = None;
    if !cfg.bypass {
        _iocost_sys_save = Some(IoCostSysSave::read_from_sys(cfg.scr_devnr));
        if let Err(e) = cfg.startup_checks() {
            if args_file.data.force {
                warn!(
                    "cfg: Ignoring startup check failures as per --force ({})",
                    &e
                );
            } else {
                error!("cfg: {}", &e);
                panic!();
            }
        }
    }

    if args_file.data.prepare {
        // ReportFiles init is responsible for clearing old report files
        // but we aren't gonna get there. Clear them explicitly.
        let now = unix_now();

        if let Err(e) = clear_old_report_files(&cfg.report_d_path, cfg.rep_retention, now) {
            warn!(
                "report: Failed to clear stale per-second report files ({:#})",
                &e
            );
        }
        if let Err(e) = clear_old_report_files(&cfg.report_1min_d_path, cfg.rep_1min_retention, now)
        {
            warn!(
                "report: Failed to clear stale per-minute report files ({:#})",
                &e
            );
        }
        return;
    }

    let mut sobjs = SysObjs::new(&cfg);
    trace!("{:#?}", &cfg);

    if let Err(e) = bench::apply_iocost(&sobjs.bench_file.data, &cfg) {
        error!(
            "cfg: Failed to configure iocost controller on {:?} ({:#})",
            cfg.scr_dev, &e
        );
        panic!();
    }

    let mem_size = sobjs.bench_file.data.hashd.actual_mem_size();
    let workload_senpai = sobjs.oomd.workload_senpai_enabled();

    if let Err(e) = slices::apply_slices(&mut sobjs.slice_file.data, mem_size, &cfg) {
        error!("cfg: Failed to apply slice configurations ({:#})", &e);
        panic!();
    }

    if let Err(e) = slices::verify_and_fix_slices(&sobjs.slice_file.data, workload_senpai, &cfg) {
        error!(
            "cfg: Failed to verify and fix slice configurations ({:#})",
            &e
        );
        panic!();
    }

    if !cfg.enforce.oomd {
        info!("cfg: Enforcement off, not starting oomd");
    } else if let Err(e) = sobjs.oomd.apply() {
        error!("cfg: Failed to initialize oomd ({:#})", &e);
        panic!();
    }

    if !cfg.enforce.all() || sobjs.slice_file.data.controlls_disabled(instance_seq()) {
        info!("cfg: Enforcement or controllers off, not starting sideloader");
    } else {
        let sideloader_cmd = &sobjs.cmd_file.data.sideloader;
        let slice_knobs = &sobjs.slice_file.data;
        if let Err(e) = sobjs.sideloader.apply(sideloader_cmd, slice_knobs) {
            error!("cfg: Failed to initialize sideloader ({:#})", &e);
            panic!();
        }
    }

    cmd::Runner::new(cfg, sobjs).run();
}