workspace-groups-remote/vendor/dsh-remote-ssh/tests/cancel.test.mjs

537 lines
27 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* 协作式取消(issue #35)—— 本插件 2.4.43。
*
* 背景:DSH 的取消是**协作式**的(`exec.signal` 必填、注册表不与工具 promise 竞速、
* 工具必须在自有工作停稳后才完成)。2.4.42 及以前本插件全文件 `exec.signal` 出现 0 次:
* 「停止键」只会把 turn 标记为取消,实际仍要等远端命令自己结束;`timeoutMs: 0` 时没有
* 上限,而唯一的手动兜底 `remote_ssh_kill` 本身是一次工具调用 —— 同一 turn 卡住时按不到。
*
* 覆盖:
* A. withTimeout:取消/超时/正常/ms=0 四种形态 + 监听器必须摘掉
* B. runPooled:预取消不建连、取消中丢弃会话、**取消绝不回退重跑**、超时仍不回退、
* 真失败仍回退、signal 透传给一次性连接
* C. runTarPipe(sync/push 的 tar 管道):取消时两端 terminate 并返回 isAbort
* D. signalRunner / toolContext 的信号透传
* E. 源码接线:13 个工具里 11 个走 SSH 的都接了信号;顺序不变量(abort 分支在回退之前)
* M. 变异负向控制:删掉 abort 分支 / 删掉工具接线 → 断言必须变红
*/
import { readFileSync } from 'node:fs'
import { fileURLToPath } from 'node:url'
const root = fileURLToPath(new URL('..', import.meta.url))
const src = readFileSync(root + '/lib/index.js', 'utf8')
let pass = 0, fail = 0
const check = (cond, label) => { if (cond) { pass++; console.log(' ✓ ' + label) } else { fail++; console.log(' ✗ FAIL: ' + label) } }
const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
function grab(text, name) {
const start = text.indexOf(name)
if (start < 0) throw new Error(name + ' not found')
const declStart = text.lastIndexOf('\n', start)
let i = text.indexOf('{', start)
let depth = 0
for (; i < text.length; i++) {
if (text[i] === '{') depth++
else if (text[i] === '}') { depth--; if (depth === 0) break }
}
return text.slice(declStart + 1, i + 1)
}
// ---------------------------------------------------------------- A. withTimeout
{
const code = [grab(src, 'function abortError'), grab(src, 'function withTimeout')].join('\n')
const { withTimeout, abortError } = new Function(code + '\nreturn { withTimeout, abortError };')()
console.log('A. withTimeout(取消 / 超时 / 正常)')
// A1 无 signal、ms<=0 → 原样返回(既有语义不能被取消功能改掉)
const p0 = Promise.resolve('x')
check(withTimeout(p0, 0, 't') === p0, 'A1 ms=0 且无 signal → 原样返回同一 promise')
// A2 正常完成 → 值透传 + 监听器摘干净
{
const ac = new AbortController()
let added = 0, removed = 0
const origAdd = ac.signal.addEventListener.bind(ac.signal)
const origRemove = ac.signal.removeEventListener.bind(ac.signal)
ac.signal.addEventListener = function (t, f, o) { if (t === 'abort') added++; return origAdd(t, f, o) }
ac.signal.removeEventListener = function (t, f, o) { if (t === 'abort') removed++; return origRemove(t, f, o) }
const v = await withTimeout(Promise.resolve('ok'), 1000, 't2', null, ac.signal)
check(v === 'ok', 'A2 正常 promise 原样透传')
check(added === 1 && removed === 1, 'A3 signal 监听器 settle 后摘掉(added=' + added + ' removed=' + removed + ')')
}
// A4 已取消 → 立即 reject isAbort,且 onTimeout 被调用(丢弃会话)
{
const ac = new AbortController()
ac.abort()
let cleaned = 0
let err = null
try { await withTimeout(new Promise(() => {}), 1000, '已取消', () => { cleaned++ }, ac.signal) } catch (e) { err = e }
check(!!err && err.isAbort === true, 'A4 预取消 → isAbort(不等远端)')
check(/已取消/.test(err.message) && cleaned === 1, 'A5 预取消也调用 onTimeout(丢弃会话)一次')
}
// A6 挂起中取消 → 立刻 reject isAbort(不等 ms 到点),onTimeout 被调用
{
const ac = new AbortController()
let cleaned = 0
const t0 = Date.now()
const prom = withTimeout(new Promise(() => {}), 60000, '挂起命令', () => { cleaned++ }, ac.signal)
setTimeout(() => ac.abort(), 30)
let err = null
try { await prom } catch (e) { err = e }
const dt = Date.now() - t0
check(!!err && err.isAbort === true, 'A6 挂起中取消 → isAbort')
check(dt < 1000, 'A7 不等 60s 超时,' + dt + 'ms 返回')
check(cleaned === 1, 'A8 onTimeout(丢弃会话)被调用')
check(err && err.isTimeout !== true, 'A9 取消不会被误标成超时')
}
// A10 取消后 ms 到点不应再产生第二个 reject(监听器/定时器都摘掉了)
{
const ac = new AbortController()
const prom = withTimeout(new Promise(() => {}), 80, 't3', null, ac.signal)
setTimeout(() => ac.abort(), 10)
let err = null
try { await prom } catch (e) { err = e }
await sleep(150)
check(!!err && err.isAbort === true, 'A10 取消优先于超时(先取消 → isAbort)')
}
// A11 超时语义不变
{
let err = null
try { await withTimeout(new Promise(() => {}), 40, '超时命令', null) } catch (e) { err = e }
check(!!err && err.isTimeout === true && !err.isAbort, 'A11 超时仍带 isTimeout(且不是 isAbort)')
}
// A12 abortError 形态
{
const e = abortError('池化命令')
check(e.isAbort === true && /池化命令/.test(e.message), 'A12 abortError 带 isAbort 与标签')
}
}
// ---------------------------------------------------------------- B. runPooled
{
console.log('B. runPooled(取消 / 超时 / 回退不变量)')
const code = [
grab(src, 'function abortError'),
grab(src, 'function withTimeout'),
grab(src, 'async function runPooled'),
grab(src, 'function settleWithin')
].join('\n')
function makeHarness(opts) {
const rec = { calls: [], sessions: new Map(), closed: 0, created: 0, runRemote: [], hups: [] }
const o = opts || {}
const factory = new Function('resolveTimeoutMs', 'sessions', 'getSession', 'sessionKeyOf', 'sshErrorHint', 'subprocess', 'runRemote', 'hupRemoteGroup',
code + '\nreturn { runPooled };')
const { runPooled } = factory(
(ms) => (ms === 0 ? 0 : (ms > 0 ? ms : 120000)),
rec.sessions,
(p, role) => {
rec.created++
const s = {
remotePid: o.pgid || 0,
close() { rec.closed++; if (o.onClose) o.onClose() },
exec(cmd, stdin, split) { rec.calls.push({ cmd, split }); return o.exec(cmd, stdin, split) }
}
rec.session = s
// 与真实现一致:getSession 会把会话登记进 sessions(runPooled 的 dropSession 靠它找)
rec.sessions.set('key:' + (role || ''), s)
return s
},
(p, role) => 'key:' + (role || ''),
(t) => 'hint:' + t,
{ spawn: () => { throw new Error('不应真的 spawn') } },
async function (subprocess, p, cmd, stdinData, maxBytes, extraOpts, timeoutMs, signal) {
rec.runRemote.push({ cmd, timeoutMs, signal })
return { ok: true, exitCode: 0, stdout: 'oneshot', stderr: '', truncated: false, error: '' }
},
async function (p, pgid) {
rec.hups.push({ p, pgid })
if (o.hup) return o.hup(p, pgid)
return true
}
)
return { runPooled, rec }
}
// B1 正常成功
{
const h = makeHarness({ exec: async () => ({ exitCode: 0, stdout: 'ok', stderr: '' }) })
const r = await h.runPooled({ id: 'p1' }, 'echo ok', undefined, undefined, true, undefined)
check(r.ok === true && r.stdout === 'ok', 'B1 正常成功路径不变')
check(h.rec.runRemote.length === 0, 'B2 成功时不走一次性连接')
}
// B3 预取消:不建连、不发命令
{
const ac = new AbortController()
ac.abort()
const h = makeHarness({ exec: async () => ({ exitCode: 0, stdout: 'should-not-run' }) })
const r = await h.runPooled({ id: 'p1' }, 'sleep 600', undefined, undefined, true, 0, undefined, ac.signal)
check(r.ok === false && r.isAbort === true, 'B3 预取消 → isAbort')
check(h.rec.created === 0, 'B4 预取消不建连(getSession 未被调用)')
check(h.rec.calls.length === 0, 'B5 预取消不发命令')
check(h.rec.runRemote.length === 0, 'B6 预取消不回退到一次性连接')
}
// B7 取消中:丢弃会话 + 不回退重跑(issue #35 的关键不变量)
{
const ac = new AbortController()
const h = makeHarness({
exec: () => new Promise((resolve) => { h.pendingResolve = resolve }),
onClose: () => { /* 真实会话 close 会杀掉 ssh,exec 随之 settle */ }
})
const t0 = Date.now()
const p = h.runPooled({ id: 'p1' }, 'sleep 600', undefined, undefined, true, 0, undefined, ac.signal)
setTimeout(() => ac.abort(), 30)
setTimeout(() => { if (h.pendingResolve) h.pendingResolve({ exitCode: 255, stdout: '', stderr: '' }) }, 60)
const r = await p
const dt = Date.now() - t0
check(r.ok === false && r.isAbort === true, 'B7 取消中 → isAbort')
check(dt < 1500, 'B8 timeoutMs=0 也能被取消(' + dt + 'ms 返回,不再无上限等待)')
check(h.rec.closed >= 1, 'B9 取消丢弃该池化会话(close 被调用)')
check(h.rec.runRemote.length === 0, 'B10 **取消绝不回退重跑**(runRemote 未被调用)')
}
// B11 超时:仍是 isTimeout 且不回退(issue #5 的既有不变量)
{
const h = makeHarness({ exec: () => new Promise(() => {}) })
const r = await h.runPooled({ id: 'p1' }, 'sleep 600', undefined, undefined, true, 30)
check(r.ok === false && r.isTimeout === true, 'B11 超时 → isTimeout')
check(h.rec.closed >= 1, 'B12 超时丢弃会话')
check(h.rec.runRemote.length === 0, 'B13 超时仍然不回退(issue #5)')
}
// B14 真失败(会话异常)→ 仍回退一次性连接,且信号透传
{
const ac = new AbortController()
const h = makeHarness({ exec: async () => { throw new Error('channel broken') } })
const r = await h.runPooled({ id: 'p1' }, 'echo ok', undefined, undefined, true, undefined, undefined, ac.signal)
check(r.ok === true && r.stdout === 'oneshot', 'B14 会话异常仍回退一次性连接(自动重连)')
check(h.rec.runRemote.length === 1, 'B15 回退只发生一次')
check(h.rec.runRemote[0].signal === ac.signal, 'B16 回退调用也带上 signal(取消能穿透到一次性连接)')
}
// B17 取消后底层 promise 迟到的 reject/resolve 不产生 unhandledRejection
{
const ac = new AbortController()
const h = makeHarness({ exec: () => new Promise((_, reject) => { h.pendingReject = reject }) })
const unhandled = []
const onUnhandled = (e) => unhandled.push(e)
process.on('unhandledRejection', onUnhandled)
const p = h.runPooled({ id: 'p1' }, 'sleep 600', undefined, undefined, true, 0, undefined, ac.signal)
setTimeout(() => ac.abort(), 20)
setTimeout(() => { if (h.pendingReject) h.pendingReject(new Error('late')) }, 40)
const r = await p
await sleep(120)
process.off('unhandledRejection', onUnhandled)
check(r.isAbort === true, 'B17 取消返回 isAbort')
check(unhandled.length === 0, 'B18 被放弃的 exec promise 没有 unhandledRejection')
}
// B19 取消 → 给远端进程组发 HUP(issue #35 复测建议:只断本地 ssh,远端命令会继续跑完)
{
const ac = new AbortController()
const h = makeHarness({
pgid: 4242,
exec: () => new Promise((resolve) => { h.pendingResolve = resolve }),
onClose: () => { if (h.pendingResolve) h.pendingResolve({ exitCode: 255, stdout: '', stderr: '' }) }
})
const p = h.runPooled({ id: 'p1' }, 'sleep 45', undefined, undefined, true, 0, undefined, ac.signal)
setTimeout(() => ac.abort(), 30)
const r = await p
check(r.isAbort === true, 'B19 取消仍返回 isAbort')
check(h.rec.hups.length === 1 && h.rec.hups[0].pgid === 4242, 'B20 取消时用会话记录的 PGID 发 HUP(实际 ' + JSON.stringify(h.rec.hups) + ')')
check(h.rec.hups[0].p && h.rec.hups[0].p.id === 'p1', 'B21 HUP 用的是该连接的 profile')
}
// B22 老会话 / 非 bash 远端:PGID 未知(0)→ 传 0 给收尾助手(由 hupRemoteGroup 自身短路,不发 SSH)
{
const ac = new AbortController()
const h = makeHarness({
exec: () => new Promise((resolve) => { h.pendingResolve = resolve }),
onClose: () => { if (h.pendingResolve) h.pendingResolve({ exitCode: 255, stdout: '', stderr: '' }) }
})
const p = h.runPooled({ id: 'p1' }, 'sleep 45', undefined, undefined, true, 0, undefined, ac.signal)
setTimeout(() => ac.abort(), 30)
const r = await p
check(r.isAbort === true && h.rec.hups.length === 1 && h.rec.hups[0].pgid === 0, 'B22 PGID 未知时传 0(收尾助手短路,不发 SSH)')
}
// B23 超时**不**杀远端:文档语义是「取消 = 终止;超时 = 仅放弃等待」
{
const h = makeHarness({ pgid: 4242, exec: () => new Promise(() => {}) })
const r = await h.runPooled({ id: 'p1' }, 'sleep 45', undefined, undefined, true, 30)
check(r.isTimeout === true, 'B23 超时仍是 isTimeout')
check(h.rec.hups.length === 0, 'B24 超时不发 HUP(远端命令可能继续运行,文档已写明)')
}
// B25 HUP 很慢也不拖住取消返回(内部有独立短超时,且与停稳并行)
{
const ac = new AbortController()
const h = makeHarness({
pgid: 4242,
exec: () => new Promise((resolve) => { h.pendingResolve = resolve }),
onClose: () => { if (h.pendingResolve) h.pendingResolve({ exitCode: 255, stdout: '', stderr: '' }) },
hup: async () => { await sleep(400); return true }
})
const t0 = Date.now()
const p = h.runPooled({ id: 'p1' }, 'sleep 45', undefined, undefined, true, 0, undefined, ac.signal)
setTimeout(() => ac.abort(), 30)
const r = await p
const dt = Date.now() - t0
check(r.isAbort === true, 'B25 HUP 慢时取消仍返回 isAbort')
check(dt < 1500, 'B26 HUP 与本地停稳并行,取消返回不被拖长(' + dt + 'ms)')
}
}
// ---------------------------------------------------------------- C. runTarPipe
{
console.log('C. runTarPipe(sync / push 的 tar 管道)')
const code = grab(src, 'async function runTarPipe')
const factory = new Function('armPipeTimeout', 'resolveSyncTimeoutMs', 'readCollected', 'syncErrText',
code + '\nreturn { runTarPipe };')
const makePipe = (budgetMs) => {
const rec = { terminated: 0 }
const armPipeTimeout = (handles, ms) => {
const state = { timedOut: false }
if (!(ms > 0)) return { state, clear() {} }
const t = setTimeout(() => { state.timedOut = true; handles.forEach((h) => { try { h.terminate() } catch (e) {} }) }, ms)
return { state, clear() { clearTimeout(t) } }
}
const { runTarPipe } = factory(armPipeTimeout, (ms) => (ms > 0 ? ms : 7200000), () => '', (e) => String(e))
const mk = () => {
let resolveDone
const done = new Promise((r) => { resolveDone = r })
return {
stdout: null, stdin: null, done,
terminate() { rec.terminated++; resolveDone({ exitCode: -1, signal: 'TERM' }) },
settle(code2) { resolveDone({ exitCode: code2 === undefined ? 0 : code2, signal: '' }) }
}
}
const a = mk(), b = mk()
return { runTarPipe, a, b, rec, budgetMs }
}
// C1 正常
{
const { runTarPipe, a, b } = makePipe(5000)
a.settle(0); b.settle(0)
const r = await runTarPipe(a, b, 5000, { label: '同步', a: 'ssh', b: 'tar' })
check(r.ok === true, 'C1 两端 exit 0 → ok')
}
// C2 预取消:两端 terminate,返回 isAbort
{
const { runTarPipe, a, b, rec } = makePipe(5000)
const ac = new AbortController()
ac.abort()
const r = await runTarPipe(a, b, 5000, { label: '推送', a: 'tar', b: 'ssh' }, ac.signal)
check(r.ok === false && r.isAbort === true, 'C2 预取消 → isAbort')
check(rec.terminated === 2, 'C3 预取消两端都 terminate(' + rec.terminated + '/2)')
}
// C4 传输中取消:立刻返回、两端 terminate、不误标超时
{
const { runTarPipe, a, b, rec } = makePipe(0)
const ac = new AbortController()
const t0 = Date.now()
const p = runTarPipe(a, b, 0, { label: '同步', a: 'ssh', b: 'tar' }, ac.signal)
setTimeout(() => ac.abort(), 25)
const r = await p
const dt = Date.now() - t0
check(r.ok === false && r.isAbort === true, 'C4 传输中取消 → isAbort')
check(rec.terminated === 2, 'C5 传输中取消两端 terminate')
check(dt < 1500, 'C6 取消后不用等默认墙钟预算(' + dt + 'ms)')
check(/已取消/.test(r.error), 'C7 错误文案说明是取消')
}
// C8 非取消失败路径的文案不变
{
const { runTarPipe, a, b } = makePipe(5000)
a.settle(2); b.settle(0)
const r = await runTarPipe(a, b, 5000, { label: '同步', a: 'ssh', b: 'tar' })
check(r.ok === false && r.isAbort !== true && /同步失败/.test(r.error), 'C8 真实失败仍是「同步失败」(不被当成取消)')
}
}
// ---------------------------------------------------------------- D. 信号透传
{
console.log('D. signalRunner / toolContext')
const runnerCode = grab(src, 'function signalRunner')
const f = new Function('runPooled', runnerCode + '\nreturn signalRunner;')(function () { return Array.prototype.slice.call(arguments) })
const ac = new AbortController()
const runner = f(ac.signal)
const args = runner({ id: 'p' }, 'cmd', 'stdin', 1024, true, 5000, 'git')
check(args.length === 8, 'D1 signalRunner 把 8 个参数原样转发给 runPooled')
check(args[7] === ac.signal, 'D2 第 8 参就是 exec.signal')
check(args[0].id === 'p' && args[1] === 'cmd' && args[4] === true && args[5] === 5000 && args[6] === 'git', 'D3 其余参数未被改写')
const tcBlock = grab(src, 'function toolContext')
check(/signal:\s*signal/.test(tcBlock) && /exec && exec\.signal/.test(tcBlock), 'D4 toolContext 把 exec.signal 带进工具上下文')
}
// ---------------------------------------------------------------- E. 源码接线
{
console.log('E. 源码接线(11 个走 SSH 的工具都要接信号)')
const SSH_TOOLS = ['remote_ssh_exec', 'remote_ssh_ls', 'remote_ssh_cat', 'remote_ssh_write', 'remote_ssh_grep',
'remote_ssh_glob', 'remote_ssh_mkdir', 'remote_ssh_delete', 'remote_ssh_move', 'remote_ssh_sync', 'remote_ssh_push']
const regions = {}
for (const name of SSH_TOOLS) {
const start = src.indexOf('name: "' + name + '"')
const next = src.indexOf('\n register({', start + 10)
regions[name] = start < 0 ? '' : src.slice(start, next < 0 ? src.length : next)
}
for (const name of SSH_TOOLS) {
check(/\bsignal\b/.test(regions[name]), 'E ' + name + ' 的 execute 引用了 signal')
}
const srUses = (src.match(/signalRunner\(/g) || []).length
check(srUses >= 6, 'E signalRunner 覆盖 runner 型 helper(' + srUses + ' 处:定义 1 + ls/cat/write/grep/glob/sync 各 1)')
check(/tc\.signal\)/.test(src) || /signalRunner\(tc\.signal\)/.test(src), 'E 工具侧通过 tc.signal 取信号')
// 顺序不变量:runPooled 里 isAbort 判断必须在「一次性连接回退」之前
const rp = grab(src, 'async function runPooled')
check(rp.indexOf('isAbort') > 0 && rp.indexOf('isTimeout') > 0, 'E runPooled 同时区分 isAbort 与 isTimeout')
check(rp.indexOf('e.isAbort') < rp.indexOf('runRemote(subprocess'), 'E runPooled 的 abort 分支在 runRemote 回退之前(否则会重跑取消掉的命令)')
check(rp.indexOf('signal && signal.aborted') > 0, 'E runPooled 入口先判预取消(不建连)')
// runRemote:abort 分支 + terminate 后停稳
const rr = grab(src, 'async function runRemote')
check(/signal\)/.test(rr.split('\n')[0]), 'E runRemote 签名带 signal')
check(rr.indexOf('e.isAbort') > 0, 'E runRemote 有 abort 分支')
check(rr.indexOf('handle.terminate()') < rr.indexOf('e.isAbort'), 'E runRemote 先 terminate 再返回 abort')
// withTimeout:监听器摘除
const wt = grab(src, 'function withTimeout')
check(wt.indexOf('removeEventListener') > 0, 'E withTimeout 摘掉 abort 监听器(否则泄漏并误触发)')
// sync / push 的 tar 管道透传
check(/runTarPipe\(sshH, tarH, o\.timeoutMs, \{ label: "同步", a: "ssh", b: "tar" \}, signal\)/.test(src), 'E 同步的 tar 管道透传 signal')
check(/runTarPipe\(tarH, sshH, o\.timeoutMs, \{ label: "推送", a: "tar", b: "ssh" \}, signal\)/.test(src), 'E 推送的 tar 管道透传 signal')
check(/remoteSyncDown\(subprocess, signalRunner\(sig\)/.test(src) && /remoteSyncUp\(subprocess, p, ws\.remotePath, ws\.mirrorPath, syncOptsFrom\(ws, args\), sig\)/.test(src),
'E sync / push 工具把 signal 交给底下两层')
// 13 个工具:profiles / kill 不需要信号(一个读设置、一个关会话)
const allTools = [...src.matchAll(/name: "(remote_ssh_[a-z_]+)"/g)].map((m) => m[1])
check(allTools.length === 13, 'E 工具总数仍是 13(' + allTools.length + ')')
check(allTools.filter((t) => SSH_TOOLS.indexOf(t) >= 0).length === 11, 'E 其中 11 个走 SSH')
// M. 变异负向控制:断言必须有牙
const mutated1 = src.replace(/if \(e && e\.isAbort\) \{[\s\S]*?return aborted\(\);\n \}/, '')
check(mutated1 !== src && !/e\.isAbort/.test(grab(mutated1, 'async function runPooled')), 'M1 变异:删掉 abort 分支后 runPooled 里不再有 isAbort(断言可检出这种回归)')
const mutated2 = src.replace('remoteListDir(signalRunner(tc.signal), tc.profile', 'remoteListDir(runPooled, tc.profile')
check(mutated2 !== src && !/remoteListDir\(signalRunner/.test(mutated2), 'M2 变异:把 ls 改回裸 runPooled 后接线断言会变红')
const mutated3 = src.replace('const r = await runPooled(tc.profile, cmd, args.stdin, undefined, true, args.timeoutMs, undefined, tc.signal);',
'const r = await runPooled(tc.profile, cmd, args.stdin, undefined, true, args.timeoutMs);')
check(mutated3 !== src, 'M3 变异:exec 掉信号的存在性可被检出')
}
// ---------------------------------------------------------------- F. runRemote(一次性连接)
{
console.log('F. runRemote(一次性连接也能被取消)')
const code = [grab(src, 'function abortError'), grab(src, 'function withTimeout'), grab(src, 'async function runRemote')].join('\n')
function makeRemote(opts) {
const rec = { terminated: 0, argv: null }
const o = opts || {}
const factory = new Function('subprocess', 'sshArgv', 'stripPqBanner', 'resolveTimeoutMs', 'MAX_BYTES', 'withTimeout',
code + '\nreturn { runRemote };')
const sub = {
spawn(cfg) {
rec.argv = cfg.argv
let resolveDone, rejectDone
const done = new Promise((res, rej) => { resolveDone = res; rejectDone = rej })
const handle = {
done,
collected: { stdout: { readFrom: () => ({ text: o.stdout || '', nextOffset: 0, lossy: false }) }, stderr: { readFrom: () => ({ text: o.stderr || '', nextOffset: 0, lossy: false }) } },
terminate() { rec.terminated++; if (o.settleOnTerminate) resolveDone({ exitCode: -1, signal: 'TERM' }) }
}
rec.handle = handle
setTimeout(() => { if (o.autoSettle) resolveDone({ exitCode: o.autoCode === undefined ? 0 : o.autoCode, signal: '' }) }, o.autoAfter || 10)
return handle
}
}
const { runRemote } = factory(
sub,
(profile, cmd) => ({ argv: ['ssh', cmd], env: {} }),
(t) => t,
(ms) => (ms === 0 ? 0 : (ms > 0 ? ms : 120000)),
1024 * 1024,
withTimeoutFromA
)
return { runRemote, rec, sub }
}
// 取 A 段已提取的真实 withTimeout(保持与生产同一份实现)
const { withTimeout: withTimeoutFromA } = new Function([grab(src, 'function abortError'), grab(src, 'function withTimeout')].join('\n') + '\nreturn { withTimeout };')()
// F1 正常完成
{
const { runRemote, sub } = makeRemote({ autoSettle: true, stdout: 'hello' })
const r = await runRemote(sub, { id: 'p' }, 'echo hello', undefined, undefined, undefined, 5000)
check(r.ok === true && r.stdout === 'hello', 'F1 正常路径不变(60s 前完成 → ok)')
}
// F2 取消:terminate 被调用、返回 isAbort、不误标超时
{
const ac = new AbortController()
const { runRemote, rec, sub } = makeRemote({ settleOnTerminate: true })
const t0 = Date.now()
const prom = runRemote(sub, { id: 'p' }, 'sleep 600', undefined, undefined, undefined, 0, ac.signal)
setTimeout(() => ac.abort(), 20)
const r = await prom
const dt = Date.now() - t0
check(r.ok === false && r.isAbort === true, 'F2 取消 → isAbort')
check(rec.terminated >= 1, 'F3 取消 terminate 子进程(不留孤儿 ssh)')
check(dt < 1500, 'F4 timeoutMs=0 也能取消(' + dt + 'ms)')
check(r.isTimeout !== true, 'F5 取消不被误标成超时')
}
// F6 预取消:立即返回、不 spawn
{
const ac = new AbortController()
ac.abort()
const { runRemote, rec, sub } = makeRemote({ settleOnTerminate: true })
const r = await runRemote(sub, { id: 'p' }, 'sleep 600', undefined, undefined, undefined, 0, ac.signal)
check(r.isAbort === true, 'F6 预取消 → isAbort')
check(!rec.handle || rec.terminated >= 1, 'F7 预取消时子进程被 terminate(spawn 已发生也不会残留)')
}
// F8 超时仍是 isTimeout
{
const { runRemote, rec, sub } = makeRemote({ settleOnTerminate: true })
const r = await runRemote(sub, { id: 'p' }, 'sleep 600', undefined, undefined, undefined, 40)
check(r.ok === false && r.isTimeout === true, 'F8 超时仍带 isTimeout')
check(rec.terminated >= 1, 'F9 超时也 terminate')
}
}
// ---------------------------------------------------------------- G. 输出净化(不能让宿主判 invalid output)
{
console.log('G. 取消结果必须匹配 output schema')
const strip = new Function([grab(src, 'function stripAbort'), 'return stripAbort;'][0] + '\nreturn stripAbort;')()
const r = strip({ ok: false, isAbort: true, error: '已取消' })
check(r.ok === false && r.error === '已取消' && !('isAbort' in r), 'G1 stripAbort 摘掉内部标记、保留 ok/error')
check(strip({ ok: true, bytes: 3 }).bytes === 3, 'G2 非取消结果原样返回')
// sync / push 的 output schema 是 additionalProperties:false,所以必须净化
check(/additionalProperties: false/.test(grab(src, 'const syncOutput = {')) || /additionalProperties: false/.test(src.slice(src.indexOf('const syncOutput'), src.indexOf('const syncOutput') + 900)),
'G3 syncOutput 是 additionalProperties:false(多一个字段就会被宿主拒)')
check((src.match(/return stripAbort\(/g) || []).length === 2, 'G4 sync 与 push 两个出口都净化了返回值')
check(/pipe\.isAbort \? \{ ok: false, isAbort: true, error: pipe\.error \}/.test(src),
'G5 runTarPipe 的取消会透到 sync/push 结果;普通失败不带 isAbort(否则 schema 校验会红)')
// exec 型工具走 normExec:它只挑 schema 里的字段
const norm = new Function([grab(src, 'function normExec'), 'return normExec;'].join('\n') + '\nreturn normExec;')()
const out = norm({ ok: false, isAbort: true, error: '已取消', exitCode: -1, stdout: '', stderr: '', truncated: false })
check(!('isAbort' in out), 'G6 normExec 不把 isAbort 漏给宿主')
check(out.isTimeout === false && out.exitCode === -1 && out.error === '已取消', 'G7 normExec 仍保留 schema 必填字段')
}
console.log('\n结果: ' + pass + ' 通过, ' + fail + ' 失败')
process.exit(fail === 0 ? 0 : 1)