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(())
}