Platform

systemstat::platform::common

Trait Platform 

Source 
pub trait Platform {

Show 18 methods    // Required methods
    fn new() -> Self;
    fn cpu_load(&self) -> Result<DelayedMeasurement<Vec<CPULoad>>>;
    fn load_average(&self) -> Result<LoadAverage>;
    fn memory(&self) -> Result<Memory>;
    fn swap(&self) -> Result<Swap>;
    fn battery_life(&self) -> Result<BatteryLife>;
    fn on_ac_power(&self) -> Result<bool>;
    fn mounts(&self) -> Result<Vec<Filesystem>>;
    fn block_device_statistics(
        &self,
    ) -> Result<BTreeMap<String, BlockDeviceStats>>;
    fn networks(&self) -> Result<BTreeMap<String, Network>>;
    fn network_stats(&self, interface: &str) -> Result<NetworkStats>;
    fn cpu_temp(&self) -> Result<f32>;
    fn socket_stats(&self) -> Result<SocketStats>;

    // Provided methods
    fn cpu_load_aggregate(&self) -> Result<DelayedMeasurement<CPULoad>> { ... }
    fn memory_and_swap(&self) -> Result<(Memory, Swap)> { ... }
    fn uptime(&self) -> Result<Duration> { ... }
    fn boot_time(&self) -> Result<OffsetDateTime> { ... }
    fn mount_at<P: AsRef<Path>>(&self, path: P) -> Result<Filesystem> { ... }

}
Expand description

The Platform trait declares all the functions for getting system information.

NOTE: any impl MUST override one of uptime or boot_time.

Required Methods§

Source

fn new() -> Self

Source

fn cpu_load(&self) -> Result<DelayedMeasurement<Vec<CPULoad>>>

Returns a delayed vector of CPU load statistics, one object per CPU (core).

You need to wait some time (about a second is good) before unwrapping the DelayedMeasurement with .done().

Source

fn load_average(&self) -> Result<LoadAverage>

Returns a load average object.

Source

fn memory(&self) -> Result<Memory>

Returns a memory information object.

Source

fn swap(&self) -> Result<Swap>

Returns a swap memory information object.

Source

fn battery_life(&self) -> Result<BatteryLife>

Returns a battery life information object.

Source

fn on_ac_power(&self) -> Result<bool>

Returns whether AC power is plugged in.

Source

fn mounts(&self) -> Result<Vec<Filesystem>>

Returns a vector of filesystem mount information objects.

Source

fn block_device_statistics(&self) -> Result<BTreeMap<String, BlockDeviceStats>>

Returns a map of block device statistics objects

Source

fn networks(&self) -> Result<BTreeMap<String, Network>>

Returns a map of network intefrace information objects.

It’s a map because most operating systems return an object per IP address, not per interface, and we’re doing deduplication and packing everything into one object per interface. You can use the .values() iterator if you need to iterate over all of them.

Source

fn network_stats(&self, interface: &str) -> Result<NetworkStats>

Returns statistics for a given interface (bytes/packets sent/received)

Source

fn cpu_temp(&self) -> Result<f32>

Returns the current CPU temperature in degrees Celsius.

Depending on the platform, this might be core 0, package, etc.

Source

fn socket_stats(&self) -> Result<SocketStats>

Returns information about the number of sockets in use

Provided Methods§

Source

fn cpu_load_aggregate(&self) -> Result<DelayedMeasurement<CPULoad>>

Returns a delayed CPU load statistics object, average over all CPUs (cores).

You need to wait some time (about a second is good) before unwrapping the DelayedMeasurement with .done().

