/* 附录 C 独立 TCP 回归:真实业务形成日志,经 Type210 下载后核对 XML。
* 复用测试主站的 APCI 工具,不调用被测日志编码器。所有产物留在本目录 .build。
* 强制结束进程再重开同一存储,验证持久性不依赖正常退出刷盘。 */
'use strict';
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const net = require('node:net');
const { spawn } = require('node:child_process');
const { once } = require('node:events');
const { setTimeout: delay } = require('node:timers/promises');
const { Master, parameterRequest } = require('./slave_example_loopback_test.cjs');
/* 限定被测可执行文件及产物在本工程 .build 内;每轮使用唯一目录并保留 XML 证据。 */
const project = path.resolve(__dirname, '..');
const build = path.join(project, '.build');
const executable = path.resolve(process.argv[2]);
const relative = path.relative(build, executable);
assert(relative && !relative.startsWith('..') && !path.isAbsolute(relative), 'Executable must be inside .build');
const directoryPath = fs.mkdtempSync(path.join(build, 'user-log-loopback-'));
const filename = 'HISTORY/ULOG/ulog.xml';
/* 独立构造 Type210 请求,名称带单字节长度;测试不借用终端的目录或日志编码函数。 */
const named = s => { const b = Buffer.from(s, 'utf8'); return Buffer.concat([Buffer.from([b.length]), b]); };
const u32 = n => { const b = Buffer.alloc(4); b.writeUInt32LE(n); return b; };
const head = (op, cause) => Buffer.from([210, 1, cause, 0x41, 7, 0, 0, 0, 0, 2, op]);
/* 允许真实业务异步监视报文穿插,但只跳过明确白名单;目标类型还须匹配操作号。 */
async function receive(master, type, operation) {
for (let n = 0; n < 256; ++n) {
const a = await master.readASDU();
if (a[0] === type) {
if (operation !== undefined) assert.equal(a[10], operation);
return a;
}
assert([1, 3, 11, 30, 31, 35].includes(a[0]), `Unexpected ASDU ${a.toString('hex')}`);
}
throw Error('Expected reply absent');
}
/* 启动同步须真实完成全站总召,不能借测试开关绕过文件 IDLE 门禁。 */
async function synchronize(master) {
await master.control(7, 11);
assert.equal((await master.readASDU())[0], 70);
await master.send([100, 1, 6, 0x72, 7, 0, 0, 0, 0, 20]);
for (let i = 0; i < 128; ++i) {
const a = await master.readASDU();
if (a[0] === 100 && a[2] === 10) return;
assert([100, 1, 3, 11, 110, 111, 112].includes(a[0]));
}
throw Error('Startup synchronization did not complete');
}
/* 启动真实子进程并等待实际监听端口,关闭模拟采样以使日志来源可逐条核对。
* 期限仅限制测试悬挂;stop 会关闭测试 socket 并结束子进程,不依赖正常退出保存。
* 强制终止仍不等于物理断电,不能验证操作系统或硬盘断电缓存的兑现情况。 */
async function launch() {
const child = spawn(executable, ['--port', '0', '--ca', '7', '--run-ms', '60000',
'--user-log', directoryPath, '--events', '0', '--background-ms', '0', '--cyclic-ms', '0'],
{ cwd: project, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
const state = { child, output: '', errors: '', sockets: [] };
child.stdout.on('data', b => { state.output += b; });
child.stderr.on('data', b => { state.errors += b; });
state.exit = once(child, 'close'); state.exit.catch(() => {});
const deadline = setTimeout(() => child.kill(), 65000);
state.stop = async () => {
for (const socket of state.sockets) socket.destroy();
if (child.exitCode === null) child.kill();
await state.exit; clearTimeout(deadline);
assert.equal(state.errors, '', state.output + '\n' + state.errors);
};
try {
for (let i = 0; i < 1000; ++i) {
const match = /LISTEN 127\.0\.0\.1:(\d+) CA=7/.exec(state.output);
if (match) { state.port = Number(match[1]); return state; }
if (child.exitCode !== null) break;
await delay(10);
}
throw Error('No listener: ' + state.output + '\n' + state.errors);
} catch (error) {
await state.stop(); throw error;
}
}
/* 每次真实 TCP 建连均重新完成启动门禁,避免把旧连接的业务状态带到新会话。 */
async function connect(state) {
const socket = net.connect({ host: '127.0.0.1', port: state.port }); state.sockets.push(socket);
const master = new Master(socket); master.asynchronous = true;
await once(socket, 'connect'); await synchronize(master); return master;
}
/* 目录 ID 非零仍按名称找到资源;空结果和大小写错误与成功单项分开核对。 */
async function directory(master, name = 'HISTORY/ULOG', range = null, success = true) {
const filter = range ? Buffer.concat([Buffer.from([1]), ...range]) : Buffer.alloc(15);
await master.send(Buffer.concat([head(1, 5), u32(77), named(name), filter]));
const a = await receive(master, 210, 2);
if (!success) { assert.notEqual(a[11], 0); return []; }
assert.equal(a[11], 0); assert.equal(a.readUInt32LE(12), 0); assert.equal(a[16], 0);
const entries = []; let offset = 18;
for (let i = 0; i < a[17]; ++i) {
const size = a[offset++]; const name = a.subarray(offset, offset + size).toString('utf8'); offset += size;
assert.equal(a[offset++], 0);
const length = a.readUInt32LE(offset); offset += 4;
const time = Buffer.from(a.subarray(offset, offset + 7)); offset += 7;
entries.push({ name, size: length, time });
}
assert.equal(offset, a.length); return entries;
}
/* 按目录宣告的同一名称和大小激活读取,逐段核对偏移、模和、连续长度及末段。
* 只有完整文件到齐才发最终确认;成功界面或单个确认不能替代字节内容验证。 */
async function read(master, entry) {
await master.send(Buffer.concat([head(3, 6), named(entry.name)]));
const a = await receive(master, 210, 4);
assert.equal(a[11], 0); const pos = 13 + a[12];
assert.equal(a.subarray(13, pos).toString('utf8'), entry.name);
assert.equal(a.readUInt32LE(pos), 0); assert.equal(a.readUInt32LE(pos + 4), entry.size);
const parts = []; let offset = 0;
for (let i = 0; i < 2000; ++i) {
const a = await receive(master, 210, 5);
assert.equal(a.readUInt32LE(11), 0); assert.equal(a.readUInt32LE(15), offset);
const bytes = a.subarray(20, -1);
assert.equal(a[a.length - 1], bytes.reduce((sum, b) => (sum + b) & 255, 0));
parts.push(bytes); offset += bytes.length;
if (a[19] === 0) {
assert.equal(offset, entry.size);
await master.send(Buffer.concat([head(6, 5), u32(0), a.subarray(15, 19), Buffer.from([0])]));
return Buffer.concat(parts);
}
assert.equal(a[19], 1);
}
throw Error('Download did not finish');
}
/* 对本例导出的 XML 做独立字段与条数检查;这是测试专用提取器,不是通用 XML 解析器。
* 字符转义和完整格式边界由公共编码专项另外覆盖,本回环关注真实业务形成的记录。 */
function records(bytes) {
const xml = bytes.toString('utf8');
assert.match(xml, /^<\?xml version="1\.0" encoding="UTF-8"\?>/);
assert.match(xml, //);
assert.match(xml, /<\/DataFile>\s*$/);
const rows = [...xml.matchAll(/]+)\/>/g)].map(m => {
const row = Object.fromEntries([...m[1].matchAll(/(\w+)="([^"]*)"/g)].map(m => [m[1], m[2]]));
assert.deepEqual(Object.keys(row).sort(), ['logType', 'tm', 'txt', 'val']);
assert.match(row.logType, /^(0[1-9]|1[01])$/);
assert.match(row.tm, /^\d{6}_\d{6}_\d{3}$/);
assert.match(row.txt, /^[\x20-\x7e]+$/); assert.match(row.val, /^[01]$/);
if (['01', '10', '11'].includes(row.logType)) assert.equal(row.val, '1');
return row;
});
assert.equal(Number(//.exec(xml)[1]), rows.length);
return rows;
}
/* 同时验证真实修改、TEST、相同值与非法值;回复回显运行值,后续日志只应多出真实变化。 */
async function parameter(master, value, test = false, negative = false, running = value) {
const request = parameterRequest(111, 0x8601, value, 1, test ? 0x86 : 6);
const expected = Buffer.from(request); expected[2] = test ? 0x87 : negative ? 0x47 : 7;
expected.writeInt16LE(running, 9);
await master.send(request); assert.deepEqual(await receive(master, 111), expected);
}
/* 新召目录才取得更新版本;单独重读旧 entry 则用于验证目录缓存承诺。 */
async function snapshot(master) {
const entries = await directory(master); assert.equal(entries.length, 1);
assert.equal(entries[0].name, filename); return read(master, entries[0]);
}
/* 第一进程验证业务与缓存,第二进程复用同一 ulog.store 验证强制终止后的恢复。
* 保留前缀按完整记录比较;正常断开若已在终止前落盘,也不能被第二次启动删掉。 */
async function run() {
let state = await launch(), saved;
try {
let master = await connect(state);
const [entry] = await directory(master); assert.equal(entry.name, filename);
const initial = await read(master, entry);
assert.deepEqual(records(initial).map(r => [r.logType, r.val]), [['01', '1'], ['02', '1']]);
await parameter(master, 350);
await parameter(master, 10, true, false, 350);
await parameter(master, 350);
await parameter(master, -1, false, true, 350);
/* 业务已经产生新日志,目录缓存承诺的旧字节仍须按原大小完整读回。 */
assert.deepEqual(await read(master, entry), initial);
const changed = await snapshot(master); const rows = records(changed);
assert.equal(rows.length, 3); assert.equal(rows[2].logType, '10');
assert.match(rows[2].txt, /34305/); assert.match(rows[2].txt, /200/); assert.match(rows[2].txt, /350/);
/* STOP/START 只改变协议激活状态,不能被误记为 TCP 连接边沿或进程启动。 */
await master.control(0x13, 0x23); await synchronize(master);
assert.deepEqual(await snapshot(master), changed, 'STOP/START must not become connection or restart logs');
await directory(master, 'history/ulog', null, false);
/* 使用明确晚于测试时间的 CP56 区间,验证过滤无结果与目录不存在的响应有区别。 */
const future = day => Buffer.from([0, 0, 0, 0, day, 1, 99]);
assert.deepEqual(await directory(master, 'HISTORY/ULOG', [future(1), future(2)]), []);
/* 真正断开后重连应产生一对 02 边沿,延时只给子进程消费断开通知,不代替内容断言。 */
await master.close(); await delay(50); master = await connect(state);
saved = await snapshot(master); const reconnected = records(saved);
assert.deepEqual(reconnected.slice(0, rows.length), rows);
assert.deepEqual(reconnected.slice(-2).map(r => [r.logType, r.val]), [['02', '0'], ['02', '1']]);
fs.writeFileSync(path.join(directoryPath, 'before-restart.xml'), saved);
} finally { await state.stop(); }
state = await launch();
try {
const master = await connect(state); const restored = await snapshot(master);
const before = records(saved), after = records(restored);
assert.deepEqual(after.slice(0, before.length), before);
assert.equal(after.filter(r => r.logType === '01').length, 2);
assert.equal(after.filter(r => r.logType === '10').length, 1);
assert.deepEqual(after.slice(-2).map(r => [r.logType, r.val]), [['01', '1'], ['02', '1']]);
fs.writeFileSync(path.join(directoryPath, 'after-restart.xml'), restored);
} finally { await state.stop(); }
console.log('UserLog TCP: startup, connection, parameter/TEST, snapshot, filter and restart passed. Artifacts: ' + directoryPath);
}
/* 任一协议、内容或清理断言失败都传播为非零退出码,供构建脚本判定失败。 */
run().catch(error => { console.error(error); process.exitCode = 1; });