236 lines
15 KiB
JavaScript
236 lines
15 KiB
JavaScript
/* 持久升级真实 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));
|
||
});
|