355 lines
13 KiB
JavaScript
355 lines
13 KiB
JavaScript
// ============================================================
|
||
// Sidecar 本地冒烟（矩阵 99 · 本地可测部分）
|
||
// 覆盖：20 次冷启动 / 端口冲突 / 崩溃重启（父进程守护）/ 中文+空格路径
|
||
// 只读调用 server/sidecar.py（python -m server.sidecar），不改后端逻辑。
|
||
// 任一检查失败 → 非零退出码。
|
||
// 用法：node scripts/smoke-sidecar-local.mjs
|
||
// 可选：APS_SIDECAR_PYTHON=<python> 指定解释器（默认 .sidecar-venv → .venv → PATH）
|
||
// ============================================================
|
||
import { spawn, spawnSync } from 'node:child_process';
|
||
import crypto from 'node:crypto';
|
||
import fs from 'node:fs';
|
||
import net from 'node:net';
|
||
import os from 'node:os';
|
||
import path from 'node:path';
|
||
import { fileURLToPath } from 'node:url';
|
||
|
||
const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
||
const isWin = process.platform === 'win32';
|
||
const LOOPBACK_HOST = '127.0.0.1';
|
||
const NONCE_HEADER = 'x-aps-sidecar-nonce';
|
||
const HEALTH_URL = (port) => `http://${LOOPBACK_HOST}:${port}/api/health`;
|
||
|
||
const results = [];
|
||
const liveChildren = new Set();
|
||
|
||
// ---------------------------------------------------------------- helpers
|
||
|
||
function resolvePython() {
|
||
if (process.env.APS_SIDECAR_PYTHON) return process.env.APS_SIDECAR_PYTHON;
|
||
const candidates = [
|
||
path.join(repoRoot, '.sidecar-venv', 'Scripts', 'python.exe'),
|
||
path.join(repoRoot, '.venv', 'Scripts', 'python.exe'),
|
||
path.join(repoRoot, '.venv', 'bin', 'python3'),
|
||
];
|
||
for (const candidate of candidates) {
|
||
if (fs.existsSync(candidate)) return candidate;
|
||
}
|
||
return isWin ? 'python' : 'python3';
|
||
}
|
||
|
||
function reservePort() {
|
||
return new Promise((resolve, reject) => {
|
||
const server = net.createServer();
|
||
server.once('error', reject);
|
||
server.listen({ host: LOOPBACK_HOST, port: 0, exclusive: true }, () => {
|
||
const address = server.address();
|
||
const port = typeof address === 'object' && address ? address.port : 0;
|
||
server.close((error) => error ? reject(error) : resolve(port));
|
||
});
|
||
});
|
||
}
|
||
|
||
function delay(milliseconds) {
|
||
return new Promise((resolve) => setTimeout(resolve, milliseconds));
|
||
}
|
||
|
||
function nonce() {
|
||
return crypto.randomBytes(32).toString('hex');
|
||
}
|
||
|
||
function probeHealth(port, expectedNonce, timeoutMs = 2_000) {
|
||
return new Promise((resolve) => {
|
||
const controller = new AbortController();
|
||
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
||
fetch(HEALTH_URL(port), {
|
||
headers: { [NONCE_HEADER]: expectedNonce },
|
||
signal: controller.signal,
|
||
})
|
||
.then(async (response) => {
|
||
const echoed = response.headers.get(NONCE_HEADER);
|
||
clearTimeout(timer);
|
||
resolve(response.status === 200 && echoed === expectedNonce);
|
||
})
|
||
.catch(() => {
|
||
clearTimeout(timer);
|
||
resolve(false);
|
||
});
|
||
});
|
||
}
|
||
|
||
async function waitForHealth(port, expectedNonce, timeoutMs = 60_000, child = null) {
|
||
const deadline = Date.now() + timeoutMs;
|
||
let last = null;
|
||
while (Date.now() < deadline) {
|
||
if (child && child.exitCode !== null) {
|
||
throw new Error(`sidecar exited early code=${child.exitCode}: ${child.stderrTail ?? ''}`);
|
||
}
|
||
last = await probeHealth(port, expectedNonce);
|
||
if (last) return true;
|
||
await delay(250);
|
||
}
|
||
throw new Error(`sidecar did not become healthy within ${timeoutMs}ms (last=${last})`);
|
||
}
|
||
|
||
function stopProcessTree(child) {
|
||
if (!child || !Number.isInteger(child.pid) || child.pid <= 0) return;
|
||
liveChildren.delete(child);
|
||
if (isWin) {
|
||
spawnSync('taskkill.exe', ['/pid', String(child.pid), '/T', '/F'], {
|
||
stdio: 'ignore',
|
||
windowsHide: true,
|
||
});
|
||
return;
|
||
}
|
||
try { child.kill('SIGKILL'); } catch { /* best effort */ }
|
||
}
|
||
|
||
async function waitExit(child, timeoutMs = 15_000) {
|
||
if (child.exitCode !== null) return child.exitCode;
|
||
return new Promise((resolve, reject) => {
|
||
const timer = setTimeout(() => reject(new Error('sidecar did not exit in time')), timeoutMs);
|
||
child.once('exit', (code) => {
|
||
clearTimeout(timer);
|
||
resolve(code ?? -1);
|
||
});
|
||
});
|
||
}
|
||
|
||
function sidecarEnv(overrides) {
|
||
return {
|
||
...process.env,
|
||
// 关键：显式隔离运行数据，绝不触碰仓库 server/data 或用户 ~/.aps
|
||
APS_MODE: 'desktop',
|
||
PYTHONNOUSERSITE: '1',
|
||
PYTHONUTF8: '1',
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function spawnSidecar({ port, token, home, env = {}, cwd = repoRoot, python, capture = true }) {
|
||
const child = spawn(python, ['-m', 'server.sidecar'], {
|
||
cwd,
|
||
env: sidecarEnv({
|
||
APS_API_HOST: LOOPBACK_HOST,
|
||
APS_API_PORT: String(port),
|
||
APS_SIDECAR_NONCE: token,
|
||
APS_PARENT_PID: String(process.pid),
|
||
APS_HOME: home,
|
||
APS_DB_PATH: path.join(home, 'data', 'master.db'),
|
||
APS_KNOWLEDGE_PATH: path.join(home, 'knowledge'),
|
||
APS_APPROVAL_PATH: path.join(home, 'approval'),
|
||
APS_WORLD_PATH: path.join(home, 'data', 'world.json'),
|
||
APS_PROJECTS_PATH: path.join(home, 'sessions', 'workspace.json'),
|
||
APS_UI_DIR: '',
|
||
LLM_PROVIDER: '', // 离线：禁止任何 LLM 外呼
|
||
PYTHONPATH: repoRoot, // 支持 cwd 为任意目录（中文/空格路径用例）
|
||
...env,
|
||
}),
|
||
stdio: ['ignore', 'pipe', 'pipe'],
|
||
windowsHide: true,
|
||
});
|
||
liveChildren.add(child);
|
||
child.nonce = token;
|
||
let stderrTail = '';
|
||
if (capture) {
|
||
child.stderr.on('data', (chunk) => {
|
||
stderrTail = (stderrTail + String(chunk)).slice(-2000);
|
||
child.stderrTail = stderrTail;
|
||
});
|
||
}
|
||
return child;
|
||
}
|
||
|
||
function check(name, ok, detail) {
|
||
results.push({ name, ok: Boolean(ok), detail: detail ?? '' });
|
||
console.log(`[${ok ? 'PASS' : 'FAIL'}] ${name}${detail ? ` — ${detail}` : ''}`);
|
||
}
|
||
|
||
async function removeDir(dir) {
|
||
try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* best effort */ }
|
||
}
|
||
|
||
// ---------------------------------------------------------------- sections
|
||
|
||
async function sectionColdStarts(python, home) {
|
||
let passed = 0;
|
||
for (let index = 1; index <= 20; index += 1) {
|
||
const port = await reservePort();
|
||
const child = spawnSidecar({ port, token: nonce(), home, python });
|
||
try {
|
||
await waitForHealth(port, child.nonce, 60_000, child);
|
||
passed += 1;
|
||
console.log(` cold-start #${index} ok (port=${port} pid=${child.pid})`);
|
||
} catch (error) {
|
||
stopProcessTree(child);
|
||
check(`冷启动 #${index}/20`, false, String(error.message ?? error));
|
||
return;
|
||
} finally {
|
||
stopProcessTree(child);
|
||
await waitExit(child).catch(() => {});
|
||
}
|
||
}
|
||
check('20 次冷启动（进程起/停）', passed === 20, `${passed}/20 成功`);
|
||
}
|
||
|
||
async function sectionPortConflict(python, home) {
|
||
const port = await reservePort();
|
||
// 预占端口并保持监听，制造冲突
|
||
const blocker = net.createServer();
|
||
await new Promise((resolve, reject) => {
|
||
blocker.once('error', reject);
|
||
blocker.listen({ host: LOOPBACK_HOST, port, exclusive: true }, resolve);
|
||
});
|
||
const child = spawnSidecar({ port, token: nonce(), home, python });
|
||
try {
|
||
const code = await waitExit(child, 25_000);
|
||
const tail = (child.stderrTail ?? '').toLowerCase();
|
||
const explicitFailure = code !== 0
|
||
&& (tail.includes('10048') || tail.includes('address already in use') || tail.includes('eaddrinuse')
|
||
|| tail.includes('bind') || tail.includes('端口') || tail.includes('使用'));
|
||
check('端口冲突（预占后应换端口或显式失败）', explicitFailure,
|
||
`exit=${code}, stderr 尾部: ${(child.stderrTail ?? '').slice(0, 220)}`);
|
||
} catch (error) {
|
||
stopProcessTree(child);
|
||
check('端口冲突（预占后应换端口或显式失败）', false, `未在 25s 内显式失败：${error.message}`);
|
||
} finally {
|
||
blocker.close();
|
||
stopProcessTree(child);
|
||
}
|
||
}
|
||
|
||
async function sectionCrashRestart(python, home) {
|
||
// 崩溃重启：脚本扮演父进程/守护，kill 掉 sidecar 后以新端口+新 nonce 重启
|
||
const port1 = await reservePort();
|
||
const child1 = spawnSidecar({ port: port1, token: nonce(), home, python });
|
||
try {
|
||
await waitForHealth(port1, child1.nonce, 60_000, child1);
|
||
} catch (error) {
|
||
stopProcessTree(child1);
|
||
check('崩溃重启（父进程守护）', false, `首次启动失败：${error.message}`);
|
||
return;
|
||
}
|
||
const firstPid = child1.pid;
|
||
stopProcessTree(child1);
|
||
await waitExit(child1).catch(() => {});
|
||
const port2 = await reservePort();
|
||
const child2 = spawnSidecar({ port: port2, token: nonce(), home, python });
|
||
let restarted = false;
|
||
try {
|
||
await waitForHealth(port2, child2.nonce, 60_000, child2);
|
||
restarted = true;
|
||
} catch (error) {
|
||
check('崩溃重启（父进程守护）', false, `kill 后重启失败：${error.message}`);
|
||
stopProcessTree(child2);
|
||
return;
|
||
} finally {
|
||
stopProcessTree(child2);
|
||
}
|
||
check('崩溃重启（kill 子进程后父进程拉起新实例）', restarted,
|
||
`pid ${firstPid} → 新 pid ${child2.pid}，端口 ${port1} → ${port2}`);
|
||
|
||
// 父进程看门狗：父进程退出后 sidecar 应自行退出（守护反向依赖）
|
||
const dummy = spawn(python, ['-c', 'import time; time.sleep(4)'], {
|
||
stdio: 'ignore',
|
||
windowsHide: true,
|
||
});
|
||
const port3 = await reservePort();
|
||
const child3 = spawnSidecar({
|
||
port: port3,
|
||
token: nonce(),
|
||
home,
|
||
python,
|
||
env: { APS_PARENT_PID: String(dummy.pid) },
|
||
});
|
||
try {
|
||
await waitForHealth(port3, child3.nonce, 60_000, child3);
|
||
const code = await waitExit(child3, 20_000);
|
||
check('父进程看门狗（父退出后 sidecar 自退出）', code === 0, `watchdog exit=${code}`);
|
||
} catch (error) {
|
||
stopProcessTree(child3);
|
||
check('父进程看门狗（父退出后 sidecar 自退出）', false, String(error.message ?? error));
|
||
} finally {
|
||
stopProcessTree(dummy);
|
||
stopProcessTree(child3);
|
||
}
|
||
}
|
||
|
||
async function sectionChinesePath(python, home) {
|
||
const base = fs.mkdtempSync(path.join(os.tmpdir(), 'aps 排产 冒烟 测试-'));
|
||
const uiDir = path.join(base, 'ui 界面');
|
||
const dataDir = path.join(base, 'data 数据');
|
||
fs.mkdirSync(uiDir, { recursive: true });
|
||
fs.mkdirSync(dataDir, { recursive: true });
|
||
fs.writeFileSync(path.join(uiDir, 'index.html'), '<!doctype html><title>APS 冒烟</title><h1>中文路径 OK</h1>', 'utf8');
|
||
const port = await reservePort();
|
||
const token = nonce();
|
||
const child = spawnSidecar({
|
||
port,
|
||
token,
|
||
home,
|
||
python,
|
||
cwd: base, // 在含中文+空格的目录启动
|
||
env: {
|
||
APS_UI_DIR: uiDir,
|
||
APS_DB_PATH: path.join(dataDir, 'smoke.db'),
|
||
APS_WORLD_PATH: path.join(dataDir, 'world.json'),
|
||
APS_HOME: path.join(base, 'home'),
|
||
APS_PROJECTS_PATH: path.join(base, 'home', 'sessions', 'workspace.json'),
|
||
},
|
||
});
|
||
try {
|
||
await waitForHealth(port, token, 60_000, child);
|
||
const response = await fetch(`http://${LOOPBACK_HOST}:${port}/`, {
|
||
headers: { [NONCE_HEADER]: token },
|
||
signal: AbortSignal.timeout(8_000),
|
||
});
|
||
const body = await response.text();
|
||
const uiOk = response.status === 200
|
||
&& /text\/html/i.test(response.headers.get('content-type') ?? '')
|
||
&& /<html|<!doctype/i.test(body);
|
||
// APS_HOME 中文/空格路径被 ensure_aps_home 实际创建（config.json 落盘）
|
||
const homeOk = fs.existsSync(path.join(base, 'home', 'config.json'))
|
||
&& fs.existsSync(path.join(base, 'home', 'data'));
|
||
const noTraceback = !(child.stderrTail ?? '').includes('Traceback');
|
||
check('中文/空格路径（cwd + APS_HOME + APS_UI_DIR 全中文空格目录）',
|
||
uiOk && homeOk && noTraceback,
|
||
`ui=${uiOk} home=${homeOk} traceback=${!noTraceback} cwd=${base}（sqlite 懒创建，健康/UI 探针不触发）`);
|
||
} catch (error) {
|
||
check('中文/空格路径（cwd + APS_HOME + APS_UI_DIR 全中文空格目录）', false, String(error.message ?? error));
|
||
} finally {
|
||
stopProcessTree(child);
|
||
await delay(500);
|
||
await removeDir(base);
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------- main
|
||
|
||
async function main() {
|
||
const python = resolvePython();
|
||
const home = fs.mkdtempSync(path.join(os.tmpdir(), 'aps-sidecar-smoke-'));
|
||
const startedAt = Date.now();
|
||
console.log(`sidecar smoke: python=${python} platform=${process.platform} home=${home}`);
|
||
|
||
try {
|
||
await sectionColdStarts(python, home);
|
||
await sectionPortConflict(python, home);
|
||
await sectionCrashRestart(python, home);
|
||
await sectionChinesePath(python, home);
|
||
} finally {
|
||
for (const child of [...liveChildren]) stopProcessTree(child);
|
||
await delay(500);
|
||
await removeDir(home);
|
||
}
|
||
|
||
const failed = results.filter((r) => !r.ok);
|
||
console.log(`\nsidecar smoke summary: ${results.length - failed.length}/${results.length} passed in ${((Date.now() - startedAt) / 1000).toFixed(1)}s`);
|
||
for (const r of results) console.log(` [${r.ok ? 'PASS' : 'FAIL'}] ${r.name}`);
|
||
if (failed.length > 0) {
|
||
console.error(`sidecar smoke FAILED: ${failed.map((f) => f.name).join('; ')}`);
|
||
process.exitCode = 1;
|
||
}
|
||
}
|
||
|
||
await main(); |