procfs 0.12.0

Interface to the linux procfs pseudo-filesystem
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

use crate::{FileWrapper, ProcResult};

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

/// The uptime of the system, based on the `/proc/uptime` file.
#[derive(Debug, Clone)]
pub struct Uptime {
    _private: (),

    /// The uptime of the system (including time spent in suspend).
    pub uptime: f64,

    /// The sum of how much time each core has spent idle.
    pub idle: f64,
}

impl Uptime {
    pub fn new() -> ProcResult<Uptime> {
        let file = FileWrapper::open("/proc/uptime")?;
        Uptime::from_reader(file)
    }

    pub fn from_reader<R: Read>(mut r: R) -> ProcResult<Uptime> {
        let mut buf = Vec::with_capacity(128);
        r.read_to_end(&mut buf)?;

        let line = String::from_utf8_lossy(&buf);
        let buf = line.trim();

        let mut s = buf.split(' ');
        let uptime = expect!(f64::from_str(expect!(s.next())));
        let idle = expect!(f64::from_str(expect!(s.next())));

        Ok(Uptime {
            _private: (),
            uptime,
            idle,
        })
    }

    /// The uptime of the system (including time spent in suspend).
    pub fn uptime_duration(&self) -> Duration {
        let secs = self.uptime.trunc() as u64;
        let csecs = (self.uptime.fract() * 100.0).round() as u32;
        let nsecs = csecs * 10_000_000;

        Duration::new(secs, nsecs)
    }

    /// The sum of how much time each core has spent idle.
    pub fn idle_duration(&self) -> Duration {
        let secs = self.idle.trunc() as u64;
        let csecs = (self.idle.fract() * 100.0).round() as u32;
        let nsecs = csecs * 10_000_000;

        Duration::new(secs, nsecs)
    }
}

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

    #[test]
    fn test_uptime() {
        let reader = Cursor::new(b"2578790.61 1999230.98\n");
        let uptime = Uptime::from_reader(reader).unwrap();

        assert_eq!(uptime.uptime_duration(), Duration::new(2578790, 610_000_000));
        assert_eq!(uptime.idle_duration(), Duration::new(1999230, 980_000_000));
    }
}