Examples found in repository?
examples/info.rs (line 98)
7fn main() {
8    let sys = System::new();
9
10    match sys.mounts() {
11        Ok(mounts) => {
12            println!("\nMounts:");
13            for mount in mounts.iter() {
14                println!("{} ---{}---> {} (available {} of {})",
15                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
16            }
17        }
18        Err(x) => println!("\nMounts: error: {}", x)
19    }
20
21    match sys.mount_at("/") {
22        Ok(mount) => {
23            println!("\nMount at /:");
24            println!("{} ---{}---> {} (available {} of {})",
25                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
26        }
27        Err(x) => println!("\nMount at /: error: {}", x)
28    }
29
30    match sys.block_device_statistics() {
31        Ok(stats) => {
32            for blkstats in stats.values() {
33                println!("{}: {:?}", blkstats.name, blkstats);
34            }
35        }
36        Err(x) => println!("\nBlock statistics error: {}", x)
37    }
38
39    match sys.networks() {
40        Ok(netifs) => {
41            println!("\nNetworks:");
42            for netif in netifs.values() {
43                println!("{} ({:?})", netif.name, netif.addrs);
44            }
45        }
46        Err(x) => println!("\nNetworks: error: {}", x)
47    }
48
49    match sys.networks() {
50        Ok(netifs) => {
51            println!("\nNetwork interface statistics:");
52            for netif in netifs.values() {
53                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
54            }
55        }
56        Err(x) => println!("\nNetworks: error: {}", x)
57    }
58
59    match sys.battery_life() {
60        Ok(battery) =>
61            print!("\nBattery: {}%, {}h{}m remaining",
62                   battery.remaining_capacity*100.0,
63                   battery.remaining_time.as_secs() / 3600,
64                   battery.remaining_time.as_secs() % 60),
65        Err(x) => print!("\nBattery: error: {}", x)
66    }
67
68    match sys.on_ac_power() {
69        Ok(power) => println!(", AC power: {}", power),
70        Err(x) => println!(", AC power: error: {}", x)
71    }
72
73    match sys.memory() {
74        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
75        Err(x) => println!("\nMemory: error: {}", x)
76    }
77
78    match sys.swap() {
79        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
80        Err(x) => println!("\nSwap: error: {}", x)
81    }
82
83    match sys.load_average() {
84        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
85        Err(x) => println!("\nLoad average: error: {}", x)
86    }
87
88    match sys.uptime() {
89        Ok(uptime) => println!("\nUptime: {:?}", uptime),
90        Err(x) => println!("\nUptime: error: {}", x)
91    }
92
93    match sys.boot_time() {
94        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
95        Err(x) => println!("\nBoot time: error: {}", x)
96    }
97
98    match sys.cpu_load_aggregate() {
99        Ok(cpu)=> {
100            println!("\nMeasuring CPU load...");
101            thread::sleep(Duration::from_secs(1));
102            let cpu = cpu.done().unwrap();
103            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
104                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
105        },
106        Err(x) => println!("\nCPU load: error: {}", x)
107    }
108
109    match sys.cpu_temp() {
110        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
111        Err(x) => println!("\nCPU temp: {}", x)
112    }
113
114    match sys.socket_stats() {
115        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
116        Err(x) => println!("\nSystem socket statistics: error: {}", x)
117    }
118}
Source

fn memory_and_swap(&self) -> Result<(Memory, Swap)>

Returns a swap and a memory information object. On some platforms this is more efficient than calling memory() and swap() separately If memory() or swap() are not implemented for a platform, this function will fail.

Source

fn uptime(&self) -> Result<Duration>

Returns the system uptime.

Examples found in repository?
examples/info.rs (line 88)
7fn main() {
8    let sys = System::new();
9
10    match sys.mounts() {
11        Ok(mounts) => {
12            println!("\nMounts:");
13            for mount in mounts.iter() {
14                println!("{} ---{}---> {} (available {} of {})",
15                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
16            }
17        }
18        Err(x) => println!("\nMounts: error: {}", x)
19    }
20
21    match sys.mount_at("/") {
22        Ok(mount) => {
23            println!("\nMount at /:");
24            println!("{} ---{}---> {} (available {} of {})",
25                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
26        }
27        Err(x) => println!("\nMount at /: error: {}", x)
28    }
29
30    match sys.block_device_statistics() {
31        Ok(stats) => {
32            for blkstats in stats.values() {
33                println!("{}: {:?}", blkstats.name, blkstats);
34            }
35        }
36        Err(x) => println!("\nBlock statistics error: {}", x)
37    }
38
39    match sys.networks() {
40        Ok(netifs) => {
41            println!("\nNetworks:");
42            for netif in netifs.values() {
43                println!("{} ({:?})", netif.name, netif.addrs);
44            }
45        }
46        Err(x) => println!("\nNetworks: error: {}", x)
47    }
48
49    match sys.networks() {
50        Ok(netifs) => {
51            println!("\nNetwork interface statistics:");
52            for netif in netifs.values() {
53                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
54            }
55        }
56        Err(x) => println!("\nNetworks: error: {}", x)
57    }
58
59    match sys.battery_life() {
60        Ok(battery) =>
61            print!("\nBattery: {}%, {}h{}m remaining",
62                   battery.remaining_capacity*100.0,
63                   battery.remaining_time.as_secs() / 3600,
64                   battery.remaining_time.as_secs() % 60),
65        Err(x) => print!("\nBattery: error: {}", x)
66    }
67
68    match sys.on_ac_power() {
69        Ok(power) => println!(", AC power: {}", power),
70        Err(x) => println!(", AC power: error: {}", x)
71    }
72
73    match sys.memory() {
74        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
75        Err(x) => println!("\nMemory: error: {}", x)
76    }
77
78    match sys.swap() {
79        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
80        Err(x) => println!("\nSwap: error: {}", x)
81    }
82
83    match sys.load_average() {
84        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
85        Err(x) => println!("\nLoad average: error: {}", x)
86    }
87
88    match sys.uptime() {
89        Ok(uptime) => println!("\nUptime: {:?}", uptime),
90        Err(x) => println!("\nUptime: error: {}", x)
91    }
92
93    match sys.boot_time() {
94        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
95        Err(x) => println!("\nBoot time: error: {}", x)
96    }
97
98    match sys.cpu_load_aggregate() {
99        Ok(cpu)=> {
100            println!("\nMeasuring CPU load...");
101            thread::sleep(Duration::from_secs(1));
102            let cpu = cpu.done().unwrap();
103            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
104                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
105        },
106        Err(x) => println!("\nCPU load: error: {}", x)
107    }
108
109    match sys.cpu_temp() {
110        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
111        Err(x) => println!("\nCPU temp: {}", x)
112    }
113
114    match sys.socket_stats() {
115        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
116        Err(x) => println!("\nSystem socket statistics: error: {}", x)
117    }
118}
Source

fn boot_time(&self) -> Result<OffsetDateTime>

Returns the system boot time.

Examples found in repository?
examples/info.rs (line 93)
7fn main() {
8    let sys = System::new();
9
10    match sys.mounts() {
11        Ok(mounts) => {
12            println!("\nMounts:");
13            for mount in mounts.iter() {
14                println!("{} ---{}---> {} (available {} of {})",
15                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
16            }
17        }
18        Err(x) => println!("\nMounts: error: {}", x)
19    }
20
21    match sys.mount_at("/") {
22        Ok(mount) => {
23            println!("\nMount at /:");
24            println!("{} ---{}---> {} (available {} of {})",
25                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
26        }
27        Err(x) => println!("\nMount at /: error: {}", x)
28    }
29
30    match sys.block_device_statistics() {
31        Ok(stats) => {
32            for blkstats in stats.values() {
33                println!("{}: {:?}", blkstats.name, blkstats);
34            }
35        }
36        Err(x) => println!("\nBlock statistics error: {}", x)
37    }
38
39    match sys.networks() {
40        Ok(netifs) => {
41            println!("\nNetworks:");
42            for netif in netifs.values() {
43                println!("{} ({:?})", netif.name, netif.addrs);
44            }
45        }
46        Err(x) => println!("\nNetworks: error: {}", x)
47    }
48
49    match sys.networks() {
50        Ok(netifs) => {
51            println!("\nNetwork interface statistics:");
52            for netif in netifs.values() {
53                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
54            }
55        }
56        Err(x) => println!("\nNetworks: error: {}", x)
57    }
58
59    match sys.battery_life() {
60        Ok(battery) =>
61            print!("\nBattery: {}%, {}h{}m remaining",
62                   battery.remaining_capacity*100.0,
63                   battery.remaining_time.as_secs() / 3600,
64                   battery.remaining_time.as_secs() % 60),
65        Err(x) => print!("\nBattery: error: {}", x)
66    }
67
68    match sys.on_ac_power() {
69        Ok(power) => println!(", AC power: {}", power),
70        Err(x) => println!(", AC power: error: {}", x)
71    }
72
73    match sys.memory() {
74        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
75        Err(x) => println!("\nMemory: error: {}", x)
76    }
77
78    match sys.swap() {
79        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
80        Err(x) => println!("\nSwap: error: {}", x)
81    }
82
83    match sys.load_average() {
84        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
85        Err(x) => println!("\nLoad average: error: {}", x)
86    }
87
88    match sys.uptime() {
89        Ok(uptime) => println!("\nUptime: {:?}", uptime),
90        Err(x) => println!("\nUptime: error: {}", x)
91    }
92
93    match sys.boot_time() {
94        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
95        Err(x) => println!("\nBoot time: error: {}", x)
96    }
97
98    match sys.cpu_load_aggregate() {
99        Ok(cpu)=> {
100            println!("\nMeasuring CPU load...");
101            thread::sleep(Duration::from_secs(1));
102            let cpu = cpu.done().unwrap();
103            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
104                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
105        },
106        Err(x) => println!("\nCPU load: error: {}", x)
107    }
108
109    match sys.cpu_temp() {
110        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
111        Err(x) => println!("\nCPU temp: {}", x)
112    }
113
114    match sys.socket_stats() {
115        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
116        Err(x) => println!("\nSystem socket statistics: error: {}", x)
117    }
118}
Source

fn mount_at<P: AsRef<Path>>(&self, path: P) -> Result<Filesystem>

Returns a filesystem mount information object for the filesystem at a given path.

Examples found in repository?
examples/info.rs (line 21)
7fn main() {
8    let sys = System::new();
9
10    match sys.mounts() {
11        Ok(mounts) => {
12            println!("\nMounts:");
13            for mount in mounts.iter() {
14                println!("{} ---{}---> {} (available {} of {})",
15                         mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
16            }
17        }
18        Err(x) => println!("\nMounts: error: {}", x)
19    }
20
21    match sys.mount_at("/") {
22        Ok(mount) => {
23            println!("\nMount at /:");
24            println!("{} ---{}---> {} (available {} of {})",
25                     mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
26        }
27        Err(x) => println!("\nMount at /: error: {}", x)
28    }
29
30    match sys.block_device_statistics() {
31        Ok(stats) => {
32            for blkstats in stats.values() {
33                println!("{}: {:?}", blkstats.name, blkstats);
34            }
35        }
36        Err(x) => println!("\nBlock statistics error: {}", x)
37    }
38
39    match sys.networks() {
40        Ok(netifs) => {
41            println!("\nNetworks:");
42            for netif in netifs.values() {
43                println!("{} ({:?})", netif.name, netif.addrs);
44            }
45        }
46        Err(x) => println!("\nNetworks: error: {}", x)
47    }
48
49    match sys.networks() {
50        Ok(netifs) => {
51            println!("\nNetwork interface statistics:");
52            for netif in netifs.values() {
53                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
54            }
55        }
56        Err(x) => println!("\nNetworks: error: {}", x)
57    }
58
59    match sys.battery_life() {
60        Ok(battery) =>
61            print!("\nBattery: {}%, {}h{}m remaining",
62                   battery.remaining_capacity*100.0,
63                   battery.remaining_time.as_secs() / 3600,
64                   battery.remaining_time.as_secs() % 60),
65        Err(x) => print!("\nBattery: error: {}", x)
66    }
67
68    match sys.on_ac_power() {
69        Ok(power) => println!(", AC power: {}", power),
70        Err(x) => println!(", AC power: error: {}", x)
71    }
72
73    match sys.memory() {
74        Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
75        Err(x) => println!("\nMemory: error: {}", x)
76    }
77
78    match sys.swap() {
79        Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
80        Err(x) => println!("\nSwap: error: {}", x)
81    }
82
83    match sys.load_average() {
84        Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
85        Err(x) => println!("\nLoad average: error: {}", x)
86    }
87
88    match sys.uptime() {
89        Ok(uptime) => println!("\nUptime: {:?}", uptime),
90        Err(x) => println!("\nUptime: error: {}", x)
91    }
92
93    match sys.boot_time() {
94        Ok(boot_time) => println!("\nBoot time: {}", boot_time),
95        Err(x) => println!("\nBoot time: error: {}", x)
96    }
97
98    match sys.cpu_load_aggregate() {
99        Ok(cpu)=> {
100            println!("\nMeasuring CPU load...");
101            thread::sleep(Duration::from_secs(1));
102            let cpu = cpu.done().unwrap();
103            println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
104                cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
105        },
106        Err(x) => println!("\nCPU load: error: {}", x)
107    }
108
109    match sys.cpu_temp() {
110        Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
111        Err(x) => println!("\nCPU temp: {}", x)
112    }
113
114    match sys.socket_stats() {
115        Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
116        Err(x) => println!("\nSystem socket statistics: error: {}", x)
117    }
118}

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§

Source§

impl Platform for PlatformImpl

An implementation of Platform for Linux. See Platform for documentation.