Files
STM32F4-Base/IEC60870-Slave/test/firmware_update_loopback_test.cjs
T
STF bdcc8b6500
CI / L0 静态门禁 (pre-commit) (push) Failing after 7m46s
CI / L0.5 主机侧单测 (MSVC) (push) Successful in 21s
添加遥控、参数装载、文件传输等业务
2026-11-16 22:19:17 -08:00

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