From fad90fdad683a612497ac7822a66a90f43fce0a2 Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 00:58:47 +0100 Subject: [PATCH] feat(sys-info): add loads more formatting tokens --- src/modules/sysinfo.rs | 198 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 180 insertions(+), 18 deletions(-) diff --git a/src/modules/sysinfo.rs b/src/modules/sysinfo.rs index 8f74292..a1ccf4c 100644 --- a/src/modules/sysinfo.rs +++ b/src/modules/sysinfo.rs @@ -34,27 +34,21 @@ impl Module for SysInfoModule { let mut format_info = HashMap::new(); - let actual_used_memory = sys.total_memory() - sys.available_memory(); - let memory_percent = actual_used_memory as f64 / sys.total_memory() as f64 * 100.0; + while let Some(refresh) = refresh_rx.recv().await { + match refresh { + RefreshType::Memory => refresh_memory_tokens(&mut format_info, &mut sys), + RefreshType::Cpu => refresh_cpu_tokens(&mut format_info, &mut sys), + RefreshType::Temps => refresh_temp_tokens(&mut format_info, &mut sys), + RefreshType::Disks => refresh_disk_tokens(&mut format_info, &mut sys), + RefreshType::Network => { + refresh_network_tokens(&mut format_info, &mut sys, interval.networks()) + } + RefreshType::System => refresh_system_tokens(&mut format_info, &mut sys), + }; - let cpu_percent = sys.global_cpu_info().cpu_usage(); - - // TODO: Add remaining format info - - format_info.insert( - String::from("memory-percent"), - format!("{:0>2.0}", memory_percent), - ); - format_info.insert( - String::from("cpu-percent"), - format!("{:0>2.0}", cpu_percent), - ); - - tx.send(ModuleUpdateEvent::Update(format_info)) + tx.send(ModuleUpdateEvent::Update(format_info.clone())) .await .expect("Failed to send system info map"); - - sleep(tokio::time::Duration::from_secs(1)).await; } }); @@ -102,3 +96,171 @@ impl Module for SysInfoModule { }) } } + +fn refresh_memory_tokens(format_info: &mut HashMap, sys: &mut System) { + sys.refresh_memory(); + + let total_memory = sys.total_memory(); + let available_memory = sys.available_memory(); + + let actual_used_memory = total_memory - available_memory; + let memory_percent = actual_used_memory as f64 / total_memory as f64 * 100.0; + + format_info.insert( + String::from("memory-free"), + (bytes_to_gigabytes(available_memory)).to_string(), + ); + format_info.insert( + String::from("memory-used"), + (bytes_to_gigabytes(actual_used_memory)).to_string(), + ); + format_info.insert( + String::from("memory-total"), + (bytes_to_gigabytes(total_memory)).to_string(), + ); + format_info.insert( + String::from("memory-percent"), + format!("{:0>2.0}", memory_percent), + ); + + let used_swap = sys.used_swap(); + let total_swap = sys.total_swap(); + + format_info.insert( + String::from("swap-free"), + (bytes_to_gigabytes(sys.free_swap())).to_string(), + ); + format_info.insert( + String::from("swap-used"), + (bytes_to_gigabytes(used_swap)).to_string(), + ); + format_info.insert( + String::from("swap-total"), + (bytes_to_gigabytes(total_swap)).to_string(), + ); + format_info.insert( + String::from("swap-percent"), + format!("{:0>2.0}", used_swap as f64 / total_swap as f64 * 100.0), + ); +} + +fn refresh_cpu_tokens(format_info: &mut HashMap, sys: &mut System) { + sys.refresh_cpu(); + + let cpu_info = sys.global_cpu_info(); + let cpu_percent = cpu_info.cpu_usage(); + + format_info.insert( + String::from("cpu-percent"), + format!("{:0>2.0}", cpu_percent), + ); +} + +fn refresh_temp_tokens(format_info: &mut HashMap, sys: &mut System) { + sys.refresh_components(); + + let components = sys.components(); + for component in components { + let key = component.label().replace(' ', "-"); + let temp = component.temperature(); + + format_info.insert(format!("temp-c:{key}"), format!("{temp:.0}")); + format_info.insert(format!("temp-f:{key}"), format!("{:.0}", c_to_f(temp))); + } +} + +fn refresh_disk_tokens(format_info: &mut HashMap, sys: &mut System) { + sys.refresh_disks(); + + for disk in sys.disks() { + // replace braces to avoid conflict with regex + let key = disk + .mount_point() + .to_str() + .map(|s| s.replace('{', "").replace('}', "")); + + if let Some(key) = key { + let total = disk.total_space(); + let available = disk.available_space(); + let used = total - available; + + format_info.insert( + format!("disk-free:{key}"), + bytes_to_gigabytes(available).to_string(), + ); + + format_info.insert( + format!("disk-used:{key}"), + bytes_to_gigabytes(used).to_string(), + ); + + format_info.insert( + format!("disk-total:{key}"), + bytes_to_gigabytes(total).to_string(), + ); + + format_info.insert( + format!("disk-percent:{key}"), + format!("{:0>2.0}", used as f64 / total as f64 * 100.0), + ); + } + } +} + +fn refresh_network_tokens(format_info: &mut HashMap, sys: &mut System, interval: u64) { + sys.refresh_networks(); + + for (iface, network) in sys.networks() { + format_info.insert( + format!("net-down:{iface}"), + format!("{:0>2.0}", bytes_to_megabits(network.received()) / interval), + ); + + format_info.insert( + format!("net-up:{iface}"), + format!( + "{:0>2.0}", + bytes_to_megabits(network.transmitted()) / interval + ), + ); + } +} + +fn refresh_system_tokens(format_info: &mut HashMap, sys: &System) { + // no refresh required for these tokens + + let load_average = sys.load_average(); + format_info.insert(String::from("load-average:1"), load_average.one.to_string()); + + format_info.insert( + String::from("load-average:5"), + load_average.five.to_string(), + ); + + format_info.insert( + String::from("load-average:15"), + load_average.fifteen.to_string(), + ); + + let uptime = Duration::from_secs(sys.uptime()).as_secs(); + let hours = uptime / 3600; + format_info.insert( + String::from("uptime"), + format!("{:0>2}:{:0>2}", hours, (uptime % 3600) / 60), + ); +} + +/// Converts celsius to fahrenheit. +fn c_to_f(c: f32) -> f32 { + c * 9.0 / 5.0 + 32.0 +} + +const fn bytes_to_gigabytes(b: u64) -> u64 { + const BYTES_IN_GIGABYTE: u64 = 1_000_000_000; + b / BYTES_IN_GIGABYTE +} + +const fn bytes_to_megabits(b: u64) -> u64 { + const BYTES_IN_MEGABIT: u64 = 125_000; + b / BYTES_IN_MEGABIT +}