Skip to content

DeepSeek Harness Tauri 桌面版 | Only 8mb installer, zero environment setup, preset plugins, Windows / macOS / Linux.

10.8 KB
Raw Blame
//! 取消正在进行的预装插件安装。
//!
//! 跨平台结束由本应用拉起的 `dsh plugin` 安装进程树:
//! - Unix(macOS/Linux):进程以独立进程组启动(`process_group(0)`,见
//!   `process.rs`),此处对注册的 PID 强制结束整组(含 pnpm / git 等子进程);
//! - Windows:对创建时记录的精确 PID 执行 `taskkill /T /F`,不再按命令行模糊
//!   枚举,避免误杀其它插件操作或用户进程。

use serde::Serialize;
use tauri::{AppHandle, Emitter, Manager};

use super::process::{ActivePluginProcess, ProcessOwner};

/// 前端监听“安装已取消”事件名
const PREINSTALL_CANCEL_EVENT: &str = "preinstall-cancelled";

/// 取消事件载荷(预留扩展字段)
#[derive(Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PreinstallCancelPayload {}

/// 强制结束当前插件安装进程树。返回是否找到并成功结束了活动进程。
pub(crate) async fn terminate_active_install() -> bool {
    let active = super::process::active_plugin_processes();
    if active.is_empty() {
        log::debug!("plugin install cancel: no active install process");
        return false;
    }
    tauri::async_runtime::spawn_blocking(move || terminate_pid_trees(active))
        .await
        .unwrap_or_else(|e| {
            log::warn!("plugin install cancel task failed: {e}");
            false
        })
}

/// 退出前同步回收所有进行中的插件安装进程树(`RunEvent::Exit` 调用)。
///
/// 安装子进程以独立进程组启动(`process_group(0)`),父进程退出**不会**连带结束
/// 它们;而取消只由前端命令(`cancel_plugin_processes` / `cancel_internal_plugins`)
/// 触发。用户在安装看起来毫无进展时关窗,留下的孤儿会继续占着档案与 pnpm store,
/// 下一次启动的安装便排在它后面——表现为永久卡在「Loading internal plugins…」且
/// 后端日志一行输出都没有。回收必须在退出路径上显式做。
pub(crate) fn terminate_active_installs_blocking() -> bool {
    let active = super::process::active_plugin_processes();
    if active.is_empty() {
        return false;
    }
    log::warn!(
        "plugin install cancel: reaping {} in-flight install process(es) before exit",
        active.len()
    );
    terminate_pid_trees(active)
}

/// 逐个结束进程树;单个失败不影响其余,返回是否全部成功。
fn terminate_pid_trees(active: Vec<(ProcessOwner, ActivePluginProcess)>) -> bool {
    let mut all_terminated = true;
    for (owner, process) in active {
        let terminate = if process.child.is_some() {
            terminate_probe_tree
        } else {
            terminate_pid_tree
        };
        all_terminated &= terminate_registered_process(owner, &process, terminate);
    }
    all_terminated
}

pub(crate) fn terminate_registered_process(
    owner: ProcessOwner,
    process: &ActivePluginProcess,
    terminate: impl FnOnce(u32) -> bool,
) -> bool {
    let Some(child) = &process.child else {
        return terminate(process.pid);
    };
    let mut child = child.lock().unwrap_or_else(|error| error.into_inner());
    let terminated = match child.try_wait() {
        Ok(Some(_)) => return true,
        Ok(None) => {
            let tree_killed = terminate(process.pid);
            let _ = child.kill();
            tree_killed
        }
        Err(error) => {
            log::warn!(
                "registered plugin process wait failed for pid {}: {error}",
                process.pid
            );
            false
        }
    };
    if !terminated {
        super::process::mark_process_cleanup_failed(
            owner,
            "PNPM_PROBE_TREE_CLEANUP_FAILED: pnpm version probe process tree termination was not confirmed".to_string(),
        );
    }
    terminated
}

pub(crate) async fn terminate_owned_install(owner: ProcessOwner) -> bool {
    let Some(process) = super::process::active_plugin_process(owner) else {
        return false;
    };
    tauri::async_runtime::spawn_blocking(move || {
        let terminate = if process.child.is_some() {
            terminate_probe_tree
        } else {
            terminate_pid_tree
        };
        terminate_registered_process(owner, &process, terminate)
    })
    .await
    .unwrap_or_else(|e| {
        log::warn!("owned plugin install cancel task failed: {e}");
        false
    })
}

#[cfg(windows)]
pub(crate) fn terminate_pid_tree(pid: u32) -> bool {
    use std::os::windows::process::CommandExt;
    let mut command = std::process::Command::new("taskkill");
    command
        .args(["/PID", &pid.to_string(), "/T", "/F"])
        .creation_flags(0x08000000);
    let ok = command
        .status()
        .map(|status| status.success())
        .unwrap_or(false);
    log::warn!("plugin install cancel: taskkill pid {pid} success={ok}");
    ok
}

#[cfg(not(windows))]
pub(crate) fn terminate_pid_tree(pid: u32) -> bool {
    // `--` 防止负 PID 被解析为信号;KILL 保证忽略 TERM 的 pnpm/git 后代也退出。
    let group = std::process::Command::new("kill")
        .args(["-KILL", "--", &format!("-{pid}")])
        .status()
        .map(|status| status.success())
        .unwrap_or(false);
    let direct = group
        || std::process::Command::new("kill")
            .args(["-KILL", &pid.to_string()])
            .status()
            .map(|status| status.success())
            .unwrap_or(false);
    log::warn!("plugin install cancel: kill process group {pid} success={direct}");
    direct
}

