341 lines
10 KiB
Rust
341 lines
10 KiB
Rust
//! 代理模块 Tauri 命令层。
|
|
|
|
use tauri::{AppHandle, State};
|
|
|
|
use super::system_proxy::{clear_system_proxy_windows, get_system_proxy_windows, set_system_proxy_windows};
|
|
use super::{
|
|
KernelInfo, KernelUpdateInfo, MihomoManager, ProfileMeta, ProxySettings, ProxyStatus, TrafficSnapshot,
|
|
};
|
|
|
|
use crate::process_manager::{ProcessInfo, ProcessManager, ProcessStatus};
|
|
|
|
/// 判断 mihomo 进程是否处于运行状态
|
|
fn mihomo_running(pm: &ProcessManager) -> bool {
|
|
matches!(
|
|
pm.get_status("proxy").map(|p| p.status),
|
|
Some(ProcessStatus::Running)
|
|
)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_get_settings(state: State<'_, MihomoManager>) -> ProxySettings {
|
|
state.load_settings()
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_save_settings(
|
|
state: State<'_, MihomoManager>,
|
|
settings: ProxySettings,
|
|
) -> Result<(), String> {
|
|
state.save_settings(&settings)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_kernel_info(
|
|
state: State<'_, MihomoManager>,
|
|
app: AppHandle,
|
|
) -> Result<KernelInfo, String> {
|
|
state.prepare_kernel(&app)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_check_kernel_update(
|
|
state: State<'_, MihomoManager>,
|
|
) -> Result<KernelUpdateInfo, String> {
|
|
state.check_kernel_update().await
|
|
}
|
|
|
|
/// 取消内核下载/安装（设置取消标志，下载循环轮询后中止）
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_cancel_kernel_install(state: State<'_, MihomoManager>) -> Result<(), String> {
|
|
state.cancel_kernel_install();
|
|
Ok(())
|
|
}
|
|
|
|
/// 前端确认 mihomo 已停止，唤醒等待中的安装流程继续解压替换。
|
|
/// （下载阶段允许 mihomo 运行以便走系统代理，解压替换前必须停止 mihomo，否则 exe 被占用）
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_confirm_install(state: State<'_, MihomoManager>) -> Result<(), String> {
|
|
state.confirm_install();
|
|
Ok(())
|
|
}
|
|
|
|
/// 应用内核更新：下载阶段已由下载模块完成，本方法仅做 need_stop → 解压 → 替换。
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_apply_kernel_update(
|
|
state: State<'_, MihomoManager>,
|
|
app: AppHandle,
|
|
zip_path: String,
|
|
) -> Result<KernelInfo, String> {
|
|
let path = std::path::PathBuf::from(zip_path);
|
|
state.apply_kernel_update(&app, path).await
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_status(pm: State<'_, ProcessManager>) -> ProxyStatus {
|
|
match pm.get_status("proxy") {
|
|
Some(p) => ProxyStatus {
|
|
running: matches!(p.status, crate::process_manager::ProcessStatus::Running),
|
|
pid: p.pid,
|
|
restart_count: p.restart_count,
|
|
},
|
|
None => ProxyStatus {
|
|
running: false,
|
|
pid: None,
|
|
restart_count: 0,
|
|
},
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_start(
|
|
state: State<'_, MihomoManager>,
|
|
pm: State<'_, ProcessManager>,
|
|
app: AppHandle,
|
|
) -> Result<ProcessInfo, String> {
|
|
let params = state.prepare_for_start(&app)?;
|
|
let info = pm.start(params)?;
|
|
// 手动启动也遵循「启动时自动开启系统代理」设置
|
|
state.apply_auto_system_proxy();
|
|
Ok(info)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_stop(state: State<'_, MihomoManager>, pm: State<'_, ProcessManager>) -> Result<(), String> {
|
|
// 关闭 mihomo 时同步关闭系统代理（若开启），避免系统代理指向已停止的端口导致断网
|
|
if get_system_proxy_windows() {
|
|
let _ = state.disable_system_proxy();
|
|
}
|
|
pm.stop("proxy")
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_restart(
|
|
state: State<'_, MihomoManager>,
|
|
pm: State<'_, ProcessManager>,
|
|
app: AppHandle,
|
|
) -> Result<ProcessInfo, String> {
|
|
let _ = pm.stop("proxy");
|
|
// 等待 TCP 端口释放（Windows 上 kill 后端口释放有延迟），在阻塞线程池中 sleep 避免阻塞主线程
|
|
tauri::async_runtime::spawn_blocking(|| {
|
|
std::thread::sleep(std::time::Duration::from_millis(800));
|
|
})
|
|
.await
|
|
.map_err(|e| format!("sleep 失败: {}", e))?;
|
|
|
|
// 启动并等待 API 就绪，带有限重试（共 3 次）：
|
|
// - 冷加载大订阅（首次解析 + geo 下载）可能远超过前端 waitForApi 的 10s 预算，
|
|
// 这里在命令内等满就绪，避免重启成功后仍被前端误判为「重启失败」导致节点不刷新。
|
|
// - 偶发的端口未及时释放 / 启动瞬间退出，通过重试自愈。
|
|
let mut last_err = "mihomo 启动失败".to_string();
|
|
for _ in 0..3 {
|
|
match start_and_wait(state.inner(), pm.inner(), &app).await {
|
|
Ok(info) => return Ok(info),
|
|
Err(e) => {
|
|
last_err = e;
|
|
// 上个实例刚退出，多等一会儿释放端口再重试
|
|
tauri::async_runtime::spawn_blocking(|| {
|
|
std::thread::sleep(std::time::Duration::from_millis(1200));
|
|
})
|
|
.await
|
|
.map_err(|x| format!("sleep 失败: {}", x))?;
|
|
}
|
|
}
|
|
}
|
|
// 所有启动尝试均失败：mihomo 已停止，同步关闭系统代理（若开启），避免代理指向已停止端口导致断网
|
|
if get_system_proxy_windows() {
|
|
let _ = state.disable_system_proxy();
|
|
}
|
|
Err(last_err)
|
|
}
|
|
|
|
/// 启动 mihomo 并等待其 HTTP API 就绪（最多 20s）。
|
|
/// - 若启动后进程立即退出，快速返回（不白等满预算），便于外层尽早重试。
|
|
/// - 若 pm.start 返回「已在运行中」，说明崩溃监控已抢先拉起进程，同样等待其 API 就绪即可。
|
|
async fn start_and_wait(
|
|
state: &MihomoManager,
|
|
pm: &ProcessManager,
|
|
app: &AppHandle,
|
|
) -> Result<ProcessInfo, String> {
|
|
let params = state.prepare_for_start(app)?;
|
|
if let Err(e) = pm.start(params) {
|
|
// "已在运行中" = 崩溃监控已拉起，不算失败；其余为上抛
|
|
if !e.contains("运行中") {
|
|
return Err(e);
|
|
}
|
|
}
|
|
|
|
let deadline = tokio::time::Instant::now() + std::time::Duration::from_secs(20);
|
|
loop {
|
|
// 进程已退出且 API 未就绪 → 启动失败（快速失败，交外层重试）
|
|
if let Some(st) = pm.get_status("proxy") {
|
|
if !matches!(st.status, ProcessStatus::Running) {
|
|
return Err("mihomo 启动后立即退出".to_string());
|
|
}
|
|
}
|
|
if state.get_version().await.is_ok() {
|
|
return pm.get_status("proxy").ok_or_else(|| "mihomo 进程不存在".to_string());
|
|
}
|
|
if tokio::time::Instant::now() >= deadline {
|
|
return Err("mihomo 启动超时，API 无响应".to_string());
|
|
}
|
|
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn proxy_version(state: State<'_, MihomoManager>) -> Result<serde_json::Value, String> {
|
|
state.get_version().await
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn proxy_get_proxies(state: State<'_, MihomoManager>) -> Result<serde_json::Value, String> {
|
|
state.get_proxies().await
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_select_proxy(
|
|
state: State<'_, MihomoManager>,
|
|
group: String,
|
|
name: String,
|
|
) -> Result<(), String> {
|
|
state.select_proxy(&group, &name).await
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_test_delay(
|
|
state: State<'_, MihomoManager>,
|
|
name: String,
|
|
url: Option<String>,
|
|
timeout: Option<u32>,
|
|
) -> Result<u32, String> {
|
|
state
|
|
.test_delay(
|
|
&name,
|
|
url.as_deref().unwrap_or("https://www.gstatic.com/generate_204"),
|
|
timeout.unwrap_or(5000),
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn proxy_get_connections(
|
|
state: State<'_, MihomoManager>,
|
|
) -> Result<serde_json::Value, String> {
|
|
state.get_connections().await
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_traffic(
|
|
state: State<'_, MihomoManager>,
|
|
) -> Result<TrafficSnapshot, String> {
|
|
state.traffic_snapshot().await
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_close_connection(
|
|
state: State<'_, MihomoManager>,
|
|
id: String,
|
|
) -> Result<(), String> {
|
|
state.close_connection(&id).await
|
|
}
|
|
|
|
#[tauri::command]
|
|
pub async fn proxy_patch_configs(
|
|
state: State<'_, MihomoManager>,
|
|
body: serde_json::Value,
|
|
) -> Result<(), String> {
|
|
state.patch_configs(body).await
|
|
}
|
|
|
|
// ---------- 订阅 ----------
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_import_profile(
|
|
state: State<'_, MihomoManager>,
|
|
url: String,
|
|
name: String,
|
|
) -> Result<ProfileMeta, String> {
|
|
state.import_profile(&url, &name).await
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn proxy_update_profile(
|
|
state: State<'_, MihomoManager>,
|
|
id: String,
|
|
) -> Result<ProfileMeta, String> {
|
|
state.update_profile(&id).await
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_delete_profile(
|
|
state: State<'_, MihomoManager>,
|
|
id: String,
|
|
) -> Result<(), String> {
|
|
state.delete_profile(&id)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_activate_profile(
|
|
state: State<'_, MihomoManager>,
|
|
id: String,
|
|
) -> Result<(), String> {
|
|
state.activate_profile(&id)
|
|
}
|
|
|
|
// ---------- 系统代理 ----------
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_set_system_proxy(
|
|
state: State<'_, MihomoManager>,
|
|
pm: State<'_, ProcessManager>,
|
|
) -> Result<(), String> {
|
|
// 停机时禁止开启系统代理：否则系统代理指向已停止的端口，会导致所有网络请求失败
|
|
if !mihomo_running(&pm) {
|
|
return Err("mihomo 未运行，无法开启系统代理".into());
|
|
}
|
|
let settings = state.load_settings();
|
|
let addr = format!("127.0.0.1:{}", settings.mixed_port);
|
|
set_system_proxy_windows(&addr)?;
|
|
let mut settings = settings;
|
|
settings.system_proxy = true;
|
|
state.save_settings(&settings)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_clear_system_proxy(
|
|
state: State<'_, MihomoManager>,
|
|
) -> Result<(), String> {
|
|
clear_system_proxy_windows()?;
|
|
let mut settings = state.load_settings();
|
|
settings.system_proxy = false;
|
|
state.save_settings(&settings)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn proxy_get_system_proxy() -> bool {
|
|
get_system_proxy_windows()
|
|
}
|