fn process_collected_raw_data()

in src/data/diskstats.rs [121:203]

• 77 lines of code
• 2 McCabe index (conditional complexity)

fn process_collected_raw_data(buffer: Data) -> Result<ProcessedData> {
    let raw_value = match buffer {
        Data::DiskstatsRaw(ref value) => value,
        _ => panic!("Invalid Data type in raw file"),
    };
    let mut diskstats = Diskstats::new();
    diskstats.set_time(raw_value.time);
    let mut data = Vec::<Diskstat>::new();
    let reader = BufReader::new(raw_value.data.as_bytes());
    for line in reader.lines() {
        let line = line?;
        let mut s = line.split_whitespace();

        let _major = s.next().unwrap().parse::<i32>();
        let _minor = s.next().unwrap().parse::<i32>();
        let name = s.next().unwrap().to_string();
        let mut diskstat = Diskstat::new(name);

        let reads = s.next().unwrap().parse::<u64>();
        let merged = s.next().unwrap().parse::<u64>();
        let sectors_read = s.next().unwrap().parse::<u64>();
        let time_reading = s.next().unwrap().parse::<u64>();
        let writes = s.next().unwrap().parse::<u64>();
        let writes_merged = s.next().unwrap().parse::<u64>();
        let sectors_written = s.next().unwrap().parse::<u64>();
        let time_writing = s.next().unwrap().parse::<u64>();
        let in_progress = s.next().unwrap().parse::<u64>();
        let time_in_progress = s.next().unwrap().parse::<u64>();
        let weighted_time_in_progress = s.next().unwrap().parse::<u64>();
        // Following since kernel 4.18
        let discards = s.next().and_then(|s| s.parse::<u64>().ok());
        let discards_merged = s.next().and_then(|s| s.parse::<u64>().ok());
        let sectors_discarded = s.next().and_then(|s| s.parse::<u64>().ok());
        let time_discarding = s.next().and_then(|s| s.parse::<u64>().ok());
        // Following since kernel 5.5
        let flushes = s.next().and_then(|s| s.parse::<u64>().ok());
        let time_flushing = s.next().and_then(|s| s.parse::<u64>().ok());

        diskstat.add(DiskstatKeys::Reads.to_string(), reads?);
        diskstat.add(DiskstatKeys::Merged.to_string(), merged?);
        diskstat.add(DiskstatKeys::SectorsRead.to_string(), sectors_read?);
        diskstat.add(DiskstatKeys::TimeReading.to_string(), time_reading?);
        diskstat.add(DiskstatKeys::Writes.to_string(), writes?);
        diskstat.add(DiskstatKeys::WritesMerged.to_string(), writes_merged?);
        diskstat.add(DiskstatKeys::SectorsWritten.to_string(), sectors_written?);
        diskstat.add(DiskstatKeys::TimeWriting.to_string(), time_writing?);
        diskstat.add(DiskstatKeys::InProgress.to_string(), in_progress?);
        diskstat.add(DiskstatKeys::TimeInProgress.to_string(), time_in_progress?);
        diskstat.add(
            DiskstatKeys::WeightedTimeInProgress.to_string(),
            weighted_time_in_progress?,
        );
        diskstat.add(
            DiskstatKeys::Discards.to_string(),
            discards.unwrap_or_default(),
        );
        diskstat.add(
            DiskstatKeys::DiscardsMerged.to_string(),
            discards_merged.unwrap_or_default(),
        );
        diskstat.add(
            DiskstatKeys::SectorsDiscarded.to_string(),
            sectors_discarded.unwrap_or_default(),
        );
        diskstat.add(
            DiskstatKeys::TimeDiscarding.to_string(),
            time_discarding.unwrap_or_default(),
        );
        diskstat.add(
            DiskstatKeys::Flushes.to_string(),
            flushes.unwrap_or_default(),
        );
        diskstat.add(
            DiskstatKeys::TimeFlushing.to_string(),
            time_flushing.unwrap_or_default(),
        );

        data.push(diskstat);
    }
    diskstats.set_data(data);
    let processed_data = ProcessedData::Diskstats(diskstats.clone());
    Ok(processed_data)
}