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