21 releases

0.1.21 Aug 17, 2022
0.1.20 Aug 14, 2022
0.1.19 Jul 10, 2022
0.1.14 Jun 20, 2022
0.1.8 Apr 13, 2022

#349 in Development tools

Download history 4/week @ 2024-01-22 3/week @ 2024-01-29 8/week @ 2024-02-05 14/week @ 2024-02-12 18/week @ 2024-02-19 34/week @ 2024-02-26 19/week @ 2024-03-04 33/week @ 2024-03-11 23/week @ 2024-03-18 8/week @ 2024-03-25 45/week @ 2024-04-01 23/week @ 2024-04-08 22/week @ 2024-04-15 23/week @ 2024-04-22 15/week @ 2024-04-29 13/week @ 2024-05-06

76 downloads per month
Used in disk_list

MIT license

120KB
3K SLoC

crates.io API Docs unlicense

get_sys_info

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 ,total_space, available_space
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

use get_sys_info::{saturating_sub_bytes, 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),
        }
    }
}

Dependencies

~1.1–7MB
~34K SLoC