添加遥控、参数装载、文件传输等业务
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s

This commit is contained in:
STF
2026-11-16 22:19:17 -08:00
parent e1b0434774
commit bdcc8b6500
288 changed files with 118386 additions and 150057 deletions
@@ -0,0 +1,235 @@
/* 持久升级真实 TCP 验证:独立生成工程包与预期 CRC,检查安装文件及跨进程恢复。
* 仅启动本目录 .build 内的宿主示例,所有数据写入新建的专用测试目录。
* 安装目标是数据文件;不执行收到的负载,不据此声称目标硬件启动成功。
* 使用:node test/firmware_update_loopback_test.cjs <本轮构建的example.exe>,Suite为FirmwareUpdate。
* Master仅复用TCP/APCI收发;211、210、202内容和I104包均由本文件独立构造。
* 顺序:打包与启动拒绝 → CRC/取消 → 两次升级及备份轮换 → 未ACK结束后的进程恢复。 */
'use strict';
const assert = require('node:assert/strict');
const fs = require('node:fs');
const net = require('node:net');
const path = require('node:path');
const { spawn, spawnSync } = require('node:child_process');
const { once } = require('node:events');
const { setTimeout: delay } = require('node:timers/promises');
const { Master } = require('./slave_example_loopback_test.cjs');
/* 只运行.build内显式指定的可执行文件,避免误测其他工程或旧的默认路径。
* 每轮使用唯一目录,结束后保留数据供人工复核;children/sockets只用于资源收尾。 */
const executable = path.resolve(process.argv[2]);
const build = path.resolve(__dirname, '..', '.build');
const relative = path.relative(build, executable);
assert(relative && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
const parent = fs.mkdtempSync(path.join(build, 'firmware-loopback-'));
const store = path.join(parent, 'store'); fs.mkdirSync(store);
const children = [], sockets = [];
const u32 = value => { const b = Buffer.alloc(4); b.writeUInt32LE(value); return b; };
const named = name => { const b = Buffer.from(name, 'ascii'); return Buffer.concat([Buffer.from([b.length]), b]); };
const fileHead = (op, cause) => Buffer.from([210, 1, cause, 0x41, 7, 0, 0, 0, 0, 2, op]);
const command = operation => Buffer.from([211, 0, operation === 'cancel' ? 8 : 6, 0x62, 7, 0,
0, 0, 0, operation === 'start' ? 0x80 : 0]);
/* 独立CRC算法先校验已知向量,再用于生成包头和202预期值;不调用被测端编码器。 */
function crc32(bytes) {
let crc = 0xffffffff;
for (const byte of bytes) {
crc ^= byte;
for (let bit = 0; bit < 8; ++bit) crc = (crc >>> 1) ^ ((crc & 1) ? 0xedb88320 : 0);
}
return (crc ^ 0xffffffff) >>> 0;
}
assert.equal(crc32(Buffer.from('123456789')), 0xcbf43926);
const packageBytes = (version, payload) => Buffer.concat([
Buffer.from('I104'), u32(version), u32(payload.length), u32(crc32(payload)), payload]);
const original = Buffer.from('initial complete program payload');
const seed = path.join(parent, 'seed.bin'); fs.writeFileSync(seed, packageBytes(1, original));
/* 让--upgrade-store自行开启210/211,证明持久模式不依赖额外开关。
* 仅首次提供seed;禁用采样与背景上送,使接收断言不受无关I帧干扰。 */
function args(runMs, initial = false) {
return ['--port', '0', '--ca', '7', '--events', '0', '--background-ms', '0', '--run-ms', String(runMs),
'--remote-parameter', '--upgrade-store', store, ...(initial ? ['--upgrade-seed', seed] : [])];
}
/* 拒绝场景必须真正启动了程序且非零退出;进程创建失败或超时不算业务拒绝通过。 */
function rejected(values) {
const result = spawnSync(executable, values, { windowsHide: true, encoding: 'utf8', timeout: 5000 });
assert.equal(result.error, undefined, result.stderr);
assert.notEqual(result.status, 0, 'Invalid startup unexpectedly succeeded');
}
/* stdout/stderr分别累积,exit在close事件完成后结算,确保断言时输出已收齐。
* 独立保护定时器用于终止卡住的测试进程,不作为被测程序的升级期限。 */
function launch(runMs, initial = false) {
const child = spawn(executable, args(runMs, initial), { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
const item = { child, output: '', errors: '', done: false };
child.stdout.on('data', bytes => { item.output += bytes; });
child.stderr.on('data', bytes => { item.errors += bytes; });
item.exit = once(child, 'close').then(([code, signal]) => { item.done = true; return { code, signal }; });
item.exit.catch(() => {});
item.timer = setTimeout(() => child.kill(), runMs + 8000);
children.push(item); return item;
}
/* 从实际LISTEN输出取随机端口,禁止把命令行端口0当作连接目标。
* 提前退出立即报告已有诊断,不继续等待或另起一个替代进程。 */
async function listener(item) {
for (let i = 0; i < 500; ++i) {
const found = item.output.match(/LISTEN 127\.0\.0\.1:(\d+) CA=7/);
if (found) return Number(found[1]);
if (item.done) break;
await delay(10);
}
throw Error(`Listener unavailable: ${item.output}\n${item.errors}`);
}
/* 大文件上传会积累多个S确认,读取时过滤它们,但仍严格核对I帧两侧序号。
* acknowledge=false只取END确认,不发送S帧;此后崩溃前不得再发会捎带N(R)的I帧。
* 返回值只含ASDU;序号在本连接累计,新连接由新Master从0开始。 */
async function response(master, acknowledge = true) {
for (let i = 0; i < 8192; ++i) {
const frame = await master.next();
if (frame[2] === 1) continue;
assert.equal(frame[2] & 1, 0);
assert.equal(frame.readUInt16LE(2) >> 1, master.nr++);
assert.equal(frame.readUInt16LE(4) >> 1, master.ns);
if (acknowledge) {
const ack = Buffer.from([0x68, 4, 1, 0, 0, 0]); ack.writeUInt16LE(master.nr << 1, 4);
master.socket.write(ack);
}
return frame.subarray(6);
}
throw Error('I-frame response missing');
}
/* 建连后完成STARTDT,并区分进程首次启动COI0与协议重建COI2。
* COI仅作时序证据,真正安装结果还须后续202及文件内容核对。 */
async function connect(port, coi = 0) {
// 旧连接关闭早于文件复制及监听恢复;限次重试新连接,不重发已经提交的升级命令。
// 只容忍重建窗口中的ECONNREFUSED,其他错误立即暴露。
let socket;
for (let attempt = 0; attempt < 300; ++attempt) {
socket = net.createConnection({ host: '127.0.0.1', port }); sockets.push(socket);
try { await once(socket, 'connect'); break; }
catch (error) {
socket.destroy();
if (error.code !== 'ECONNREFUSED' || attempt === 299) throw error;
await delay(10);
}
}
const master = new Master(socket);
await master.control(7, 0x0b);
assert.deepEqual(await response(master), Buffer.from([70, 1, 4, 0, 7, 0, 0, 0, 0, coi]));
return master;
}
/* 211确认除COT外应镜像请求;acknowledge参数显式控制后续是否允许安装授权成立。 */
async function reply(master, operation, cause = operation === 'cancel' ? 9 : 7, acknowledge = true) {
const request = command(operation), expected = Buffer.from(request); expected[2] = cause;
await master.send(request); assert.deepEqual(await response(master, acknowledge), expected);
}
/* 202同时读0x8005/0x8006:版本是含NUL的十进制字符串,CRC是纯负载CRC32。
* 连TLV类型、长度和地址一起比对,防止只看到新版本号就漏掉旧CRC。 */
async function imageValues(master, version, payload) {
await master.send(Buffer.from([202, 2, 6, 0x73, 7, 0, 0, 0, 5, 0x80, 0, 6, 0x80, 0]));
const value = Buffer.from(`${version}\0`, 'ascii');
assert.deepEqual(await response(master), Buffer.concat([Buffer.from([202, 2, 7, 0x73, 7, 0, 0, 0, 0,
5, 0x80, 0, 4, value.length]), value, Buffer.from([6, 0x80, 0, 35, 4]), u32(crc32(payload))]));
}
/* 先确认op8,再把16字节包头故意拆到前三段,段校验与整包CRC分开验证。
* valid=false时仍保证各段和校验正确,预期失败来自最终文件完整性检查。
* op10同时检查最后一段偏移及结果;接收成功在这里不代表END或安装完成。 */
async function upload(master, bytes, valid = true) {
await master.send(Buffer.concat([fileHead(7, 6), named('upgrade.bin'), u32(17), u32(bytes.length)]));
const active = await response(master);
assert.equal(active[10], 8); assert.equal(active[2], 7); assert.equal(active[11], 0);
const burst = []; let offset = 0, last = 0;
for (const length of [5, 7, ...Array(Math.ceil(bytes.length / 228) + 2).fill(228)]) {
if (offset === bytes.length) break;
const part = bytes.subarray(offset, Math.min(offset + length, bytes.length));
const sum = part.reduce((v, b) => (v + b) & 255, 0);
burst.push(master.frame(Buffer.concat([fileHead(9, 5), u32(17), u32(offset),
Buffer.from([offset + part.length < bytes.length ? 1 : 0]), part, Buffer.from([sum])])));
last = offset; offset += part.length;
}
assert.equal(offset, bytes.length); master.socket.write(Buffer.concat(burst));
assert.deepEqual(await response(master), Buffer.concat([
fileHead(10, valid ? 7 : 0x47), u32(0), u32(last), Buffer.from([valid ? 0 : 1])]));
}
/* 对外安装文件必须等于纯负载,不能夹带工程包头;有旧版预期时也逐字节核对备份。 */
function files(current, backup) {
assert.deepEqual(fs.readFileSync(path.join(store, 'dtu')), current);
if (backup) assert.deepEqual(fs.readFileSync(path.join(store, 'dtu-1')), backup);
}
/* 正常场景必须自然退出0且stderr为空;强制中断场景单独等待,不复用此成功判据。 */
async function finish(item) {
assert.deepEqual(await item.exit, { code: 0, signal: null }, `${item.output}\n${item.errors}`);
assert.equal(item.errors, ''); clearTimeout(item.timer);
}
/* 成功链在COMMIT后先证明旧安装及读回值未变,END被ACK后才等待断线和重连。
* 本夹具连续使用相邻版本,故旧版预期为version-1;函数返回新连接供下一步检查。 */
async function activate(master, item, port, version, payload, old) {
await reply(master, 'start'); await upload(master, packageBytes(version, payload));
files(old); await imageValues(master, version - 1, old);
const closed = once(master.socket, 'close'); await reply(master, 'end'); await closed;
assert(!item.done, 'Host installation should finish through the existing protocol restart path');
master = await connect(port, 2); await imageValues(master, version, payload); files(payload, old);
return master;
}
/* 各阶段共用持久目录,却使用不同进程,避免把进程内缓存误当成恢复结果。 */
async function exercise() {
/* 打包工具产物与独立包构造逐字节相等;重复输出必须拒绝且原文件保持不变。 */
const payloadPath = path.join(parent, 'original.payload'), packed = path.join(parent, 'generated-seed.bin');
fs.writeFileSync(payloadPath, original);
const packArgs = [path.join(__dirname, '..', 'scripts', 'make_upgrade_package.cjs'),
'--version', '1', '--input', payloadPath, '--output', packed];
const generated = spawnSync(process.execPath, packArgs, { windowsHide: true, encoding: 'utf8' });
assert.equal(generated.error, undefined); assert.equal(generated.status, 0, generated.stderr);
assert.deepEqual(fs.readFileSync(packed), packageBytes(1, original));
const repeated = spawnSync(process.execPath, packArgs, { windowsHide: true, encoding: 'utf8' });
assert.equal(repeated.error, undefined); assert.notEqual(repeated.status, 0);
assert.deepEqual(fs.readFileSync(packed), packageBytes(1, original));
rejected(['--upgrade-seed', seed, '--run-ms', '1']);
rejected(args(1)); // Empty store requires a real old image, never an invented version record.
const first = launch(8000, true), port = await listener(first);
let master = await connect(port); await imageValues(master, 1, original); files(original);
rejected(args(1)); // A second process cannot open the live store.
await reply(master, 'start');
/* 仅损坏头中的整包期望CRC,验证文件拒绝后END也拒绝,取消可释放原会话。 */
const bad = packageBytes(2, Buffer.from('corrupted image')); bad[12] ^= 1;
await upload(master, bad, false); await reply(master, 'end', 0x47); await reply(master, 'cancel');
files(original);
await reply(master, 'start'); await upload(master, packageBytes(2, Buffer.from('cancelled candidate')));
await reply(master, 'cancel'); files(original); await imageValues(master, 1, original);
/* 70KB超过旧RAM模式上限;接收、安装及随后重开仍须保持每个负载字节。 */
const second = Buffer.alloc(70000);
for (let i = 0; i < second.length; ++i) second[i] = (i * 31 + 7) & 255;
master = await activate(master, first, port, 2, second, original);
await master.close(); await finish(first);
rejected(args(1, true)); // Re-provisioning cannot overwrite an existing installation.
files(second, original);
/* 重新开进程验证已确认版本保留,再升第3版,备份必须从初始版轮转到第2版。 */
const reopened = launch(5000), nextPort = await listener(reopened);
master = await connect(nextPort); await imageValues(master, 2, second); files(second, original);
const third = Buffer.from('third installed payload');
master = await activate(master, reopened, nextPort, 3, third, second);
await master.close(); await finish(reopened);
/* END肯定确认已经收到,但刻意不ACK;短暂观察后终止进程。
* 下一次启动必须丢弃未授权候选,当前第3版及第2版备份均不能变化。 */
const crashed = launch(10000), crashPort = await listener(crashed);
master = await connect(crashPort); await imageValues(master, 3, third);
await reply(master, 'start'); await upload(master, packageBytes(4, Buffer.from('unacknowledged candidate')));
await reply(master, 'end', 7, false); await delay(80); files(third, second);
crashed.child.kill(); await crashed.exit; clearTimeout(crashed.timer);
const recovery = launch(1000), recoveryPort = await listener(recovery);
master = await connect(recoveryPort); await imageValues(master, 3, third); files(third, second);
await master.close(); await finish(recovery);
console.log(`Firmware TCP passed: streaming >64KB, CRC/cancel, ACK-gated install, dtu/dtu-1, two upgrades, process restart, unacknowledged END recovery; artifacts=${parent}`);
}
/* 任一断言失败打印所有进程输出并设置非零状态;最后只释放socket、计时器和子进程。
* 保留唯一测试目录,便于区分传输、安装、备份与恢复阶段的实际产物。 */
exercise().catch(error => {
console.error(error);
for (const item of children) console.error(item.output, item.errors);
process.exitCode = 1;
}).finally(async () => {
for (const socket of sockets) socket.destroy();
for (const item of children) { clearTimeout(item.timer); if (!item.done) item.child.kill(); }
await Promise.allSettled(children.map(item => item.exit));
});