feat(hikvision): 任务权重与普通/加急双通道调度,修复录制进程崩溃与 frpc 孤儿问题

feat: hik_tasks 新增 weight(0=普通 1=加急),三处下发入口(fetchTasks/receiveTask/HTTP download)解析落库,老库启动 ALTER 自动补列+索引

feat: 调度器拆双通道——普通通道只跑 weight=0、加急通道只跑 weight=1,每 NVR 各 1 路,两通道互不排斥、加急通道自身互斥;任务启动抽成 _startHikTaskDownload

fix: fetchTasks 对已排队任务同步权重复下发(此前直接 continue,服务端把排队任务转加急不生效)

fix(hikvision): _httpPlaybackDownload 的 ws.on('finish') 裸调 fs.statSync,临时文件被 cleanupTmp 删除后抛 ENOENT 未捕获导致整个进程退出(2026-09-11 平台离线约 48 分钟);加 settled 守卫 + try/catch

feat(index): 增加 uncaughtException/unhandledRejection 兜底,未捕获异常只记日志不退出进程

feat(frpc): 启动前清理使用同一 ini 的遗留/孤儿 frpc(孤儿长期占着 frp 代理名,导致平台经隧道进来的调用全部失败);新增启动代际守卫,避免并发调用产生多个 frpc 抢同一代理名;修正日志占位符未格式化问题
This commit is contained in:
liufumingren 2026-09-11 18:14:12 +08:00
parent caeca2da52
commit 37e7b8ddaa
5 changed files with 342 additions and 138 deletions

View File

