getsysinfo

get system information: | Information | Description | | ----------- | ----------- | | CPU load | CPU load info| | load average| Text| |memory usage|get real time memory usage| |uptime / boot time|get system bootup time| |battery life|get battery life info| |filesystem mounts (and disk usage)|get filesystem mounts ,totalspace, availablespace| |disk I/O statistics|get disk io info| |network interfaces|get network interfaces info| |network traffic statistics|get network statistic info| |CPU temperature|get CPU useage|

| Supported platforms | | ----------- | |FreeBSD| |Linux| |OpenBSD| |Windows| |macOS|

example

```rust use getsysinfo::{saturatingsubbytes, Platform, System}; use std::thread; use std::time::Duration;

fn main() { let sys = System::new();

{
    let mounts = sys.mounts().unwrap_or_else(|r| {
        println!("get mounts error:{}", r);
        vec![]
    });
    for mount in mounts.iter() {
        println!(
            "[mounted_from:{}, file_type:{},mounted_at:{},available:{},total:{}]",
            mount.fs_mounted_from, mount.fs_type, mount.fs_mounted_on, mount.avail, mount.total
        );
    }
}
{
    match sys.mount_at("/") {
        Ok(mount) => {
            println!(
                "[mounted_from:{}, file_type:{},mounted_at:{},available:{},total:{}]",
                mount.fs_mounted_from,
                mount.fs_type,
                mount.fs_mounted_on,
                mount.avail,
                mount.total
            );
        }
        Err(x) => println!("\n mount_at /: error: {}", x),
    }
}
{
    let stats = sys.block_device_statistics().unwrap_or_else(|r| {
        println!("get block_device_statistics error error:{}", r);
        std::collections::BTreeMap::new()
    });
    for blkstats in stats.values() {
        println!("{}: {:?}", blkstats.name, blkstats);
    }
}
{
    let netifs = sys.networks().unwrap_or_else(|r| {
        println!("\n networks: error: {}", r);
        std::collections::BTreeMap::new()
    });
    for netif in netifs.values() {
        println!(
            "{} statistics: ({:?})",
            netif.name,
            sys.network_stats(&netif.name)
        );
    }
}
{
    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!("\n battery: 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!(
            "\n memory: {} used / {} ({} bytes) total ({:?})",
            saturating_sub_bytes(mem.total, mem.free),
            mem.total,
            mem.total.as_u64(),
            mem.platform_memory
        ),
        Err(x) => println!("\n memory: error: {}", x),
    }
}
{
    match sys.load_average() {
        Ok(loadavg) => println!(
            "\n load_average: {} {} {}",
            loadavg.one, loadavg.five, loadavg.fifteen
        ),
        Err(x) => println!("\n load_average: error: {}", x),
    }
}
{
    match sys.uptime() {
        Ok(uptime) => println!("\n uptime: {:?}", uptime),
        Err(x) => println!("\n uptime: error: {}", x),
    }
}
{
    match sys.boot_time() {
        Ok(boot_time) => println!("\n boot_time: {}", boot_time),
        Err(x) => println!("\n boot_time: error: {}", x),
    }
}
{
    match sys.cpu_load_aggregate() {
        Ok(cpu) => {
            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!("\n cpu_load_aggregate: error: {}", x),
    }
}
{
    match sys.cpu_temp() {
        Ok(cpu_temp) => println!("\n cpu_temp: {}", cpu_temp),
        Err(x) => println!("\n cpu_temp: {}", x),
    }
}
{
    match sys.socket_stats() {
        Ok(stats) => println!("\nsocket_stats: {:?}", stats),
        Err(x) => println!("\nsocket_stats: error: {}", x),
    }
}

}

```