liufumingren 5bd90a45ff fix(agent): 面单识别断流死循环改指数退避 + 后台服务单实例
- label-scan 断流重连从固定 3s 改为 3s 起指数退避到 60s;连上稳定 30s 才清零;
  内存不足(OutOfMemory / Cannot allocate memory)固定等 60s。
  现场 2026-11-18:两路主码流 + 系统提交内存耗尽时,每 3 秒重拉一次 ffmpeg 自己踩自己
- AgentHost 加 Global\YuncangTraceAgent.instance 单实例锁:服务与 --agent-run 双开时
  第二个实例直接退出,不再重复拉流、抢写 agent-status.json、抢 hik-worker 管道
- hik-worker 管道创建失败改为 3→30s 退避重试,连续 12 次失败退出(交给主进程熔断)
- agent-status.json 的「变了就写」判据剔除每帧都变的诊断计数器,不再 2.5 次/秒重写
- scan-records.json 改为共享读 + 原子替换(File.Move),桌面端不再刷「文件被另一个进程占用」
- publish-desktop:releaseNotes 用 node 侧字符串回写 version.json,避免命令行中文乱码

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-11-19 00:46:12 +08:00

895 lines
38 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Scan;
namespace YuncangTrace.LocalService.Services;
/// <summary>
/// 后台扫码服务的运行主体(LocalSystem)。
///
/// 职责:
/// 1. 读 <c>%ProgramData%\YuncangTrace\agent.json</c> 里的**长期设备令牌**,跑扫码 TCP 收码 + 上报循环;
/// 2. 监视 <c>channels.json</c>(桌面端改通道后自动重连);
/// 3. 定时 NTP 校时(LocalSystem 改系统时间不需要 UAC);
/// 4. 把运行状态写进 <c>agent-status.json</c>,桌面端只读展示;
/// 5. 执行桌面端写进 <c>agent-command.json</c> 的一次性命令(立即上传 / 清空记录 / 立即校时)。
///
/// 与桌面端**完全解耦**:桌面端退出、用户注销都不影响这里。
/// </summary>
public static class AgentHost
{
/// <summary>状态写盘保活间隔(内容没变也最多 30 秒写一次)</summary>
private static readonly TimeSpan StatusKeepAlive = TimeSpan.FromSeconds(30);
/// <summary>心跳日志落盘间隔:心跳 60 秒一次,但日志每 5 分钟才写一行(避免刷屏又能看出断点)</summary>
private static readonly TimeSpan HeartbeatLogInterval = TimeSpan.FromMinutes(5);
private sealed class NtpState
{
public string LastSyncAt { get; set; } = "";
public double OffsetSeconds { get; set; }
public double RoundTripMs { get; set; }
public DateTime? ServerTime { get; set; }
public string? Error { get; set; }
}
public static async Task RunAsync(CancellationToken ct)
{
AgentPaths.MachineMode = true;
AgentPaths.IsServiceProcess = true;
// 一台机器只允许一个后台扫码服务:两个实例会同时拉两套面单摄像头(内存/带宽翻倍)、
// 同时写 agent-status.json(后写的撞上「拒绝访问」)、同时抢 hik-worker 命名管道。
using var instanceLock = TryAcquireInstanceLock();
if (instanceLock is null)
{
AppLog.Write("[agent] 已有另一个后台服务实例在运行,本进程直接退出(不重复拉流、不抢写状态文件)");
return;
}
AppLog.Write("[agent] 后台扫码服务启动");
try
{
while (!ct.IsCancellationRequested)
{
var config = AgentFiles.LoadConfig();
if (config is null
|| string.IsNullOrWhiteSpace(config.ServerBaseUrl)
|| string.IsNullOrWhiteSpace(config.DeviceToken))
{
AppLog.Write("[agent] 还没有可用配置(等待桌面端「开启设备服务」写入 agent.json)");
AgentFiles.SaveStatus(new AgentStatus
{
Running = false,
Version = Version,
LastError = "没有配置(agent.json 缺失或缺少设备令牌)",
});
if (!await DelayAsync(TimeSpan.FromSeconds(3), ct).ConfigureAwait(false)) break;
continue;
}
try
{
await RunCoreAsync(config, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[agent] 运行失败:{ex.Message}");
AgentFiles.SaveStatus(new AgentStatus
{
Running = false,
Version = Version,
DeviceSn = config.DeviceSn,
SubjectId = config.SubjectId,
LastError = ex.Message,
});
if (!await DelayAsync(TimeSpan.FromSeconds(5), ct).ConfigureAwait(false)) break;
}
}
}
finally
{
AgentFiles.SaveStatus(new AgentStatus { Running = false, Version = Version });
AppLog.Write("[agent] 后台扫码服务停止");
}
}
private static string Version =>
typeof(AgentHost).Assembly.GetName().Version?.ToString() ?? "1.0.0";
/// <summary>
/// 后台服务单实例锁。
///
/// 服务跑在 Session 0、手动 <c>--agent-run</c> 跑在用户会话,而 <c>Local\</c> 是按会话隔离的
/// (根本抓不到这种"同机双实例"),所以优先用 <c>Global\</c>。
/// 普通用户没有 SeCreateGlobalPrivilege 时会拿不到对象:这时只要服务已安装且在跑,
/// 就同样判定为"已有实例";否则退化成 <c>Local\</c>,至少挡住同一会话内的重复启动。
/// </summary>
private static Mutex? TryAcquireInstanceLock()
{
foreach (var name in new[] { @"Global\YuncangTraceAgent.instance", @"Local\YuncangTraceAgent.instance" })
{
Mutex mutex;
try
{
mutex = new Mutex(initiallyOwned: false, name);
}
catch (UnauthorizedAccessException)
{
if (IsAgentServiceRunning()) return null;
continue;
}
try
{
if (mutex.WaitOne(TimeSpan.Zero)) return mutex;
}
catch (AbandonedMutexException)
{
return mutex; // 上一个实例没释放就退出了:这个锁现在归我们
}
mutex.Dispose();
return null; // 对象建得出来但抢不到 → 确实有实例在跑
}
// 两个命名空间都建不了(极端权限情况):不阻塞启动,交一个空锁占位
return new Mutex();
}
private static bool IsAgentServiceRunning()
{
try
{
using var service = new System.ServiceProcess.ServiceController(ServiceInstaller.ServiceName);
return service.Status != System.ServiceProcess.ServiceControllerStatus.Stopped;
}
catch
{
return false; // 没安装 / 查不到:当作没有
}
}
private static async Task RunCoreAsync(AgentConfig config, CancellationToken ct)
{
// 用内存里的设置喂给 DeviceService:它只用到 DeviceToken / DeviceSn / SubjectId / Enabled
var settings = new AppSettings
{
ServerBaseUrl = config.ServerBaseUrl,
SubjectId = config.SubjectId,
DeviceId = config.DeviceId,
DeviceSn = config.DeviceSn,
DeviceServiceEnabled = true,
DeviceToken = config.DeviceToken,
NtpEnabled = config.NtpEnabled,
NtpServer = config.NtpServer,
NtpSyncIntervalMinutes = config.NtpIntervalMinutes,
};
var api = new ApiClient(config.ServerBaseUrl);
// 服务不需要用户令牌(激活/停用由桌面端做),只用长期设备令牌上报
var session = new Session { ServerBaseUrl = config.ServerBaseUrl };
var device = new DeviceService(api, settings, session);
var scan = new ScanService(device);
var ntp = new NtpState();
// 令牌以 agent-token.json 为准(服务续期后会更新它),没有才退回 agent.json
var storedToken = AgentFiles.LoadToken();
var refreshToken = !string.IsNullOrWhiteSpace(storedToken?.RefreshToken)
? storedToken!.RefreshToken
: config.RefreshToken;
if (!string.IsNullOrWhiteSpace(storedToken?.DeviceToken))
{
settings.DeviceToken = storedToken!.DeviceToken;
}
var nextRefreshAt = DateTime.MinValue;
DateTime? lastTokenRefreshAt = null;
string? lastTokenRefreshError = null;
var nextHeartbeatAt = DateTime.MinValue;
DateTime? lastHeartbeatAt = null;
DateTime? lastHeartbeatLoggedAt = null;
DateTime? lastHeartbeatFailLoggedAt = null;
string? lastHeartbeatError = null;
var configTime = AgentFiles.FileTime(AgentPaths.ConfigFile);
var channelsTime = AgentFiles.FileTime(AgentPaths.ChannelsFile);
var nextNtpAt = config.NtpEnabled ? DateTime.UtcNow : DateTime.MaxValue;
var lastStatusJson = string.Empty;
var lastStatusWriteAt = DateTime.MinValue;
// 取流子进程:懒启动,崩了只影响取流,扫码链路完全不受影响
var hikStatus = new AgentHikStatus { VideoRoot = AgentPaths.VideosRoot };
await using var hikWorker = new HikWorkerSupervisor();
hikWorker.StateChanged += () =>
{
hikStatus.Connected = hikWorker.IsConnected;
hikStatus.BlockedUntil = hikWorker.BlockedUntil;
hikStatus.LastError = hikWorker.LastError;
};
try
{
device.EnsureUploadLoop();
await scan.StartAsync().ConfigureAwait(false);
scan.StartDiscovery(); // 常驻发现:设备 DHCP 换 IP 时能自己重连
// 自检要尽早:worker 一就绪,局域网询问才有应答(UDP 16100)。
// 以前延后 20 秒,导致「刚启动/刚更新完」这段时间本机查询探测不到设备管理服务,
// 白白退化成云端中转 —— 而云任务反过来才把 worker 拉起来,形成恶性循环。
_ = Task.Run(async () =>
{
try
{
if (!await DelayAsync(TimeSpan.FromSeconds(3), ct).ConfigureAwait(false)) return;
ApplyHikProbe(hikStatus, await hikWorker.ProbeAsync(ct).ConfigureAwait(false));
hikStatus.Connected = hikWorker.IsConnected;
AppLog.Write($"[agent] 取流自检:sdk={hikStatus.SdkDir ?? "未找到"},"
+ $"ffmpeg={hikStatus.FfmpegPath ?? "未找到"}");
}
catch (OperationCanceledException)
{
// 服务停止,正常
}
catch (Exception ex)
{
hikStatus.Available = false;
hikStatus.LastError = ex.Message;
AppLog.Write($"[agent] 取流自检失败(扫码不受影响):{ex.Message}");
}
}, CancellationToken.None);
AppLog.Write($"[agent] 扫码已启动:{scan.Channels.Count} 个通道"
+ $"(SN {config.DeviceSn},主体 {config.SubjectId})");
// 边缘任务通道:设备主动出站长轮询领任务(跨公司取流用)。
// 与扫码链路完全解耦:这里出错只记日志,不影响收码上报。
_ = Task.Run(() => RunEdgeTaskLoopAsync(api, settings, hikWorker, scan, ct), CancellationToken.None);
while (!ct.IsCancellationRequested)
{
// 400ms 一轮:状态文件写得及时,桌面端才能尽快看到「刚识别到的条码」
// (识别本身是毫秒级,慢在拉流和解码,不该再被状态刷新拖 1 秒)
if (!await DelayAsync(TimeSpan.FromMilliseconds(400), ct).ConfigureAwait(false)) break;
// ① 配置变了(换令牌 / 换服务器 / 改 NTP)→ 外层重建链路
var newConfigTime = AgentFiles.FileTime(AgentPaths.ConfigFile);
if (newConfigTime != configTime)
{
AppLog.Write("[agent] agent.json 已变更,重建扫码链路");
break;
}
// ② 通道配置变了(桌面端增删/改静音)→ 重新加载并连接
var newChannelsTime = AgentFiles.FileTime(AgentPaths.ChannelsFile);
if (newChannelsTime != channelsTime)
{
channelsTime = newChannelsTime;
AppLog.Write("[agent] channels.json 已变更,重新加载通道");
scan.Stop();
await scan.StartAsync().ConfigureAwait(false);
scan.StartDiscovery();
// 文件里就是完整通道列表:按全量对账再推一次,
// 桌面端那边推送失败(离线/未登录)时也能保证服务器跟着删/加。
scan.RequestChannelSync(replace: true);
}
// ③ 桌面端的一次性命令
var command = AgentFiles.LoadCommand();
if (command is not null)
{
AgentFiles.ClearCommand();
// 手动续期(测试/排障):不管剩多少天都立即换一次
if (command.RefreshTokenAt is not null)
{
var refreshed = await TryRefreshTokenAsync(api, config.DeviceSn, refreshToken)
.ConfigureAwait(false);
if (refreshed is not null)
{
settings.DeviceToken = refreshed.Token;
refreshToken = refreshed.RefreshToken;
AgentFiles.SaveToken(new AgentToken
{
DeviceToken = refreshed.Token,
RefreshToken = refreshed.RefreshToken,
ExpiresAt = JwtUtil.Expiry(refreshed.Token),
});
lastTokenRefreshAt = DateTime.Now;
lastTokenRefreshError = null;
nextRefreshAt = DateTime.MinValue;
}
else
{
lastTokenRefreshError = "手动续期失败(详见日志)";
}
}
await ApplyCommandAsync(command, device, scan, config, ntp).ConfigureAwait(false);
if (command.ReloadChannelsAt is not null)
{
channelsTime = AgentFiles.FileTime(AgentPaths.ChannelsFile);
}
if (command.NtpSyncAt is not null && config.NtpEnabled)
{
nextNtpAt = DateTime.UtcNow.AddMinutes(Math.Max(config.NtpIntervalMinutes, 5));
}
}
// ④ 令牌自动续期:访问令牌剩不到 7 天(或已过期)时用刷新令牌换新
if (!string.IsNullOrWhiteSpace(refreshToken) && DateTime.Now >= nextRefreshAt)
{
var expiresAt = JwtUtil.Expiry(settings.DeviceToken);
var needRefresh = expiresAt is null || expiresAt.Value - DateTime.Now < TimeSpan.FromDays(7);
if (needRefresh)
{
var refreshed = await TryRefreshTokenAsync(api, config.DeviceSn, refreshToken)
.ConfigureAwait(false);
if (refreshed is not null)
{
settings.DeviceToken = refreshed.Token;
refreshToken = refreshed.RefreshToken;
AgentFiles.SaveToken(new AgentToken
{
DeviceToken = refreshed.Token,
RefreshToken = refreshed.RefreshToken,
ExpiresAt = JwtUtil.Expiry(refreshed.Token),
});
lastTokenRefreshAt = DateTime.Now;
lastTokenRefreshError = null;
nextRefreshAt = DateTime.MinValue;
}
else
{
lastTokenRefreshError = "自动续期失败(10 分钟后重试)";
nextRefreshAt = DateTime.Now.AddMinutes(10); // 失败 10 分钟后再试(别每分钟刷日志)
}
}
else
{
nextRefreshAt = DateTime.Now.AddMinutes(30); // 还没到窗口,半小时后复查
}
}
// ⑤ 设备心跳:每 60 秒一次,让后端 last_seen_at 反映「后台服务还在」
if (DateTime.UtcNow >= nextHeartbeatAt)
{
try
{
var beat = await api.HeartbeatAsync(settings.DeviceToken, ct).ConfigureAwait(false);
// 心跳顺带同步主体状态:过期/停用 → 上报循环暂停(GUI/服务两种模式都走这里)
device.ApplySubjectState(beat?.Subject);
if (lastHeartbeatAt is null)
{
AppLog.Write("[agent] 设备心跳已开始(每 60 秒,每 5 分钟落一行日志)");
}
else if (lastHeartbeatError is not null)
{
AppLog.Write("[agent] 设备心跳已恢复");
}
else if (lastHeartbeatLoggedAt is null
|| DateTime.UtcNow - lastHeartbeatLoggedAt.Value >= HeartbeatLogInterval)
{
// 心跳本身 60 秒一次,但只在每 5 分钟落一行,方便隔天回看「几点断的」
var online = scan.Channels.Count(item => item.Connected);
AppLog.Write($"[agent] 心跳正常(在线通道 {online}/{scan.Channels.Count},"
+ $"待上传 {ScanRecordStore.PendingCount()} 条)");
lastHeartbeatLoggedAt = DateTime.UtcNow;
}
lastHeartbeatAt = DateTime.Now;
lastHeartbeatError = null;
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
// 首次失败必记;持续失败每 5 分钟补一行,避免刷屏又不至于整段没痕迹
if (lastHeartbeatError is null
|| lastHeartbeatFailLoggedAt is null
|| DateTime.UtcNow - lastHeartbeatFailLoggedAt.Value >= HeartbeatLogInterval)
{
AppLog.Write($"[agent] 设备心跳失败:{ex.Message}");
lastHeartbeatFailLoggedAt = DateTime.UtcNow;
}
lastHeartbeatError = ex.Message;
// 401 = 令牌过期/被撤销,下一轮让续期逻辑先试一下
if (ex is ApiException { StatusCode: 401 })
{
nextRefreshAt = DateTime.MinValue;
}
}
finally
{
nextHeartbeatAt = DateTime.UtcNow.AddSeconds(60);
}
}
// ⑥ NTP
if (config.NtpEnabled && DateTime.UtcNow >= nextNtpAt)
{
await SyncNtpAsync(config.NtpServer, ntp).ConfigureAwait(false);
nextNtpAt = DateTime.UtcNow.AddMinutes(Math.Max(config.NtpIntervalMinutes, 5));
}
// ⑦ 状态:内容变化才写,30 秒没变化保活写一次。
// 每帧都在变的诊断计数器(FramesRead / LastWaitMs…)不参与比较 ——
// 否则 400ms 一轮里几乎每轮都在重写文件(2.5 次/秒),对现场机械盘是纯磨损。
{
var status = BuildStatus(scan, device, config, ntp, hikStatus);
status.TokenExpiresAt = JwtUtil.Expiry(settings.DeviceToken);
status.RefreshTokenExpiresAt = AgentFiles.LoadToken()?.RefreshExpiresAt;
status.LastTokenRefreshAt = lastTokenRefreshAt;
status.LastTokenRefreshError = lastTokenRefreshError;
status.LastHeartbeatAt = lastHeartbeatAt;
status.LastHeartbeatError = lastHeartbeatError;
status.UpdatedAt = default; // 签名忽略时间戳
var signature = StatusSignature(status);
if (signature != lastStatusJson || DateTime.UtcNow - lastStatusWriteAt >= StatusKeepAlive)
{
AgentFiles.SaveStatus(status);
lastStatusJson = signature;
lastStatusWriteAt = DateTime.UtcNow;
SaveDiscovered(scan);
}
}
}
}
finally
{
scan.Stop();
device.StopUploadLoop();
AgentFiles.SaveStatus(BuildStatus(scan, device, config, ntp, hikStatus, running: false));
AppLog.Write("[agent] 扫码链路已停止");
}
}
private static async Task ApplyCommandAsync(AgentCommand command, DeviceService device, ScanService scan,
AgentConfig config, NtpState ntp)
{
if (command.TriggerUploadAt is not null)
{
AppLog.Write("[agent] 收到命令:立即上传");
device.TriggerUpload();
}
if (command.ClearRecordsAt is not null)
{
var removed = ScanRecordStore.Clear(command.ClearChannelId);
AppLog.Write($"[agent] 收到命令:清空扫码记录 {removed} 条"
+ (string.IsNullOrWhiteSpace(command.ClearChannelId) ? "" : $"(通道 {command.ClearChannelId})"));
}
if (command.ReloadChannelsAt is not null)
{
AppLog.Write("[agent] 收到命令:重新加载通道");
scan.Stop();
await scan.StartAsync().ConfigureAwait(false);
scan.StartDiscovery();
}
if (command.NtpSyncAt is not null)
{
var server = string.IsNullOrWhiteSpace(command.NtpServer) ? config.NtpServer : command.NtpServer!;
AppLog.Write("[agent] 收到命令:立即校时");
await SyncNtpAsync(server, ntp).ConfigureAwait(false);
}
}
private static async Task<DeviceTokenRefresh?> TryRefreshTokenAsync(ApiClient api, string sn, string refreshToken)
{
try
{
var result = await api.RefreshDeviceTokenAsync(sn, refreshToken).ConfigureAwait(false);
var expiresAt = JwtUtil.Expiry(result.Token);
AppLog.Write($"[agent] 设备令牌已续期(新到期 {expiresAt?.ToString("yyyy-MM-dd HH:mm:ss") ?? "未知"})");
return result;
}
catch (Exception ex)
{
AppLog.Write($"[agent] 设备令牌续期失败:{ex.Message}");
return null;
}
}
private static async Task SyncNtpAsync(string server, NtpState state)
{
try
{
var result = await ClockSyncService.SyncAsync(server).ConfigureAwait(false);
state.LastSyncAt = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
state.OffsetSeconds = result.Offset.TotalSeconds;
state.RoundTripMs = result.RoundTrip.TotalMilliseconds;
state.ServerTime = result.ServerTime.LocalDateTime;
state.Error = null;
AppLog.Write(result.Offset.Duration() < ClockSyncService.MinimumAdjust
? $"[agent] NTP 校时:{server} 偏差 {result.Offset.TotalSeconds:+0.00;-0.00} 秒(在误差范围内,未调整)"
: $"[agent] NTP 校时完成:{server} 偏差 {result.Offset.TotalSeconds:+0.00;-0.00} 秒,"
+ $"往返 {result.RoundTrip.TotalMilliseconds:0} ms");
}
catch (Exception ex)
{
state.Error = $"NTP 校时失败:{ex.Message}";
AppLog.Write($"[agent] NTP 校时失败({server}):{ex.Message}");
}
}
private static AgentStatus BuildStatus(ScanService scan, DeviceService device, AgentConfig config,
NtpState ntp, AgentHikStatus hik, bool running = true)
{
return new AgentStatus
{
Running = running && scan.Running,
Version = Version,
DeviceSn = config.DeviceSn,
SubjectId = config.SubjectId,
UploadStatus = scan.UploadStatus,
ChannelSyncStatus = scan.ChannelSyncStatus,
PendingRecords = ScanRecordStore.PendingCount(),
Channels = scan.Channels.Select(channel => new AgentChannelStatus
{
Mac = channel.Mac,
Connected = channel.Connected,
LastIp = channel.LastIp,
LastCode = channel.LastCode,
LastCodeAt = channel.LastCodeAt,
}).ToList(),
LastError = ntp.Error,
Hik = hik,
LabelScan = new AgentLabelScanStatus
{
Pulled = scan.LabelScan.Snapshot.PulledAt is not null,
PulledAt = scan.LabelScan.Snapshot.PulledAt,
Revision = scan.LabelScan.Snapshot.Revision,
StatusText = scan.LabelScan.Snapshot.StatusText,
Error = scan.LabelScan.Snapshot.Error,
Items = scan.LabelScan.Runtimes.Select(runtime => new AgentLabelCameraStatus
{
WorkstationId = runtime.WorkstationId,
CameraId = runtime.CameraId,
WorkstationName = runtime.WorkstationName,
CameraName = runtime.CameraName,
ChannelId = runtime.ChannelId,
ChannelName = runtime.ChannelName,
Summary = runtime.Summary,
StateText = runtime.StateText,
LastCode = runtime.LastCode,
LastCodeAt = runtime.LastCodeAt,
LastHitAt = runtime.LastHitAt,
StreamText = runtime.StreamText,
LastDecodeMs = runtime.LastDecodeMs,
LastCvMs = runtime.LastCvMs,
LastPath = runtime.LastPath,
RoiFailStreak = runtime.RoiFailStreak,
SteadyHits = runtime.SteadyHits,
FramesRead = runtime.FramesRead,
FrameThrottled = runtime.FrameThrottled,
FramesDecoded = runtime.FramesDecoded,
LastWaitMs = runtime.LastWaitMs,
LastLoopMs = runtime.LastLoopMs,
RoiText = runtime.RoiText,
RecentCodes = runtime.RecentCodes,
RoiRatio = runtime.RoiRatio,
FrameLag = runtime.FrameLag,
FrameDropped = runtime.FrameDropped,
Hits = runtime.Hits,
LastError = runtime.LastError,
}).ToList(),
Warnings = scan.LabelScan.Snapshot.Warnings.Select(item => item.Display).ToList(),
},
Osd = scan.Osd.ToStatus(),
LogDropped = AppLog.Dropped,
LogLastDroppedAt = AppLog.LastDroppedAt,
NtpLastSyncAt = ntp.LastSyncAt,
NtpLastOffsetSeconds = ntp.OffsetSeconds,
NtpRoundTripMs = ntp.RoundTripMs,
NtpServerTime = ntp.ServerTime,
};
}
/// <summary>
/// 状态文件的「内容签名」:剔掉每帧都变的诊断计数器,只留真正值得立刻让界面看到的变化。
///
/// 400ms 一轮里这些计数器几乎每轮都是新值,参与比较就等于每 400ms 重写一次状态文件
/// (2.5 次/秒、一天二十万次),对现场机械盘毫无意义。诊断字段靠 30 秒保活写回去。
/// </summary>
private static string StatusSignature(AgentStatus status)
{
var node = JsonSerializer.SerializeToNode(status)!.AsObject();
if (node[nameof(AgentStatus.LabelScan)] is JsonObject labelScan
&& labelScan[nameof(AgentLabelScanStatus.Items)] is JsonArray items)
{
foreach (var item in items.OfType<JsonObject>())
{
foreach (var name in VolatileLabelFields) item.Remove(name);
}
}
return node.ToJsonString();
}
/// <summary>面单识别里每帧都会变的排障字段(不参与状态文件的「变了就写」判据)</summary>
private static readonly string[] VolatileLabelFields =
{
nameof(AgentLabelCameraStatus.FramesRead),
nameof(AgentLabelCameraStatus.FrameThrottled),
nameof(AgentLabelCameraStatus.FramesDecoded),
nameof(AgentLabelCameraStatus.LastWaitMs),
nameof(AgentLabelCameraStatus.LastLoopMs),
nameof(AgentLabelCameraStatus.FrameLag),
nameof(AgentLabelCameraStatus.FrameDropped),
nameof(AgentLabelCameraStatus.LastDecodeMs),
nameof(AgentLabelCameraStatus.LastCvMs),
nameof(AgentLabelCameraStatus.LastPath),
nameof(AgentLabelCameraStatus.RoiFailStreak),
nameof(AgentLabelCameraStatus.SteadyHits),
nameof(AgentLabelCameraStatus.RoiText),
nameof(AgentLabelCameraStatus.RoiRatio),
};
/// <summary>
/// 边缘任务循环:长轮询领任务 → 交给 worker 执行 → 回结果。
///
/// 云端握着挂起的请求,所以任务一到就能立刻送达(不需要等下一次心跳)。
/// 这里任何异常都只记日志并退避重试,绝不影响扫码链路。
/// </summary>
private static async Task RunEdgeTaskLoopAsync(ApiClient api, AppSettings settings,
HikWorkerSupervisor worker, ScanService scan, CancellationToken ct)
{
var retryMs = 1000;
while (!ct.IsCancellationRequested)
{
try
{
var task = await api.PollEdgeTaskAsync(settings.DeviceToken, 20, ct).ConfigureAwait(false);
retryMs = 1000;
if (task is null) continue; // 这段时间没任务,立刻再挂
AppLog.Write($"[edge] 领到任务 {task.Id}({task.Type})");
var (result, ok) = await ExecuteEdgeTaskAsync(api, settings, worker, scan, task, ct).ConfigureAwait(false);
await api.SubmitEdgeTaskResultAsync(settings.DeviceToken, task.Id, result, ct)
.ConfigureAwait(false);
AppLog.Write($"[edge] 任务 {task.Id} 完成:ok={ok}");
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[edge] 任务通道异常({retryMs / 1000.0:0.0} 秒后重试):{ex.Message}");
if (!await DelayAsync(TimeSpan.FromMilliseconds(retryMs), ct).ConfigureAwait(false)) break;
retryMs = Math.Min(retryMs * 2, 30000);
}
}
}
/// <summary>执行一个边缘任务;返回要回传给云端的结果对象</summary>
private static async Task<(object Result, bool Ok)> ExecuteEdgeTaskAsync(ApiClient api, AppSettings settings,
HikWorkerSupervisor worker, ScanService scan, ApiClient.EdgeTask task, CancellationToken ct)
{
try
{
switch (task.Type)
{
case "labelScan.refresh":
{
// 只是「叫醒」:真正的配置以 GET /api/scanner/label-cameras 为准
await scan.LabelScan.RefreshAsync("服务端通知变更", ct).ConfigureAwait(false);
// 工作台/摄像头绑定的变更也会推这个通知:OSD 字幕配置一起重拉
await scan.Osd.RefreshAsync("服务端通知变更", ct).ConfigureAwait(false);
var snapshot = scan.LabelScan.Snapshot;
var osd = scan.Osd.Snapshot;
return (new
{
// ok 只看面单识别配置:OSD 是附加能力,后端没升级(404)时不该把整个任务判失败
ok = string.IsNullOrWhiteSpace(snapshot.Error),
count = snapshot.Items.Count,
revision = snapshot.Revision,
osdWorkstations = osd.Items.Count,
osdCameras = osd.CameraCount,
error = snapshot.Error,
osdError = osd.Error,
}, string.IsNullOrWhiteSpace(snapshot.Error));
}
case "check":
{
var data = await worker.CheckAsync(task.Payload, ct).ConfigureAwait(false);
if (data is not { } element) return (new { ok = false, error = "worker 无返回" }, false);
var hasRecord = element.TryGetProperty("hasRecord", out var v) && v.ValueKind == JsonValueKind.True;
var frames = element.TryGetProperty("frames", out var f) && f.TryGetInt32(out var parsed) ? parsed : 0;
return (new
{
ok = true,
hasRecord,
frames,
error = ReadString(element, "error"),
source = ReadString(element, "source"),
}, true);
}
case "download":
{
var uploadTaskId = task.Payload.ValueKind == JsonValueKind.Object
? ReadString(task.Payload, "uploadTaskId") ?? ""
: "";
try
{
var data = await worker.DownloadAsync(task.Payload, ct).ConfigureAwait(false);
var file = ReadString(data, "merged")
?? ReadFirstSegment(data);
if (string.IsNullOrEmpty(file) || !File.Exists(file))
{
return (new { ok = false, error = "没有生成成片", uploadTaskId }, false);
}
if (uploadTaskId.Length == 0)
{
return (new { ok = false, error = "任务缺少 uploadTaskId", uploadTaskId }, false);
}
var size = await api.UploadEdgeFileAsync(settings.DeviceToken, uploadTaskId, file, ct)
.ConfigureAwait(false);
TryDeleteFile(file);
return (new { ok = true, size, uploadTaskId }, true);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
return (new { ok = false, error = ex.Message, uploadTaskId }, false);
}
}
default:
return (new { ok = false, error = $"不支持的任务类型:{task.Type}" }, false);
}
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
return (new { ok = false, error = ex.Message }, false);
}
}
/// <summary>下载结果是多段时取第一段(合并失败才会走到)</summary>
private static string? ReadFirstSegment(JsonElement? data)
{
if (data is not { ValueKind: JsonValueKind.Object } element) return null;
if (!element.TryGetProperty("segments", out var segments) || segments.ValueKind != JsonValueKind.Array)
{
return null;
}
foreach (var item in segments.EnumerateArray())
{
var value = item.ValueKind == JsonValueKind.String ? item.GetString() : null;
if (!string.IsNullOrWhiteSpace(value)) return value;
}
return null;
}
/// <summary>传完就删:现场机器不会有人来清理临时成片</summary>
private static void TryDeleteFile(string path)
{
try
{
if (File.Exists(path)) File.Delete(path);
}
catch (Exception ex)
{
AppLog.Write($"[edge] 清理成片失败({path}):{ex.Message}");
}
}
/// <summary>把 worker 自检结果落到状态里(失败只标记不可用,不影响扫码)</summary>
private static void ApplyHikProbe(AgentHikStatus status, JsonElement? probe)
{
if (probe is not { } element || element.ValueKind != JsonValueKind.Object)
{
status.Available = false;
return;
}
status.Available = element.TryGetProperty("sdkFound", out var found)
&& found.ValueKind == JsonValueKind.True;
status.SdkDir = ReadString(element, "sdkDir");
status.FfmpegPath = ReadString(element, "ffmpegPath");
var root = ReadString(element, "videoRoot");
if (!string.IsNullOrWhiteSpace(root)) status.VideoRoot = root;
status.ProbedAt = DateTime.Now;
if (!status.Available)
{
status.LastError ??= "未找到 HCNetSDK.dll(服务目录 native\\HCNetSDK 缺失)";
}
}
private static string? ReadString(JsonElement element, string name)
=> element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
? value.GetString()
: null;
/// <summary>读 worker 返回的字符串字段(data 可能为 null)</summary>
private static string? ReadString(JsonElement? data, string name)
=> data is { } element ? ReadString(element, name) : null;
private static void SaveDiscovered(ScanService scan)
{
var devices = scan.DiscoveredDevices
.Select(item => new AgentDiscoveredDevice
{
Mac = item.Mac,
Ip = item.Ip,
HostName = item.HostName,
Model = item.Model,
Firmware = item.Version,
})
.ToList();
AgentFiles.SaveDiscovered(devices);
}
private static async Task<bool> DelayAsync(TimeSpan delay, CancellationToken ct)
{
try
{
await Task.Delay(delay, ct).ConfigureAwait(false);
return true;
}
catch (OperationCanceledException)
{
return false;
}
}
}