get_sys_info

get system information:

example

use std::thread;
use std::time::Duration;
use get_sys_info::{System, Platform, saturating_sub_bytes};

fn main() {
    let sys = System::new();
    match sys.mounts() {
        Ok(mounts) => {
            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);
            }
        }
        Err(x) => println!("\n mounts error: {}", x)
    }

    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)
    }

    match sys.block_device_statistics() {
        Ok(stats) => {
            for blkstats in stats.values() {
                println!("{}: {:?}", blkstats.name, blkstats);
            }
        }
        Err(x) => println!("\n block_device_statistics error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            for netif in netifs.values() {
                println!("{} ({:?})", netif.name, netif.addrs);
            }
        }
        Err(x) => println!("\n networks: error: {}", x)
    }

    match sys.networks() {
        Ok(netifs) => {
            for netif in netifs.values() {
                println!("{} statistics: ({:?})", netif.name, sys.network_stats(&netif.name));
            }
        }
        Err(x) => println!("\n networks: 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!("\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)
    }
}