From 35ce3b4d455dea001de96d406778eb152787a905 Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 00:56:47 +0100 Subject: [PATCH 1/7] chore: use cargo patch block --- Cargo.lock | 4 ++-- Cargo.toml | 12 ++++++++---- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4608c8c..6f83f0b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1746,9 +1746,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.46" +version = "1.0.47" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94e2ef8dbfc347b10c094890f778ee2e36ca9bb4262e86dc99cd217e35f3470b" +checksum = "5ea3d908b0e36316caf9e9e2c4625cdde190a7e6f440d794667ed17a1855e725" dependencies = [ "unicode-ident", ] diff --git a/Cargo.toml b/Cargo.toml index fc9c670..d3591d3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -29,13 +29,17 @@ cornfig = "0.3.0" lazy_static = "1.4.0" async_once = "0.2.6" regex = "1.6.0" -stray = { git = "https://github.com/JakeStanger/stray.git", branch = "fix/tracing" } +stray = { version = "0.1.1" } dirs = "4.0.0" walkdir = "2.3.2" notify = "5.0.0" mpd_client = "1.0.0" -swayipc-async = { git = "https://github.com/JakeStanger/swayipc-rs.git", branch = "feat/derive-clone" } -sysinfo = "0.26.2" +swayipc-async = { version = "2.0.1" } +sysinfo = "0.26.4" wayland-client = "0.29.5" wayland-protocols = { version = "0.29.5", features=["unstable_protocols", "client"] } -smithay-client-toolkit = "0.16.0" \ No newline at end of file +smithay-client-toolkit = "0.16.0" + +[patch.crates-io] +stray = { git = "https://github.com/JakeStanger/stray.git", branch = "fix/tracing" } +swayipc-async = { git = "https://github.com/JakeStanger/swayipc-rs.git", branch = "feat/derive-clone" } \ No newline at end of file From fad90fdad683a612497ac7822a66a90f43fce0a2 Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 00:58:47 +0100 Subject: [PATCH 2/7] 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 +} From dec402edd9d6c5b8677ff337699ad99ebc69b776 Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 00:59:18 +0100 Subject: [PATCH 3/7] feat(sys-info): config options for refresh intervals --- src/modules/sysinfo.rs | 192 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 185 insertions(+), 7 deletions(-) diff --git a/src/modules/sysinfo.rs b/src/modules/sysinfo.rs index a1ccf4c..00ae104 100644 --- a/src/modules/sysinfo.rs +++ b/src/modules/sysinfo.rs @@ -5,8 +5,10 @@ use gtk::Label; use regex::{Captures, Regex}; use serde::Deserialize; use std::collections::HashMap; -use sysinfo::{CpuExt, System, SystemExt}; +use std::time::Duration; +use sysinfo::{ComponentExt, CpuExt, DiskExt, NetworkExt, RefreshKind, System, SystemExt}; use tokio::spawn; +use tokio::sync::mpsc; use tokio::sync::mpsc::{Receiver, Sender}; use tokio::time::sleep; @@ -14,6 +16,96 @@ use tokio::time::sleep; pub struct SysInfoModule { /// List of formatting strings. format: Vec, + /// Number of seconds between refresh + #[serde(default = "Interval::default")] + interval: Interval, +} + +#[derive(Debug, Deserialize, Copy, Clone)] +pub struct Intervals { + #[serde(default = "default_interval")] + memory: u64, + #[serde(default = "default_interval")] + cpu: u64, + #[serde(default = "default_interval")] + temps: u64, + #[serde(default = "default_interval")] + disks: u64, + #[serde(default = "default_interval")] + networks: u64, + #[serde(default = "default_interval")] + system: u64, +} + +#[derive(Debug, Deserialize, Copy, Clone)] +#[serde(untagged)] +pub enum Interval { + All(u64), + Individual(Intervals), +} + +impl Default for Interval { + fn default() -> Self { + Self::All(default_interval()) + } +} + +impl Interval { + fn memory(self) -> u64 { + match self { + Interval::All(n) => n, + Interval::Individual(intervals) => intervals.memory, + } + } + + fn cpu(self) -> u64 { + match self { + Interval::All(n) => n, + Interval::Individual(intervals) => intervals.cpu, + } + } + + fn temps(self) -> u64 { + match self { + Interval::All(n) => n, + Interval::Individual(intervals) => intervals.temps, + } + } + + fn disks(self) -> u64 { + match self { + Interval::All(n) => n, + Interval::Individual(intervals) => intervals.disks, + } + } + + fn networks(self) -> u64 { + match self { + Interval::All(n) => n, + Interval::Individual(intervals) => intervals.networks, + } + } + + fn system(self) -> u64 { + match self { + Interval::All(n) => n, + Interval::Individual(intervals) => intervals.system, + } + } +} + +const fn default_interval() -> u64 { + 5 +} + +#[derive(Debug)] +enum RefreshType { + Memory, + Cpu, + Temps, + Disks, + Network, + System, } impl Module for SysInfoModule { @@ -26,13 +118,99 @@ impl Module for SysInfoModule { tx: Sender>, _rx: Receiver, ) -> Result<()> { + let interval = self.interval; + + let refresh_kind = RefreshKind::everything() + .without_processes() + .without_users_list(); + + let mut sys = System::new_with_specifics(refresh_kind); + sys.refresh_components_list(); + sys.refresh_disks_list(); + sys.refresh_networks_list(); + + let (refresh_tx, mut refresh_rx) = mpsc::channel(16); + + // memory refresh + { + let tx = refresh_tx.clone(); + spawn(async move { + loop { + tx.send(RefreshType::Memory) + .await + .expect("Failed to send memory refresh"); + sleep(Duration::from_secs(interval.memory())).await; + } + }); + } + + // cpu refresh + { + let tx = refresh_tx.clone(); + spawn(async move { + loop { + tx.send(RefreshType::Cpu) + .await + .expect("Failed to send cpu refresh"); + sleep(Duration::from_secs(interval.cpu())).await; + } + }); + } + + // temp refresh + { + let tx = refresh_tx.clone(); + spawn(async move { + loop { + tx.send(RefreshType::Temps) + .await + .expect("Failed to send temperature refresh"); + sleep(Duration::from_secs(interval.temps())).await; + } + }); + } + + // disk refresh + { + let tx = refresh_tx.clone(); + spawn(async move { + loop { + tx.send(RefreshType::Disks) + .await + .expect("Failed to send disk refresh"); + sleep(Duration::from_secs(interval.disks())).await; + } + }); + } + + // network refresh + { + let tx = refresh_tx.clone(); + spawn(async move { + loop { + tx.send(RefreshType::Network) + .await + .expect("Failed to send network refresh"); + sleep(Duration::from_secs(interval.networks())).await; + } + }); + } + + // system refresh + { + let tx = refresh_tx.clone(); + spawn(async move { + loop { + tx.send(RefreshType::System) + .await + .expect("Failed to send system refresh"); + sleep(Duration::from_secs(interval.system())).await; + } + }); + } + spawn(async move { - let mut sys = System::new_all(); - - loop { - sys.refresh_all(); - - let mut format_info = HashMap::new(); + let mut format_info = HashMap::new(); while let Some(refresh) = refresh_rx.recv().await { match refresh { From 91c57edc73f15397ea0de70c4a6a6532c35caf2a Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 01:00:14 +0100 Subject: [PATCH 4/7] feat(sys-info): pango markup support --- src/modules/sysinfo.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/modules/sysinfo.rs b/src/modules/sysinfo.rs index 00ae104..1d7217d 100644 --- a/src/modules/sysinfo.rs +++ b/src/modules/sysinfo.rs @@ -245,7 +245,11 @@ impl Module for SysInfoModule { let mut labels = Vec::new(); for format in &self.format { - let label = Label::builder().label(format).name("item").build(); + let label = Label::builder() + .label(format) + .use_markup(true) + .name("item") + .build(); label.set_angle(info.bar_position.get_angle()); container.add(&label); labels.push(label); @@ -261,7 +265,7 @@ impl Module for SysInfoModule { .to_string() }); - label.set_text(format_compiled.as_ref()); + label.set_markup(format_compiled.as_ref()); } Continue(true) From 9e6dbbd131a09f101b0d490265fe7d4ec564e38c Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 01:00:43 +0100 Subject: [PATCH 5/7] fix(sys-info): tokens not replaced if more than one in string --- src/modules/sysinfo.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/modules/sysinfo.rs b/src/modules/sysinfo.rs index 1d7217d..989311e 100644 --- a/src/modules/sysinfo.rs +++ b/src/modules/sysinfo.rs @@ -238,7 +238,7 @@ impl Module for SysInfoModule { context: WidgetContext, info: &ModuleInfo, ) -> Result> { - let re = Regex::new(r"\{([\w-]+)}")?; + let re = Regex::new(r"\{([^}]+)}")?; let container = gtk::Box::new(info.bar_position.get_orientation(), 10); @@ -259,7 +259,7 @@ impl Module for SysInfoModule { let formats = self.format; context.widget_rx.attach(None, move |info| { for (format, label) in formats.iter().zip(labels.clone()) { - let format_compiled = re.replace(format, |caps: &Captures| { + let format_compiled = re.replace_all(format, |caps: &Captures| { info.get(&caps[1]) .unwrap_or(&caps[0].to_string()) .to_string() From e4e72d800875077ff73faef8c84cc5b8874886a1 Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 01:03:20 +0100 Subject: [PATCH 6/7] style(sys-info): fix clippy warnings & run fmt --- src/modules/sysinfo.rs | 48 +++++++++++++++++++++++------------------- 1 file changed, 26 insertions(+), 22 deletions(-) diff --git a/src/modules/sysinfo.rs b/src/modules/sysinfo.rs index 989311e..ff2dc87 100644 --- a/src/modules/sysinfo.rs +++ b/src/modules/sysinfo.rs @@ -51,45 +51,45 @@ impl Default for Interval { } impl Interval { - fn memory(self) -> u64 { + const fn memory(self) -> u64 { match self { - Interval::All(n) => n, - Interval::Individual(intervals) => intervals.memory, + Self::All(n) => n, + Self::Individual(intervals) => intervals.memory, } } - fn cpu(self) -> u64 { + const fn cpu(self) -> u64 { match self { - Interval::All(n) => n, - Interval::Individual(intervals) => intervals.cpu, + Self::All(n) => n, + Self::Individual(intervals) => intervals.cpu, } } - fn temps(self) -> u64 { + const fn temps(self) -> u64 { match self { - Interval::All(n) => n, - Interval::Individual(intervals) => intervals.temps, + Self::All(n) => n, + Self::Individual(intervals) => intervals.temps, } } - fn disks(self) -> u64 { + const fn disks(self) -> u64 { match self { - Interval::All(n) => n, - Interval::Individual(intervals) => intervals.disks, + Self::All(n) => n, + Self::Individual(intervals) => intervals.disks, } } - fn networks(self) -> u64 { + const fn networks(self) -> u64 { match self { - Interval::All(n) => n, - Interval::Individual(intervals) => intervals.networks, + Self::All(n) => n, + Self::Individual(intervals) => intervals.networks, } } - fn system(self) -> u64 { + const fn system(self) -> u64 { match self { - Interval::All(n) => n, - Interval::Individual(intervals) => intervals.system, + Self::All(n) => n, + Self::Individual(intervals) => intervals.system, } } } @@ -198,7 +198,7 @@ impl Module for SysInfoModule { // system refresh { - let tx = refresh_tx.clone(); + let tx = refresh_tx; spawn(async move { loop { tx.send(RefreshType::System) @@ -219,9 +219,9 @@ impl Module for SysInfoModule { 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()) + refresh_network_tokens(&mut format_info, &mut sys, interval.networks()); } - RefreshType::System => refresh_system_tokens(&mut format_info, &mut sys), + RefreshType::System => refresh_system_tokens(&mut format_info, &sys), }; tx.send(ModuleUpdateEvent::Update(format_info.clone())) @@ -389,7 +389,11 @@ fn refresh_disk_tokens(format_info: &mut HashMap, sys: &mut Syst } } -fn refresh_network_tokens(format_info: &mut HashMap, sys: &mut System, interval: u64) { +fn refresh_network_tokens( + format_info: &mut HashMap, + sys: &mut System, + interval: u64, +) { sys.refresh_networks(); for (iface, network) in sys.networks() { From a06c4bccca6cb51935605ac9239e63024fb7c663 Mon Sep 17 00:00:00 2001 From: Jake Stanger Date: Sun, 16 Oct 2022 01:03:36 +0100 Subject: [PATCH 7/7] docs(examples): add full system info config --- examples/sys-info.corn | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 examples/sys-info.corn diff --git a/examples/sys-info.corn b/examples/sys-info.corn new file mode 100644 index 0000000..ec1556d --- /dev/null +++ b/examples/sys-info.corn @@ -0,0 +1,23 @@ +{ + end = [ + { + type = "sys-info" + + interval.memory = 30 + interval.cpu = 1 + interval.temps = 5 + interval.disks = 300 + interval.networks = 3 + + format = [ + " {cpu-percent}% | {temp-c:k10temp-Tccd1}°C" + " {memory-used} / {memory-total} GB ({memory-percent}%)" + "| {swap-used} / {swap-total} GB ({swap-percent}%)" + " {disk-used:/} / {disk-total:/} GB ({disk-percent:/}%)" + "李 {net-down:enp39s0} / {net-up:enp39s0} Mbps" + "猪 {load-average:1} | {load-average:5} | {load-average:15}" + " {uptime}" + ] + } + ] +} \ No newline at end of file