282 lines
10 KiB
Rust
282 lines
10 KiB
Rust
use miette::{Result, IntoDiagnostic, Diagnostic, Report};
|
|
use thiserror::Error;
|
|
use std::sync::mpsc;
|
|
use std::thread;
|
|
use std::time::{Duration, Instant};
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::io;
|
|
|
|
use clap::Parser;
|
|
use tracing::{info, debug, error};
|
|
|
|
use crossterm::{
|
|
event::{self, Event, KeyCode},
|
|
execute,
|
|
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
|
|
};
|
|
use ratatui::{backend::CrosstermBackend, Terminal};
|
|
|
|
use ember_tune_rs::cli::Cli;
|
|
use ember_tune_rs::mediator::{TelemetryState, UiCommand, BenchmarkPhase};
|
|
use ember_tune_rs::sal::traits::{AuditError, PlatformSal};
|
|
use ember_tune_rs::sal::mock::MockSal;
|
|
use ember_tune_rs::sal::heuristic::engine::HeuristicEngine;
|
|
use ember_tune_rs::sal::heuristic::discovery::SystemFactSheet;
|
|
use ember_tune_rs::load::{StressNg};
|
|
use ember_tune_rs::orchestrator::BenchmarkOrchestrator;
|
|
use ember_tune_rs::ui::dashboard::{draw_dashboard, DashboardState};
|
|
use ember_tune_rs::engine::OptimizationResult;
|
|
use owo_colors::OwoColorize;
|
|
|
|
#[derive(Error, Diagnostic, Debug)]
|
|
#[error("Multiple pre-flight audit failures occurred.")]
|
|
struct MultiAuditError {
|
|
#[related]
|
|
errors: Vec<AuditError>,
|
|
}
|
|
|
|
fn print_summary_report(result: &OptimizationResult) {
|
|
println!();
|
|
let header = format!("{}", " 🔥 ember-tune optimization complete! ".bold().on_red().white());
|
|
println!("╭──────────────────────────────────────────────────╮");
|
|
println!("│ {:<48} │", header);
|
|
println!("├──────────────────────────────────────────────────┤");
|
|
|
|
if result.is_partial {
|
|
println!("│ {} │", " ⚠ WARNING: PARTIAL RESULTS (INTERRUPTED) ".yellow().bold());
|
|
println!("├──────────────────────────────────────────────────┤");
|
|
}
|
|
|
|
let knee_label = "Silicon Knee:".cyan();
|
|
println!("│ {:<28} {:>5.1} W / {:>3.0}°C │", knee_label, result.silicon_knee_watts, result.max_temp_c);
|
|
|
|
let res_label = "Thermal Resistance (Rθ):".cyan();
|
|
println!("│ {:<28} {:>8.3} K/W │", res_label, result.thermal_resistance_kw);
|
|
|
|
println!("│ │");
|
|
println!("│ {} │", "Recommended Limits:".bold().green());
|
|
println!("│ Sustained (PL1): {:>5.1} W │", result.recommended_pl1);
|
|
println!("│ Burst (PL2): {:>5.1} W │", result.recommended_pl2);
|
|
|
|
println!("│ │");
|
|
println!("│ {} │", "Apply these to your system:".bold().magenta());
|
|
for (id, path) in &result.config_paths {
|
|
println!("│ {:<10}: {:<34} │", id, path.display());
|
|
}
|
|
println!("╰──────────────────────────────────────────────────╯");
|
|
println!();
|
|
}
|
|
|
|
fn setup_logging(verbose: bool) -> tracing_appender::non_blocking::WorkerGuard {
|
|
let file_appender = tracing_appender::rolling::never("/var/log", "ember-tune.log");
|
|
let (non_blocking, guard) = tracing_appender::non_blocking(file_appender);
|
|
|
|
let level = if verbose { tracing::Level::DEBUG } else { tracing::Level::INFO };
|
|
|
|
tracing_subscriber::fmt()
|
|
.with_max_level(level)
|
|
.with_writer(non_blocking)
|
|
.with_ansi(false)
|
|
.init();
|
|
|
|
guard
|
|
}
|
|
|
|
fn main() -> Result<()> {
|
|
// 1. Diagnostics & CLI Initialization
|
|
let args = Cli::parse();
|
|
let _log_guard = setup_logging(args.verbose);
|
|
|
|
// Set panic hook to restore terminal state
|
|
std::panic::set_hook(Box::new(|panic_info| {
|
|
let _ = disable_raw_mode();
|
|
let mut stdout = io::stdout();
|
|
let _ = execute!(stdout, LeaveAlternateScreen, crossterm::cursor::Show);
|
|
eprintln!("\n\x1b[1;31mFATAL ERROR: ember-tune Panicked\x1b[0m");
|
|
eprintln!("----------------------------------------");
|
|
eprintln!("{}", panic_info);
|
|
eprintln!("----------------------------------------\n");
|
|
}));
|
|
|
|
info!("ember-tune starting with args: {:?}", args);
|
|
|
|
let ctx = ember_tune_rs::sal::traits::EnvironmentCtx::production();
|
|
|
|
// 2. Platform Detection & Audit
|
|
let (sal_box, facts): (Box<dyn PlatformSal>, SystemFactSheet) = if args.mock {
|
|
(Box::new(MockSal::new()), SystemFactSheet::default())
|
|
} else {
|
|
HeuristicEngine::detect_and_build(ctx)?
|
|
};
|
|
let sal: Arc<dyn PlatformSal> = sal_box.into();
|
|
|
|
println!("{}", console::style("─── Pre-flight System Audit ───").bold().cyan());
|
|
let mut audit_failures = Vec::new();
|
|
|
|
for step in sal.audit() {
|
|
print!(" Checking {:<40} ", step.description);
|
|
io::Write::flush(&mut io::stdout()).into_diagnostic()?;
|
|
|
|
match step.outcome {
|
|
Ok(_) => { println!("{}", console::style("[✓]").green()); }
|
|
Err(e) => {
|
|
println!("{}", console::style("[✗]").red());
|
|
audit_failures.push(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
if !audit_failures.is_empty() {
|
|
println!();
|
|
return Err(Report::new(MultiAuditError { errors: audit_failures }));
|
|
}
|
|
|
|
if args.audit_only {
|
|
println!("{}", console::style("✓ All pre-flight audits passed.").green().bold());
|
|
return Ok(());
|
|
}
|
|
|
|
// 3. Terminal Setup
|
|
enable_raw_mode().into_diagnostic()?;
|
|
let mut stdout = io::stdout();
|
|
execute!(stdout, EnterAlternateScreen).into_diagnostic()?;
|
|
let backend_stdout = io::stdout();
|
|
let backend_term = CrosstermBackend::new(backend_stdout);
|
|
let mut terminal = Terminal::new(backend_term).into_diagnostic()?;
|
|
|
|
// 4. State & Communication Setup
|
|
let running = Arc::new(AtomicBool::new(true));
|
|
let r = running.clone();
|
|
|
|
let (telemetry_tx, telemetry_rx) = mpsc::channel::<TelemetryState>();
|
|
let (command_tx, command_rx) = mpsc::channel::<UiCommand>();
|
|
|
|
let c_tx = command_tx.clone();
|
|
ctrlc::set_handler(move || {
|
|
let _ = c_tx.send(UiCommand::Abort);
|
|
r.store(false, Ordering::SeqCst);
|
|
}).expect("Error setting Ctrl-C handler");
|
|
|
|
// 5. Spawn Backend Orchestrator
|
|
let sal_backend = sal.clone();
|
|
let facts_backend = facts.clone();
|
|
let config_out = args.config_out.clone();
|
|
let backend_handle = thread::spawn(move || {
|
|
let workload = Box::new(StressNg::new());
|
|
let mut orchestrator = BenchmarkOrchestrator::new(
|
|
sal_backend,
|
|
facts_backend,
|
|
workload,
|
|
telemetry_tx,
|
|
command_rx,
|
|
config_out,
|
|
);
|
|
orchestrator.run()
|
|
});
|
|
|
|
// 6. Frontend Event Loop
|
|
let mut ui_state = DashboardState::new();
|
|
let mut last_telemetry = TelemetryState {
|
|
cpu_model: "Loading...".to_string(),
|
|
total_ram_gb: 0,
|
|
tick: 0,
|
|
cpu_temp: 0.0,
|
|
power_w: 0.0,
|
|
current_freq: 0.0,
|
|
fans: Vec::new(),
|
|
governor: "detecting".to_string(),
|
|
pl1_limit: 0.0,
|
|
pl2_limit: 0.0,
|
|
fan_tier: "auto".to_string(),
|
|
is_throttling: false,
|
|
phase: BenchmarkPhase::Auditing,
|
|
history_watts: Vec::new(),
|
|
history_temp: Vec::new(),
|
|
history_mhz: Vec::new(),
|
|
log_event: None,
|
|
metadata: std::collections::HashMap::new(),
|
|
is_emergency: false,
|
|
emergency_reason: None,
|
|
};
|
|
|
|
let tick_rate = Duration::from_millis(100);
|
|
let mut last_tick = Instant::now();
|
|
|
|
while running.load(Ordering::SeqCst) {
|
|
terminal.draw(|f| {
|
|
draw_dashboard(f, f.area(), &last_telemetry, &ui_state);
|
|
}).into_diagnostic()?;
|
|
|
|
let timeout = tick_rate
|
|
.checked_sub(last_tick.elapsed())
|
|
.unwrap_or(Duration::from_secs(0));
|
|
|
|
if event::poll(timeout).into_diagnostic()? {
|
|
if let Event::Key(key) = event::read().into_diagnostic()? {
|
|
match key.code {
|
|
KeyCode::Char('q') | KeyCode::Esc => {
|
|
let _ = command_tx.send(UiCommand::Abort);
|
|
running.store(false, Ordering::SeqCst);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
while let Ok(new_state) = telemetry_rx.try_recv() {
|
|
if let Some(log) = &new_state.log_event {
|
|
ui_state.add_log(log.clone());
|
|
debug!("Backend Log: {}", log);
|
|
} else {
|
|
ui_state.update(&new_state);
|
|
last_telemetry = new_state;
|
|
}
|
|
}
|
|
|
|
if last_tick.elapsed() >= tick_rate { last_tick = Instant::now(); }
|
|
if backend_handle.is_finished() { break; }
|
|
}
|
|
|
|
// 7. Terminal Restoration
|
|
let _ = disable_raw_mode();
|
|
let _ = execute!(terminal.backend_mut(), LeaveAlternateScreen);
|
|
let _ = terminal.show_cursor();
|
|
|
|
// 8. Final Report & Hardware Restoration
|
|
let join_res = backend_handle.join();
|
|
|
|
// Explicit hardware restoration
|
|
info!("Restoring hardware state...");
|
|
if let Err(e) = sal.restore() {
|
|
error!("Failed to restore hardware state: {}", e);
|
|
}
|
|
|
|
match join_res {
|
|
Ok(Ok(result)) => {
|
|
print_summary_report(&result);
|
|
}
|
|
Ok(Err(e)) => {
|
|
let err_str = e.to_string();
|
|
if err_str == "ABORTED" {
|
|
println!("{}", "Benchmark aborted by user.".yellow());
|
|
} else if err_str.contains("EMERGENCY_ABORT") {
|
|
println!();
|
|
println!("{}", " 🚨 EMERGENCY ABORT TRIGGERED ".bold().on_red().white());
|
|
println!("Reason: {}", err_str.replace("EMERGENCY_ABORT: ", "").red().bold());
|
|
println!("{}", "Hardware state has been restored to safe defaults.".yellow());
|
|
println!();
|
|
} else {
|
|
error!("Orchestrator encountered error: {}", e);
|
|
eprintln!("{} {}", "Error:".red().bold(), e);
|
|
}
|
|
}
|
|
Err(_) => {
|
|
error!("Backend thread panicked!");
|
|
}
|
|
}
|
|
|
|
info!("ember-tune exited gracefully.");
|
|
Ok(())
|
|
}
|