proc_sys_parser 0.1.22

This crate provides routines for parsing linux /proc files into Rust structs. There are multiple other crates doing this, but these either do not choose to process the statistics in way to make them directly usable, or generalize the statistics and loose the detail.
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281

/*!
Read data from `/proc/fs/xfs/stat` into the struct [`ProcFsXfsStat`].

The processor of `/proc/fs/xfs/stat` takes the values in the file, and puts them in the struct [`ProcFsXfsStat`].
The values in the stat file are detailed data about the function of the XFS filesystem on linux.

Documentation:
The documentation seems to be gone, or at least not easy to find. Using the Wayback machine I managed to find an old page that provides a good description:
<https://web.archive.org/web/20220902080208/https://xfs.org/index.php/Runtime_Stats
Here is an example obtaining the data from `/proc/fs/xfs/stat`:
```no_run
use proc_sys_parser::fs_xfs_stat;

let proc_fs_xfs_stat = fs_xfs_stat::read();

println!("{:#?}", proc_fs_xfs_stat);
```
Example output:
```text
ProcFsXfsStat {
    xs_write_calls: 0.0,
    xs_read_calls: 0.0,
    xs_write_bytes: 0.0,
    xs_read_bytes: 0,
}
```
(edited for readability)

If you want to change the path and/or file that is read for [`ProcFsXfsStat`], which is `/proc/fs/xfs/stat`
by default, use:
```no_run
use proc_sys_parser::{meminfo, meminfo::Builder};

let proc_loadavg = Builder::new().path("/myproc").read();
```

*/
use std::fs::read_to_string;

/// Struct for holding `/proc/fs/xfs/stat` statistics
#[derive(Debug, PartialEq, Default)]
pub struct ProcFsXfsStat {
    pub xs_write_calls: Option<u64>,
    pub xs_read_calls: Option<u64>,
    pub xs_write_bytes: Option<u64>,
    pub xs_read_bytes: Option<u64>,
}

/// Builder pattern for [`ProcFsXfsStat`]
#[derive(Default)]
pub struct Builder {
    pub proc_path: String,
    pub proc_file: String,
}

impl Builder {
    pub fn new() -> Builder {
        Builder {
            proc_path: "/proc".to_string(),
            proc_file: "fs/xfs/stat".to_string(),
        }
    }

    pub fn path(mut self, proc_path: &str) -> Builder {
        self.proc_path = proc_path.to_string();
        self
    }
    pub fn file(mut self, proc_file: &str) -> Builder {
        self.proc_file = proc_file.to_string();
        self
    }
    pub fn read(self) -> ProcFsXfsStat {
        ProcFsXfsStat::read_proc_fs_xfs_stat(
            format!("{}/{}", &self.proc_path, &self.proc_file).as_str(),
        )
    }
}

/// The main function for building a [`ProcMemInfo`] struct with current data.
/// This uses the Builder pattern, which allows settings such as the filename to specified.
//pub fn read() -> Result<()> {
pub fn read() -> ProcFsXfsStat {
    Builder::new().read()
}

