fn process_cmdline()

in resctl-bench-intf/src/args.rs [501:668]

• 163 lines of code
• 29 McCabe index (conditional complexity)

    fn process_cmdline(&mut self, matches: &clap::ArgMatches) -> bool {
        let dfl = Args::default();
        let mut updated = false;

        if let Some(v) = matches.value_of("dir") {
            self.dir = if v.len() > 0 {
                v.to_string()
            } else {
                dfl.dir.clone()
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("dev") {
            self.dev = if v.len() > 0 {
                Some(v.to_string())
            } else {
                None
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("linux") {
            self.linux_tar = if v.len() > 0 {
                Some(v.to_string())
            } else {
                None
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("rep-retention") {
            self.rep_retention = if v.len() > 0 {
                v.parse::<u64>().unwrap()
            } else {
                dfl.rep_retention
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("systemd-timeout") {
            self.systemd_timeout = if v.len() > 0 {
                parse_duration(v).unwrap().max(1.0)
            } else {
                dfl.systemd_timeout
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("hashd-size") {
            self.hashd_size = if v.len() > 0 {
                Some((parse_size(v).unwrap() as usize).max(*PAGE_SIZE))
            } else {
                None
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("hashd-cpu-load") {
            self.hashd_fake_cpu_load = match v {
                "keep" | "" => None,
                "fake" => Some(true),
                "real" => Some(false),
                v => panic!("Invalid --hashd-cpu-load value {:?}", v),
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("iocost-qos") {
            self.iocost_qos_ovr = if v.len() > 0 {
                let mut ovr = IoCostQoSOvr::default();
                for (k, v) in Self::parse_propset(v).iter() {
                    ovr.parse(k, v)
                        .with_context(|| format!("Parsing iocost QoS override \"{}={}\"", k, v))
                        .unwrap();
                }
                ovr
            } else {
                Default::default()
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("swappiness") {
            self.swappiness_ovr = if v.len() > 0 {
                let v = v.parse::<u32>().expect("Parsing swappiness");
                if v > 200 {
                    panic!("Swappiness {} out of range", v);
                }
                Some(v)
            } else {
                None
            };
        }
        if let Some(v) = matches.value_of("mem-profile") {
            self.mem_profile = match v {
                "off" => None,
                v => Some(v.parse::<u32>().expect("Invalid mem-profile")),
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("mem-avail") {
            self.mem_avail = if v.len() > 0 {
                parse_size(v).unwrap() as usize
            } else {
                0
            };
            updated = true;
        }
        if let Some(v) = matches.value_of("mem-margin") {
            self.mem_margin = if v.len() > 0 {
                parse_frac(v).unwrap()
            } else {
                dfl.mem_margin
            };
            updated = true;
        }

        self.result = matches.value_of("result").unwrap_or("").into();
        self.iocost_from_sys = matches.is_present("iocost-from-sys");
        self.keep_reports = matches.is_present("keep-reports");
        self.clear_reports = matches.is_present("clear-reports");
        self.force = matches.is_present("force");
        self.force_shadow_inode_prot_test = matches.is_present("force-shadow-inode-prot-test");
        self.skip_shadow_inode_prot_test = matches.is_present("skip-shadow-inode-prot-test");
        self.test = matches.is_present("test");
        self.verbosity = Self::verbosity(matches);

        updated |= match matches.subcommand() {
            ("run", Some(subm)) => self.process_subcommand(Mode::Run, subm),
            ("study", Some(subm)) => self.process_subcommand(Mode::Study, subm),
            ("solve", Some(subm)) => self.process_subcommand(Mode::Solve, subm),
            ("format", Some(subm)) => self.process_subcommand(Mode::Format, subm),
            ("summary", Some(subm)) => self.process_subcommand(Mode::Summary, subm),
            #[cfg(feature = "lambda")]
            ("lambda", Some(subm)) => self.process_subcommand(Mode::Lambda, subm),
            ("pack", Some(_subm)) => {
                self.mode = Mode::Pack;
                false
            }
            ("merge", Some(subm)) => {
                self.mode = Mode::Merge;
                self.merge_by_id = subm.is_present("by-id");
                self.merge_ignore_versions = subm.is_present("ignore-versions");
                self.merge_ignore_sysreqs = subm.is_present("ignore-sysreqs");
                self.merge_multiple = subm.is_present("multiple");
                self.merge_srcs = subm
                    .values_of("SOURCEFILE")
                    .unwrap()
                    .map(|x| x.to_string())
                    .collect();
                false
            }
            ("deps", Some(_subm)) => {
                self.mode = Mode::Deps;
                false
            }
            ("doc", Some(subm)) => {
                self.mode = Mode::Doc;
                self.doc_subjects = subm
                    .values_of("SUBJECT")
                    .unwrap()
                    .map(|x| x.to_string())
                    .collect();
                false
            }
            _ => false,
        };

        if self.mode != Mode::Doc && self.mode != Mode::Deps && self.result.len() == 0 {
            error!("{:?} requires --result", &self.mode);
            exit(1);
        }

        updated
    }