LFeng/Thing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 6 Wiki Activity

性能优化

Browse Source
This commit is contained in:
zhongluofeng
2026-08-06 10:33:16 +08:00
parent c7578a2e6b
commit e66c53e66d
105 changed files with 7273 additions and 5002 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/src/monitor_kernel.rs
+70 -37
View File
@@ -175,11 +175,11 @@ pub fn check_and_relaunch_if_needed(app_data_dir: &std::path::Path) -> bool {
Ok(e) => e,
Err(_) => return false,
};
eprintln!("[monitor] 检测到永久提权标志，以管理员权限重启 Thing");
crate::logger::log_info("monitor", "检测到永久提权标志，以管理员权限重启 Thing");
match shell_execute_elevated(&exe.to_string_lossy(), "", None) {
Ok(()) => true,
Err(e) => {
eprintln!("[monitor] 永久提权重启失败（用户可能取消了 UAC）: {}", e);
crate::logger::log_warn("monitor", &format!("永久提权重启失败（用户可能取消了 UAC）: {}", e));
false
}
}
@@ -247,6 +247,17 @@ pub struct MonitorKernel {
listener_ids: Arc<Mutex<Vec<tauri::EventId>>>,
/// 是否以管理员权限运行（提权模式下进程不受 ProcessManager 管控，停止走 /shutdown）
elevated: Arc<AtomicBool>,
/// SSE 订阅循环活跃标志（重入守卫，防止并发/重复订阅导致双 emit monitor-data）
subscribing: Arc<AtomicBool>,
}
/// SSE 订阅循环标志守卫：Drop 时复位 subscribing，覆盖所有 return / abort 路径
struct SubGuard(Arc<AtomicBool>);
impl Drop for SubGuard {
fn drop(&mut self) {
self.0.store(false, Ordering::SeqCst);
}
}
impl MonitorKernel {
@@ -265,6 +276,7 @@ impl MonitorKernel {
sub_handle: Arc::new(Mutex::new(None)),
listener_ids: Arc::new(Mutex::new(Vec::new())),
elevated: Arc::new(AtomicBool::new(false)),
subscribing: Arc::new(AtomicBool::new(false)),
}
}
@@ -381,10 +393,18 @@ impl MonitorKernel {
/// 流程：轮询 /status 等 ready → 订阅 /stream → 解析 SSE 事件 → emit "monitor-data"
/// 写入熔断：SSE 断开后停止 emit，等待外部调用 reconnect 或 process-status-changed 触发重连
pub async fn start_subscription(self: Self, app: AppHandle) {
// 重入守卫：已有订阅循环在运行则跳过，防止并发/重复订阅（双 emit monitor-data）
if self.subscribing.swap(true, Ordering::SeqCst) {
crate::logger::log_warn("monitor", "已有 SSE 订阅循环运行中，跳过重复订阅");
return;
}
// Drop 时复位标志，覆盖所有 return 路径（含 stop 时 abort 取消）
let _guard = SubGuard(self.subscribing.clone());
// 1. 轮询等待 Kernel ready（冷启动约 5s）
if let Err(e) = self.wait_for_ready(&app).await {
eprintln!("[monitor] 等待 Kernel ready 失败，订阅不启动: {}", e);
let _ = app.emit("monitor-error", serde_json::json!({ "stage": "ready", "message": e }));
crate::logger::log_warn("monitor", &format!("等待 Kernel ready 失败，订阅不启动: {}", e));
let _ = app.emit(crate::constants::events::MONITOR_ERROR, serde_json::json!({ "stage": "ready", "message": e }));
return;
}
@@ -409,7 +429,7 @@ impl MonitorKernel {
match resp.json::<KernelStatus>().await {
Ok(s) if s.ready => {
let _ = app.emit(
"monitor-ready",
crate::constants::events::MONITOR_READY,
serde_json::json!({
"isAdmin": s.is_admin,
"sensorCount": s.sensor_count,
@@ -426,8 +446,10 @@ impl MonitorKernel {
Err(e) => last_err = e.to_string(),
}
// 通知前端正在加载（前端可显示 "Kernel 启动中..."）
let elapsed = READY_TIMEOUT_MS.saturating_sub(deadline.duration_since(std::time::Instant::now()).as_millis() as u64);
let _ = app.emit("monitor-loading", serde_json::json!({ "elapsedMs": elapsed }));
// 用 saturating_duration_since：now 超过 deadline 时返回 0，避免 duration_since panic
let remaining = deadline.saturating_duration_since(std::time::Instant::now()).as_millis() as u64;
let elapsed = READY_TIMEOUT_MS.saturating_sub(remaining);
let _ = app.emit(crate::constants::events::MONITOR_LOADING, serde_json::json!({ "elapsedMs": elapsed }));
tokio::time::sleep(Duration::from_millis(READY_POLL_INTERVAL_MS)).await;
}
Err(format!("Kernel 在 {}ms 内未就绪: {}", READY_TIMEOUT_MS, last_err))
@@ -441,24 +463,24 @@ impl MonitorKernel {
match self.subscribe_once(&url, &app).await {
// 正常结束（客户端取消或服务端关闭）
Ok(()) => {
eprintln!("[monitor] SSE 流正常结束");
crate::logger::log_info("monitor", "SSE 流正常结束");
break;
}
Err(e) => {
eprintln!("[monitor] SSE 流异常断开: {}，3s 后重试", e);
crate::logger::log_warn("monitor", &format!("SSE 流异常断开: {}，3s 后重试", e));
let _ = app.emit(
"monitor-disconnected",
crate::constants::events::MONITOR_DISCONNECTED,
serde_json::json!({ "message": e }),
);
tokio::time::sleep(Duration::from_secs(3)).await;
// 重连前先确认 Kernel 是否还活着（可能已被 stop）
if !self.is_kernel_alive().await {
eprintln!("[monitor] Kernel 已停止，退出 SSE 循环");
crate::logger::log_info("monitor", "Kernel 已停止，退出 SSE 循环");
// 提权模式下 Kernel 崩溃/退出后重置 elevated 标志，
// 否则 monitor_status 会一直认为提权模式但 Kernel 已死，用户无法重启
if self.is_elevated() {
self.elevated.store(false, Ordering::SeqCst);
eprintln!("[monitor] 提权 Kernel 已退出，重置 elevated 标志");
crate::logger::log_info("monitor", "提权 Kernel 已退出，重置 elevated 标志");
}
break;
}
@@ -497,7 +519,7 @@ impl MonitorKernel {
if let Some(json_str) = parse_sse_data(&event_str) {
if let Ok(snap) = serde_json::from_str::<SensorSnapshot>(&json_str) {
let _ = app.emit("monitor-data", snap);
let _ = app.emit(crate::constants::events::MONITOR_DATA, snap);
}
}
}
@@ -519,9 +541,11 @@ impl MonitorKernel {
/// 停止 SSE 订阅（进程由 ProcessManager.stop 负责）
pub async fn stop_subscription(&self, app: &AppHandle) {
// 取消 SSE 任务
// 取消 SSE 任务并等待其退出，确保 subscribing 重入守卫复位。
// 否则 stop 后立即 start 时旧任务仍在 Drop，新订阅会被守卫误跳过。
if let Some(handle) = self.sub_handle.lock().await.take() {
handle.abort();
let _ = handle.await;
}
// 取消 process-status-changed 监听
let ids = self.listener_ids.lock().await.drain(..).collect::<Vec<_>>();
@@ -552,7 +576,7 @@ impl MonitorKernel {
let this = this.clone();
let app = app_clone.clone();
tauri::async_runtime::spawn(async move {
eprintln!("[monitor] 检测到 Kernel 重启恢复，重新订阅 SSE");
crate::logger::log_info("monitor", "检测到 Kernel 重启恢复，重新订阅 SSE");
// 重启后需要重新等待 ready（冷启动约 5s）
this.clone().start_subscription(app).await;
});
@@ -585,20 +609,23 @@ impl MonitorKernel {
if status.ready {
if thing_elevated {
// Thing 是管理员：停止已有 Kernel（无论什么权限），用 ProcessManager 重启以继承权限
eprintln!("[monitor] Thing 已提权，重启 ThingHK 以继承管理员权限");
crate::logger::log_info("monitor", "Thing 已提权，重启 ThingHK 以继承管理员权限");
let _ = self.shutdown_kernel().await;
tokio::time::sleep(Duration::from_millis(500)).await;
} else if status.is_admin {
// Thing 非管理员，但已有提权 Kernel：直接接管
eprintln!("[monitor] 检测到已有提权 Kernel 运行中，直接接管");
crate::logger::log_info("monitor", "检测到已有提权 Kernel 运行中，直接接管");
self.elevated.store(true, Ordering::SeqCst);
let kernel = self.clone();
kernel.clone().register_auto_reconnect(app.clone()).await;
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
// 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
if !kernel.subscribing.load(Ordering::SeqCst) {
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
}
// 提权模式下无 ProcessInfo，返回一个占位的
return Ok(crate::process_manager::ProcessInfo {
id: PROCESS_ID.into(),
@@ -609,7 +636,7 @@ impl MonitorKernel {
});
} else {
// Thing 非管理员，已有普通 Kernel：先停止
eprintln!("[monitor] 检测到已有普通权限 Kernel 运行中，先停止再重启");
crate::logger::log_info("monitor", "检测到已有普通权限 Kernel 运行中，先停止再重启");
let _ = self.shutdown_kernel().await;
tokio::time::sleep(Duration::from_millis(500)).await;
}
@@ -623,7 +650,7 @@ impl MonitorKernel {
// Thing 是管理员时，ThingHK 继承权限，标记 elevated（仍由 ProcessManager 管理）
if thing_elevated {
self.elevated.store(true, Ordering::SeqCst);
eprintln!("[monitor] ThingHK 已以管理员权限启动（继承自 Thing）");
crate::logger::log_info("monitor", "ThingHK 已以管理员权限启动（继承自 Thing）");
}
// 用 self 的 clone（共享 Arc<Mutex> 状态）启动订阅，
@@ -631,11 +658,14 @@ impl MonitorKernel {
// stop_subscription 时才能正确清理 listener。
let kernel = self.clone();
kernel.clone().register_auto_reconnect(app.clone()).await;
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
// 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
if !kernel.subscribing.load(Ordering::SeqCst) {
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
}
Ok(info)
}
@@ -703,17 +733,20 @@ impl MonitorKernel {
}
self.elevated.store(true, Ordering::SeqCst);
eprintln!("[monitor] 提权启动已发起，等待 Kernel ready");
crate::logger::log_info("monitor", "提权启动已发起，等待 Kernel ready");
// 5. 启动 SSE 订阅（提权模式不注册 register_auto_reconnect：
// 提权进程不归 ProcessManager 管，process-status-changed 事件不会触发，
// 注册了反而可能在其他进程状态变化时误触发 SSE 重连）
let kernel = self.clone();
let app_clone = app.clone();
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
// 已有订阅循环在运行则不覆盖句柄（否则旧任务句柄丢失，stop 无法取消）
if !kernel.subscribing.load(Ordering::SeqCst) {
let handle = tauri::async_runtime::spawn(async move {
kernel.start_subscription(app_clone).await;
});
*self.sub_handle.lock().await = Some(handle);
}
Ok(())
}
@@ -745,7 +778,7 @@ impl MonitorKernel {
self.stop_subscription(app).await;
// 仅当 ThingHK 提权但 Thing 未提权时才需要 /shutdown（ProcessManager 无法 kill 管理员进程）
if self.is_elevated() && !is_thing_elevated() {
eprintln!("[monitor] 退出清理：停止提权 Kernel（/shutdown）");
crate::logger::log_info("monitor", "退出清理：停止提权 Kernel（/shutdown）");
let _ = self.shutdown_kernel().await;
self.elevated.store(false, Ordering::SeqCst);
}
@@ -852,13 +885,13 @@ pub async fn monitor_elevate_self(
if is_thing_elevated() {
// 已是管理员，只需设置标志，无需重启
eprintln!("[monitor] Thing 已是管理员，仅设置永久提权标志");
crate::logger::log_info("monitor", "Thing 已是管理员，仅设置永久提权标志");
return Ok(());
}
let exe = std::env::current_exe().map_err(|e| format!("获取当前路径失败: {}", e))?;
let exe_str = exe.to_string_lossy().to_string();
eprintln!("[monitor] 永久提权：以管理员权限重启 Thing");
crate::logger::log_info("monitor", "永久提权：以管理员权限重启 Thing");
shell_execute_elevated(&exe_str, "", None)?;
// 退出当前进程（非提权），新的提权进程会接管
app.exit(0);