netmon 0.1.3

A simple CLI and library for network monitor, mainly network speed monitoring.
Documentation 
1
2
3
4
5
6
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

use crate::platform::get_current_netstat;
use common::NetStatRow;
use std::io::Error;
use std::time::Duration;

pub mod common;
pub mod platform;

pub fn get_current_netstat_by_iface(iface: &str) -> Result<Option<NetStatRow>, Error> {
    let stats = get_current_netstat()?;
    let found = stats.into_iter().find(|stat| &stat.name == iface);
    Ok(found)
}

pub fn print_net_speed_by_iface(iface: &str, duration_secs: Option<u8>) {
    let mut last_stats = NetStatRow::default();
    let duration_secs = duration_secs.unwrap_or(1);
    let duration = Duration::from_secs(duration_secs as u64);
    loop {
        let stats = get_current_netstat_by_iface(iface).unwrap().unwrap();
        if last_stats.name == "" {
            last_stats = stats.clone();
            continue;
        }
        let ibytes_diff = stats.ibytes - last_stats.ibytes;
        let obytes_diff = stats.obytes - last_stats.obytes;
        let in_mbps = (ibytes_diff as f32)
            / 1024.0
            / 1024.0
            / duration.as_secs_f32()
            / (duration_secs as f32);
        let out_mbps = (obytes_diff as f32)
            / 1024.0
            / 1024.0
            / duration.as_secs_f32()
            / (duration_secs as f32);
        println!(
            "Name: {}, {:.2} MBps in, {:.2} MBps out",
            stats.name, in_mbps, out_mbps
        );
        std::thread::sleep(duration); // Adjust the interval as needed
        last_stats = stats.clone();
    }
}

pub fn print_total_net_speed() {
    let mut last_ibytes = 0;
    let mut last_obytes = 0;
    let duration = Duration::from_secs(1);
    loop {
        let stats = get_current_netstat().unwrap();
        let ibytes: u64 = stats.iter().map(|stat| stat.ibytes).sum();
        let obytes: u64 = stats.iter().map(|stat| stat.obytes).sum();
        if last_ibytes == 0 {
            last_ibytes = ibytes;
            last_obytes = obytes;
            continue;
        }
        let ibytes_diff = ibytes - last_ibytes;
        let obytes_diff = obytes - last_obytes;
        let in_mbps = (ibytes_diff as f32) / 1024.0 / 1024.0 / duration.as_secs_f32();
        let out_mbps = (obytes_diff as f32) / 1024.0 / 1024.0 / duration.as_secs_f32();
        println!(
            "Total Network Throughput: {:.2} MBps in, {:.2} MBps out",
            in_mbps, out_mbps
        );
        std::thread::sleep(duration); // Adjust the interval as needed
        last_ibytes = ibytes;
        last_obytes = obytes;
    }
}