wayle-sysinfo 0.1.2

CPU, memory, disk, and network metrics
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::{sync::RwLock, time::Duration};

use tokio_util::sync::CancellationToken;
use tracing::debug;
use wayle_core::Property;

use crate::{
    builder::SysinfoServiceBuilder,
    polling,
    types::{CpuData, DiskData, MemoryData, NetworkData},
};

/// System information service for monitoring CPU, memory, disk, and network.
///
/// Provides reactive properties that update at configurable intervals.
/// All metrics are polled in the background and exposed via `Property<T>`
/// for both snapshot access (`.get()`) and stream-based watching (`.watch()`).
///
/// Polling intervals can be changed at runtime via `set_*_interval()` methods.
#[derive(Debug)]
pub struct SysinfoService {
    pub(crate) cancellation_token: CancellationToken,
    pub(crate) cpu_token: RwLock<CancellationToken>,
    pub(crate) memory_token: RwLock<CancellationToken>,
    pub(crate) disk_token: RwLock<CancellationToken>,
    pub(crate) network_token: RwLock<CancellationToken>,
    pub(crate) cpu_interval: RwLock<Duration>,
    pub(crate) cpu_temp_sensor: RwLock<String>,

    /// CPU metrics including usage, frequency, and temperature.
    pub cpu: Property<CpuData>,

    /// Memory and swap metrics.
    pub memory: Property<MemoryData>,

    /// Disk metrics for all mounted filesystems.
    pub disks: Property<Vec<DiskData>>,

    /// Network metrics for all interfaces.
    pub network: Property<Vec<NetworkData>>,
}

impl SysinfoService {
    /// Returns a builder for configuring the service.
    pub fn builder() -> SysinfoServiceBuilder {
        SysinfoServiceBuilder::new()
    }

    /// Updates the CPU polling interval.
    pub fn set_cpu_interval(&self, interval: Duration) {
        debug!(?interval, "Updating CPU polling interval");
        if let Ok(mut guard) = self.cpu_interval.write() {
            *guard = interval;
        }
        self.restart_cpu_polling();
    }

    /// Updates the CPU temperature sensor label.
    pub fn set_cpu_temp_sensor(&self, sensor: &str) {
        debug!(?sensor, "Updating CPU temperature sensor");
        if let Ok(mut guard) = self.cpu_temp_sensor.write() {
            *guard = sensor.to_owned();
        }
        self.restart_cpu_polling();
    }

    fn restart_cpu_polling(&self) {
        let interval = self.cpu_interval.read().map(|g| *g).unwrap_or_default();
        let sensor = self
            .cpu_temp_sensor
            .read()
            .map(|g| g.clone())
            .unwrap_or_default();

        let new_token = self.cancellation_token.child_token();
        if let Ok(mut guard) = self.cpu_token.write() {
            guard.cancel();
            polling::cpu::spawn(new_token.clone(), self.cpu.clone(), interval, sensor);
            *guard = new_token;
        }
    }

    /// Updates the memory polling interval.
    ///
    /// Restarts the memory polling task with the new interval.
    pub fn set_memory_interval(&self, interval: Duration) {
        debug!(?interval, "Updating memory polling interval");
        let new_token = self.cancellation_token.child_token();
        if let Ok(mut guard) = self.memory_token.write() {
            guard.cancel();
            polling::memory::spawn(new_token.clone(), self.memory.clone(), interval);
            *guard = new_token;
        }
    }

    /// Updates the disk polling interval.
    ///
    /// Restarts the disk polling task with the new interval.
    pub fn set_disk_interval(&self, interval: Duration) {
        debug!(?interval, "Updating disk polling interval");
        let new_token = self.cancellation_token.child_token();
        if let Ok(mut guard) = self.disk_token.write() {
            guard.cancel();
            polling::disk::spawn(new_token.clone(), self.disks.clone(), interval);
            *guard = new_token;
        }
    }

    /// Updates the network polling interval.
    ///
    /// Restarts the network polling task with the new interval.
    pub fn set_network_interval(&self, interval: Duration) {
        debug!(?interval, "Updating network polling interval");
        let new_token = self.cancellation_token.child_token();
        if let Ok(mut guard) = self.network_token.write() {
            guard.cancel();
            polling::network::spawn(new_token.clone(), self.network.clone(), interval);
            *guard = new_token;
        }
    }
}

impl Drop for SysinfoService {
    fn drop(&mut self) {
        self.cancellation_token.cancel();
    }
}