use anyhow::Result;
use clap::Parser;
use corelens::{
app::App,
collector::{self, cpu::CpuCollector},
config::Config,
event::{Event, spawn_event_reader},
ui,
};
use crossterm::{
cursor::{Hide, Show},
event::KeyCode,
execute,
terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
};
use ratatui::{Terminal, backend::CrosstermBackend};
use std::io;
use tokio::sync::mpsc;
use tracing_subscriber::EnvFilter;
struct TerminalGuard;
impl TerminalGuard {
fn enter() -> Result<Self> {
enable_raw_mode()?;
execute!(io::stdout(), EnterAlternateScreen, Hide)?;
Ok(Self)
}
}
impl Drop for TerminalGuard {
fn drop(&mut self) {
let _ = disable_raw_mode();
let _ = execute!(io::stdout(), Show, LeaveAlternateScreen);
}
}
fn restore_terminal() {
let _ = disable_raw_mode();
let _ = execute!(io::stdout(), Show, LeaveAlternateScreen);
}
#[tokio::main]
async fn main() -> Result<()> {
tracing_subscriber::fmt()
.with_env_filter(EnvFilter::from_default_env())
.with_target(false)
.init();
let config = Config::parse();
if config.debug_topology {
let mut collector = CpuCollector::new();
let topology = collector.collect()?;
let diagnostics = &topology.diagnostics;
println!("Online logical CPUs: {}", diagnostics.online_logical_cpus);
println!(
"Assigned logical CPUs: {}",
diagnostics.assigned_logical_cpus
);
println!("Physical cores: {}", diagnostics.physical_core_count);
println!("P-cores: {}", diagnostics.performance_core_count);
println!("E-cores: {}", diagnostics.efficiency_core_count);
println!("Unknown: {}", diagnostics.unknown_core_count);
for (index, core) in topology.cores.iter().enumerate() {
println!(
"C{index}: package={:?} die={:?} core_id={:?} logical={:?}",
core.package_id, core.die_id, core.core_id, core.logical_cpus
);
}
return Ok(());
}
let _guard = TerminalGuard::enter()?;
let previous_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |panic| {
restore_terminal();
previous_hook(panic);
}));
let mut terminal = Terminal::new(CrosstermBackend::new(io::stdout()))?;
let (event_tx, mut event_rx) = mpsc::unbounded_channel();
let (refresh_tx, mut refresh_rx) = mpsc::unbounded_channel();
let (force_tx, force_rx) = mpsc::unbounded_channel();
spawn_event_reader(event_tx);
tokio::spawn(collector::run_collection_loop(config, refresh_tx, force_rx));
let mut sigint = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::interrupt())?;
let mut app = App::default();
loop {
terminal.draw(|frame| ui::draw(frame, &app))?;
tokio::select! {
Some(Event::Key(key)) = event_rx.recv() => {
if key.code == KeyCode::Char('r') { let _ = force_tx.send(()); app.status = vec!["Refresh requested".into()]; }
else if app.handle_key(key) { break; }
}
Some(refresh) = refresh_rx.recv() => app.apply(refresh),
_ = sigint.recv() => break,
}
}
drop(terminal);
Ok(())
}