@ -221,10 +221,15 @@ class Main extends EventEmitter {
const url = new URL(req.url, `http://${req.headers.host}`); const url = new URL(req.url, `http://${req.headers.host}`);
const pathname = url.pathname; const pathname = url.pathname;
// 解析 JSON body // 解析 JSON body(解析失败返回 400,不能让坏请求打死整个服务)
let body = null; let body = null;
if (req.method === 'POST' && req.headers['content-type']?.includes('application/json')) { if (req.method === 'POST' && req.headers['content-type']?.includes('application/json')) {
body = await this._readRequestBody(req); try {
body = await this._readRequestBody(req);
} catch (e) {
this._sendJson(res, 400, { success: false, message: 'JSON 解析失败' });
return;
}
} }
try { try {
@ -373,17 +378,19 @@ class Main extends EventEmitter {
// 下载前:检查存储配额 // 下载前:检查存储配额
this.checkHikStorageQuota().catch(e => console.error('[Hikvision] 预下载配额检查失败:', e.message)); this.checkHikStorageQuota().catch(e => console.error('[Hikvision] 预下载配额检查失败:', e.message));
// 写入任务池(保存相对路径) // 写入任务池(保存相对路径);weight: 0=普通(默认),1=加急(优先调度)
const weight = Number(body.weight) === 1 ? 1 : 0;
this.db.table('hik_tasks').insert({ this.db.table('hik_tasks').insert({
task_id: taskId, task_id: taskId,
task_params: JSON.stringify({ task_params: JSON.stringify({
ip: body.ip, port: body.port || 7681, httpPort: body.httpPort || 80, ip: body.ip, port: body.port || 7681, httpPort: body.httpPort || 80,
user: body.user, pass: body.pass, user: body.user, pass: body.pass,
channel: body.channel || 33, start: body.start, end: body.end, channel: body.channel || 33, start: body.start, end: body.end,
speed: body.speed || 4, output: relOutput, videoTime speed: body.speed || 4, output: relOutput, videoTime, weight
}), }),
status: 'pending', status: 'pending',
retry: 0, retry: 0,
weight,
timeout: videoTime + 60, timeout: videoTime + 60,
tmp_file_path: relOutput tmp_file_path: relOutput
}); });
@ -497,6 +504,7 @@ class Main extends EventEmitter {
return { return {
id: r.id, task_id: r.task_id, unique_code: r.unique_code || '', id: r.id, task_id: r.task_id, unique_code: r.unique_code || '',
status: apiStatus, status: apiStatus,
weight: r.weight || 0,
ip: params.ip || '', channel: params.channel || 0, ip: params.ip || '', channel: params.channel || 0,
speed: params.speed || 4, videoTime: params.videoTime || 0, speed: params.speed || 4, videoTime: params.videoTime || 0,
rec_start: params.start || '', rec_end: params.end || '', rec_start: params.start || '', rec_end: params.end || '',
@ -598,18 +606,33 @@ class Main extends EventEmitter {
WHERE status IN ('failed','timeout','error') AND retry >= 3 AND fail_logged = 0 WHERE status IN ('failed','timeout','error') AND retry >= 3 AND fail_logged = 0
`); `);
// ④ 每个录像机(IP)最多 maxPerNvr 个并发 worker // ④ 双通道调度(每台 NVR 两条互相独立的通道,互不排斥)
const maxPerNvr = 1; // 每 NVR 最多 1 路并发(多路回放会拖垮 NVR 推流导致录制不完整) // 普通通道:只跑 weight=0 的任务,每 NVR 1 路
const maxTotal = 4; // 总并发上限(跨多个 NVR) // 加急通道:只跑 weight=1 的任务,每 NVR 1 路(加急之间仍互斥,同一 NVR 不会并发两条加急)
const maxNormalPerNvr = 1; // 每 NVR 普通通道并发上限
const maxUrgentPerNvr = 1; // 每 NVR 加急通道并发上限(加急通道自身互斥)
const maxTotalNormal = 4; // 普通通道跨 NVR 总并发上限
const maxTotalUrgent = 2; // 加急通道跨 NVR 总并发上限
// 获取正在运行的 IP 及其并发数 // 分别统计两条通道正在运行的 IP 并发数
const runningRows = this.db.all(`SELECT json_extract(task_params, '$.ip') as ip, COUNT(*) as cnt FROM hik_tasks WHERE status = 'running' GROUP BY ip`); const runningRows = this.db.all(`
const runningCount = new Map(); SELECT json_extract(task_params, '$.ip') AS ip,
for (const r of runningRows) { if (r.ip) runningCount.set(r.ip, r.cnt); } CASE WHEN COALESCE(weight, 0) = 1 THEN 1 ELSE 0 END AS urgent,
COUNT(*) AS cnt
FROM hik_tasks WHERE status = 'running' GROUP BY ip, urgent
`);
const normalRunning = new Map();
const urgentRunning = new Map();
for (const r of runningRows) {
if (!r.ip) continue;
(r.urgent ? urgentRunning : normalRunning).set(r.ip, r.cnt);
}
// 获取待处理任务,按 IP 分组取最早的多条 // 待处理任务按通道分桶(加急优先、其次入队顺序),每 NVR 每通道最多留 perNvrCap 个
const pendingRows = this.db.all(`SELECT * FROM hik_tasks WHERE status = 'pending' ORDER BY id ASC`); const pendingRows = this.db.all(`SELECT * FROM hik_tasks WHERE status = 'pending' ORDER BY COALESCE(weight, 0) DESC, id ASC`);
const pendingByIp = new Map(); const pendingNormalByIp = new Map();
const pendingUrgentByIp = new Map();
let pendingValid = 0;
for (const pt of pendingRows) { for (const pt of pendingRows) {
const tp = JSON.parse(pt.task_params || '{}'); const tp = JSON.parse(pt.task_params || '{}');
const ip = tp.ip; const ip = tp.ip;
@ -617,80 +640,40 @@ class Main extends EventEmitter {
this.db.run(`UPDATE hik_tasks SET status='failed', error_message='参数不完整' WHERE id = ?`, pt.id); this.db.run(`UPDATE hik_tasks SET status='failed', error_message='参数不完整' WHERE id = ?`, pt.id);
continue; continue;
} }
if (!pendingByIp.has(ip)) pendingByIp.set(ip, []); pendingValid++;
if (pendingByIp.get(ip).length < maxPerNvr) pendingByIp.get(ip).push(pt); const isUrgent = Number(pt.weight) === 1;
const bucket = isUrgent ? pendingUrgentByIp : pendingNormalByIp;
const perNvrCap = isUrgent ? maxUrgentPerNvr : maxNormalPerNvr;
if (!bucket.has(ip)) bucket.set(ip, []);
if (bucket.get(ip).length < perNvrCap) bucket.get(ip).push(pt);
} }
let started = 0; // 单通道启动:先加急通道(优先占用空出的 worker),再普通通道
for (const [ip, tasks] of pendingByIp) { const startLane = (bucket, runningCount, perNvrCap, totalCap) => {
const current = runningCount.get(ip) || 0; let started = 0;
if (current >= maxPerNvr) continue; // 该 NVR 已达并发上限 for (const [ip, tasks] of bucket) {
if (started >= maxTotal) break; const current = runningCount.get(ip) || 0;
// 最多启动 maxPerNvr - current 个新任务 if (current >= perNvrCap) continue; // 该 NVR 该通道已达并发上限
const slots = Math.min(tasks.length, maxPerNvr - current, maxTotal - started); if (started >= totalCap) break;
for (let i = 0; i < slots; i++) { // 最多启动 perNvrCap - current 个新任务
const pt = tasks[i]; const slots = Math.min(tasks.length, perNvrCap - current, totalCap - started);
const downloadCfg = { ...JSON.parse(pt.task_params || '{}'), output: this._resolvePath(JSON.parse(pt.task_params || '{}').output) }; for (let i = 0; i < slots; i++) {
const wid = ip; // 用 IP 作为 worker_id this._startHikTaskDownload(tasks[i]);
this.db.run(`UPDATE hik_tasks SET status='running', worker_id=?, start_time=datetime('now') WHERE id=?`, wid, pt.id); runningCount.set(ip, (runningCount.get(ip) || 0) + 1);
started++;
const taskId = pt.task_id; }
const tp = JSON.parse(pt.task_params || '{}');
const self = this;
const task = {
startTime: Date.now(),
progress: { chunks: 0, totalBytes: 0, totalMB: 0, speed: tp.speed || 4 },
params: tp, status: 'running',
unique_code: pt.unique_code || '', // 服务器下发的任务编号
_aborted: false, // receiveTask 强制覆盖时设为 true
abort() {
task._aborted = true;
if (typeof task._abortDownload === 'function') {
try { task._abortDownload(); } catch {}
}
},
_onDone: (result) => {
if (task._aborted) return; // 已被强制终止,跳过所有后续处理
if (result.success === false || (result.size || 0) === 0) {
const errMsg = result.success === false ? '录制返回失败' : '录制文件大小为 0';
task._onError(new Error(errMsg));
return;
}
task.status = 'done'; task.result = result;
const relResult = { ...result, output: self._relativizePath(result.output || '') };
self.db.run(`UPDATE hik_tasks SET status='completed', end_time=datetime('now'), error_message=NULL, result=? WHERE task_id=?`, JSON.stringify(relResult), taskId);
try { self.db.table('hik_downloads').insert({ task_id: taskId, ip: tp.ip || '', channel: tp.channel || 0, output_path: relResult.output || tp.output || '', file_size: result.size || 0, duration: result.duration || 0, resolution: result.resolution || '', status: 'done' }); } catch (e) {}
self.checkHikStorageQuota().catch(() => {});
self._pushTaskResult(taskId, relResult);
setTimeout(() => self._hikTasks.delete(taskId), 5 * 60 * 1000);
self._scheduleHikTasks();
},
_onError: (err) => {
if (task._aborted) return; // 已被强制终止,跳过所有后续处理
task.status = 'error'; task.error = err.message;
// 录像机无此时间视频 → 永久失败,不再重试
const permanent = err.message === '录像机无此时间视频';
self.db.run(
permanent
? `UPDATE hik_tasks SET status='failed', retry=3, notice=1, end_time=datetime('now'), error_message=? WHERE task_id=?`
: `UPDATE hik_tasks SET status='failed', end_time=datetime('now'), error_message=? WHERE task_id=?`,
err.message, taskId
);
try { const fp = self._resolvePath(tp.output); if (fp && fs.existsSync(fp)) fs.unlinkSync(fp); } catch {}
self._pushTaskFailed(taskId, err.message);
setTimeout(() => self._hikTasks.delete(taskId), 5 * 60 * 1000);
self._scheduleHikTasks();
}
};
this._hikTasks.set(taskId, task);
hikvisionService.startDownload(downloadCfg, taskId, task);
runningCount.set(ip, (runningCount.get(ip) || 0) + 1);
started++;
} }
return started;
};
const urgentStarted = startLane(pendingUrgentByIp, urgentRunning, maxUrgentPerNvr, maxTotalUrgent);
const normalStarted = startLane(pendingNormalByIp, normalRunning, maxNormalPerNvr, maxTotalNormal);
if (urgentStarted + normalStarted > 0) {
console.log('[Hikvision] 调度启动 %d 个任务(加急 %d / 普通 %d)', urgentStarted + normalStarted, urgentStarted, normalStarted);
} }
// 空闲拉取
const pendingCount = pendingByIp.size; // 空闲拉取(两条通道都没有待处理任务时)
if (pendingCount === 0) { if (pendingValid === 0) {
const now = Date.now(); const now = Date.now();
if (!this._lastFetchTime || (now - this._lastFetchTime) > 5 * 60 * 1000) { if (!this._lastFetchTime || (now - this._lastFetchTime) > 5 * 60 * 1000) {
this._lastFetchTime = now; this._lastFetchTime = now;
@ -707,6 +690,75 @@ class Main extends EventEmitter {
} }
} }
/**
* 启动单个录像任务下载(普通通道 / 加急通道共用)
* 由 _scheduleHikTasks 在通道有空位时调用
* @param {object} pt hik_tasks 行记录
* @returns {boolean} 是否成功启动
*/
_startHikTaskDownload(pt) {
const hikvisionService = this.services.hikvision;
if (!hikvisionService || typeof hikvisionService.startDownload !== 'function') return false;
const tp = JSON.parse(pt.task_params || '{}');
const downloadCfg = { ...tp, output: this._resolvePath(tp.output) };
const wid = tp.ip; // 用 IP 作为 worker_id
this.db.run(`UPDATE hik_tasks SET status='running', worker_id=?, start_time=datetime('now') WHERE id=?`, wid, pt.id);
const taskId = pt.task_id;
const self = this;
const isUrgent = Number(pt.weight) === 1;
const task = {
startTime: Date.now(),
progress: { chunks: 0, totalBytes: 0, totalMB: 0, speed: tp.speed || 4 },
params: tp, status: 'running',
unique_code: pt.unique_code || '', // 服务器下发的任务编号
_aborted: false, // receiveTask 强制覆盖时设为 true
abort() {
task._aborted = true;
if (typeof task._abortDownload === 'function') {
try { task._abortDownload(); } catch {}
}
},
_onDone: (result) => {
if (task._aborted) return; // 已被强制终止,跳过所有后续处理
if (result.success === false || (result.size || 0) === 0) {
const errMsg = result.success === false ? '录制返回失败' : '录制文件大小为 0';
task._onError(new Error(errMsg));
return;
}
task.status = 'done'; task.result = result;
const relResult = { ...result, output: self._relativizePath(result.output || '') };
self.db.run(`UPDATE hik_tasks SET status='completed', end_time=datetime('now'), error_message=NULL, result=? WHERE task_id=?`, JSON.stringify(relResult), taskId);
try { self.db.table('hik_downloads').insert({ task_id: taskId, ip: tp.ip || '', channel: tp.channel || 0, output_path: relResult.output || tp.output || '', file_size: result.size || 0, duration: result.duration || 0, resolution: result.resolution || '', status: 'done' }); } catch (e) {}
self.checkHikStorageQuota().catch(() => {});
self._pushTaskResult(taskId, relResult);
setTimeout(() => self._hikTasks.delete(taskId), 5 * 60 * 1000);
self._scheduleHikTasks();
},
_onError: (err) => {
if (task._aborted) return; // 已被强制终止,跳过所有后续处理
task.status = 'error'; task.error = err.message;
// 录像机无此时间视频 → 永久失败,不再重试
const permanent = err.message === '录像机无此时间视频';
self.db.run(
permanent
? `UPDATE hik_tasks SET status='failed', retry=3, notice=1, end_time=datetime('now'), error_message=? WHERE task_id=?`
: `UPDATE hik_tasks SET status='failed', end_time=datetime('now'), error_message=? WHERE task_id=?`,
err.message, taskId
);
try { const fp = self._resolvePath(tp.output); if (fp && fs.existsSync(fp)) fs.unlinkSync(fp); } catch {}
self._pushTaskFailed(taskId, err.message);
setTimeout(() => self._hikTasks.delete(taskId), 5 * 60 * 1000);
self._scheduleHikTasks();
}
};
this._hikTasks.set(taskId, task);
console.log('[Hikvision] 启动录制: %s ip=%s ch=%s 通道=%s', taskId, tp.ip || '', tp.channel || '', isUrgent ? '加急' : '普通');
hikvisionService.startDownload(downloadCfg, taskId, task);
return true;
}
/** /**
* 启动任务调度定时器 * 启动任务调度定时器
*/ */
@ -763,7 +815,7 @@ class Main extends EventEmitter {
AND task_id NOT IN ( AND task_id NOT IN (
SELECT task_id FROM hik_task_fail_log GROUP BY task_id HAVING COUNT(*) > 10 SELECT task_id FROM hik_task_fail_log GROUP BY task_id HAVING COUNT(*) > 10
) )
ORDER BY created_at ASC ORDER BY COALESCE(weight, 0) DESC, created_at ASC
LIMIT 20 LIMIT 20
) )
`); `);
@ -1649,6 +1701,9 @@ class Main extends EventEmitter {
try { this.db.exec('ALTER TABLE hik_tasks ADD COLUMN push_retry INTEGER DEFAULT 0'); } catch (_) {} try { this.db.exec('ALTER TABLE hik_tasks ADD COLUMN push_retry INTEGER DEFAULT 0'); } catch (_) {}
try { this.db.exec('ALTER TABLE hik_tasks ADD COLUMN push_next_retry_at TEXT DEFAULT \'\''); } catch (_) {} try { this.db.exec('ALTER TABLE hik_tasks ADD COLUMN push_next_retry_at TEXT DEFAULT \'\''); } catch (_) {}
try { this.db.exec('ALTER TABLE hik_tasks ADD COLUMN fail_logged INTEGER DEFAULT 0'); } catch (_) {} try { this.db.exec('ALTER TABLE hik_tasks ADD COLUMN fail_logged INTEGER DEFAULT 0'); } catch (_) {}
// 权重:0=普通(默认),1=加急。加急任务在待执行队列中优先调度
try { this.db.exec('ALTER TABLE hik_tasks ADD COLUMN weight INTEGER DEFAULT 0'); } catch (_) {}
try { this.db.exec('CREATE INDEX IF NOT EXISTS idx_hik_tasks_weight ON hik_tasks(status, weight)'); } catch (_) {}
this.db.exec(` this.db.exec(`
CREATE TABLE IF NOT EXISTS hik_task_fail_log ( CREATE TABLE IF NOT EXISTS hik_task_fail_log (
id INTEGER PRIMARY KEY AUTOINCREMENT, id INTEGER PRIMARY KEY AUTOINCREMENT,
@ -1702,6 +1757,7 @@ class Main extends EventEmitter {
status TEXT DEFAULT 'pending', status TEXT DEFAULT 'pending',
worker_id INTEGER, worker_id INTEGER,
retry INTEGER DEFAULT 0, retry INTEGER DEFAULT 0,
weight INTEGER DEFAULT 0,
notice INTEGER DEFAULT 0, notice INTEGER DEFAULT 0,
timeout INTEGER DEFAULT 0, timeout INTEGER DEFAULT 0,
error_message TEXT, error_message TEXT,
@ -1716,6 +1772,7 @@ class Main extends EventEmitter {
CREATE INDEX IF NOT EXISTS idx_hik_tasks_status ON hik_tasks(status); CREATE INDEX IF NOT EXISTS idx_hik_tasks_status ON hik_tasks(status);
CREATE INDEX IF NOT EXISTS idx_hik_tasks_worker ON hik_tasks(worker_id); CREATE INDEX IF NOT EXISTS idx_hik_tasks_worker ON hik_tasks(worker_id);
CREATE INDEX IF NOT EXISTS idx_hik_tasks_unique_code ON hik_tasks(unique_code); CREATE INDEX IF NOT EXISTS idx_hik_tasks_unique_code ON hik_tasks(unique_code);
CREATE INDEX IF NOT EXISTS idx_hik_tasks_weight ON hik_tasks(status, weight);
CREATE TABLE IF NOT EXISTS hik_task_fail_log ( CREATE TABLE IF NOT EXISTS hik_task_fail_log (
id INTEGER PRIMARY KEY AUTOINCREMENT, id INTEGER PRIMARY KEY AUTOINCREMENT,

View File

@ -27,6 +27,7 @@ CREATE TABLE IF NOT EXISTS hik_tasks (
status TEXT DEFAULT 'pending', status TEXT DEFAULT 'pending',
worker_id INTEGER, worker_id INTEGER,
retry INTEGER DEFAULT 0, retry INTEGER DEFAULT 0,
weight INTEGER DEFAULT 0,
notice INTEGER DEFAULT 0, notice INTEGER DEFAULT 0,
timeout INTEGER DEFAULT 0, timeout INTEGER DEFAULT 0,
error_message TEXT, error_message TEXT,
@ -43,6 +44,7 @@ CREATE TABLE IF NOT EXISTS hik_tasks (
CREATE INDEX IF NOT EXISTS idx_hik_tasks_unique_code ON hik_tasks(unique_code); CREATE INDEX IF NOT EXISTS idx_hik_tasks_unique_code ON hik_tasks(unique_code);
CREATE INDEX IF NOT EXISTS idx_hik_tasks_status ON hik_tasks(status); CREATE INDEX IF NOT EXISTS idx_hik_tasks_status ON hik_tasks(status);
CREATE INDEX IF NOT EXISTS idx_hik_tasks_worker ON hik_tasks(worker_id); CREATE INDEX IF NOT EXISTS idx_hik_tasks_worker ON hik_tasks(worker_id);
CREATE INDEX IF NOT EXISTS idx_hik_tasks_weight ON hik_tasks(status, weight);
-- 任务失败记录表(每次重试耗尽记一条;失败记录 > 10 条的任务不再被重扫) -- 任务失败记录表(每次重试耗尽记一条;失败记录 > 10 条的任务不再被重扫)
CREATE TABLE IF NOT EXISTS hik_task_fail_log ( CREATE TABLE IF NOT EXISTS hik_task_fail_log (

View File

@ -1,5 +1,16 @@
import app from './core/main.js'; import app from './core/main.js';
// 兜底:未捕获异常 / 未处理的 Promise 拒绝只记录日志,不让整个录制服务进程退出。
// 背景:2026-09-11 17:05 曾因海康下载回调里一次 ENOENT(临时文件已被清理后又 statSync)未被捕获,
// 导致 printserver 进程直接退出、平台显示「离线」约 48 分钟。录制端是无人值守进程,
// 保持存活优先于 crash-fast;异常仍会完整打印到 run.log 便于排查。
process.on('uncaughtException', (err) => {
console.error('[Fatal] 未捕获异常(已兜底,进程继续运行):', err && err.stack ? err.stack : err);
});
process.on('unhandledRejection', (reason) => {
console.error('[Fatal] 未处理的 Promise 拒绝(已兜底,进程继续运行):', reason && reason.stack ? reason.stack : reason);
});
console.log(`后端已启动(仅 WS 模式),监听端口: ${app.config.wsPort}`); console.log(`后端已启动(仅 WS 模式),监听端口: ${app.config.wsPort}`);
export default app; export default app;

View File

@ -1,4 +1,4 @@
import { spawn } from 'child_process'; import { spawn, execSync } from 'child_process';
import fs from 'fs'; import fs from 'fs';
import path from 'path'; import path from 'path';
import service from '../core/BaseService.js'; import service from '../core/BaseService.js';
@ -36,6 +36,7 @@ class FrpcService extends service {
this.process = null; this.process = null;
this.status = 'stopped'; // stopped | starting | running | error this.status = 'stopped'; // stopped | starting | running | error
this._watchTimer = null; this._watchTimer = null;
this._startGen = 0; // 启动代际号:并发调用 _startFrpc 时只允许最后一次真正 spawn
this.updateConfig = this.updateConfig.bind(this); this.updateConfig = this.updateConfig.bind(this);
this.getStatus = this.getStatus.bind(this); this.getStatus = this.getStatus.bind(this);
@ -55,8 +56,7 @@ class FrpcService extends service {
const recording = isRecordingMode(this.config); const recording = isRecordingMode(this.config);
const shouldAutoStart = recording && (!!cfg.enabled || !!cfg.serverAddr); const shouldAutoStart = recording && (!!cfg.enabled || !!cfg.serverAddr);
if (shouldAutoStart) { if (shouldAutoStart) {
_logFile('[Frpc] 自动启动 frpc (enabled=%s, recording=%s)', _logFile('[Frpc] 自动启动 frpc (enabled=' + !!cfg.enabled + ', recording=' + recording + ')');
!!cfg.enabled, recording);
if (!cfg.enabled) { if (!cfg.enabled) {
// 补写 enabled 标记,避免后续 updateConfig 判定混乱 // 补写 enabled 标记,避免后续 updateConfig 判定混乱
cfg.enabled = true; cfg.enabled = true;
@ -64,8 +64,7 @@ class FrpcService extends service {
} }
this._startFrpc(); this._startFrpc();
} else { } else {
_logFile('[Frpc] 跳过自动启动 (enabled=%s, recording=%s)', _logFile('[Frpc] 跳过自动启动 (enabled=' + !!cfg.enabled + ', recording=' + recording + ')');
!!cfg.enabled, recording);
} }
} }
@ -198,8 +197,15 @@ class FrpcService extends service {
_startFrpc() { _startFrpc() {
const hadProcess = !!this.process; const hadProcess = !!this.process;
this._stopFrpc(); this._stopFrpc();
// 代际号:更新配置等场景会并发调用 _startFrpc,且清理遗留进程后会延迟 2 秒才 spawn,
// 没有这个守卫会出现“两次调用各 spawn 一次” → 两个 frpc 抢同一代理名(第二个报 already exists)
const gen = ++this._startGen;
const doSpawn = () => { const doSpawn = (retried) => {
if (gen !== this._startGen) {
_logFile('[Frpc] 忽略过期的启动请求(已有更新的启动流程)');
return;
}
const exePath = this._findFrpcExe(); const exePath = this._findFrpcExe();
if (!exePath) { if (!exePath) {
@ -212,6 +218,21 @@ class FrpcService extends service {
} }
const iniPath = this._generateFrpcIni(); const iniPath = this._generateFrpcIni();
// 启动前先清理「使用同一 ini」的遗留 frpc(含父进程已死的孤儿):它们占着同一个 frp 代理名,
// 新实例会报 `proxy ... already exists` 而注册失败 → 平台经隧道进来的调用全部失败
// (2026-09-11 实测:frpc.log 自 2026-07-28 起累计 32724 条该错误)。
if (!retried) {
const stale = this._killStaleFrpc(iniPath);
if (stale > 0) {
_logFile('[Frpc] 已终止 ' + stale + ' 个遗留 frpc 进程,2 秒后强制清理残留并重新启动');
setTimeout(() => {
if (gen !== this._startGen) return; // 已被更新的启动请求取代
this._killStaleFrpc(iniPath, true);
doSpawn(true);
}, 2000);
return;
}
}
_logFile('[Frpc] 启动 frpc:', exePath, '-c', iniPath); _logFile('[Frpc] 启动 frpc:', exePath, '-c', iniPath);
_logFile('[Frpc] ini 内容:', fs.readFileSync(iniPath, 'utf-8')); _logFile('[Frpc] ini 内容:', fs.readFileSync(iniPath, 'utf-8'));
@ -275,6 +296,56 @@ class FrpcService extends service {
} }
} }
/**
* 清理「命令行里带本服务 ini 路径」的遗留 frpc 进程(不碰系统上其它 frpc,如宝塔的 /www/server/frpc/frpc)。
* 场景:node 进程被 kill/崩溃时,它 spawn 的 frpc 会变成孤儿(PPID=1)继续占着 frp 代理名,
* 导致新 frpc 注册失败、平台无法经隧道访问本机(任务派发走 WS 出站通道不受影响,故不易察觉)。
* @param {string} iniPath 本服务生成的 frpc.ini 绝对路径
* @param {boolean} force true=直接 SIGKILL,false=SIGTERM 优雅退出
* @returns {number} 被终止的进程数
*/
_killStaleFrpc(iniPath, force = false) {
if (!iniPath) return 0;
const selfPid = this.process ? this.process.pid : null;
const rows = [];
try {
if (process.platform === 'win32') {
// PowerShell 脚本用 -EncodedCommand(base64) 传递,彻底避开 cmd/PowerShell 的多层引号问题
const psScript = "Get-CimInstance Win32_Process -Filter \"Name='frpc.exe'\" | ForEach-Object { \"$($_.ProcessId)||$($_.CommandLine)\" }";
const b64 = Buffer.from(psScript, 'utf16le').toString('base64');
const out = execSync(`powershell -NoProfile -NonInteractive -EncodedCommand ${b64}`,
{ encoding: 'utf-8', timeout: 10000, windowsHide: true });
for (const line of out.split(/\r?\n/)) {
const i = line.indexOf('||');
if (i <= 0) continue;
const pid = Number(line.slice(0, i));
if (pid) rows.push({ pid, args: line.slice(i + 2) });
}
} else {
const out = execSync('ps -eo pid=,args=', { encoding: 'utf-8', timeout: 8000 });
for (const line of out.split('\n')) {
const m = line.trim().match(/^(\d+)\s+(.*)$/);
if (m) rows.push({ pid: Number(m[1]), args: m[2] });
}
}
} catch (e) {
_errFile('[Frpc] 枚举 frpc 进程失败:', e.message);
return 0;
}
let killed = 0;
for (const r of rows) {
if (!r.pid || r.pid === process.pid || r.pid === selfPid) continue;
if (!r.args || !r.args.includes(iniPath)) continue;
try {
process.kill(r.pid, force ? 'SIGKILL' : 'SIGTERM');
killed++;
_logFile('[Frpc] 已清理遗留 frpc pid=' + r.pid + (force ? '(SIGKILL)' : '(SIGTERM)'));
} catch (_) { /* 进程可能已退出 */ }
}
return killed;
}
_stopFrpc() { _stopFrpc() {
clearTimeout(this._watchTimer); clearTimeout(this._watchTimer);
if (this.process) { if (this.process) {
@ -292,7 +363,7 @@ class FrpcService extends service {
const prev = this.status; const prev = this.status;
this.status = newStatus; this.status = newStatus;
if (prev !== newStatus) { if (prev !== newStatus) {
_logFile('[Frpc] 状态变更: %s -> %s', prev, newStatus); _logFile('[Frpc] 状态变更: ' + prev + ' -> ' + newStatus);
// 通知本地前端 // 通知本地前端
this.app.emit('frpcStatusChange', { status: newStatus }); this.app.emit('frpcStatusChange', { status: newStatus });
} }

View File

@ -45,10 +45,25 @@ class HikvisionService extends BaseService {
const srv = item.server || {}; const srv = item.server || {};
const cam = item.camera || {}; const cam = item.camera || {};
const uniqueCode = item.uniqueCode || ''; const uniqueCode = item.uniqueCode || '';
// 权重:服务端不下发 weight 即为 0(普通);下发 1 = 加急(走加急通道)
const weight = Number(item.weight) === 1 ? 1 : 0;
if (uniqueCode) { if (uniqueCode) {
const existing = ad.db.get('SELECT id FROM hik_tasks WHERE unique_code = ?', uniqueCode); const existing = ad.db.get('SELECT id, status, weight FROM hik_tasks WHERE unique_code = ?', uniqueCode);
if (existing) continue; if (existing) {
// 同一任务再次下发:仍排队中则同步权重(服务端转加急 → 改表为 1,转入加急通道等待)
if (Number(existing.weight) !== weight && existing.status === 'pending') {
ad.db.run(
`UPDATE hik_tasks SET weight=?, task_params=json_set(COALESCE(task_params,'{}'), '$.weight', ?) WHERE id=?`,
weight, weight, existing.id
);
console.log('[Hikvision] fetchTasks 排队任务权重变更: %s %d → %d', uniqueCode, Number(existing.weight) || 0, weight);
// 权重变化立即触发调度,不必等 3 秒定时器(加急可立刻占用加急通道)
ad._lastFetchTime = null;
ad._scheduleHikTasks();
}
continue;
}
} }
const startStr = item.start_time || ''; const startStr = item.start_time || '';
@ -74,9 +89,9 @@ class HikvisionService extends BaseService {
user: srv.username || 'admin', pass: srv.password || '', user: srv.username || 'admin', pass: srv.password || '',
channel: cam.channel_id || 33, channel: cam.channel_id || 33,
start: fmtStart, end: fmtEnd, start: fmtStart, end: fmtEnd,
speed: 4, output: relOutput, videoTime speed: 4, output: relOutput, videoTime, weight
}), }),
status: 'pending', retry: 0, status: 'pending', retry: 0, weight,
timeout: videoTime + 60, tmp_file_path: relOutput timeout: videoTime + 60, tmp_file_path: relOutput
}); });
created++; created++;
@ -132,6 +147,8 @@ class HikvisionService extends BaseService {
const httpPort = data.httpPort || srv.internal_port || 80; const httpPort = data.httpPort || srv.internal_port || 80;
const port = data.port || 7681; const port = data.port || 7681;
const speed = data.speed || 4; const speed = data.speed || 4;
// 权重:0=普通(默认),1=加急(优先调度)
const weight = Number(data.weight) === 1 ? 1 : 0;
if (!ip || !user || !pass || !start || !end) { if (!ip || !user || !pass || !start || !end) {
return { ok: false, message: '缺少必要参数: ip, user, pass, start, end' }; return { ok: false, message: '缺少必要参数: ip, user, pass, start, end' };
@ -184,10 +201,11 @@ class HikvisionService extends BaseService {
ip, port, httpPort, ip, port, httpPort,
user, pass, user, pass,
channel, start, end, channel, start, end,
speed, output: relOutput, videoTime speed, output: relOutput, videoTime, weight
}), }),
status: 'pending', status: 'pending',
retry: 0, retry: 0,
weight,
timeout: videoTime + 60, timeout: videoTime + 60,
tmp_file_path: relOutput tmp_file_path: relOutput
}); });
@ -612,11 +630,9 @@ class HikvisionService extends BaseService {
console.log('[Hikvision] HTTP回放: 录像机无此时间视频 ch=%d %s ~ %s', channel, start, end); console.log('[Hikvision] HTTP回放: 录像机无此时间视频 ch=%d %s ~ %s', channel, start, end);
throw new Error('录像机无此时间视频'); throw new Error('录像机无此时间视频');
} }
// 输入侧偏移 = 工单窗口起点相对段起点的秒数(下载接口返回整段流,ffmpeg -ss 走 Range 定位) // 输入侧偏移 = 工单窗口起点相对段起点的秒数(下载接口返回整段流)
const offsetSec = Math.floor((best.ovS - best.segS) / 1000); const offsetSec = Math.floor((best.ovS - best.segS) / 1000);
const durSec = Math.ceil((best.ovE - best.ovS) / 1000); const durSec = Math.ceil((best.ovE - best.ovS) / 1000);
// token 与 playbackURI 必须原样传递(URL 编码反而 400/401)
const downloadUrl = `http://${ip}:${httpPort}/ISAPI/ContentMgmt/download?token=${session.token}&playbackURI=${best.uri}`;
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
const ffmpegPath = this._findFfmpeg(); const ffmpegPath = this._findFfmpeg();
@ -624,49 +640,96 @@ class HikvisionService extends BaseService {
const outFile = output.endsWith('.mp4') ? output : output.replace(/\.ps$/i, '') + '.mp4'; const outFile = output.endsWith('.mp4') ? output : output.replace(/\.ps$/i, '') + '.mp4';
const outDir = path.dirname(outFile); const outDir = path.dirname(outFile);
if (outDir && outDir !== '.') fs.mkdirSync(outDir, { recursive: true }); if (outDir && outDir !== '.') fs.mkdirSync(outDir, { recursive: true });
const tmpFile = outFile + '.imkh';
const t0 = Date.now(); const t0 = Date.now();
const timeoutMs = Math.max(60000, durSec * 1000 + 120000);
const cookieStr = Object.entries(session.cookieJar || {}).map(([k, v]) => `${k}=${v}`).join('; '); const cookieStr = Object.entries(session.cookieJar || {}).map(([k, v]) => `${k}=${v}`).join('; ');
console.log('[Hikvision] HTTP回放: ffmpeg 下载 ch=%d 段偏移 %ds 时长 %ds', channel, offsetSec, durSec); console.log('[Hikvision] HTTP回放: 整段下载 ch=%d 段偏移 %ds 时长 %ds', channel, offsetSec, durSec);
const args = ['-hide_banner', '-loglevel', 'warning']; // 阶段1:流式下载整段 IMKH 到本地临时文件(ffmpeg 对 IMKH 流的 Range 切片在老版本不可靠)
if (cookieStr) args.push('-headers', `Cookie: ${cookieStr}\r\n`); // 阶段2:本地文件切片(-ss 输入侧精确 seek,任何 ffmpeg 版本均可靠)
args.push('-ss', String(offsetSec), '-t', String(durSec), '-i', downloadUrl, let settled = false;
'-c:v', 'copy', '-an', '-y', outFile); const finishErr = (err) => { if (!settled) { settled = true; reject(err); } };
const child = spawn(ffmpegPath, args, { stdio: ['ignore', 'ignore', 'pipe'] }); const cleanupTmp = () => { try { if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile); } catch { /* */ } };
let stderrTail = '';
child.stderr.on('data', (d) => { stderrTail = (stderrTail + d.toString()).slice(-800); }); const req = http.request({
const timer = setTimeout(() => { hostname: ip, port: httpPort,
try { child.kill('SIGKILL'); } catch { /* */ } path: `/ISAPI/ContentMgmt/download?token=${session.token}&playbackURI=${best.uri}`,
reject(new Error(`HTTP回放: 下载超时(${Math.round(timeoutMs / 1000)}s)`)); method: 'GET',
}, timeoutMs); headers: cookieStr ? { 'User-Agent': 'Mozilla/5.0', 'Cookie': cookieStr } : { 'User-Agent': 'Mozilla/5.0' }
if (task) { }, (res) => {
task._abortDownload = () => { try { child.kill('SIGKILL'); } catch { /* */ } }; if (res.statusCode !== 200) {
} let b = '';
// 下载期间定期更新进度(按已写入文件大小) res.on('data', (c) => { b += c; });
const progTimer = setInterval(() => { res.on('end', () => finishErr(new Error(`HTTP回放: 下载失败 HTTP ${res.statusCode} ${String(b).slice(0, 200)}`)));
if (!task) return; return;
try {
const sz = fs.existsSync(outFile) ? fs.statSync(outFile).size : 0;
task.progress.totalBytes = sz;
task.progress.totalMB = Math.round(sz / 1048576 * 10) / 10;
} catch { /* */ }
}, 3000);
const stopProg = () => clearInterval(progTimer);
child.on('error', (err) => { clearTimeout(timer); stopProg(); reject(new Error('HTTP回放: ffmpeg 启动失败 ' + err.message)); });
child.on('close', (code) => {
clearTimeout(timer);
stopProg();
if (task && task._aborted) { reject(new Error('任务已中止')); return; }
const size = fs.existsSync(outFile) ? fs.statSync(outFile).size : 0;
if (code === 0 && size > 0) {
const elapsed = (Date.now() - t0) / 1000;
console.log('[Hikvision] HTTP回放: 下载完成 %s (%.1fMB, %.1fs)', outFile, size / 1048576, elapsed);
resolve({ total: size, chunks: 0, elapsed, httpFallback: true, mp4Path: outFile });
} else {
reject(new Error(`HTTP回放: 下载失败(exit=${code}) ${stderrTail.slice(-300)}`));
} }
const contentLen = parseInt(res.headers['content-length'] || '0', 10) || 0;
// 下载超时按段大小保底 2MB/s 估算(段最大约 1GB),并设总上限 20 分钟
const dlTimeoutMs = Math.min(20 * 60 * 1000, Math.max(120000, (contentLen / 2097152) * 1000 + 60000));
const ws = fs.createWriteStream(tmpFile, { highWaterMark: 512 * 1024 });
res.pipe(ws);
res.on('data', () => {
if (task) {
const sz = ws.bytesWritten || 0;
task.progress.totalBytes = sz;
task.progress.totalMB = Math.round(sz / 1048576 * 10) / 10;
}
});
const dlTimer = setTimeout(() => {
req.destroy(); cleanupTmp();
finishErr(new Error(`HTTP回放: 整段下载超时(${Math.round(dlTimeoutMs / 1000)}s)`));
}, dlTimeoutMs);
res.on('close', () => clearTimeout(dlTimer));
ws.on('error', (e) => { req.destroy(); finishErr(new Error('HTTP回放: 写临时文件失败 ' + e.message)); });
res.on('error', (e) => { finishErr(new Error('HTTP回放: 下载中断 ' + e.message)); });
ws.on('finish', () => {
// 已被超时/中止分支结束(settled=true,临时文件可能已被 cleanupTmp 删除)→ 不能再读文件,
// 否则 statSync 抛 ENOENT 成为未捕获异常,直接让整个录制服务进程退出(2026-09-11 实际发生)
if (settled) return;
if (task && task._aborted) { cleanupTmp(); finishErr(new Error('任务已中止')); return; }
let dlSize = 0;
try {
dlSize = fs.statSync(tmpFile).size;
} catch (e) {
cleanupTmp();
finishErr(new Error('HTTP回放: 临时文件不可读(已清理或写入失败) ' + e.message));
return;
}
console.log('[Hikvision] HTTP回放: 整段下载完成 (%.1fMB)', dlSize / 1048576);
// 阶段2:本地切片
// 用输出侧 -ss:对无索引的 IMKH 流,老版 ffmpeg 输入侧 seek 无效,
// 输出侧 -ss 顺序读+丢弃到窗口起点(本地文件读取快),窗口截取正确
const sliceArgs = ['-hide_banner', '-loglevel', 'warning',
'-i', tmpFile, '-ss', String(offsetSec), '-t', String(durSec),
'-c:v', 'copy', '-an', '-y', outFile];
const child = spawn(ffmpegPath, sliceArgs, { stdio: ['ignore', 'ignore', 'pipe'] });
let stderrTail = '';
child.stderr.on('data', (d) => { stderrTail = (stderrTail + d.toString()).slice(-800); });
const sliceTimer = setTimeout(() => {
try { child.kill('SIGKILL'); } catch { /* */ }
cleanupTmp(); finishErr(new Error('HTTP回放: 切片超时(60s)'));
}, 60000);
child.on('error', (err) => { clearTimeout(sliceTimer); cleanupTmp(); finishErr(new Error('HTTP回放: ffmpeg 启动失败 ' + err.message)); });
child.on('close', (code) => {
clearTimeout(sliceTimer);
cleanupTmp();
if (task && task._aborted) { finishErr(new Error('任务已中止')); return; }
const size = fs.existsSync(outFile) ? fs.statSync(outFile).size : 0;
if (code === 0 && size > 0) {
const elapsed = (Date.now() - t0) / 1000;
console.log('[Hikvision] HTTP回放: 切片完成 %s (%.1fMB, %.1fs)', outFile, size / 1048576, elapsed);
resolve({ total: size, chunks: 0, elapsed, httpFallback: true, mp4Path: outFile });
} else {
finishErr(new Error(`HTTP回放: 切片失败(exit=${code}) ${stderrTail.slice(-300)}`));
}
});
});
}); });
req.on('error', (e) => { cleanupTmp(); finishErr(new Error('HTTP回放: 下载请求失败 ' + e.message)); });
if (task) {
task._abortDownload = () => { req.destroy(); cleanupTmp(); };
}
req.end();
}); });
}); });
} }