const net = require('net');
|
const fs = require('fs');
|
const path = require('path');
|
const crypto = require('crypto');
|
const { startHttpApi } = require('./http-api');
|
const logger = require('./logger');
|
// 阿里云 IoT 长连接上报工具
|
const { sendDataToAliyun, closeAllConnections } = require('./aliyun-iot');
|
// 阿里云配置
|
const { getAliyunConfig, getMqttConfig } = require('./api');
|
// MQTT 客户端
|
const { initMqtt, publishToMqtt, closeMqtt } = require('./mqtt-client');
|
|
// ====== TCP 配置（从 tcp-config.json 读取，可打包部署）======
|
function loadTcpConfig() {
|
const baseDir = (typeof process !== 'undefined' && process.pkg) ? path.dirname(process.execPath) : __dirname;
|
const candidates = [
|
{ path: path.join(baseDir, 'tcp-config.json'), source: 'exedir' },
|
{ path: path.join(__dirname, 'tcp-config.json'), source: 'srcdir' }
|
];
|
for (const c of candidates) {
|
try {
|
const raw = fs.readFileSync(c.path, 'utf8');
|
const obj = JSON.parse(raw);
|
obj.__meta = { source: c.source, path: c.path };
|
return obj;
|
} catch (_) { /* continue */ }
|
}
|
const def = { host: '0.0.0.0', port: 8234, maxClients: 50 };
|
def.__meta = { source: 'default', path: null };
|
return def;
|
}
|
const tcpCfg = loadTcpConfig();
|
const PORT = tcpCfg.port || 8234;
|
const HOST = tcpCfg.host || '0.0.0.0';
|
const MAX_CLIENTS = tcpCfg.maxClients || 50;
|
// 指令下发间隔（毫秒），从配置读取并做安全兜底
|
const GET_DATA_INTERVAL = Math.max(1000, tcpCfg.getDataIntervalMs || 60000);
|
const ACTIVATE_INTERVAL = Math.max(60000, tcpCfg.activateIntervalMs || 600000);
|
// =================================
|
|
// ====== 阿里云配置（从 aliyun-config.json 读取） ======
|
const aliyunCfg = getAliyunConfig();
|
const ALIYUN_ENABLED = aliyunCfg.enabled !== false; // 默认启用，除非显式为 false
|
// =========================================
|
|
// ====== MQTT 配置（从 mqtt-config.json 读取） ======
|
const mqttCfg = getMqttConfig();
|
const MQTT_ENABLED = mqttCfg.enabled === true; // 默认禁用，需显式启用
|
if (MQTT_ENABLED) {
|
initMqtt(mqttCfg);
|
}
|
// =========================================
|
|
// 指令定义（HEX 字符串）
|
const ACTIVATE_CMD_HEX = '16 2f 40 31 04 03';
|
const GET_DATA_CMD_HEX = '16 31 3f 43 44 04 03';
|
|
// ===== 工具函数 =====
|
function hexToBuffer(hexStr) {
|
const hex = hexStr.replace(/\s+/g, '');
|
const bytes = [];
|
for (let i = 0; i < hex.length; i += 2) {
|
bytes.push(parseInt(hex.substr(i, 2), 16));
|
}
|
return Buffer.from(bytes);
|
}
|
|
function bufferToHex(buf) {
|
return buf.toString('hex').replace(/(.{2})/g, '$1 ').trim().toUpperCase();
|
}
|
|
// 格式化时间为 yyyy-MM-dd HH:mm:ss
|
function formatDateTime(date = new Date()) {
|
const pad = (n) => String(n).padStart(2, '0');
|
return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
|
}
|
|
const ACTIVATE_CMD = hexToBuffer(ACTIVATE_CMD_HEX);
|
const GET_DATA_CMD = hexToBuffer(GET_DATA_CMD_HEX);
|
const FRAME_END = Buffer.from([0x06, 0x03]);
|
|
// 采样十六进制输出，避免日志过长
|
function bufferToHexSample(buf, limit = 64) {
|
const hex = bufferToHex(buf);
|
if (buf.length <= limit) return hex;
|
const sliced = buf.subarray(0, limit);
|
return bufferToHex(sliced) + ' ...';
|
}
|
|
// 指令脱敏：只输出长度与短摘要，避免泄露明文HEX
|
function obfuscateHex(hexStr) {
|
if (!hexStr) return '<obf:empty>';
|
const normalized = hexStr.replace(/\s+/g, '').toUpperCase();
|
const len = Math.floor(normalized.length / 2);
|
const sha = crypto.createHash('sha256').update(normalized).digest('hex').slice(0, 8).toUpperCase();
|
return `<obf len=${len} sha=${sha}>`;
|
}
|
|
// ===== 发送辅助：处理回压 =====
|
function safeWrite(socket, buffer, label, log) {
|
try {
|
const ok = socket.write(buffer);
|
if (!ok) {
|
console.log(`⏳ 写入等待回压恢复: ${label}`);
|
if (log) log.warn('tx.backpressure', { label, bytes: buffer.length });
|
socket.once('drain', () => {
|
console.log(`✅ 回压恢复，已继续发送: ${label}`);
|
if (log) log.info('tx.drain', { label });
|
});
|
}
|
} catch (err) {
|
console.error(`❌ 发送失败 (${label}):`, err.message);
|
if (log) log.error('tx.error', { label, error: err.message });
|
}
|
}
|
|
// ===== 解析逻辑（复用 app.js 思路） =====
|
function extractAllFields(frame) {
|
const ascii = frame.toString('ascii');
|
const fields = {};
|
const regex = /([A-Z])([+-]?\d{3,6})/g;
|
let match;
|
while ((match = regex.exec(ascii)) !== null) {
|
const tag = match[1];
|
const valueStr = match[2];
|
const num = parseInt(valueStr, 10);
|
if (!isNaN(num) && !(tag in fields)) {
|
fields[tag] = num;
|
}
|
}
|
return fields;
|
}
|
|
function extractSerialNumber(frame) {
|
const ascii = frame.toString('ascii');
|
console.log(` └─ 尝试提取序列号，完整 ASCII: "${ascii}"`);
|
const iMatches = [...ascii.matchAll(/I[A-Za-z0-9]{8}(?=[A-Z])/g)];
|
console.log(` • 找到 ${iMatches.length} 个匹配的 I 字段`);
|
if (iMatches.length < 2) {
|
console.log(' • 未找到第二个 I 字段');
|
return null;
|
}
|
const secondMatch = iMatches[1];
|
const serial = secondMatch[0].slice(1);
|
console.log(` • 找到序列号: "${serial}"`);
|
if (/[A-Za-z]/.test(serial) && /\d/.test(serial)) return serial;
|
return null;
|
}
|
|
// 尝试从原始 ASCII 中探测 Kt/V（例如: KTV034, Kt/V=035 等）
|
function extractKTVFromAscii(ascii) {
|
// 常见书写: KTV034、Kt/V=035、ktv: 034
|
const patterns = [
|
/(KTV)\s*[:=]?\s*([0-9]{2,3})/i,
|
/(KT\s*\/\s*V)\s*[:=]?\s*([0-9]{2,3})/i,
|
/(KTV)\s*([0-9]{2,3})/i
|
];
|
for (const re of patterns) {
|
const m = ascii.match(re);
|
if (m && m[2]) {
|
const raw = parseInt(m[2], 10);
|
if (!isNaN(raw)) {
|
return +(raw / 100).toFixed(2);
|
}
|
}
|
}
|
return null;
|
}
|
|
function printClinicalParams(params) {
|
console.log('\n🩺 临床参数解析（TCP 服务端接收）:');
|
const known = {};
|
if ('V' in params) { console.log(` • 静脉压: ${params.V} mmHg`); known.V = true; }
|
if ('A' in params) { console.log(` • 动脉压: ${params.A} mmHg`); known.A = true; }
|
if ('U' in params) { console.log(` • 跨膜压 (TMP): ${params.U} mmHg`); known.U = true; }
|
if ('T' in params) { console.log(` • 透析液温度: ${(params.T / 10).toFixed(1)} °C`); known.T = true; }
|
if ('C' in params) { console.log(` • 电导率: ${(params.C / 10).toFixed(1)} mS/cm`); known.C = true; }
|
if ('I' in params) { console.log(` • 实际透析液流量: ${params.I} mL/min`); known.I = true; }
|
if ('Q' in params) { console.log(` • 有效血流量: ${params.Q} mL/min`); known.Q = true; }
|
if ('R' in params) { console.log(` • 超滤速率: ${(params.R / 1000).toFixed(2)} L/h`); known.R = true; }
|
if ('P' in params) { console.log(` • 已完成超滤量: ${(params.P / 1000).toFixed(2)} L`); known.P = true; }
|
if ('G' in params) { console.log(` • 超滤目标量: ${(params.G / 1000).toFixed(2)} L`); known.G = true; }
|
if ('H' in params) {
|
const mins = params.H;
|
console.log(` • 剩余治疗时间: ${mins} 分钟 (${Math.floor(mins / 60)}h ${mins % 60}m)`);
|
known.H = true;
|
}
|
if ('N' in params) { console.log(` • 钠浓度: ${(params.N / 10).toFixed(1)} mmol/L`); known.N = true; }
|
if ('Y' in params) {
|
console.log(` • 累计血容量: ${(params.Y / 10).toFixed(1)} L`);
|
known.Y = true;
|
}
|
const maybe = { B: '血泵设定值?', S: '系统状态码?', X: '静脉壶状态?', M: '总治疗时间?', L: '肝素累计?', Z: 'TMP补偿?' };
|
for (const [tag, desc] of Object.entries(maybe)) {
|
if (tag in params && !(tag in known)) {
|
console.log(` • ${desc} (${tag}): ${params[tag]}`);
|
known[tag] = true;
|
}
|
}
|
const unknownTags = Object.keys(params).filter(t => !(t in known));
|
if (unknownTags.length > 0) {
|
console.log(` • 未识别字段: ${unknownTags.map(t => `${t}=${params[t]}`).join(', ')}`);
|
}
|
}
|
|
// 构建中文属性的 JSON 结果
|
function buildChineseJson(params, serialFromState) {
|
const map = {
|
V: '静脉压',
|
A: '动脉压',
|
U: '跨膜压',
|
T: '透析液温度(°C)',
|
C: '电导率(mS/cm)',
|
I: '实际透析液流量',
|
Q: '有效血流量',
|
R: '超滤速率(L/h)',
|
P: '已完成超滤量(L)',
|
G: '超滤目标量(L)',
|
H: '剩余治疗时间(分钟)',
|
N: '钠浓度(mmol/L)',
|
Y: '累计血容量(L)',
|
B: '血泵设定值',
|
S: '系统状态码',
|
X: '静脉壶状态',
|
M: '总治疗时间(分钟)',
|
L: '肝素累计',
|
Z: 'TMP补偿'
|
};
|
|
function convert(tag, val) {
|
if (val === undefined || val === null) return val;
|
switch (tag) {
|
case 'T':
|
case 'C':
|
case 'N':
|
return parseFloat((val / 10).toFixed(1));
|
case 'Y':
|
return parseFloat((val / 10).toFixed(1));
|
case 'R':
|
case 'P':
|
case 'G':
|
return parseFloat((val / 1000).toFixed(2));
|
default:
|
return val;
|
}
|
}
|
|
const obj = {
|
'接收时间': formatDateTime(),
|
'设备序列号': serialFromState || null
|
};
|
|
const knownTags = new Set(Object.keys(map));
|
for (const [tag, cname] of Object.entries(map)) {
|
if (tag in params) {
|
obj[cname] = convert(tag, params[tag]);
|
}
|
}
|
|
const others = {};
|
for (const [tag, value] of Object.entries(params)) {
|
if (!knownTags.has(tag)) {
|
others[tag] = value;
|
}
|
}
|
if (Object.keys(others).length > 0) {
|
obj['未识别字段'] = others;
|
}
|
|
return obj;
|
}
|
|
function handleFrame(frame, state) {
|
const hexStr = frame.toString('hex').replace(/(.{2})/g, '$1 ').trim().toUpperCase();
|
const asciiFull = frame.toString('ascii').replace(/[^\x20-\x7E]/g, '.');
|
console.log(`\n📥 [${new Date().toLocaleTimeString()}] 接收到完整数据帧`);
|
console.log(` HEX (${frame.length} bytes): ${hexStr}`);
|
console.log(` ASCII: "${asciiFull}"`);
|
state.log.info('rx.frame', { clientId: state.id, serial: state.detectedSerial, remote: state.remoteAddress, bytes: frame.length, hex: hexStr, ascii: asciiFull });
|
if (frame.length < 15) {
|
console.log(' └─ ⚠️ 忽略短帧（ACK）');
|
return;
|
}
|
if (!state.detectedSerial) {
|
const serial = extractSerialNumber(frame);
|
if (serial) {
|
state.detectedSerial = serial;
|
// 切换到设备子日志器，携带 IP 与 clientId
|
state.log = logger.forDevice(serial, state.remoteAddress, state.id);
|
console.log(` 🏷️ 设备序列号: ${serial}`);
|
state.log.info('id.detected', { clientId: state.id, serial, remote: state.remoteAddress });
|
}
|
}
|
const params = extractAllFields(frame);
|
printClinicalParams(params);
|
state.log.info('parse.params', { clientId: state.id, serial: state.detectedSerial, params });
|
|
// 额外探测 Kt/V 值
|
const asciiRaw = frame.toString('ascii');
|
const ktvDetected = extractKTVFromAscii(asciiRaw);
|
if (ktvDetected != null) {
|
console.log(` • Kt/V(探测): ${ktvDetected}`);
|
}
|
|
// === 生成并打印中文属性的 JSON ===
|
const dataJson = buildChineseJson(params, state.detectedSerial);
|
if (ktvDetected != null) {
|
dataJson['Kt/V'] = ktvDetected;
|
}
|
console.log(`\n🧾 数据JSON [#${state.id}]:`);
|
console.log(JSON.stringify(dataJson, null, 2));
|
|
// 写入设备数据缓存（按设备序列号）
|
if (state.detectedSerial) {
|
deviceCache.set(state.detectedSerial, {
|
data: dataJson,
|
updatedAt: new Date().toISOString(),
|
clientId: state.id
|
});
|
state.log.info('cache.update', { serial: state.detectedSerial, clientId: state.id });
|
|
// 上报到阿里云 IoT（使用序列号作为设备ID，受 aliyun-config.json 的 enabled 控制）
|
if (ALIYUN_ENABLED) {
|
try {
|
const aliyunProps = mapToAliyunProps(params, state);
|
if (Object.keys(aliyunProps).length > 0) {
|
console.log(`\n📤 准备上报阿里云 [${state.detectedSerial}] 属性:`);
|
console.log(JSON.stringify(aliyunProps, null, 2));
|
state.log.info('aliyun.sendProps', { serial: state.detectedSerial, clientId: state.id, ip: state.remoteAddress, props: aliyunProps });
|
sendDataToAliyun(state.detectedSerial, aliyunProps, { ip: state.remoteAddress, clientId: state.id });
|
}
|
} catch (e) {
|
console.error('❌ 上报阿里云失败:', e.message);
|
}
|
} else {
|
state.log.info('aliyun.disabled', { serial: state.detectedSerial, clientId: state.id, reason: 'aliyun-config.json enabled=false' });
|
}
|
|
// 发布到 MQTT（受 mqtt-config.json 的 enabled 控制）
|
if (MQTT_ENABLED) {
|
try {
|
// MQTT 使用与阿里云物模型相同的格式
|
const aliyunProps = mapToAliyunProps(params, state);
|
publishToMqtt(state.detectedSerial, aliyunProps, `${state.remoteAddress}:${state.id}`);
|
} catch (e) {
|
console.error('❌ MQTT 发布失败:', e.message);
|
state.log.error('mqtt.publish.error', { serial: state.detectedSerial, error: e.message });
|
}
|
}
|
}
|
}
|
|
// 每个连接维护独立缓冲区
|
function createConnectionHandler(socket) {
|
// 连接数量限制
|
if (clients.size >= MAX_CLIENTS) {
|
console.warn('⚠️ 超出最大并发限制，拒绝新连接');
|
try { socket.destroy(); } catch {}
|
return;
|
}
|
|
const id = ++connectionSeq;
|
const state = {
|
id,
|
rxBuffer: Buffer.alloc(0),
|
detectedSerial: null,
|
timerId: null,
|
activateTimerId: null,
|
lastActivityAt: Date.now(),
|
log: logger.child({ clientId: id })
|
};
|
clients.set(id, { socket, state });
|
|
socket.setKeepAlive(true, 10000);
|
socket.setNoDelay(true);
|
const remote = `${socket.remoteAddress}:${socket.remotePort}`;
|
state.remoteAddress = socket.remoteAddress;
|
// 将连接级子日志器包含 IP，便于排错
|
state.log = logger.child({ clientId: id, ip: state.remoteAddress });
|
console.log(`🔗 [#${id}] 客户端已连接: ${remote}`);
|
state.log.info('conn.open', { clientId: id, remote: remote });
|
|
// 连接后立即发送激活指令（日志脱敏）
|
console.log(`📤 [#${id}] ${new Date().toLocaleTimeString()} 发送 激活指令: ${obfuscateHex(ACTIVATE_CMD_HEX)}`);
|
safeWrite(socket, ACTIVATE_CMD, '激活指令', state.log);
|
state.log.info('tx.activate', { clientId: id, hexObf: obfuscateHex(ACTIVATE_CMD_HEX), bytes: ACTIVATE_CMD.length });
|
|
// 周期发送获取治疗数据指令（日志脱敏）
|
state.timerId = setInterval(() => {
|
console.log(`📤 [#${id}] ${new Date().toLocaleTimeString()} 发送 获取治疗数据: ${obfuscateHex(GET_DATA_CMD_HEX)}`);
|
safeWrite(socket, GET_DATA_CMD, '获取治疗数据', state.log);
|
state.log.info('tx.getData', { clientId: id, hexObf: obfuscateHex(GET_DATA_CMD_HEX), bytes: GET_DATA_CMD.length });
|
}, GET_DATA_INTERVAL);
|
|
// 周期发送激活指令（保活，日志脱敏）
|
state.activateTimerId = setInterval(() => {
|
console.log(`📤 [#${id}] ${new Date().toLocaleTimeString()} 发送 保活激活指令: ${obfuscateHex(ACTIVATE_CMD_HEX)}`);
|
safeWrite(socket, ACTIVATE_CMD, '保活激活指令', state.log);
|
state.log.info('tx.activate.periodic', { clientId: id, hexObf: obfuscateHex(ACTIVATE_CMD_HEX), bytes: ACTIVATE_CMD.length });
|
}, ACTIVATE_INTERVAL);
|
|
socket.on('data', (chunk) => {
|
state.lastActivityAt = Date.now();
|
state.log.info('rx.chunk', { clientId: id, bytes: chunk.length, hexSample: bufferToHexSample(chunk), truncated: chunk.length > 64 });
|
state.rxBuffer = Buffer.concat([state.rxBuffer, chunk]);
|
let endIndex;
|
while ((endIndex = state.rxBuffer.indexOf(FRAME_END)) !== -1) {
|
const frame = state.rxBuffer.subarray(0, endIndex + FRAME_END.length);
|
handleFrame(frame, state);
|
state.rxBuffer = state.rxBuffer.subarray(endIndex + FRAME_END.length);
|
}
|
if (state.rxBuffer.length > 1024 * 1024) {
|
console.warn('⚠️ 接收缓冲区异常增长，清空');
|
state.log.warn('rx.buffer.reset', { reason: 'overflow', size: state.rxBuffer.length });
|
state.rxBuffer = Buffer.alloc(0);
|
}
|
});
|
|
socket.on('error', (err) => {
|
console.error(`❌ [#${id}] 连接错误 (${remote}):`, err.message);
|
state.log.error('conn.error', { clientId: id, remote, error: err.message });
|
});
|
|
socket.on('close', () => {
|
console.log(`🔌 [#${id}] 客户端断开: ${remote}`);
|
state.log.info('conn.close', { clientId: id, remote });
|
if (state.timerId) clearInterval(state.timerId);
|
if (state.activateTimerId) clearInterval(state.activateTimerId);
|
clients.delete(id);
|
});
|
}
|
|
// 创建并启动服务器
|
const server = net.createServer(createConnectionHandler);
|
server.maxConnections = MAX_CLIENTS;
|
const clients = new Map();
|
let connectionSeq = 0;
|
const deviceCache = new Map(); // 序列号 -> 最新数据
|
let shutdownInitiated = false;
|
const SOCKET_GRACE_MS = 2000; // socket优雅关闭等待
|
const FORCE_EXIT_MS = 8000; // 最长等待后强制退出
|
|
// 将解析到的参数映射为阿里云物模型的属性标识，只保留能匹配的字段
|
function mapToAliyunProps(params, state) {
|
const out = {};
|
// A 脱水目标量 ← G 超滤目标量
|
if (params.G != null) out.A = (params.G / 1000).toFixed(2);
|
// B 脱水量 ← P 已完成超滤量
|
if (params.P != null) out.B = (params.P / 1000).toFixed(2);
|
// C 脱水速率 ← R 超滤速率（原始值/1000 → L/h）
|
if (params.R != null) out.C = (params.R / 1000).toFixed(2);
|
// D 血液流速 ← Q 有效血流量
|
if (params.Q != null) out.D = String(params.Q);
|
// o 动脉压 ← A 动脉压
|
if (params.A != null) out.o = String(params.A);
|
// E 肝素速率（暂无解析源，跳过）
|
// F 透析液温度 ← T/10
|
if (params.T != null) out.F = (params.T / 10).toFixed(1);
|
// G 透析液电导度 ← C/10
|
if (params.C != null) out.G = (params.C / 10).toFixed(1);
|
// H 静脉压 ← V
|
if (params.V != null) out.H = String(params.V);
|
// I 透析液压（暂无解析源，跳过）
|
// J 跨膜压 ← U
|
if (params.U != null) out.J = String(params.U);
|
// K 透析时间 ← 优先 M(总治疗时间)，其次 H(剩余时间)
|
if (params.H != null) out.K = String(params.H); else if (params.H != null) out.K = String(params.H);
|
// L 透析液流速 ← I 实际透析液流量
|
if (params.I != null) out.L = String(params.I);
|
|
// U 血流总量 ← Y 累计血容量，转换为 L（一位小数）
|
if (params.Y != null) out.U = (params.Y / 10).toFixed(1);
|
|
// 辅助属性
|
if (state.detectedSerial) out.n = state.detectedSerial; // 序列号
|
out.suedtime = formatDateTime(); // 传输时间
|
out.deviceType = 'Fresenius4008S';
|
out.deviceName = state.detectedSerial || 'unknown';
|
if (state.remoteAddress) out.IPAddress = state.remoteAddress;
|
|
return out;
|
}
|
|
server.on('error', (err) => {
|
console.error('❌ 服务器错误:', err.message);
|
logger.error('server.error', { error: err.message });
|
});
|
|
server.listen(PORT, HOST, () => {
|
console.log(`🩺 Fresenius 4008S TCP 服务端已启动`);
|
console.log(`🛰️ 监听: ${HOST}:${PORT} | 最大并发: ${MAX_CLIENTS}`);
|
console.log(`⚙️ TCP配置来源: ${tcpCfg.__meta?.source || 'unknown'}${tcpCfg.__meta?.path ? ' (' + tcpCfg.__meta.path + ')' : ''}`);
|
console.log(`📏 下发指令: 激活=${obfuscateHex(ACTIVATE_CMD_HEX)}，取数=${obfuscateHex(GET_DATA_CMD_HEX)}`);
|
console.log(`⏱️ 间隔: 获取数据=${GET_DATA_INTERVAL}ms；保活激活=${ACTIVATE_INTERVAL}ms`);
|
console.log(`☁️ 阿里云IoT: ${ALIYUN_ENABLED ? '✅ 已启用' : '❌ 已禁用'} (配置来源: ${aliyunCfg.__meta?.source || 'unknown'})`);
|
console.log(`📡 MQTT: ${MQTT_ENABLED ? '✅ 已启用' : '❌ 已禁用'} ${MQTT_ENABLED ? `(${mqttCfg.brokerUrl}:${mqttCfg.port})` : '(配置来源: ' + (mqttCfg.__meta?.source || 'unknown') + ')'}`);
|
console.log('📜 行为: 连接即下发激活；按配置周期保活激活与获取数据；收到数据帧后解析');
|
logger.info('server.start.config', {
|
tcp: {
|
source: tcpCfg.__meta?.source,
|
path: tcpCfg.__meta?.path,
|
host: HOST,
|
port: PORT,
|
maxClients: MAX_CLIENTS,
|
getDataIntervalMs: GET_DATA_INTERVAL,
|
activateIntervalMs: ACTIVATE_INTERVAL,
|
},
|
http: {
|
enabled: httpCfg.enabled,
|
source: httpCfg.__meta?.source,
|
path: httpCfg.__meta?.path,
|
host: httpCfg.host,
|
port: httpCfg.port,
|
},
|
aliyun: {
|
enabled: ALIYUN_ENABLED,
|
source: aliyunCfg.__meta?.source,
|
path: aliyunCfg.__meta?.path,
|
},
|
mqtt: {
|
enabled: MQTT_ENABLED,
|
source: mqttCfg.__meta?.source,
|
path: mqttCfg.__meta?.path,
|
brokerUrl: MQTT_ENABLED ? mqttCfg.brokerUrl : undefined,
|
port: MQTT_ENABLED ? mqttCfg.port : undefined,
|
}
|
});
|
});
|
|
// ===== HTTP 服务：使用独立模块与配置启动 =====
|
function loadHttpConfig() {
|
const baseDir = (typeof process !== 'undefined' && process.pkg) ? path.dirname(process.execPath) : __dirname;
|
const candidates = [
|
{ path: path.join(baseDir, 'http-config.json'), source: 'exedir' },
|
{ path: path.join(__dirname, 'http-config.json'), source: 'srcdir' }
|
];
|
for (const c of candidates) {
|
try {
|
const raw = fs.readFileSync(c.path, 'utf8');
|
const obj = JSON.parse(raw);
|
obj.__meta = { source: c.source, path: c.path };
|
// 默认值兜底
|
if (obj.enabled === undefined) obj.enabled = false;
|
if (obj.host === undefined) obj.host = '0.0.0.0';
|
if (obj.port === undefined) obj.port = 8080;
|
return obj;
|
} catch (_) { /* continue */ }
|
}
|
const def = { enabled: false, host: '0.0.0.0', port: 8080 };
|
def.__meta = { source: 'default', path: null };
|
return def;
|
}
|
|
const httpCfg = loadHttpConfig();
|
if (httpCfg.enabled) {
|
const host = httpCfg.host || HOST;
|
const port = httpCfg.port || 8080;
|
console.log(`🌐 HTTP API 配置来源: ${httpCfg.__meta?.source || 'unknown'}${httpCfg.__meta?.path ? ' (' + httpCfg.__meta.path + ')' : ''}`);
|
console.log(`🌐 HTTP API 监听: ${host}:${port}`);
|
logger.info('http.config', { source: httpCfg.__meta?.source, path: httpCfg.__meta?.path, host, port });
|
startHttpApi({
|
host,
|
port,
|
getDevices: () => {
|
const serials = [];
|
for (const { state } of clients.values()) {
|
if (state.detectedSerial) serials.push(state.detectedSerial);
|
}
|
return serials;
|
},
|
getAllData: () => {
|
const all = {};
|
for (const [serial, entry] of deviceCache.entries()) {
|
all[serial] = { updatedAt: entry.updatedAt, data: entry.data };
|
}
|
return all;
|
},
|
getDataBySerial: (serial) => {
|
const entry = deviceCache.get(serial);
|
return entry ? { serial, updatedAt: entry.updatedAt, data: entry.data } : null;
|
}
|
});
|
} else {
|
console.log('HTTP API 未启用（可通过 http-config.json 启用）');
|
}
|
|
// 优雅关闭
|
function shutdown() {
|
if (shutdownInitiated) return;
|
shutdownInitiated = true;
|
console.log('\n🛑 正在关闭服务器...');
|
logger.info('server.shutdown.start');
|
|
// 停止新连接
|
try {
|
server.close(() => {
|
console.log('✅ 已关闭监听 (不再接受新连接)');
|
logger.info('server.stop.listen');
|
});
|
} catch (e) {
|
console.error('server.close 出错:', e.message);
|
logger.error('server.stop.error', { error: e.message });
|
}
|
|
// 逐个关闭现有连接：清理计时器，优雅结束，再强制销毁
|
for (const [id, { socket, state }] of clients.entries()) {
|
try {
|
if (state && state.timerId) {
|
clearInterval(state.timerId);
|
state.timerId = null;
|
}
|
if (state && state.activateTimerId) {
|
clearInterval(state.activateTimerId);
|
state.activateTimerId = null;
|
}
|
const remote = `${socket.remoteAddress}:${socket.remotePort}`;
|
console.log(`🔻 关闭连接 [#${id}] ${remote}`);
|
(state.log || logger).info('conn.shutdown', { clientId: id, remote });
|
// 优雅结束
|
try { socket.end(); } catch {}
|
// 超时后强制销毁
|
setTimeout(() => {
|
if (!socket.destroyed) {
|
try { socket.destroy(); } catch {}
|
(state.log || logger).warn('conn.destroy', { clientId: id, remote });
|
}
|
clients.delete(id);
|
}, SOCKET_GRACE_MS);
|
} catch (e) {
|
logger.error('conn.shutdown.error', { clientId: id, error: e.message });
|
}
|
}
|
|
// 关闭阿里云 IoT 所有设备连接
|
try {
|
closeAllConnections();
|
logger.info('aliyun.close.all');
|
} catch (e) {
|
console.error('关闭阿里云 IoT 连接失败:', e.message);
|
logger.error('aliyun.close.error', { error: e.message });
|
}
|
|
// 关闭 MQTT 连接
|
try {
|
if (MQTT_ENABLED) {
|
closeMqtt();
|
}
|
} catch (e) {
|
console.error('关闭 MQTT 连接失败:', e.message);
|
logger.error('mqtt.close.error', { error: e.message });
|
}
|
|
// 最长等待后强制退出
|
const forceTimer = setTimeout(() => {
|
const remaining = clients.size;
|
if (remaining > 0) {
|
console.warn(`⏱️ 强制退出，仍有 ${remaining} 个连接未释放`);
|
logger.warn('server.stop.force', { remaining });
|
}
|
process.exit(0);
|
}, FORCE_EXIT_MS);
|
|
// 若全部释放，尽快退出
|
const checkClear = () => {
|
if (clients.size === 0) {
|
clearTimeout(forceTimer);
|
console.log('🟢 连接已清空，退出进程');
|
logger.info('server.stop');
|
process.exit(0);
|
}
|
};
|
setTimeout(checkClear, SOCKET_GRACE_MS + 200);
|
}
|
|
process.on('SIGINT', shutdown);
|
process.on('SIGTERM', shutdown);
|
