crabtop 0.1.0

Terminal-based Linux system monitor with CPU, memory, GPU and thermal metrics
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

use std::sync::Arc;
use std::time::Duration;

use tokio::sync::RwLock;
use tokio::task::JoinHandle;

use crate::config::Config;
use crate::metrics::{Collectors, Histories, Snapshot};

pub struct AppState {
    pub snapshot: Snapshot,
    pub history: Histories,
    pub config: Config,
    pub paused: bool,
}

impl AppState {
    pub fn new(config: Config) -> Self {
        let history = Histories::new(config.history);
        Self {
            snapshot: Snapshot::default(),
            history,
            config,
            paused: false,
        }
    }
}

pub type SharedState = Arc<RwLock<AppState>>;

pub fn spawn_poller(state: SharedState) -> JoinHandle<()> {
    tokio::task::spawn_blocking(move || {
        let mut collectors = Collectors::new();
        let rt = tokio::runtime::Handle::current();

        let initial_interval = rt.block_on(async {
            let s = state.read().await;
            s.config.interval
        });
        std::thread::sleep(initial_interval);

        loop {
            let (interval, paused) = rt.block_on(async {
                let s = state.read().await;
                (s.config.interval, s.paused)
            });

            if !paused {
                collectors.refresh();
                let snap = Snapshot {
                    cpu: collectors.cpu(),
                    mem: collectors.mem(),
                    temp: collectors.temp(),
                    gpus: collectors.gpu(),
                };

                rt.block_on(async {
                    let mut s = state.write().await;
                    s.history.push(&snap);
                    s.snapshot = snap;
                });
            }

            std::thread::sleep(interval);
        }
    })
}

pub fn render_interval() -> Duration {
    Duration::from_millis(100)
}