#[cfg(windows)]
pub(crate) use terminate_pid_tree as terminate_probe_tree;

#[cfg(not(windows))]
pub(crate) fn terminate_probe_tree(pid: u32) -> bool {
    unsafe { libc::kill(-(pid as libc::pid_t), libc::SIGKILL) == 0 }
}

/// 取消正在进行的预装插件安装。
pub async fn cancel(app_handle: &AppHandle) {
    terminate_active_install().await;

    if let Some(window) = app_handle.get_webview_window("main") {
        let _ = window.emit(PREINSTALL_CANCEL_EVENT, PreinstallCancelPayload {});
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[cfg(windows)]
    fn spawn_hung_child() -> std::process::Child {
        use std::os::windows::process::CommandExt;
        let mut command = std::process::Command::new("cmd.exe");
        command
            .args(["/C", "ping -n 60 127.0.0.1 >NUL"])
            .creation_flags(0x08000000);
        command.spawn().unwrap()
    }

    #[cfg(unix)]
    fn spawn_hung_child() -> std::process::Child {
        use std::os::unix::process::CommandExt;
        let mut command = std::process::Command::new("sh");
        command.args(["-c", "sleep 60"]).process_group(0);
        command.spawn().unwrap()
    }

    #[tokio::test]
    async fn stale_probe_snapshot_never_kills_after_the_child_is_reaped() {
        use std::sync::{Arc, Mutex};

        let _test_guard = super::super::process::TEST_PROCESS_LOCK.lock().await;
        #[cfg(windows)]
        let child = {
            use std::os::windows::process::CommandExt;
            std::process::Command::new("cmd.exe")
                .creation_flags(0x08000000)
                .args(["/D", "/C", "exit 0"])
                .spawn()
                .unwrap()
        };
        #[cfg(unix)]
        let child = std::process::Command::new("sh")
            .args(["-c", "exit 0"])
            .spawn()
            .unwrap();
        let child = Arc::new(Mutex::new(child));
        let owner = super::super::process::new_process_owner();
        let guard = super::super::process::PidGuard::set_child(owner, &child);
        let snapshot = super::super::process::active_plugin_processes()
            .into_iter()
            .find(|(active_owner, _)| *active_owner == owner)
            .unwrap()
            .1;
        assert!(child.lock().unwrap().wait().unwrap().success());
        drop(guard);
        let mut killed = false;
        assert!(terminate_registered_process(owner, &snapshot, |_| {
            killed = true;
            true
        }));
        assert!(
            !killed,
            "a copied probe record must preserve the reaped child identity"
        );
        assert_eq!(super::super::process::active_plugin_pid(owner), None);
    }

    #[tokio::test]
    async fn failed_probe_cancel_keeps_tree_failure_after_root_exit() {
        use std::sync::{Arc, Mutex};

        let _test_guard = super::super::process::TEST_PROCESS_LOCK.lock().await;
        #[cfg(windows)]
        let mut command = {
            use std::os::windows::process::CommandExt;
            let mut command = std::process::Command::new("cmd.exe");
            command
                .creation_flags(0x08000000)
                .args(["/D", "/C", "set /p token="]);
            command
        };
        #[cfg(unix)]
        let mut command = {
            use std::os::unix::process::CommandExt;
            let mut command = std::process::Command::new("sh");
            command.args(["-c", "read -r token"]).process_group(0);
            command
        };
        let child = Arc::new(Mutex::new(
            command.stdin(std::process::Stdio::piped()).spawn().unwrap(),
        ));
        let owner = super::super::process::new_process_owner();
        let guard = super::super::process::PidGuard::set_child(owner, &child);
        let process = super::super::process::active_plugin_process(owner).unwrap();
        let terminated = terminate_registered_process(owner, &process, |_| false);
        {
            let mut child = child.lock().unwrap();
            let _ = child.kill();
            child.wait().unwrap();
        }
        let failure = super::super::process::acquire_process_lock().await;
        drop(guard);
        super::super::process::clear_process_cleanup_failed(owner);
        assert!(!terminated);
        assert!(
            matches!(failure, Err(reason) if reason.starts_with("PNPM_PROBE_TREE_CLEANUP_FAILED:"))
        );
    }

    #[tokio::test]
    async fn forced_cancel_kills_hung_child_and_releases_pid_slot() {
        let _test_guard = super::super::process::TEST_PROCESS_LOCK.lock().await;
        let mut child = spawn_hung_child();
        let pid = child.id();
        let owner = super::super::process::new_process_owner();
        let guard = super::super::process::PidGuard::set(owner, pid);

        assert_eq!(super::super::process::active_plugin_pid(owner), Some(pid));
        assert!(terminate_owned_install(owner).await);

        let exited = tokio::time::timeout(std::time::Duration::from_secs(5), async {
            loop {
                if child.try_wait().unwrap().is_some() {
                    break;
                }
                tokio::time::sleep(std::time::Duration::from_millis(25)).await;
            }
        })
        .await;
        assert!(exited.is_ok(), "hung plugin child should be force-killed");

        drop(guard);
        assert_eq!(super::super::process::active_plugin_pid(owner), None);
    }
}