62 lines
3.0 KiB
Rust
62 lines
3.0 KiB
Rust
use tauri::State;
|
|
use crate::models::*;
|
|
use crate::profiler::*;
|
|
use chrono::Utc;
|
|
use std::process::Command as StdCommand;
|
|
|
|
#[tauri::command]
|
|
pub fn get_system_stats(state: State<AppState>, minimal: bool) -> SystemStats {
|
|
let mut sys = state.sys.lock().unwrap();
|
|
let mut profiling = state.profiling.lock().unwrap();
|
|
let mut pss_cache = state.pss_cache.lock().unwrap();
|
|
let self_pid = std::process::id();
|
|
let syspulse_pids = get_syspulse_pids(self_pid, &sys);
|
|
let snapshot = collect_snapshot(&mut sys, &syspulse_pids, &mut pss_cache, profiling.is_active);
|
|
if profiling.is_active { profiling.snapshots.push(snapshot.clone()); }
|
|
let recording_duration = profiling.start_time.map(|s| (Utc::now() - s).num_seconds() as u64).unwrap_or(0);
|
|
let display_processes = if minimal && !profiling.is_active { Vec::new() } else {
|
|
let mut p = snapshot.processes.clone();
|
|
p.sort_by(|a, b| b.cpu_usage.partial_cmp(&a.cpu_usage).unwrap_or(std::cmp::Ordering::Equal));
|
|
p.truncate(50);
|
|
p
|
|
};
|
|
SystemStats { cpu_usage: snapshot.cpu_usage, total_memory: sys.total_memory(), used_memory: sys.used_memory(), processes: display_processes, is_recording: profiling.is_active, recording_duration }
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn get_initial_report(state: State<AppState>) -> Option<Report> { state.initial_report.lock().unwrap().clone() }
|
|
|
|
#[tauri::command]
|
|
pub fn save_report(report: Report) -> Result<String, String> {
|
|
let json = serde_json::to_string_pretty(&report).map_err(|e| e.to_string())?;
|
|
let path = format!("syspulse_report_{}.json", Utc::now().format("%Y%m%d_%H%M%S"));
|
|
std::fs::write(&path, json).map_err(|e| e.to_string())?;
|
|
Ok(path)
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn start_profiling(state: State<AppState>) {
|
|
let mut profiling = state.profiling.lock().unwrap();
|
|
profiling.is_active = true; profiling.mode = ProfilingMode::Global; profiling.target_pid = None; profiling.start_time = Some(Utc::now()); profiling.snapshots.clear();
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn start_targeted_profiling(state: State<AppState>, pid: u32) {
|
|
let mut profiling = state.profiling.lock().unwrap();
|
|
profiling.is_active = true; profiling.mode = ProfilingMode::Targeted; profiling.target_pid = Some(pid); profiling.start_time = Some(Utc::now()); profiling.snapshots.clear();
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn stop_profiling(state: State<AppState>) -> Report {
|
|
let mut profiling = state.profiling.lock().unwrap();
|
|
profiling.is_active = false;
|
|
let snapshots: Vec<Snapshot> = profiling.snapshots.drain(..).collect();
|
|
generate_report(profiling.start_time.unwrap_or(Utc::now()), snapshots, profiling.mode, profiling.target_pid)
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub fn run_as_admin(command: String) -> Result<String, String> {
|
|
let output = StdCommand::new("pkexec").arg("sh").arg("-c").arg(&command).output().map_err(|e| e.to_string())?;
|
|
if output.status.success() { Ok(String::from_utf8_lossy(&output.stdout).to_string()) } else { Err(String::from_utf8_lossy(&output.stderr).to_string()) }
|
|
}
|