psi 0.1.2

Linux Pressure Stall Information (PSI) for Rust
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

use std::error::Error;
use std::fmt;
use std::io::ErrorKind;
use std::num::{ParseFloatError, ParseIntError};

pub(crate) use std::result::Result as StdResult;
pub(crate) use ParseError::*;
pub(crate) use PsiError::*;

pub type Result<T> = StdResult<T, PsiError>;

/// Error type for PSI
#[derive(Debug)]
pub enum PsiError {
    IoError(std::io::Error),
    PsiParseError(ParseError),
    InvalidThreshold(std::io::Error),
    UnexpectedTriggerEvent {
        expected_kind: crate::PsiKind,
        expected_line: crate::PsiLine,
    },
    UnregisteredEvent,
    PsiTriggerFileError,
    LoggingInitError(log::SetLoggerError),
}

/// Error type for PSI parsing
#[derive(Debug)]
pub enum ParseError {
    TotalParseError(ParseIntError),
    AvgParseError(ParseFloatError),
    UnexpectedTerm(String),
    MissingLine(crate::PsiLine),
}

impl From<ParseError> for PsiError {
    fn from(e: ParseError) -> Self {
        PsiParseError(e)
    }
}

impl Error for PsiError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            IoError(e) => Some(e),
            PsiParseError(e) => match e {
                TotalParseError(_) => None,
                AvgParseError(_) => None,
                UnexpectedTerm(_) => None,
                MissingLine(_) => None,
            },
            InvalidThreshold(e) => Some(e),
            LoggingInitError(e) => Some(e),
            _ => None,
        }
    }
}

impl fmt::Display for PsiError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self.source() {
            None => match self {
                UnexpectedTriggerEvent {
                    expected_kind,
                    expected_line,
                } => write!(
                    f,
                    "unexpected trigger event; expected {} {}",
                    expected_kind, expected_line
                ),
                UnregisteredEvent => write!(f, "unregistered event triggered"),
                PsiParseError(p) => match p {
                    UnexpectedTerm(t) => write!(f, "unexpected psi term '{}'", t),
                    TotalParseError(e) => write!(f, "error parsing psi total: {}", e),
                    AvgParseError(e) => write!(f, "error parsing psi avg: {}", e),
                    MissingLine(line) => write!(f, "missing line '{}'", line),
                },
                _ => write!(f, "unknown error"),
            },
            Some(e) => write!(f, "{}", e),
        }
    }
}

impl From<std::io::Error> for PsiError {
    fn from(e: std::io::Error) -> Self {
        match e.kind() {
            ErrorKind::InvalidInput => InvalidThreshold(e),
            _ => IoError(e),
        }
    }
}

impl From<ParseFloatError> for PsiError {
    fn from(e: ParseFloatError) -> Self {
        PsiParseError(AvgParseError(e))
    }
}

impl From<ParseIntError> for PsiError {
    fn from(e: ParseIntError) -> Self {
        PsiParseError(TotalParseError(e))
    }
}

impl From<log::SetLoggerError> for PsiError {
    fn from(e: log::SetLoggerError) -> Self {
        LoggingInitError(e)
    }
}