systemstat/
data.rs

1//! This module provides the data structures that represent system information.
2//!
3//! They're always the same across all platforms.
4
5pub use bytesize::ByteSize;
6pub use std::collections::BTreeMap;
7use std::io;
8pub use std::net::{Ipv4Addr, Ipv6Addr};
9use std::ops::Sub;
10pub use std::time::Duration;
11pub use time::OffsetDateTime;
12
13#[cfg(feature = "serde")]
14use serde::{Deserialize, Serialize};
15
16#[inline(always)]
17pub fn saturating_sub_bytes(l: ByteSize, r: ByteSize) -> ByteSize {
18    ByteSize::b(l.as_u64().saturating_sub(r.as_u64()))
19}
20
21/// A wrapper for a measurement that takes time.
22///
23/// Time should pass between getting the object and calling .done() on it.
24pub struct DelayedMeasurement<T> {
25    res: Box<dyn Fn() -> io::Result<T> + Send>,
26}
27
28impl<T> DelayedMeasurement<T> {
29    #[inline(always)]
30    pub fn new(f: Box<dyn Fn() -> io::Result<T> + Send>) -> DelayedMeasurement<T> {
31        DelayedMeasurement { res: f }
32    }
33
34    #[inline(always)]
35    pub fn done(&self) -> io::Result<T> {
36        (self.res)()
37    }
38}
39
40#[cfg(not(target_os = "linux"))]
41#[cfg_attr(
42    feature = "serde",
43    derive(Serialize, Deserialize),
44    serde(crate = "the_serde")
45)]
46#[derive(Debug, Clone)]
47pub struct PlatformCpuLoad {}
48
49#[cfg(target_os = "linux")]
50#[cfg_attr(
51    feature = "serde",
52    derive(Serialize, Deserialize),
53    serde(crate = "the_serde")
54)]
55#[derive(Debug, Clone)]
56pub struct PlatformCpuLoad {
57    pub iowait: f32,
58}
59
60impl PlatformCpuLoad {
61    #[cfg(target_os = "linux")]
62    #[inline(always)]
63    pub fn avg_add(self, rhs: &Self) -> Self {
64        PlatformCpuLoad {
65            iowait: (self.iowait + rhs.iowait) / 2.0,
66        }
67    }
68
69    #[cfg(not(target_os = "linux"))]
70    #[inline(always)]
71    pub fn avg_add(self, _rhs: &Self) -> Self {
72        PlatformCpuLoad {}
73    }
74
75    #[cfg(target_os = "linux")]
76    #[inline(always)]
77    pub fn zero() -> Self {
78        PlatformCpuLoad { iowait: 0.0 }
79    }
80
81    #[cfg(not(target_os = "linux"))]
82    #[inline(always)]
83    pub fn zero() -> Self {
84        PlatformCpuLoad {}
85    }
86
87    #[cfg(target_os = "linux")]
88    #[inline(always)]
89    pub fn from(input: f32) -> Self {
90        PlatformCpuLoad { iowait: input }
91    }
92
93    #[cfg(not(target_os = "linux"))]
94    #[inline(always)]
95    pub fn from(_input: f32) -> Self {
96        PlatformCpuLoad {}
97    }
98
99    #[cfg(target_os = "linux")]
100    #[inline(always)]
101    pub fn sum(&self) -> f32 {
102        self.iowait
103    }
104
105    #[cfg(not(target_os = "linux"))]
106    #[inline(always)]
107    pub fn sum(&self) -> f32 {
108        0.0
109    }
110}
111
112#[cfg_attr(
113    feature = "serde",
114    derive(Serialize, Deserialize),
115    serde(crate = "the_serde")
116)]
117#[derive(Debug, Clone)]
118pub struct CPULoad {
119    pub user: f32,
120    pub nice: f32,
121    pub system: f32,
122    pub interrupt: f32,
123    pub idle: f32,
124    pub platform: PlatformCpuLoad,
125}
126
127impl CPULoad {
128    #[inline(always)]
129    pub fn avg_add(self, rhs: &Self) -> Self {
130        CPULoad {
131            user: (self.user + rhs.user) / 2.0,
132            nice: (self.nice + rhs.nice) / 2.0,
133            system: (self.system + rhs.system) / 2.0,
134            interrupt: (self.interrupt + rhs.interrupt) / 2.0,
135            idle: (self.idle + rhs.idle) / 2.0,
136            platform: self.platform.avg_add(&rhs.platform),
137        }
138    }
139}
140
141#[cfg_attr(
142    feature = "serde",
143    derive(Serialize, Deserialize),
144    serde(crate = "the_serde")
145)]
146#[derive(Debug, Clone, Copy)]
147pub struct CpuTime {
148    pub user: usize,
149    pub nice: usize,
150    pub system: usize,
151    pub interrupt: usize,
152    pub idle: usize,
153    pub other: usize,
154}
155
156impl<'a> Sub<&'a CpuTime> for CpuTime {
157    type Output = CpuTime;
158
159    #[inline(always)]
160    fn sub(self, rhs: &CpuTime) -> CpuTime {
161        CpuTime {
162            user: self.user.saturating_sub(rhs.user),
163            nice: self.nice.saturating_sub(rhs.nice),
164            system: self.system.saturating_sub(rhs.system),
165            interrupt: self.interrupt.saturating_sub(rhs.interrupt),
166            idle: self.idle.saturating_sub(rhs.idle),
167            other: self.other.saturating_sub(rhs.other),
168        }
169    }
170}
171
172impl CpuTime {
173    pub fn to_cpuload(&self) -> CPULoad {
174        let total = self.user + self.nice + self.system + self.interrupt + self.idle + self.other;
175        if total == 0 {
176            CPULoad {
177                user: 0.0,
178                nice: 0.0,
179                system: 0.0,
180                interrupt: 0.0,
181                idle: 0.0,
182                platform: PlatformCpuLoad::zero(),
183            }
184        } else {
185            CPULoad {
186                user: self.user as f32 / total as f32,
187                nice: self.nice as f32 / total as f32,
188                system: self.system as f32 / total as f32,
189                interrupt: self.interrupt as f32 / total as f32,
190                idle: self.idle as f32 / total as f32,
191                platform: PlatformCpuLoad::from(self.other as f32 / total as f32),
192            }
193        }
194    }
195}
196
197#[cfg_attr(
198    feature = "serde",
199    derive(Serialize, Deserialize),
200    serde(crate = "the_serde")
201)]
202#[derive(Debug, Clone)]
203pub struct LoadAverage {
204    pub one: f32,
205    pub five: f32,
206    pub fifteen: f32,
207}
208
209#[cfg(target_os = "windows")]
210#[cfg_attr(
211    feature = "serde",
212    derive(Serialize, Deserialize),
213    serde(crate = "the_serde")
214)]
215#[derive(Debug, Clone)]
216pub struct PlatformMemory {
217    pub load: u32,
218    pub total_phys: ByteSize,
219    pub avail_phys: ByteSize,
220    pub total_pagefile: ByteSize,
221    pub avail_pagefile: ByteSize,
222    pub total_virt: ByteSize,
223    pub avail_virt: ByteSize,
224    pub avail_ext: ByteSize,
225}
226
227#[cfg(target_os = "freebsd")]
228#[cfg_attr(
229    feature = "serde",
230    derive(Serialize, Deserialize),
231    serde(crate = "the_serde")
232)]
233#[derive(Debug, Clone)]
234pub struct PlatformMemory {
235    pub active: ByteSize,
236    pub inactive: ByteSize,
237    pub wired: ByteSize,
238    pub cache: ByteSize,
239    pub zfs_arc: ByteSize,
240    pub free: ByteSize,
241}
242
243#[cfg(any(target_os = "openbsd", target_os = "illumos", target_os = "solaris"))]
244#[cfg_attr(
245    feature = "serde",
246    derive(Serialize, Deserialize),
247    serde(crate = "the_serde")
248)]
249#[derive(Debug, Clone)]
250pub struct PlatformMemory {
251    pub total: ByteSize,
252    pub active: ByteSize,
253    pub inactive: ByteSize,
254    pub wired: ByteSize,
255    pub cache: ByteSize,
256    pub free: ByteSize,
257    pub paging: ByteSize,
258    pub sw: ByteSize,
259    pub swinuse: ByteSize,
260    pub swonly: ByteSize,
261}
262
263#[cfg(target_os = "netbsd")]
264#[cfg_attr(
265    feature = "serde",
266    derive(Serialize, Deserialize),
267    serde(crate = "the_serde")
268)]
269#[derive(Debug, Clone)]
270pub struct PlatformMemory {
271    pub pageshift: i64,
272    pub total: ByteSize,
273    pub active: ByteSize,
274    pub inactive: ByteSize,
275    pub wired: ByteSize,
276    pub free: ByteSize,
277    pub paging: ByteSize,
278    pub anon: ByteSize,
279    pub files: ByteSize,
280    pub exec: ByteSize,
281    pub sw: ByteSize,
282    pub swinuse: ByteSize,
283    pub swonly: ByteSize,
284}
285
286#[cfg(target_vendor = "apple")]
287#[cfg_attr(
288    feature = "serde",
289    derive(Serialize, Deserialize),
290    serde(crate = "the_serde")
291)]
292#[derive(Debug, Clone)]
293pub struct PlatformMemory {
294    pub total: ByteSize,
295    pub active: ByteSize,
296    pub inactive: ByteSize,
297    pub wired: ByteSize,
298    pub free: ByteSize,
299    pub purgeable: ByteSize,
300    pub speculative: ByteSize,
301    pub compressor: ByteSize,
302    pub throttled: ByteSize,
303    pub external: ByteSize,
304    pub internal: ByteSize,
305    pub uncompressed_in_compressor: ByteSize,
306}
307
308#[cfg(any(target_os = "linux", target_os = "android"))]
309#[cfg_attr(
310    feature = "serde",
311    derive(Serialize, Deserialize),
312    serde(crate = "the_serde")
313)]
314#[derive(Debug, Clone)]
315pub struct PlatformMemory {
316    pub meminfo: BTreeMap<String, ByteSize>,
317}
318
319#[cfg_attr(
320    feature = "serde",
321    derive(Serialize, Deserialize),
322    serde(crate = "the_serde")
323)]
324#[derive(Debug, Clone)]
325pub struct Memory {
326    pub total: ByteSize,
327    pub free: ByteSize,
328    pub platform_memory: PlatformMemory,
329}
330
331#[cfg(any(
332    target_os = "windows",
333    target_os = "linux",
334    target_os = "android",
335    target_os = "openbsd",
336    target_os = "netbsd",
337    target_os = "illumos",
338    target_os = "solaris"
339))]
340pub type PlatformSwap = PlatformMemory;
341
342#[cfg(any(target_vendor = "apple", target_os = "freebsd"))]
343#[cfg_attr(
344    feature = "serde",
345    derive(Serialize, Deserialize),
346    serde(crate = "the_serde")
347)]
348#[derive(Debug, Clone)]
349pub struct PlatformSwap {
350    pub total: ByteSize,
351    pub avail: ByteSize,
352    pub used: ByteSize,
353    pub pagesize: ByteSize,
354    pub encrypted: bool,
355}
356
357#[cfg_attr(
358    feature = "serde",
359    derive(Serialize, Deserialize),
360    serde(crate = "the_serde")
361)]
362#[derive(Debug, Clone)]
363pub struct Swap {
364    pub total: ByteSize,
365    pub free: ByteSize,
366    pub platform_swap: PlatformSwap,
367}
368
369#[cfg_attr(
370    feature = "serde",
371    derive(Serialize, Deserialize),
372    serde(crate = "the_serde")
373)]
374#[derive(Debug, Clone)]
375pub struct BatteryLife {
376    pub remaining_capacity: f32,
377    pub remaining_time: Duration,
378}
379
380#[cfg_attr(
381    feature = "serde",
382    derive(Serialize, Deserialize),
383    serde(crate = "the_serde")
384)]
385#[derive(Debug, Clone)]
386pub struct Filesystem {
387    /// Used file nodes in filesystem
388    pub files: usize,
389    /// Total file nodes in filesystem
390    pub files_total: usize,
391    /// Free nodes available to non-superuser
392    pub files_avail: usize,
393    /// Free bytes in filesystem
394    pub free: ByteSize,
395    /// Free bytes available to non-superuser
396    pub avail: ByteSize,
397    /// Total bytes in filesystem
398    pub total: ByteSize,
399    /// Maximum filename length
400    pub name_max: usize,
401    pub fs_type: String,
402    pub fs_mounted_from: String,
403    pub fs_mounted_on: String,
404}
405
406#[cfg_attr(
407    feature = "serde",
408    derive(Serialize, Deserialize),
409    serde(crate = "the_serde")
410)]
411#[derive(Debug, Clone)]
412pub struct BlockDeviceStats {
413    pub name: String,
414    pub read_ios: usize,
415    pub read_merges: usize,
416    pub read_sectors: usize,
417    pub read_ticks: usize,
418    pub write_ios: usize,
419    pub write_merges: usize,
420    pub write_sectors: usize,
421    pub write_ticks: usize,
422    pub in_flight: usize,
423    pub io_ticks: usize,
424    pub time_in_queue: usize,
425}
426
427#[cfg_attr(
428    feature = "serde",
429    derive(Serialize, Deserialize),
430    serde(crate = "the_serde")
431)]
432#[derive(Debug, Clone, PartialEq)]
433pub enum IpAddr {
434    Empty,
435    Unsupported,
436    V4(Ipv4Addr),
437    V6(Ipv6Addr),
438}
439
440#[cfg_attr(
441    feature = "serde",
442    derive(Serialize, Deserialize),
443    serde(crate = "the_serde")
444)]
445#[derive(Debug, Clone)]
446pub struct NetworkAddrs {
447    pub addr: IpAddr,
448    pub netmask: IpAddr,
449}
450
451#[cfg_attr(
452    feature = "serde",
453    derive(Serialize, Deserialize),
454    serde(crate = "the_serde")
455)]
456#[derive(Debug, Clone)]
457pub struct Network {
458    pub name: String,
459    pub addrs: Vec<NetworkAddrs>,
460}
461
462#[cfg_attr(
463    feature = "serde",
464    derive(Serialize, Deserialize),
465    serde(crate = "the_serde")
466)]
467#[derive(Debug, Clone)]
468pub struct NetworkStats {
469    pub rx_bytes: ByteSize,
470    pub tx_bytes: ByteSize,
471    pub rx_packets: u64,
472    pub tx_packets: u64,
473    pub rx_errors: u64,
474    pub tx_errors: u64,
475}
476
477#[cfg_attr(
478    feature = "serde",
479    derive(Serialize, Deserialize),
480    serde(crate = "the_serde")
481)]
482#[derive(Debug, Clone)]
483pub struct SocketStats {
484    pub tcp_sockets_in_use: usize,
485    pub tcp_sockets_orphaned: usize,
486    pub udp_sockets_in_use: usize,
487    pub tcp6_sockets_in_use: usize,
488    pub udp6_sockets_in_use: usize,
489}
systemstat/data.rs

systemstat/
data.rs
