procsys 0.7.0

Rust library to retrieve system, kernel, and process metrics from the pseudo-filesystems /proc and /sys
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

use serde::Serialize;

use crate::{
    error::{CollectResult, MetricError},
    utils,
};

/// LoadAvg represents an entry in /proc/loadavg
#[derive(Debug, Serialize, Clone, Default)]
pub struct Swaps {
    pub filename: String,
    pub swap_type: String,
    pub size: u64,
    pub used: u64,
    pub priority: i32,
}

impl Swaps {
    fn new() -> Self {
        Default::default()
    }
}

/// collects returns all configured swap devices on the system
/// # Example
/// ```
/// use procsys::swaps;
///
/// let sys_swapinfo = swaps::collect().expect("swaps information");
/// let json_output = serde_json::to_string_pretty(&sys_swapinfo).unwrap();
/// println!("{}", json_output);
///
/// ```
pub fn collect() -> CollectResult<Vec<Swaps>> {
    collect_from("/proc/swaps")
}

fn collect_from(filename: &str) -> CollectResult<Vec<Swaps>> {
    let mut swaps_info: Vec<Swaps> = Vec::new();
    let swaps_data = utils::read_file_lines(filename)?;

    for line in &swaps_data[1..] {
        let swap_info = line.to_owned();
        let swap_info_field: Vec<&str> = swap_info
            .split_whitespace()
            .filter(|s| !s.is_empty())
            .collect();

        if swap_info_field.len() != 5 {
            return Err(MetricError::InvalidFieldNumberError(
                "swaps".to_string(),
                swap_info_field.len(),
                line.to_owned(),
            ));
        }

        let mut swap_data = Swaps::new();
        swap_data.filename = swap_info_field[0].to_string();
        swap_data.swap_type = swap_info_field[1].to_string();
        swap_data.size = swap_info_field[2].parse::<u64>().unwrap_or_default();
        swap_data.used = swap_info_field[3].parse::<u64>().unwrap_or_default();
        swap_data.priority = swap_info_field[4].parse::<i32>().unwrap_or_default();

        swaps_info.push(swap_data);
    }

    Ok(swaps_info)
}

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

    #[test]
    fn system_swaps() {
        let swaps_info = collect_from("test_data/fixtures/proc/swaps").expect("swaps information");

        assert_eq!(swaps_info.len(), 2);

        for swap_data in swaps_info {
            match swap_data.filename.as_str() {
                "/dev/zram0" => {
                    assert_eq!(swap_data.swap_type, "partition");
                    assert_eq!(swap_data.size, 8388604);
                    assert_eq!(swap_data.used, 0);
                    assert_eq!(swap_data.priority, 100);
                }
                "/dev/dm-2" => {
                    assert_eq!(swap_data.swap_type, "partition");
                    assert_eq!(swap_data.size, 131068);
                    assert_eq!(swap_data.used, 176);
                    assert_eq!(swap_data.priority, -2);
                }
                _ => panic!("invalid swap filename: {}", swap_data.filename),
            }
        }
    }
}