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
134
135
136
137
138
139
140
141
142
143
144
145
146
147

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

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

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

enum ClocksourceInfo {
    AvailableClockSource,
    CurrentClockSource,
}

impl ClocksourceInfo {
    fn into_string(self) -> String {
        let info_str = match self {
            ClocksourceInfo::AvailableClockSource => "available_clocksource",
            ClocksourceInfo::CurrentClockSource => "current_clocksource",
        };

        info_str.to_string()
    }
}

/// Clocksource contains a clocksource information read from '/sys/devices/system/clocksource'
#[derive(Debug, Serialize, Clone)]
pub struct Clocksource {
    pub name: String,
    pub available_clocksource: Vec<String>,
    pub current_clocksource: String,
}

impl Clocksource {
    fn new(
        name: String,
        available_clocksource: Vec<String>,
        current_clocksource: String,
    ) -> Clocksource {
        Self {
            name,
            available_clocksource,
            current_clocksource,
        }
    }
}

/// collects clocksources information
/// # Example
/// ```
/// use procsys::sysfs::clocksource;
///
/// let clocksources = clocksource::collect().expect("clocksource information");
///
/// for clock_src in clocksources {
///     println!("name: {}", clock_src.name);
///     println!("available clocksource: {:?}", clock_src.available_clocksource);
///     println!("current clocksource: {}", clock_src.current_clocksource);
/// }
///
/// ```
pub fn collect() -> CollectResult<Vec<Clocksource>> {
    let clock_source_path = Path::new("/sys/devices/system/clocksource");
    collect_from(clock_source_path)
}

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

    for clock_dev in WalkDir::new(base_path).into_iter().filter_map(|e| e.ok()) {
        if clock_dev.file_name() == "clocksource" {
            continue;
        }

        let clocksource_name = clock_dev
            .file_name()
            .to_str()
            .unwrap_or_default()
            .trim()
            .to_string();

        if clocksource_name.is_empty() {
            continue;
        }

        if !clocksource_name.starts_with("clocksource") {
            continue;
        }

        let current_clocksource = collect_clocksource_info(
            ClocksourceInfo::CurrentClockSource,
            &clocksource_name,
            base_path,
        )?
        .unwrap_or_default();

        let available_clocksource = collect_clocksource_info(
            ClocksourceInfo::AvailableClockSource,
            &clocksource_name,
            base_path,
        )?
        .unwrap_or_default()
        .split(' ')
        .map(|v| v.to_string())
        .collect::<Vec<String>>();

        clock_sources.push(Clocksource::new(
            clocksource_name,
            available_clocksource,
            current_clocksource,
        ));
    }

    Ok(clock_sources)
}

fn collect_clocksource_info(
    info: ClocksourceInfo,
    name: &str,
    class_path: &Path,
) -> CollectResult<Option<String>> {
    let info_str = info.into_string();
    let info_path = Path::new(class_path).join(name).join(info_str);

    match fs::read_to_string(info_path.as_path()) {
        Ok(content) => Ok(Some(content.trim().to_string())),
        Err(err) => Err(MetricError::IOError(info_path, err)),
    }
}

#[cfg(test)]

mod tests {
    use super::*;

    #[test]
    fn clocksource_collect() {
        let clock_source_path = Path::new("test_data/fixtures/sys/devices/system/clocksource");
        let clock_sources =
            collect_from(clock_source_path).expect("collecting clock source information");

        assert!(clock_sources.len().eq(&1));
        assert!(clock_sources[0].name.eq("clocksource0"));
        assert!(clock_sources[0]
            .available_clocksource
            .eq(&["tsc", "hpet", "acpi_pm"]));
        assert!(clock_sources[0].current_clocksource.eq("tsc"));
    }
}