fn apply_cmd()

in rd-agent/src/cmd.rs [233:356]

• 116 lines of code
• 20 McCabe index (conditional complexity)

    fn apply_cmd(
        &mut self,
        removed_sysloads: &mut Vec<Sysload>,
        removed_sideloads: &mut Vec<Sideload>,
    ) -> Result<bool> {
        let cmd = &self.sobjs.cmd_file.data;
        let bench = &self.sobjs.bench_file.data;
        let mut repeat = false;

        self.sobjs.cmd_ack_file.data.cmd_seq = cmd.cmd_seq;
        if let Err(e) = self.sobjs.cmd_ack_file.commit() {
            warn!(
                "cmd: Failed to update {:?} ({:?})",
                &self.cfg.cmd_ack_path, &e
            );
        }

        self.apply_swappiness(cmd.swappiness)?;
        self.apply_zswap_enabled(cmd.zswap_enabled)?;

        match self.state {
            Idle => {
                if cmd.bench_iocost_seq > bench.iocost_seq {
                    self.bench_iocost = Some(bench::start_iocost_bench(&*self.cfg)?);
                    self.state = BenchIoCost;
                    self.force_apply = true;
                } else if cmd.bench_hashd_seq > bench.hashd_seq {
                    if bench.iocost_seq > 0 || self.cfg.force_running {
                        if let Err(e) = self.balloon.set_size(cmd.bench_hashd_balloon_size) {
                            error!(
                                "cmd: Failed to set balloon size to {:.2}G for hashd bench ({:?})",
                                to_gb(cmd.bench_hashd_balloon_size),
                                &e
                            );
                            panic!();
                        }

                        self.sobjs.oomd.stop();

                        self.bench_hashd = Some(bench::start_hashd_bench(
                            &*self.cfg,
                            cmd.hashd[0].log_bps,
                            0,
                            cmd.bench_hashd_args.clone(),
                        )?);
                        self.hashd_set.mark_bench_start();

                        self.state = BenchHashd;
                        self.force_apply = true;
                    } else if !self.warned_bench {
                        warn!("cmd: iocost benchmark must be run before hashd benchmark");
                        self.warned_bench = true;
                    }
                } else if bench.hashd_seq > 0 || self.cfg.force_running {
                    info!("cmd: Transitioning to Running state");
                    self.state = Running;
                    repeat = true;
                } else if !self.warned_init {
                    warn!("cmd: hashd benchmark hasn't been run yet, staying idle");
                    self.warned_init = true;
                }
            }
            Running => {
                if cmd.bench_hashd_seq > bench.hashd_seq || cmd.bench_iocost_seq > bench.iocost_seq
                {
                    self.become_idle();
                } else {
                    if let Err(e) = self.apply_workloads() {
                        error!("cmd: Failed to apply workload changes ({:?})", &e);
                        panic!();
                    }

                    let side_defs = &self.sobjs.side_def_file.data;
                    let sysload_target = &self.sobjs.cmd_file.data.sysloads;
                    if let Err(e) = self.side_runner.apply_sysloads(
                        sysload_target,
                        side_defs,
                        &self.sobjs.bench_file.data,
                        Some(removed_sysloads),
                    ) {
                        warn!("cmd: Failed to apply sysload changes ({:?})", &e);
                    }
                    let sideload_target = &self.sobjs.cmd_file.data.sideloads;
                    if let Err(e) = self.side_runner.apply_sideloads(
                        sideload_target,
                        side_defs,
                        &self.sobjs.bench_file.data,
                        Some(removed_sideloads),
                    ) {
                        warn!("cmd: Failed to apply sideload changes ({:?})", &e);
                    }

                    let balloon_size = ((total_memory() as f64)
                        * &self.sobjs.cmd_file.data.balloon_ratio)
                        as usize;
                    if let Err(e) = self.balloon.set_size(balloon_size) {
                        error!(
                            "cmd: Failed to set balloon size to {:.2}G ({:?})",
                            to_gb(balloon_size),
                            &e
                        );
                        panic!();
                    }
                }
            }
            BenchHashd => {
                if cmd.bench_hashd_seq <= bench.hashd_seq {
                    info!("cmd: Canceling hashd benchmark");
                    self.become_idle();
                }
            }
            BenchIoCost => {
                if cmd.bench_iocost_seq <= bench.iocost_seq {
                    info!("cmd: Canceling iocost benchmark");
                    self.become_idle();
                }
            }
        }
        if self.state != Idle {
            self.warned_bench = false;
            self.warned_init = false;
        }
        Ok(repeat)
    }