Merge pull request #26 from JakeStanger/feat/sysinfo-tokens

Add loads more tokens & interval options to `sysinfo`, optimise info refreshing

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",
 ]

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"
+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" }

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}"
+            ]
+        }
+    ]
+}

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<String>,
+    /// 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 {
+    const fn memory(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.memory,
+        }
+    }
+
+    const fn cpu(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.cpu,
+        }
+    }
+
+    const fn temps(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.temps,
+        }
+    }
+
+    const fn disks(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.disks,
+        }
+    }
+
+    const fn networks(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.networks,
+        }
+    }
+
+    const fn system(self) -> u64 {
+        match self {
+            Self::All(n) => n,
+            Self::Individual(intervals) => intervals.system,
+        }
+    }
+}
+
+const fn default_interval() -> u64 {
+    5
+}
+
+#[derive(Debug)]
+enum RefreshType {
+    Memory,
+    Cpu,
+    Temps,
+    Disks,
+    Network,
+    System,
 }
 
 impl Module<gtk::Box> for SysInfoModule {
@@ -26,35 +118,115 @@ impl Module<gtk::Box> for SysInfoModule {
         tx: Sender<ModuleUpdateEvent<Self::SendMessage>>,
         _rx: Receiver<Self::ReceiveMessage>,
     ) -> 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;
+            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();
+            let mut format_info = HashMap::new();
 
-            loop {
-                sys.refresh_all();
+            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, &sys),
+                };
 
-                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;
-
-                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;
             }
         });
 
@@ -66,14 +238,18 @@ impl Module<gtk::Box> for SysInfoModule {
         context: WidgetContext<Self::SendMessage, Self::ReceiveMessage>,
         info: &ModuleInfo,
     ) -> Result<ModuleWidget<gtk::Box>> {
-        let re = Regex::new(r"\{([\w-]+)}")?;
+        let re = Regex::new(r"\{([^}]+)}")?;
 
         let container = gtk::Box::new(info.bar_position.get_orientation(), 10);
 
         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);
@@ -83,13 +259,13 @@ impl Module<gtk::Box> 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()
                     });
 
-                    label.set_text(format_compiled.as_ref());
+                    label.set_markup(format_compiled.as_ref());
                 }
 
                 Continue(true)
@@ -102,3 +278,175 @@ impl Module<gtk::Box> for SysInfoModule {
         })
     }
 }
+
+fn refresh_memory_tokens(format_info: &mut HashMap<String, String>, 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<String, String>, 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<String, String>, 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<String, String>, 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<String, String>,
+    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<String, String>, 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
+}