psutil 5.4.0

Process and system monitoring library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use std::str::FromStr;

use crate::host::LoadAvg;
use crate::{read_file, Error, Result};

const PROC_LOADAVG: &str = "/proc/loadavg";

impl FromStr for LoadAvg {
	type Err = Error;

	fn from_str(s: &str) -> Result<Self> {
		let fields = match s.split_whitespace().collect::<Vec<_>>() {
			fields if fields.len() >= 3 => Ok(fields),
			_ => Err(Error::MissingData {
				path: PROC_LOADAVG.into(),
				contents: s.to_string(),
			}),
		}?;

		let parse = |s: &str| -> Result<f64> {
			s.parse().map_err(|err| Error::ParseFloat {
				path: PROC_LOADAVG.into(),
				contents: s.to_string(),
				source: err,
			})
		};

		let one = parse(fields[0])?;
		let five = parse(fields[1])?;
		let fifteen = parse(fields[2])?;

		Ok(LoadAvg { one, five, fifteen })
	}
}

pub fn loadavg() -> Result<LoadAvg> {
	LoadAvg::from_str(&read_file(PROC_LOADAVG)?)
}

#[cfg(test)]
mod unit_tests {
	use super::*;
	use crate::FloatCount;
	use float_cmp::approx_eq;

	#[test]
	fn test_loadaverage() {
		let loadavg = loadavg().unwrap();
		// shouldn't be negative
		assert!(loadavg.one >= 0.0);
		assert!(loadavg.five >= 0.0);
		assert!(loadavg.fifteen >= 0.0);
	}

	#[test]
	fn test_parse_loadavg() {
		let input = "0.49 0.70 0.84 2/519 1454\n";
		let loadavg = LoadAvg::from_str(input).unwrap();
		assert!(approx_eq!(FloatCount, loadavg.one, 0.49));
		assert!(approx_eq!(FloatCount, loadavg.five, 0.70));
		assert!(approx_eq!(FloatCount, loadavg.fifteen, 0.84));
	}
}