215 lines
12 KiB
JavaScript
215 lines
12 KiB
JavaScript
/* 附录 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, /<Header fileType="Ulog" fileVer="1\.00" devID="[^"]+"\s*\/>/);
|
|
assert.match(xml, /<\/DataFile>\s*$/);
|
|
const rows = [...xml.matchAll(/<DI\s+([^>]+)\/>/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(/<DataRec num="(\d+)">/.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; });
|