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
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
132
133

use std::path::{Path, PathBuf};

use serde::Serialize;
use walkdir::WalkDir;

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

enum CoolingInfo {
    CoolingType,
    MaxState,
    CurState,
    Unknown,
}

impl CoolingInfo {
    fn from(name: &str) -> CoolingInfo {
        match name {
            "type" => CoolingInfo::CoolingType,
            "max_state" => CoolingInfo::MaxState,
            "cur_state" => CoolingInfo::CurState,
            _ => CoolingInfo::Unknown,
        }
    }
}

/// Cooling contains a cooling device information from files in /sys/class/thermal/cooling_device[0-9]*
#[derive(Debug, Serialize, Clone, Default)]
pub struct Cooling {
    pub name: String,
    pub cooling_type: String,
    pub max_state: i64,
    pub cur_state: i64,
}

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

/// collects cooling devices information
/// # Example
/// ```
/// use procsys::sysfs::class_cooling;
///
/// let cooling_devices = class_cooling::collect().expect("cooling information");
/// let json_output = serde_json::to_string_pretty(&cooling_devices).unwrap();
/// println!("{}", json_output);
///
/// ```
pub fn collect() -> CollectResult<Vec<Cooling>> {
    let cooling_class_path = Path::new("/sys/class/thermal/");
    collect_from(cooling_class_path)
}

fn collect_from(base_path: &Path) -> CollectResult<Vec<Cooling>> {
    let mut cooling_devs = Vec::new();

    for cdevice in utils::list_dir_content(base_path, "cooling_device", "thermal") {
        let mut cooling_device = Cooling::new();
        cooling_device.name = cdevice.to_string();

        let mut cdev_path = PathBuf::from(base_path);

        cdev_path.push(&cdevice);

        for cdev_info in WalkDir::new(&cdev_path).into_iter().filter_map(|e| e.ok()) {
            let cdev_info_name = cdev_info
                .file_name()
                .to_str()
                .unwrap_or_default()
                .to_string();

            if cdev_info_name == cdevice {
                continue;
            }

            match CoolingInfo::from(&cdev_info_name) {
                CoolingInfo::CoolingType => {
                    if let Some(c) =
                        utils::collect_info_string(&cdev_info_name, cdev_path.as_path())?
                    {
                        cooling_device.cooling_type = c;
                    }
                }
                CoolingInfo::MaxState => {
                    if let Some(c) = utils::collect_info_i64(&cdev_info_name, cdev_path.as_path())?
                    {
                        cooling_device.max_state = c;
                    }
                }
                CoolingInfo::CurState => {
                    if let Some(c) = utils::collect_info_i64(&cdev_info_name, cdev_path.as_path())?
                    {
                        cooling_device.cur_state = c;
                    }
                }
                CoolingInfo::Unknown => {}
            }
        }

        cooling_devs.push(cooling_device);
    }

    Ok(cooling_devs)
}

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

    #[test]
    fn cooling_devices() {
        let cooling_class_path = Path::new("test_data/fixtures/sys/class/thermal/");
        let cdev = collect_from(cooling_class_path).expect("collecting cooling information");

        for cooling in cdev {
            match cooling.name.as_str() {
                "cooling_device0" => {
                    assert!(cooling.cur_state.eq(&0));
                    assert!(cooling.max_state.eq(&50));
                    assert!(cooling.cooling_type.eq("Processor"));
                }
                "cooling_device1" => {
                    assert!(cooling.cur_state.eq(&-1));
                    assert!(cooling.max_state.eq(&27));
                    assert!(cooling.cooling_type.eq("intel_powerclamp"));
                }
                _ => panic!("invalid cooling device: {}", cooling.name),
            }
        }
    }
}