const net = require('net');
|
const { JhmDecoder } = require('./decoder');
|
|
function normalizeIp(address) {
|
if (!address) {
|
return '';
|
}
|
|
if (address.startsWith('::ffff:')) {
|
return address.slice(7);
|
}
|
|
return address;
|
}
|
|
function formatReceivedTimestamp(date = new Date()) {
|
const year = date.getFullYear();
|
const month = String(date.getMonth() + 1).padStart(2, '0');
|
const day = String(date.getDate()).padStart(2, '0');
|
const hour = String(date.getHours()).padStart(2, '0');
|
const minute = String(date.getMinutes()).padStart(2, '0');
|
const second = String(date.getSeconds()).padStart(2, '0');
|
|
return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
|
}
|
|
class TcpService {
|
constructor(options) {
|
this.tcpConfig = options.tcpConfig;
|
this.devices = options.devices || [];
|
this.alModelPath = options.alModelPath;
|
this.publishBloodPressureTime = options.publishBloodPressureTime !== false;
|
this.logger = options.logger || console;
|
this.onMetric = typeof options.onMetric === 'function' ? options.onMetric : () => {};
|
this.server = null;
|
this.sessions = new Map();
|
this.deviceMap = this.buildDeviceMap(this.devices);
|
}
|
|
buildDeviceMap(devices) {
|
const map = new Map();
|
|
for (const device of devices) {
|
if (!device || !device.ip || !device.deviceId) {
|
continue;
|
}
|
|
map.set(normalizeIp(device.ip), {
|
...device,
|
name: device.name || device['备注'] || device.deviceId,
|
});
|
}
|
|
return map;
|
}
|
|
getReceivedMetricTime() {
|
return formatReceivedTimestamp();
|
}
|
|
async start() {
|
this.server = net.createServer((socket) => {
|
this.handleConnection(socket);
|
});
|
|
this.server.maxConnections = this.tcpConfig.maxConnections || 100;
|
|
this.server.on('error', (error) => {
|
this.logger.error(`[TCP] 服务错误: ${error.message}`);
|
});
|
|
await new Promise((resolve, reject) => {
|
this.server.once('listening', resolve);
|
this.server.once('error', reject);
|
this.server.listen({
|
host: this.tcpConfig.host,
|
port: this.tcpConfig.port,
|
backlog: this.tcpConfig.backlog || 128,
|
});
|
});
|
|
this.logger.info(`[TCP] 已监听 ${this.tcpConfig.host}:${this.tcpConfig.port} devices=${this.deviceMap.size} maxConnections=${this.server.maxConnections}`);
|
}
|
|
handleConnection(socket) {
|
const clientIp = normalizeIp(socket.remoteAddress);
|
const device = this.deviceMap.get(clientIp);
|
|
if (!device) {
|
this.logger.warn(`[TCP] 未配置设备接入，ip=${clientIp} port=${socket.remotePort}，连接将被关闭`);
|
socket.destroy();
|
return;
|
}
|
|
const decoder = new JhmDecoder({
|
alModelPath: this.alModelPath,
|
maxBufferBytes: this.tcpConfig.maxBufferBytes || 8192,
|
});
|
|
this.sessions.set(socket, {
|
clientIp,
|
device,
|
decoder,
|
});
|
|
if (this.tcpConfig.keepAlive) {
|
socket.setKeepAlive(true, this.tcpConfig.keepAliveDelayMs || 10000);
|
}
|
|
socket.setNoDelay(Boolean(this.tcpConfig.noDelay));
|
socket.setTimeout(this.tcpConfig.socketTimeoutMs || 120000);
|
|
this.logger.info(`[TCP] 设备已连接 deviceId=${device.deviceId} ip=${clientIp} port=${socket.remotePort} activeSessions=${this.sessions.size}`);
|
|
socket.on('data', (chunk) => {
|
this.handleData(socket, chunk);
|
});
|
|
socket.on('timeout', () => {
|
this.logger.warn(`[TCP] 连接超时 deviceId=${device.deviceId} ip=${clientIp}`);
|
socket.destroy();
|
});
|
|
socket.on('error', (error) => {
|
this.logger.error(`[TCP] 连接异常 deviceId=${device.deviceId} ip=${clientIp}: ${error.message}`);
|
});
|
|
socket.on('close', () => {
|
this.sessions.delete(socket);
|
this.logger.info(`[TCP] 设备已断开 deviceId=${device.deviceId} ip=${clientIp} activeSessions=${this.sessions.size}`);
|
});
|
}
|
|
handleData(socket, chunk) {
|
const session = this.sessions.get(socket);
|
|
if (!session) {
|
return;
|
}
|
|
this.logger.info(`[TCP] 收到原始数据 deviceId=${session.device.deviceId} bytes=${chunk.length}`);
|
|
const results = session.decoder.push(chunk);
|
|
if (results.length === 0) {
|
this.logger.warn(`[TCP] 当前数据片段未形成完整报文 deviceId=${session.device.deviceId} bytes=${chunk.length}`);
|
}
|
|
for (const result of results) {
|
if (!result.publish) {
|
if (!result.ok) {
|
this.logger.warn(`[TCP] 丢弃无效报文 deviceId=${session.device.deviceId} reason=${result.reason}`);
|
} else {
|
this.logger.warn(`[TCP] 跳过未发布报文 deviceId=${session.device.deviceId} reason=${result.reason || 'publish-disabled'} raw=${result.rawHex || ''}`);
|
}
|
continue;
|
}
|
|
if (result.protocol === 'blood-pressure' && this.publishBloodPressureTime) {
|
result.metric = {
|
...result.metric,
|
M: this.getReceivedMetricTime(),
|
};
|
}
|
|
this.logger.info(`[TCP] 收到指标 deviceId=${session.device.deviceId} metric=${JSON.stringify(result.metric)} raw=${result.rawHex}`);
|
this.onMetric(session.device, result.metric, result);
|
}
|
}
|
|
async stop() {
|
this.logger.info(`[TCP] 开始停止 TCP 服务 activeSessions=${this.sessions.size}`);
|
|
for (const socket of this.sessions.keys()) {
|
socket.destroy();
|
}
|
|
this.sessions.clear();
|
|
if (!this.server) {
|
return;
|
}
|
|
await new Promise((resolve) => {
|
this.server.close(resolve);
|
});
|
|
this.server = null;
|
this.logger.info('[TCP] TCP 服务已停止');
|
}
|
}
|
|
module.exports = {
|
formatReceivedTimestamp,
|
TcpService,
|
normalizeIp,
|
};
|
