corelens 0.1.0

Linux TUI for CPU topology, local AI workloads, and GPU metrics
Documentation
pub mod cpu;
pub mod gpu;
pub mod memory;
pub mod nvidia;
pub mod ollama;
pub mod process;
pub mod sensors;
pub mod topology;

use crate::{
    config::Config,
    model::{
        ServiceStatus, cpu::CpuTopology, gpu::GpuSnapshot, memory::MemorySnapshot,
        ollama::OllamaModel, process::ProcessSnapshot,
    },
};
use anyhow::Result;
use tokio::sync::mpsc;
use tracing::warn;

#[derive(Debug, Clone)]
pub struct RefreshResult {
    pub cpu: CpuTopology,
    pub processes: Vec<ProcessSnapshot>,
    pub gpu: ServiceStatus<Vec<GpuSnapshot>>,
    pub ollama: ServiceStatus<Vec<OllamaModel>>,
    pub memory: MemorySnapshot,
    pub errors: Vec<String>,
}

pub async fn run_collection_loop(
    config: Config,
    tx: mpsc::UnboundedSender<RefreshResult>,
    mut force_rx: mpsc::UnboundedReceiver<()>,
) -> Result<()> {
    let mut cpu_collector = cpu::CpuCollector::new();
    let mut process_collector = process::ProcessCollector::new("/proc");
    let mut gpu_collector = gpu::CompositeGpuCollector::new();
    let ollama_collector = ollama::OllamaCollector::new(&config.ollama_url)?;
    let mut memory_collector = memory::MemoryCollector::default();
    let mut last_gpu = None;
    let mut last_ollama = None;
    let mut interval = tokio::time::interval(std::time::Duration::from_millis(
        config.refresh_interval_ms(),
    ));

    loop {
        tokio::select! {
            _ = interval.tick() => {},
            Some(_) = force_rx.recv() => {},
        }
        let mut errors = Vec::new();
        let cpu = match cpu_collector.collect() {
            Ok(value) => value,
            Err(error) => {
                errors.push(format!("CPU: {error}"));
                cpu_collector.last.clone().unwrap_or_default()
            }
        };
        let processes = match process_collector.collect(cpu.cpus.len()) {
            Ok(value) => value,
            Err(error) => {
                errors.push(format!("processes: {error}"));
                process_collector.last.clone().unwrap_or_default()
            }
        };
        let memory = match memory_collector.collect() {
            Ok(value) => value,
            Err(error) => {
                errors.push(format!("memory: {error}"));
                memory_collector.last.unwrap_or_default()
            }
        };
        let gpu = match gpu_collector.collect() {
            Ok(value) => {
                last_gpu = Some(value.clone());
                ServiceStatus::Available(value)
            }
            Err(error) => {
                warn!(%error, "GPU collection failed");
                errors.push(format!("GPU: {error}"));
                last_gpu.clone().map_or_else(
                    || ServiceStatus::Unavailable(error.to_string()),
                    ServiceStatus::Available,
                )
            }
        };
        let ollama = match ollama_collector.collect().await {
            Ok(value) => {
                last_ollama = Some(value.clone());
                ServiceStatus::Available(value)
            }
            Err(error) => {
                errors.push(format!("Ollama: {error}"));
                last_ollama.clone().map_or_else(
                    || ServiceStatus::Unavailable(error.to_string()),
                    ServiceStatus::Available,
                )
            }
        };
        if tx
            .send(RefreshResult {
                cpu,
                processes,
                gpu,
                ollama,
                memory,
                errors,
            })
            .is_err()
        {
            break;
        }
    }
    Ok(())
}