impl ProcFsXfsStat {
    pub fn new() -> ProcFsXfsStat {
        ProcFsXfsStat::default()
    }
    pub fn parse_proc_fs_xfs_stat(proc_fs_xfs_stat: &str) -> ProcFsXfsStat {
        let mut proc_fs_xfs_stat_struct = ProcFsXfsStat::new();

        for line in proc_fs_xfs_stat.lines() {
            match line {
                line if line.starts_with("rw ") => {
                    let fields: Vec<&str> = line.split_whitespace().collect();
                    proc_fs_xfs_stat_struct.xs_write_calls = fields[1].parse::<u64>().ok();
                    proc_fs_xfs_stat_struct.xs_read_calls = fields[2].parse::<u64>().ok();
                }
                line if line.starts_with("xpc ") => {
                    let fields: Vec<&str> = line.split_whitespace().collect();
                    proc_fs_xfs_stat_struct.xs_write_bytes = fields[2].parse::<u64>().ok();
                    proc_fs_xfs_stat_struct.xs_read_bytes = fields[3].parse::<u64>().ok();
                }
                &_ => { /* anything else currently not implemented */ }
            }
        }

        proc_fs_xfs_stat_struct
    }
    pub fn read_proc_fs_xfs_stat(proc_fs_xfs_stat: &str) -> ProcFsXfsStat {
        let proc_fs_xfs_stat_output = read_to_string(proc_fs_xfs_stat).unwrap_or(String::from(""));

        ProcFsXfsStat::parse_proc_fs_xfs_stat(&proc_fs_xfs_stat_output)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use rand::distributions::Alphanumeric;
    use rand::{thread_rng, Rng};
    use std::fs::{create_dir_all, remove_dir_all, write};

    #[test]
    fn parse_proc_fs_xfs_stat_file() {
        let proc_fs_xfs_stat_file = "extent_alloc 3151384 534926060 3164945 476294498
abt 0 0 0 0
blk_map 353485831 851213330 9893230 6817550 6030586 1560908330 0
bmbt 0 0 0 0
dir 5970443 6945777 6874500 1854279411
trans 39942 3767813357 952
ig 7083866 4980513 0 2103353 0 1340957 3563694470
log 30274117 2045001872 23068 2926274 1401173
push_ail 3772005417 0 347558251 47834761 0 10641092 1400 928650954 0 572818
xstrat 2700722 0
rw 654716312 3877049901
attr 4264349303 6452433 454032 7692
icluster 0 41315812 1121686510
vnodes 762396 0 0 0 6315567 6315567 6315567 0
buf 2125016617 439870 2124576784 214995 432462 439837 0 568672 35579
abtb2 8079740 64538375 1770206 1765154 164 160 17096 10764 5314 4577 197 180 361 340 483092775
abtc2 16641798 135205710 5522173 5517194 236 232 17074 5466 4602 6952 280 264 516 496 1165831063
bmbt2 1170218 8837872 213928 214306 0 0 2153 2180 2381 2153 38 32 38 32 938847
ibt2 12712723 59099644 10126 9119 4 2 3 0 235 1 7 2 11 4 409636
fibt2 17438004 37870019 1700811 1700870 0 0 0 0 0 0 0 0 0 0 18621882
rmapbt 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
refcntbt 220 12 2 2 0 0 0 0 0 0 0 0 0 0 0
qm 0 0 0 0 0 0 0 0 0
xpc 1839985078272 1924118614718 41117984770168
defer_relog 0
debug 0";
        let result = ProcFsXfsStat::parse_proc_fs_xfs_stat(&proc_fs_xfs_stat_file);
        assert_eq!(
            result,
            ProcFsXfsStat {
                xs_write_calls: Some(654716312),
                xs_read_calls: Some(3877049901),
                xs_write_bytes: Some(1924118614718),
                xs_read_bytes: Some(41117984770168),
            }
        );
    }
    #[test]
    fn create_proc_fs_xfs_stat_file_and_read() {
        let proc_fs_xfs_stat_file = "extent_alloc 3151384 534926060 3164945 476294498
abt 0 0 0 0
blk_map 353485831 851213330 9893230 6817550 6030586 1560908330 0
bmbt 0 0 0 0
dir 5970443 6945777 6874500 1854279411
trans 39942 3767813357 952
ig 7083866 4980513 0 2103353 0 1340957 3563694470
log 30274117 2045001872 23068 2926274 1401173
push_ail 3772005417 0 347558251 47834761 0 10641092 1400 928650954 0 572818
xstrat 2700722 0
rw 654716312 3877049901
attr 4264349303 6452433 454032 7692
icluster 0 41315812 1121686510
vnodes 762396 0 0 0 6315567 6315567 6315567 0
buf 2125016617 439870 2124576784 214995 432462 439837 0 568672 35579
abtb2 8079740 64538375 1770206 1765154 164 160 17096 10764 5314 4577 197 180 361 340 483092775
abtc2 16641798 135205710 5522173 5517194 236 232 17074 5466 4602 6952 280 264 516 496 1165831063
bmbt2 1170218 8837872 213928 214306 0 0 2153 2180 2381 2153 38 32 38 32 938847
ibt2 12712723 59099644 10126 9119 4 2 3 0 235 1 7 2 11 4 409636
fibt2 17438004 37870019 1700811 1700870 0 0 0 0 0 0 0 0 0 0 18621882
rmapbt 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
refcntbt 220 12 2 2 0 0 0 0 0 0 0 0 0 0 0
qm 0 0 0 0 0 0 0 0 0
xpc 1839985078272 1924118614718 41117984770168
defer_relog 0
debug 0";

        let directory_suffix: String = thread_rng()
            .sample_iter(&Alphanumeric)
            .take(8)
            .map(char::from)
            .collect();
        let test_path = format!("/tmp/test.{}", directory_suffix);
        create_dir_all(format!("{}/fs/xfs", test_path)).expect("Error creating mock directory.");

        write(format!("{}/fs/xfs/stat", test_path), proc_fs_xfs_stat_file)
            .expect(format!("Error writing to {}/fs/xfs/stat", test_path).as_str());
        let result = Builder::new().path(&test_path).read();

        remove_dir_all(test_path).unwrap();

        assert_eq!(
            result,
            ProcFsXfsStat {
                xs_write_calls: Some(654716312),
                xs_read_calls: Some(3877049901),
                xs_write_bytes: Some(1924118614718),
                xs_read_bytes: Some(41117984770168),
            }
        );
    }
    #[test]
    fn read_nonexistent_proc_fs_xfs_stat_file() -> Result<(), ProcSysParserError> {
        // uncomment to see the error message
        //let _result = Builder::new().path("/xxxxxxxxxxxx").read()?;
        assert_eq!(
            Builder::new().path("/xxxxxxxxxxxx").read(),
            ProcFsXfsStat {
                xs_write_calls: None,
                xs_read_calls: None,
                xs_write_bytes: None,
                xs_read_bytes: None,
            }
        );
        Ok(())
    }

    #[test]
    fn parse_proc_fs_xfs_stat_file_line_missing_xpc_entries() -> Result<(), ProcSysParserError> {
        let proc_fs_xfs_stat_file = "extent_alloc 3151384 534926060 3164945 476294498
abt 0 0 0 0
blk_map 353485831 851213330 9893230 6817550 6030586 1560908330 0
bmbt 0 0 0 0
dir 5970443 6945777 6874500 1854279411
trans 39942 3767813357 952
ig 7083866 4980513 0 2103353 0 1340957 3563694470
log 30274117 2045001872 23068 2926274 1401173
push_ail 3772005417 0 347558251 47834761 0 10641092 1400 928650954 0 572818
xstrat 2700722 0
rw 654716312 3877049901
attr 4264349303 6452433 454032 7692
icluster 0 41315812 1121686510
vnodes 762396 0 0 0 6315567 6315567 6315567 0
buf 2125016617 439870 2124576784 214995 432462 439837 0 568672 35579
abtb2 8079740 64538375 1770206 1765154 164 160 17096 10764 5314 4577 197 180 361 340 483092775
abtc2 16641798 135205710 5522173 5517194 236 232 17074 5466 4602 6952 280 264 516 496 1165831063
bmbt2 1170218 8837872 213928 214306 0 0 2153 2180 2381 2153 38 32 38 32 938847
ibt2 12712723 59099644 10126 9119 4 2 3 0 235 1 7 2 11 4 409636
fibt2 17438004 37870019 1700811 1700870 0 0 0 0 0 0 0 0 0 0 18621882
rmapbt 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
refcntbt 220 12 2 2 0 0 0 0 0 0 0 0 0 0 0
qm 0 0 0 0 0 0 0 0 0
defer_relog 0
debug 0";
        let result = ProcFsXfsStat::parse_proc_fs_xfs_stat(&proc_fs_xfs_stat_file);
        assert_eq!(
            result,
            ProcFsXfsStat {
                xs_write_calls: Some(654716312),
                xs_read_calls: Some(3877049901),
                xs_write_bytes: None,
                xs_read_bytes: None,
            }
        );
        Ok(())
    }
    /*
    #[test]
    fn parse_corrupted_loadavg_line_wrong_entry() -> Result<(), ProcSysParserError> {
        let loadavg_line = format!("AAA 0.19 0.13 1/161 7\n");
        //let result = ProcLoadavg::parse_proc_loadavg(&loadavg_line)?;
        let result = ProcLoadavg::parse_proc_loadavg(&loadavg_line);
        Ok(assert!(result.is_err()))
    }
    */
}