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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
|
use crate::error::{AppError, AppResult};
use network_interface::{NetworkInterface, NetworkInterfaceConfig};
use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NetworkAdapter {
pub name: String,
pub is_up: bool,
pub is_loopback: bool,
}
impl fmt::Display for NetworkAdapter {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.name)
}
}
impl From<NetworkInterface> for NetworkAdapter {
fn from(interface: NetworkInterface) -> Self {
let is_loopback = interface.name.to_lowercase().contains("lo");
let is_up = !interface.addr.is_empty();
Self {
name: interface.name,
is_up,
is_loopback,
}
}
}
pub fn get_network_adapters() -> AppResult<Vec<NetworkAdapter>> {
NetworkInterface::show()
.map_err(AppError::NetworkInterfaceError)
.map(|interfaces| interfaces.into_iter().map(NetworkAdapter::from).collect())
}
pub fn get_active_network_adapters() -> AppResult<Vec<NetworkAdapter>> {
get_network_adapters().map(|adapters| {
adapters
.into_iter()
.filter(|adapter| adapter.is_up && !adapter.is_loopback)
.collect()
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::test;
test! {
fn test_get_network_adapters() {
let adapters = get_network_adapters()?;
assert!(!adapters.is_empty(), "No network adapters found");
for adapter in &adapters {
assert!(!adapter.name.is_empty(), "Found adapter with empty name");
}
let up_adapters = adapters.iter().filter(|a| a.is_up).count();
assert!(up_adapters > 0, "No adapters are up");
let non_loopback = adapters.iter().filter(|a| !a.is_loopback).count();
assert!(non_loopback > 0, "All adapters are loopback interfaces");
}
}
test! {
fn test_get_active_network_adapters() {
let adapters = get_active_network_adapters()?;
assert!(!adapters.is_empty(), "No active network adapters found");
for adapter in &adapters {
assert!(adapter.is_up, "Found inactive adapter: {}", adapter.name);
assert!(!adapter.is_loopback, "Found loopback adapter: {}", adapter.name);
}
}
}
test! {
fn test_network_adapter_display() {
let adapter = NetworkAdapter {
name: "eth0".to_string(),
is_up: true,
is_loopback: false,
};
assert_eq!(format!("{}", adapter), "eth0");
}
}
}
|
