mirror of
https://gitcode.com/JianFeeeee/HomeAgent.git
synced 2026-10-15 12:15:16 +00:00
ceb8a7b165
内核侧配合 SDK 仓 b2872f3：兼容性不再依赖任何自造版本号。
删除三处自造号：
- ProtocolVersion（协议号）→ 改为比对主版本段（MajorVersion）
- shmVersion（共享段 header）→ 改为校验描述符个数（field_count）
- unifiedVersion（SuperBlock）→ 结构自描述，不再校验
握手契约随之调整：
HandshakeParams: protocol(int) → core_version(string)
HandshakeResult: protocol(int) → sdk_version 承担判据
内核比对 MajorVersion(meta.Version) == MajorVersion(res.SDKVersion)，
跨主版本即拒并提示重编（主版本跃迁 = 破坏性变更的定义）。
为什么废除：额外的号需要人去记得升，而它没有任何结构性约束兜底，
必然腐烂。实证：ProtocolVersion 常量在多次布局变更里只升过一次，
对应的守卫测试长期失败无人察觉（期望 18/1，实际 19/2）。
新增判据：
- TestProcess_MajorVersionMismatchRejected：跨主版本被拒（testdata/badproto）
- TestProcess_SameMajorDifferentMinorAccepted：同主版本放行（新增 testdata/oldminor）
后者是 §七「1.x 内纯追加、不调新面不用重编」规约的落地 —— 若误用全等
比较，未重编的存量插件会被无谓地全部拒绝。
两条均经变异验证：改成全等比较 → 前者过/后者挂；删掉校验 → 前者挂。
505 lines
15 KiB
Go
505 lines
15 KiB
Go
package proc
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"os"
|
||
"os/exec"
|
||
"path/filepath"
|
||
"strings"
|
||
"sync"
|
||
"testing"
|
||
"time"
|
||
)
|
||
|
||
// Process 的测试用真实子进程（go build 出的小二进制），而非 mock：
|
||
// 崩溃隔离、EOF 感知、Kill 回收这些性质只有真进程才能验证——
|
||
// 它们恰是迁移相对 C ABI 的核心收益（§9.5）。
|
||
|
||
// buildTestPlugin 编译 testdata 下的假插件，返回二进制路径。
|
||
func buildTestPlugin(t *testing.T, srcName string) string {
|
||
t.Helper()
|
||
if _, err := exec.LookPath("go"); err != nil {
|
||
t.Skip("环境无 go 工具链，跳过子进程测试")
|
||
}
|
||
|
||
src := filepath.Join("testdata", srcName)
|
||
if _, err := os.Stat(src); err != nil {
|
||
t.Fatalf("测试插件源码缺失 %s: %v", src, err)
|
||
}
|
||
|
||
bin := filepath.Join(t.TempDir(), strings.TrimSuffix(srcName, ".go"))
|
||
cmd := exec.Command("go", "build", "-o", bin, src)
|
||
cmd.Env = append(os.Environ(), "CGO_ENABLED=0")
|
||
if out, err := cmd.CombinedOutput(); err != nil {
|
||
t.Fatalf("编译测试插件 %s 失败: %v\n%s", srcName, err, out)
|
||
}
|
||
return bin
|
||
}
|
||
|
||
// noopHandler 是最简的内核侧 handler（测试中不需要真实 core.* 能力）。
|
||
func noopHandler(method string, params json.RawMessage) (interface{}, error) {
|
||
return nil, fmt.Errorf("测试环境未实现 %s", method)
|
||
}
|
||
|
||
func TestProcess_SpawnHandshakeAndToolInvoke(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
|
||
p, err := Spawn("echo", bin, Options{Handler: noopHandler})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
defer p.Kill()
|
||
|
||
if p.PID() == 0 {
|
||
t.Error("PID 应非零")
|
||
}
|
||
|
||
raw, err := p.Call(MethodToolInvoke, ToolInvokeParams{
|
||
Name: "echo_tool",
|
||
Args: map[string]interface{}{"text": "你好"},
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("tool.invoke: %v", err)
|
||
}
|
||
var res ToolInvokeResult
|
||
if err := json.Unmarshal(raw, &res); err != nil {
|
||
t.Fatalf("解析应答: %v", err)
|
||
}
|
||
if res.Result != "你好" {
|
||
t.Fatalf("工具应回显 '你好'，实际 %v", res.Result)
|
||
}
|
||
}
|
||
|
||
// 插件返回错误时调用方必须收到 error —— 对比 C ABI 路径的 output_send
|
||
// 永远返回成功（§9.4，现网 2 次消息发不出而模型以为成功）。
|
||
func TestProcess_PluginErrorIsReported(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
p, err := Spawn("echo", bin, Options{Handler: noopHandler})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
defer p.Kill()
|
||
|
||
_, err = p.Call(MethodToolInvoke, ToolInvokeParams{Name: "fail_tool"})
|
||
if err == nil {
|
||
t.Fatal("插件返回错误时调用方应收到 error")
|
||
}
|
||
if !strings.Contains(err.Error(), "故意失败") {
|
||
t.Errorf("错误信息应透传插件的原因，实际: %v", err)
|
||
}
|
||
}
|
||
|
||
// 插件反向调用内核（51 个 core.* method 的机制验证）。
|
||
func TestProcess_PluginCallsBackIntoKernel(t *testing.T) {
|
||
bin := buildTestPlugin(t, "callbackplugin.go")
|
||
|
||
var (
|
||
mu sync.Mutex
|
||
gotCall []string
|
||
)
|
||
handler := func(method string, params json.RawMessage) (interface{}, error) {
|
||
mu.Lock()
|
||
gotCall = append(gotCall, method)
|
||
mu.Unlock()
|
||
switch method {
|
||
case MethodSettingsGet:
|
||
return map[string]interface{}{"value": "配置值"}, nil
|
||
case MethodToolRegister:
|
||
return nil, nil
|
||
}
|
||
return nil, fmt.Errorf("未实现 %s", method)
|
||
}
|
||
|
||
p, err := Spawn("cb", bin, Options{Handler: handler})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
defer p.Kill()
|
||
|
||
// plugin.start 期间插件会回调 tool.register + settings.get
|
||
if _, err := p.Call(MethodPluginStart, nil); err != nil {
|
||
t.Fatalf("plugin.start: %v", err)
|
||
}
|
||
|
||
mu.Lock()
|
||
defer mu.Unlock()
|
||
if len(gotCall) < 2 {
|
||
t.Fatalf("内核应收到插件的反向调用，实际 %v", gotCall)
|
||
}
|
||
hasRegister, hasSettings := false, false
|
||
for _, m := range gotCall {
|
||
if m == MethodToolRegister {
|
||
hasRegister = true
|
||
}
|
||
if m == MethodSettingsGet {
|
||
hasSettings = true
|
||
}
|
||
}
|
||
if !hasRegister || !hasSettings {
|
||
t.Errorf("应收到 tool.register 与 settings.get，实际 %v", gotCall)
|
||
}
|
||
}
|
||
|
||
// 崩溃隔离：插件 panic 只让子进程退出，内核存活并收到 onExit（§9.5 表格第 2 行）。
|
||
// C ABI 路径下 panic 跨 C 栈，recover 兜不住会带崩整个 homed（§1.4）。
|
||
func TestProcess_CrashIsolationAndExitDetection(t *testing.T) {
|
||
bin := buildTestPlugin(t, "crashplugin.go")
|
||
|
||
exitCh := make(chan error, 1)
|
||
p, err := Spawn("crash", bin, Options{
|
||
Handler: noopHandler,
|
||
OnExit: func(name string, err error) { exitCh <- err },
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
|
||
// 触发插件 panic
|
||
_, callErr := p.Call(MethodToolInvoke, ToolInvokeParams{Name: "boom"})
|
||
if callErr == nil {
|
||
t.Error("插件崩溃时在途调用应返回错误，而非挂死")
|
||
}
|
||
|
||
select {
|
||
case exitErr := <-exitCh:
|
||
if exitErr == nil {
|
||
t.Error("panic 退出应报告非 nil 错误（供 recordCrash 使用）")
|
||
}
|
||
case <-time.After(5 * time.Second):
|
||
t.Fatal("未在 5s 内检测到进程退出（EOF 感知失效）")
|
||
}
|
||
|
||
select {
|
||
case <-p.Exited():
|
||
case <-time.After(time.Second):
|
||
t.Error("Exited() 通道应已关闭")
|
||
}
|
||
|
||
// 进程已退出后继续调用应立即失败，不能挂死
|
||
if _, err := p.Call(MethodToolInvoke, ToolInvokeParams{Name: "echo_tool"}); !errors.Is(err, ErrProcessExited) {
|
||
t.Errorf("退出后调用应返回 ErrProcessExited，实际 %v", err)
|
||
}
|
||
}
|
||
|
||
// 优雅停止：plugin.stop 后进程自行退出。
|
||
func TestProcess_GracefulStop(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
p, err := Spawn("echo", bin, Options{Handler: noopHandler})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
|
||
if err := p.Stop(); err != nil {
|
||
t.Fatalf("Stop: %v", err)
|
||
}
|
||
select {
|
||
case <-p.Exited():
|
||
case <-time.After(3 * time.Second):
|
||
t.Fatal("Stop 后进程应退出")
|
||
}
|
||
if err := p.ExitError(); err != nil {
|
||
t.Errorf("优雅停止应无错误退出，实际 %v", err)
|
||
}
|
||
}
|
||
|
||
// **真正的取消**：卡死的插件可被 Kill 回收（§9.3 对照 cgo 超时线程永久泄漏）。
|
||
func TestProcess_KillHungPlugin(t *testing.T) {
|
||
bin := buildTestPlugin(t, "hangplugin.go")
|
||
p, err := Spawn("hang", bin, Options{Handler: noopHandler})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
|
||
// 调用会卡住，用 context 超时返回（调用方不被拖死）
|
||
ctx, cancel := context.WithTimeout(context.Background(), 300*time.Millisecond)
|
||
defer cancel()
|
||
_, err = p.CallContext(ctx, MethodToolInvoke, ToolInvokeParams{Name: "hang_tool"})
|
||
if err == nil {
|
||
t.Fatal("卡死的调用应因 ctx 超时返回")
|
||
}
|
||
if !errors.Is(err, context.DeadlineExceeded) {
|
||
t.Errorf("应为 DeadlineExceeded，实际 %v", err)
|
||
}
|
||
|
||
// pending 条目必须已清理（不泄漏）
|
||
p.mu.Lock()
|
||
pendingCount := len(p.pending)
|
||
p.mu.Unlock()
|
||
if pendingCount != 0 {
|
||
t.Errorf("超时后 pending 表应清空，实际残留 %d 条", pendingCount)
|
||
}
|
||
|
||
// Kill 真正回收资源
|
||
if err := p.Kill(); err != nil {
|
||
t.Fatalf("Kill: %v", err)
|
||
}
|
||
select {
|
||
case <-p.Exited():
|
||
case <-time.After(3 * time.Second):
|
||
t.Fatal("Kill 后进程应退出")
|
||
}
|
||
}
|
||
|
||
// 通知（ID=0）不等应答——事件投递路径必须 post-and-forget（§2.4 约束 B）。
|
||
func TestProcess_NotifyDoesNotWait(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
p, err := Spawn("echo", bin, Options{Handler: noopHandler})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
defer p.Kill()
|
||
|
||
start := time.Now()
|
||
for i := 0; i < 100; i++ {
|
||
if err := p.Notify("event.deliver", map[string]interface{}{"seq": i}); err != nil {
|
||
t.Fatalf("Notify: %v", err)
|
||
}
|
||
}
|
||
elapsed := time.Since(start)
|
||
// 100 条通知若每条都等应答，至少要 100 个往返；post-and-forget 应远快于此
|
||
if elapsed > time.Second {
|
||
t.Errorf("100 条通知耗时 %v，疑似在等应答（应 post-and-forget）", elapsed)
|
||
}
|
||
|
||
// 通知不占 pending 表
|
||
p.mu.Lock()
|
||
pendingCount := len(p.pending)
|
||
p.mu.Unlock()
|
||
if pendingCount != 0 {
|
||
t.Errorf("通知不应占用 pending 表，实际 %d 条", pendingCount)
|
||
}
|
||
}
|
||
|
||
// 并发调用：pending 表按 ID 正确路由，应答不串。
|
||
func TestProcess_ConcurrentCallsRouteCorrectly(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
p, err := Spawn("echo", bin, Options{Handler: noopHandler})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
defer p.Kill()
|
||
|
||
const n = 50
|
||
var wg sync.WaitGroup
|
||
errs := make(chan error, n)
|
||
for i := 0; i < n; i++ {
|
||
wg.Add(1)
|
||
go func(i int) {
|
||
defer wg.Done()
|
||
want := fmt.Sprintf("msg-%d", i)
|
||
raw, err := p.Call(MethodToolInvoke, ToolInvokeParams{
|
||
Name: "echo_tool",
|
||
Args: map[string]interface{}{"text": want},
|
||
})
|
||
if err != nil {
|
||
errs <- err
|
||
return
|
||
}
|
||
var res ToolInvokeResult
|
||
if err := json.Unmarshal(raw, &res); err != nil {
|
||
errs <- err
|
||
return
|
||
}
|
||
if res.Result != want {
|
||
errs <- fmt.Errorf("应答串了：期望 %q，实际 %v", want, res.Result)
|
||
}
|
||
}(i)
|
||
}
|
||
wg.Wait()
|
||
close(errs)
|
||
for err := range errs {
|
||
t.Errorf("并发调用失败: %v", err)
|
||
}
|
||
}
|
||
|
||
// 主版本不匹配必须显式拒绝，不能半兼容运行。
|
||
//
|
||
// 为什么需要显式拦下：主版本两端（如 C ABI 时代与子进程时代）的帧格式与
|
||
// 共享段布局都不同，错配不会报错、只会静默失效（空参数、字段被忽略）。
|
||
// 判据是双方版本号的**主版本段**，不是任何自定协议号。
|
||
func TestProcess_MajorVersionMismatchRejected(t *testing.T) {
|
||
bin := buildTestPlugin(t, "badprotoplugin.go")
|
||
_, err := Spawn("badproto", bin, Options{Handler: noopHandler})
|
||
if err == nil {
|
||
t.Fatal("主版本不匹配应拒绝建链")
|
||
}
|
||
if !strings.Contains(err.Error(), "主版本不匹配") {
|
||
t.Errorf("错误应说明主版本不匹配，实际: %v", err)
|
||
}
|
||
// 运维可读性：光报“不匹配”不能定位到行动。生产上碰到它的现场是
|
||
// “只更新了内核没重编插件”，所以错误里必须带出这条修复指令。
|
||
if !strings.Contains(err.Error(), "hmapdev") || !strings.Contains(err.Error(), "重编") {
|
||
t.Errorf("错误应给出重编插件的修复指令，实际: %v", err)
|
||
}
|
||
}
|
||
|
||
// 同主版本内的中版本差异（内核 1.4.0 vs 插件 SDK 1.1.0）必须**允许**建链。
|
||
//
|
||
// 这是 §七「1.x 内纯追加、不调新面就不用重编」规约的落地：若不校验主版本
|
||
// 而是全等比较，未重编的存量插件会被无谓地全部拒绝。
|
||
func TestProcess_SameMajorDifferentMinorAccepted(t *testing.T) {
|
||
bin := buildTestPlugin(t, "oldminorplugin.go")
|
||
p, err := Spawn("oldminor", bin, Options{Handler: noopHandler})
|
||
if err != nil {
|
||
t.Fatalf("同主版本（1.x）应允许建链: %v", err)
|
||
}
|
||
defer func() { _ = p.Stop() }()
|
||
}
|
||
|
||
func TestProcess_SpawnRequiresHandler(t *testing.T) {
|
||
if _, err := Spawn("x", "/bin/true", Options{}); err == nil {
|
||
t.Fatal("缺少 Handler 应报错（插件无法回调内核）")
|
||
}
|
||
}
|
||
|
||
// 插件死亡但孙子进程仍持有 stdout 写端时，内核必须仍能感知退出。
|
||
//
|
||
// 这是「EOF 不等于进程死亡」的回归测试。旧实现只在 readLoop 读到 EOF 后
|
||
// 才 markExited，而 exec.Command 起的孙子进程默认继承插件的 stdout：
|
||
// 插件本体退出后写端仍被孙子持有，EOF 永不到来，于是
|
||
// - 在途调用挂到自己的超时；
|
||
// - OnExit 不触发 → 崩溃计数、工具摘除、自动重启全都不发生；
|
||
// - 进程表里插件已是僵尸，注册表里却一切正常。
|
||
//
|
||
// 生产上 browser 拉 chromium、editdoc 拉 python 正是这个形状。
|
||
// 现在由专职 waitLoop 直接 wait4(2) 判定，不再依赖 fd 生命周期。
|
||
func TestProcess_ExitDetectedDespiteInheritedStdout(t *testing.T) {
|
||
if _, err := exec.LookPath("sleep"); err != nil {
|
||
t.Skip("环境无 sleep，跳过")
|
||
}
|
||
bin := buildTestPlugin(t, "forkplugin.go")
|
||
|
||
exitCh := make(chan error, 1)
|
||
p, err := Spawn("fork", bin, Options{
|
||
Handler: noopHandler,
|
||
OnExit: func(name string, err error) { exitCh <- err },
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
defer p.Kill()
|
||
|
||
// 让插件本体退出（孙子 sleep 300 仍活着，继续持有 stdout 写端）
|
||
if _, callErr := p.Call(MethodToolInvoke, ToolInvokeParams{Name: "die"}); callErr == nil {
|
||
t.Error("插件退出时在途调用应返回错误")
|
||
}
|
||
|
||
select {
|
||
case exitErr := <-exitCh:
|
||
if exitErr == nil {
|
||
t.Error("非零退出码应报告为错误（供崩溃计数使用）")
|
||
}
|
||
case <-time.After(5 * time.Second):
|
||
t.Fatal("孙子进程持有 stdout 时未能感知插件退出——退化回只靠 EOF 判定")
|
||
}
|
||
|
||
if _, err := p.Call(MethodToolInvoke, ToolInvokeParams{Name: "x"}); !errors.Is(err, ErrProcessExited) {
|
||
t.Errorf("退出后调用应返回 ErrProcessExited，实际 %v", err)
|
||
}
|
||
}
|
||
|
||
// Supervisor 台账：握手成功即在册，进程退出即注销。
|
||
func TestSupervisor_TrackAndUntrack(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
sup := NewSupervisor()
|
||
|
||
p, err := Spawn("echo", bin, Options{Handler: noopHandler, Supervisor: sup})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
if sup.Count() != 1 {
|
||
t.Fatalf("握手成功后应在册，实际 %d", sup.Count())
|
||
}
|
||
got, ok := sup.Get("echo")
|
||
if !ok || got.PID() != p.PID() {
|
||
t.Errorf("台账里的进程应是刚 spawn 的那个")
|
||
}
|
||
list := sup.List()
|
||
if len(list) != 1 || !list[0].Alive || list[0].PID != p.PID() {
|
||
t.Errorf("List 应报告存活与 PID，实际 %+v", list)
|
||
}
|
||
|
||
if err := p.Stop(); err != nil {
|
||
t.Fatalf("Stop: %v", err)
|
||
}
|
||
// 退出回调在 markExited 里注销，等它落地
|
||
deadline := time.Now().Add(3 * time.Second)
|
||
for sup.Count() != 0 && time.Now().Before(deadline) {
|
||
time.Sleep(10 * time.Millisecond)
|
||
}
|
||
if sup.Count() != 0 {
|
||
t.Errorf("进程退出后应注销，实际仍有 %d 个在册", sup.Count())
|
||
}
|
||
}
|
||
|
||
// StopAll 必须停掉全部在册子进程——内核关停时不留孤儿。
|
||
func TestSupervisor_StopAllLeavesNoSurvivor(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
sup := NewSupervisor()
|
||
|
||
var procs []*Process
|
||
for i := 0; i < 3; i++ {
|
||
p, err := Spawn(fmt.Sprintf("echo%d", i), bin, Options{Handler: noopHandler, Supervisor: sup})
|
||
if err != nil {
|
||
t.Fatalf("Spawn %d: %v", i, err)
|
||
}
|
||
procs = append(procs, p)
|
||
}
|
||
if sup.Count() != 3 {
|
||
t.Fatalf("应有 3 个在册，实际 %d", sup.Count())
|
||
}
|
||
|
||
sup.StopAll(5 * time.Second)
|
||
|
||
for _, p := range procs {
|
||
select {
|
||
case <-p.Exited():
|
||
case <-time.After(2 * time.Second):
|
||
t.Errorf("%s 未被 StopAll 停掉（会成为孤儿进程）", p.Name())
|
||
}
|
||
}
|
||
}
|
||
|
||
// 卡死插件（不响应 plugin.stop）必须在 StopAll 的预算内被强杀。
|
||
func TestSupervisor_StopAllKillsUnresponsive(t *testing.T) {
|
||
bin := buildTestPlugin(t, "hangplugin.go")
|
||
sup := NewSupervisor()
|
||
|
||
p, err := Spawn("hang", bin, Options{Handler: noopHandler, Supervisor: sup})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
|
||
// 预算给足以覆盖 stopGracePeriod，之后剩下的一律 Kill
|
||
sup.StopAll(500 * time.Millisecond)
|
||
|
||
select {
|
||
case <-p.Exited():
|
||
case <-time.After(10 * time.Second):
|
||
t.Error("不响应 plugin.stop 的插件应被强制结束，否则 homed 关停会被它拖住")
|
||
}
|
||
}
|
||
|
||
// 关停后完成握手的进程不得留存：立即被结束，不能活过内核。
|
||
func TestSupervisor_TrackAfterCloseKillsProcess(t *testing.T) {
|
||
bin := buildTestPlugin(t, "echoplugin.go")
|
||
sup := NewSupervisor()
|
||
sup.StopAll(time.Second) // 置 closed
|
||
|
||
p, err := Spawn("late", bin, Options{Handler: noopHandler, Supervisor: sup})
|
||
if err != nil {
|
||
t.Fatalf("Spawn: %v", err)
|
||
}
|
||
if sup.Count() != 0 {
|
||
t.Errorf("关停后不应再纳管新进程，实际在册 %d", sup.Count())
|
||
}
|
||
select {
|
||
case <-p.Exited():
|
||
case <-time.After(3 * time.Second):
|
||
t.Error("关停后冒出的进程应被立即结束")
|
||
}
|
||
}
|