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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::str::FromStr;
use std::time::Duration;

use crate::cpu::CpuTimes;
use crate::{read_file, Count, Error, Result, TICKS_PER_SECOND};

const PROC_STAT: &str = "/proc/stat";

impl FromStr for CpuTimes {
	type Err = Error;

	fn from_str(line: &str) -> Result<Self> {
		let fields = line
			.split_whitespace()
			.skip(1)
			.map(|entry| {
				entry.parse().map_err(|err| Error::ParseInt {
					path: PROC_STAT.into(),
					contents: line.to_string(),
					source: err,
				})
			})
			.collect::<Result<Vec<Count>>>()?
			.into_iter()
			.map(|entry| Duration::from_secs_f64(entry as f64 / *TICKS_PER_SECOND))
			.collect::<Vec<Duration>>();

		if fields.len() < 7 {
			return Err(Error::MissingData {
				path: PROC_STAT.into(),
				contents: line.to_string(),
			});
		}

		let user = fields[0];
		let nice = fields[1];
		let system = fields[2];
		let idle = fields[3];
		let iowait = fields[4];
		let irq = fields[5];
		let softirq = fields[6];

		// since kernel 2.6.11
		let steal = if fields.len() >= 8 {
			Some(fields[7])
		} else {
			None
		};
		// since kernel 2.6.24
		let guest = if fields.len() >= 9 {
			Some(fields[8])
		} else {
			None
		};
		// since kernel 2.6.33
		let guest_nice = if fields.len() >= 10 {
			Some(fields[9])
		} else {
			None
		};

		Ok(CpuTimes {
			user,
			system,
			idle,
			nice,
			iowait,
			irq,
			softirq,
			steal,
			guest,
			guest_nice,
		})
	}
}

pub fn cpu_times() -> Result<CpuTimes> {
	let contents = read_file(PROC_STAT)?;
	let lines: Vec<_> = contents.lines().collect();

	if lines.is_empty() {
		return Err(Error::MissingData {
			path: PROC_STAT.into(),
			contents,
		});
	}

	CpuTimes::from_str(lines[0])
}

pub fn cpu_times_percpu() -> Result<Vec<CpuTimes>> {
	let contents = read_file(PROC_STAT)?;
	let lines: Vec<_> = contents
		.lines()
		.skip(1)
		.take_while(|line| line.starts_with("cpu"))
		.collect();

	if lines.is_empty() {
		return Err(Error::MissingData {
			path: PROC_STAT.into(),
			contents,
		});
	}

	lines.into_iter().map(CpuTimes::from_str).collect()
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn test_parse_cpu_times() {
		let line = "cpu  11867200 6935 2978038 19104017 85955 502109 144021 0 0 0";
		let result = CpuTimes::from_str(line).unwrap();
		let expected = CpuTimes {
			user: Duration::from_secs_f64(11_867_200_f64 / *TICKS_PER_SECOND),
			nice: Duration::from_secs_f64(6935_f64 / *TICKS_PER_SECOND),
			system: Duration::from_secs_f64(2_978_038_f64 / *TICKS_PER_SECOND),
			idle: Duration::from_secs_f64(19_104_017_f64 / *TICKS_PER_SECOND),
			iowait: Duration::from_secs_f64(85955_f64 / *TICKS_PER_SECOND),
			irq: Duration::from_secs_f64(502_109_f64 / *TICKS_PER_SECOND),
			softirq: Duration::from_secs_f64(144_021_f64 / *TICKS_PER_SECOND),
			steal: Some(Duration::default()),
			guest: Some(Duration::default()),
			guest_nice: Some(Duration::default()),
		};
		assert_eq!(result, expected);
	}
}