Trait systemstat::platform::common::Platform
source · pub trait Platform {
Show 18 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>;
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§
fn new() -> Self
sourcefn cpu_load(&self) -> Result<DelayedMeasurement<Vec<CPULoad>>>
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()
.
sourcefn load_average(&self) -> Result<LoadAverage>
fn load_average(&self) -> Result<LoadAverage>
Returns a load average object.
sourcefn battery_life(&self) -> Result<BatteryLife>
fn battery_life(&self) -> Result<BatteryLife>
Returns a battery life information object.
sourcefn on_ac_power(&self) -> Result<bool>
fn on_ac_power(&self) -> Result<bool>
Returns whether AC power is plugged in.
sourcefn mounts(&self) -> Result<Vec<Filesystem>>
fn mounts(&self) -> Result<Vec<Filesystem>>
Returns a vector of filesystem mount information objects.
sourcefn block_device_statistics(&self) -> Result<BTreeMap<String, BlockDeviceStats>>
fn block_device_statistics(&self) -> Result<BTreeMap<String, BlockDeviceStats>>
Returns a map of block device statistics objects
sourcefn networks(&self) -> Result<BTreeMap<String, Network>>
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.
sourcefn network_stats(&self, interface: &str) -> Result<NetworkStats>
fn network_stats(&self, interface: &str) -> Result<NetworkStats>
Returns statistics for a given interface (bytes/packets sent/received)
sourcefn cpu_temp(&self) -> Result<f32>
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.
sourcefn socket_stats(&self) -> Result<SocketStats>
fn socket_stats(&self) -> Result<SocketStats>
Returns information about the number of sockets in use
Provided Methods§
sourcefn cpu_load_aggregate(&self) -> Result<DelayedMeasurement<CPULoad>>
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?
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
fn main() {
let sys = System::new();
match sys.mounts() {
Ok(mounts) => {
println!("\nMounts:");
for mount in mounts.iter() {
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
}
Err(x) => println!("\nMounts: error: {}", x)
}
match sys.mount_at("/") {
Ok(mount) => {
println!("\nMount at /:");
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
Err(x) => println!("\nMount at /: error: {}", x)
}
match sys.block_device_statistics() {
Ok(stats) => {
for blkstats in stats.values() {
println!("{}: {:?}", blkstats.name, blkstats);
}
}
Err(x) => println!("\nBlock statistics error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetworks:");
for netif in netifs.values() {
println!("{} ({:?})", netif.name, netif.addrs);
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetwork interface statistics:");
for netif in netifs.values() {
println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.battery_life() {
Ok(battery) =>
print!("\nBattery: {}%, {}h{}m remaining",
battery.remaining_capacity*100.0,
battery.remaining_time.as_secs() / 3600,
battery.remaining_time.as_secs() % 60),
Err(x) => print!("\nBattery: error: {}", x)
}
match sys.on_ac_power() {
Ok(power) => println!(", AC power: {}", power),
Err(x) => println!(", AC power: error: {}", x)
}
match sys.memory() {
Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
Err(x) => println!("\nMemory: error: {}", x)
}
match sys.swap() {
Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
Err(x) => println!("\nSwap: error: {}", x)
}
match sys.load_average() {
Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
Err(x) => println!("\nLoad average: error: {}", x)
}
match sys.uptime() {
Ok(uptime) => println!("\nUptime: {:?}", uptime),
Err(x) => println!("\nUptime: error: {}", x)
}
match sys.boot_time() {
Ok(boot_time) => println!("\nBoot time: {}", boot_time),
Err(x) => println!("\nBoot time: error: {}", x)
}
match sys.cpu_load_aggregate() {
Ok(cpu)=> {
println!("\nMeasuring CPU load...");
thread::sleep(Duration::from_secs(1));
let cpu = cpu.done().unwrap();
println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
},
Err(x) => println!("\nCPU load: error: {}", x)
}
match sys.cpu_temp() {
Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
Err(x) => println!("\nCPU temp: {}", x)
}
match sys.socket_stats() {
Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
Err(x) => println!("\nSystem socket statistics: error: {}", x)
}
}
sourcefn memory_and_swap(&self) -> Result<(Memory, Swap)>
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.
sourcefn uptime(&self) -> Result<Duration>
fn uptime(&self) -> Result<Duration>
Returns the system uptime.
Examples found in repository?
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
fn main() {
let sys = System::new();
match sys.mounts() {
Ok(mounts) => {
println!("\nMounts:");
for mount in mounts.iter() {
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
}
Err(x) => println!("\nMounts: error: {}", x)
}
match sys.mount_at("/") {
Ok(mount) => {
println!("\nMount at /:");
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
Err(x) => println!("\nMount at /: error: {}", x)
}
match sys.block_device_statistics() {
Ok(stats) => {
for blkstats in stats.values() {
println!("{}: {:?}", blkstats.name, blkstats);
}
}
Err(x) => println!("\nBlock statistics error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetworks:");
for netif in netifs.values() {
println!("{} ({:?})", netif.name, netif.addrs);
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetwork interface statistics:");
for netif in netifs.values() {
println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.battery_life() {
Ok(battery) =>
print!("\nBattery: {}%, {}h{}m remaining",
battery.remaining_capacity*100.0,
battery.remaining_time.as_secs() / 3600,
battery.remaining_time.as_secs() % 60),
Err(x) => print!("\nBattery: error: {}", x)
}
match sys.on_ac_power() {
Ok(power) => println!(", AC power: {}", power),
Err(x) => println!(", AC power: error: {}", x)
}
match sys.memory() {
Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
Err(x) => println!("\nMemory: error: {}", x)
}
match sys.swap() {
Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
Err(x) => println!("\nSwap: error: {}", x)
}
match sys.load_average() {
Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
Err(x) => println!("\nLoad average: error: {}", x)
}
match sys.uptime() {
Ok(uptime) => println!("\nUptime: {:?}", uptime),
Err(x) => println!("\nUptime: error: {}", x)
}
match sys.boot_time() {
Ok(boot_time) => println!("\nBoot time: {}", boot_time),
Err(x) => println!("\nBoot time: error: {}", x)
}
match sys.cpu_load_aggregate() {
Ok(cpu)=> {
println!("\nMeasuring CPU load...");
thread::sleep(Duration::from_secs(1));
let cpu = cpu.done().unwrap();
println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
},
Err(x) => println!("\nCPU load: error: {}", x)
}
match sys.cpu_temp() {
Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
Err(x) => println!("\nCPU temp: {}", x)
}
match sys.socket_stats() {
Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
Err(x) => println!("\nSystem socket statistics: error: {}", x)
}
}
sourcefn boot_time(&self) -> Result<OffsetDateTime>
fn boot_time(&self) -> Result<OffsetDateTime>
Returns the system boot time.
Examples found in repository?
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
fn main() {
let sys = System::new();
match sys.mounts() {
Ok(mounts) => {
println!("\nMounts:");
for mount in mounts.iter() {
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
}
Err(x) => println!("\nMounts: error: {}", x)
}
match sys.mount_at("/") {
Ok(mount) => {
println!("\nMount at /:");
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
Err(x) => println!("\nMount at /: error: {}", x)
}
match sys.block_device_statistics() {
Ok(stats) => {
for blkstats in stats.values() {
println!("{}: {:?}", blkstats.name, blkstats);
}
}
Err(x) => println!("\nBlock statistics error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetworks:");
for netif in netifs.values() {
println!("{} ({:?})", netif.name, netif.addrs);
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetwork interface statistics:");
for netif in netifs.values() {
println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.battery_life() {
Ok(battery) =>
print!("\nBattery: {}%, {}h{}m remaining",
battery.remaining_capacity*100.0,
battery.remaining_time.as_secs() / 3600,
battery.remaining_time.as_secs() % 60),
Err(x) => print!("\nBattery: error: {}", x)
}
match sys.on_ac_power() {
Ok(power) => println!(", AC power: {}", power),
Err(x) => println!(", AC power: error: {}", x)
}
match sys.memory() {
Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
Err(x) => println!("\nMemory: error: {}", x)
}
match sys.swap() {
Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
Err(x) => println!("\nSwap: error: {}", x)
}
match sys.load_average() {
Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
Err(x) => println!("\nLoad average: error: {}", x)
}
match sys.uptime() {
Ok(uptime) => println!("\nUptime: {:?}", uptime),
Err(x) => println!("\nUptime: error: {}", x)
}
match sys.boot_time() {
Ok(boot_time) => println!("\nBoot time: {}", boot_time),
Err(x) => println!("\nBoot time: error: {}", x)
}
match sys.cpu_load_aggregate() {
Ok(cpu)=> {
println!("\nMeasuring CPU load...");
thread::sleep(Duration::from_secs(1));
let cpu = cpu.done().unwrap();
println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
},
Err(x) => println!("\nCPU load: error: {}", x)
}
match sys.cpu_temp() {
Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
Err(x) => println!("\nCPU temp: {}", x)
}
match sys.socket_stats() {
Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
Err(x) => println!("\nSystem socket statistics: error: {}", x)
}
}
sourcefn mount_at<P: AsRef<Path>>(&self, path: P) -> Result<Filesystem>
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?
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
fn main() {
let sys = System::new();
match sys.mounts() {
Ok(mounts) => {
println!("\nMounts:");
for mount in mounts.iter() {
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
}
Err(x) => println!("\nMounts: error: {}", x)
}
match sys.mount_at("/") {
Ok(mount) => {
println!("\nMount at /:");
println!("{} ---{}---> {} (available {} of {})",
mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total);
}
Err(x) => println!("\nMount at /: error: {}", x)
}
match sys.block_device_statistics() {
Ok(stats) => {
for blkstats in stats.values() {
println!("{}: {:?}", blkstats.name, blkstats);
}
}
Err(x) => println!("\nBlock statistics error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetworks:");
for netif in netifs.values() {
println!("{} ({:?})", netif.name, netif.addrs);
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.networks() {
Ok(netifs) => {
println!("\nNetwork interface statistics:");
for netif in netifs.values() {
println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
}
}
Err(x) => println!("\nNetworks: error: {}", x)
}
match sys.battery_life() {
Ok(battery) =>
print!("\nBattery: {}%, {}h{}m remaining",
battery.remaining_capacity*100.0,
battery.remaining_time.as_secs() / 3600,
battery.remaining_time.as_secs() % 60),
Err(x) => print!("\nBattery: error: {}", x)
}
match sys.on_ac_power() {
Ok(power) => println!(", AC power: {}", power),
Err(x) => println!(", AC power: error: {}", x)
}
match sys.memory() {
Ok(mem) => println!("\nMemory: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(mem.total, mem.free), mem.total, mem.total.as_u64(), mem.platform_memory),
Err(x) => println!("\nMemory: error: {}", x)
}
match sys.swap() {
Ok(swap) => println!("\nSwap: {} used / {} ({} bytes) total ({:?})", saturating_sub_bytes(swap.total, swap.free), swap.total, swap.total.as_u64(), swap.platform_swap),
Err(x) => println!("\nSwap: error: {}", x)
}
match sys.load_average() {
Ok(loadavg) => println!("\nLoad average: {} {} {}", loadavg.one, loadavg.five, loadavg.fifteen),
Err(x) => println!("\nLoad average: error: {}", x)
}
match sys.uptime() {
Ok(uptime) => println!("\nUptime: {:?}", uptime),
Err(x) => println!("\nUptime: error: {}", x)
}
match sys.boot_time() {
Ok(boot_time) => println!("\nBoot time: {}", boot_time),
Err(x) => println!("\nBoot time: error: {}", x)
}
match sys.cpu_load_aggregate() {
Ok(cpu)=> {
println!("\nMeasuring CPU load...");
thread::sleep(Duration::from_secs(1));
let cpu = cpu.done().unwrap();
println!("CPU load: {}% user, {}% nice, {}% system, {}% intr, {}% idle ",
cpu.user * 100.0, cpu.nice * 100.0, cpu.system * 100.0, cpu.interrupt * 100.0, cpu.idle * 100.0);
},
Err(x) => println!("\nCPU load: error: {}", x)
}
match sys.cpu_temp() {
Ok(cpu_temp) => println!("\nCPU temp: {}", cpu_temp),
Err(x) => println!("\nCPU temp: {}", x)
}
match sys.socket_stats() {
Ok(stats) => println!("\nSystem socket statistics: {:?}", stats),
Err(x) => println!("\nSystem socket statistics: error: {}", x)
}
}
Implementors§
impl Platform for PlatformImpl
An implementation of Platform
for FreeBSD.
See Platform
for documentation.