liufumingren f38bf082f1 修掉「本机明明有设备管理服务却走云端」
现场表现:更新/重启后头几十秒里本机查询都提示「改问云端」。原因是
hik-worker 的懒启动被安排在 20 秒后,而 UDP 17310 应答由 worker 提供;
A 探测不到就只能走云端,偏偏是云任务反过来才把 worker 拉起来,形成死循环。

- worker 自检从启动后 20 秒提前到 3 秒(实测 UDP/TCP 约 5 秒内就绪)
- 局域网应答的 UDP 绑定加 30 次重试(约 60 秒),上一条日志里它在重启后
  没绑上且没有任何痕迹;现在失败会记「第 N 次重试」和最终放弃
- AppLog 改为独占写 + 失败落本进程旁路文件 log_<日期>.p<pid>.txt,
  避免并发写把行写截断(FileShare.ReadWrite 会撕裂行)

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-22 03:19:09 +08:00

563 lines
22 KiB
C#
Raw Permalink 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.IO.Pipes;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using YuncangTrace.LocalService.Services.Hik;
namespace YuncangTrace.LocalService.Services;
/// <summary>
/// 海康取流的**隔离子进程**(<c>--hik-worker</c>)。
///
/// 只有它加载 HCNetSDK 并持有 NVR 会话池(<see cref="HikDeviceService"/> 的 <c>_sessions</c>);
/// 扫码服务主进程通过命名管道派任务。这样 SDK 崩掉只会杀掉本进程,
/// 重启即可恢复,收码/上报完全不受影响。
///
/// ⚠️ 跑在 Session 0(LocalSystem):没有桌面,PlayM4 渲染窗口之类的功能永远不在这里做。
/// </summary>
public static class HikWorker
{
/// <summary>worker 入口;返回进程退出码</summary>
public static async Task<int> RunAsync(CancellationToken ct)
{
AgentPaths.MachineMode = true;
AgentPaths.IsServiceProcess = true;
AppLog.Write($"[hik-worker] 启动,目录 {AppContext.BaseDirectory}");
using var hik = new HikDeviceService();
using var playback = new HikPlaybackService(hik);
// 服务端不查库(没有用户令牌),只用到 DownloadByPlanAsync
var download = new PlaybackDownloadService(
new OrderQueryService(),
playback,
() => null,
() => 0,
() => null,
() => AgentPaths.VideosRoot);
// 一次只执行一份计划:避免多个大任务互抢带宽与 ffmpeg CPU,排队交给上层
using var downloadGate = new SemaphoreSlim(1, 1);
var state = new WorkerState { Download = download, Playback = playback, Gate = downloadGate };
// 取流接口 + 局域网发现。两个任务都吞异常只记日志 ——
// 发现/取流坏掉不能影响扫码(那是主进程的事,本来就不在这里)。
var edgeTasks = new EdgeDownloadTasks(AgentPaths.VideosRoot);
var edgeHttp = new EdgeHttpService(edgeTasks, downloadGate,
subjectId => AgentFiles.LoadConfig() is { } config && config.SubjectId == subjectId && subjectId > 0);
_ = Task.Run(() => RunLanResponderAsync(ct), CancellationToken.None);
_ = Task.Run(() => edgeHttp.RunAsync(download, playback, ct), CancellationToken.None);
try
{
while (!ct.IsCancellationRequested)
{
NamedPipeServerStream pipe;
try
{
pipe = new NamedPipeServerStream(
HikWorkerPipe.PipeName,
PipeDirection.InOut,
NamedPipeServerStream.MaxAllowedServerInstances,
PipeTransmissionMode.Byte,
PipeOptions.Asynchronous);
}
catch (Exception ex)
{
// 管道建不起来通常是被占用/权限问题:等一会再来,不能退出
AppLog.Write($"[hik-worker] 创建管道失败(3 秒后重试):{ex.Message}");
if (!await DelayAsync(TimeSpan.FromSeconds(3), ct).ConfigureAwait(false)) break;
continue;
}
await using (pipe)
{
try
{
await pipe.WaitForConnectionAsync(ct).ConfigureAwait(false);
await ServeAsync(pipe, state, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[hik-worker] 会话异常(继续等待新连接):{ex.Message}");
}
}
if (state.ShutdownRequested) break;
}
}
finally
{
AppLog.Write("[hik-worker] 退出");
}
return 0;
}
private sealed class WorkerState
{
public PlaybackDownloadService Download { get; init; } = null!;
public HikPlaybackService Playback { get; init; } = null!;
public SemaphoreSlim Gate { get; init; } = null!;
public bool ShutdownRequested { get; set; }
}
/// <summary>校验某时段有没有录像(真拉一小段,与桌面端本地校验同一套实现)</summary>
private static async Task<HikWorkerResponse> CheckAsync(HikWorkerRequest request, WorkerState state,
CancellationToken ct)
{
if (request.Payload is not { ValueKind: JsonValueKind.Object } payload)
{
return Fail(request, "缺少校验参数");
}
var host = GetString(payload, "nvrHost");
if (string.IsNullOrWhiteSpace(host)) return Fail(request, "缺少 nvrHost");
var port = payload.TryGetProperty("nvrPort", out var portElement) && portElement.TryGetInt32(out var parsedPort)
? parsedPort
: 8000;
if (!payload.TryGetProperty("channelNo", out var channelElement) || !channelElement.TryGetInt32(out var channelNo))
{
return Fail(request, "缺少 channelNo");
}
if (!payload.TryGetProperty("startTime", out var startElement) || !startElement.TryGetDateTimeOffset(out var start)
|| !payload.TryGetProperty("endTime", out var endElement) || !endElement.TryGetDateTimeOffset(out var end))
{
return Fail(request, "startTime/endTime 不合法");
}
var check = await state.Playback.CheckAsync(host!, port,
GetString(payload, "username") ?? "", GetString(payload, "password") ?? "",
channelNo, start, end, ct).ConfigureAwait(false);
return Ok(request, new
{
hasRecord = check.HasRecord,
frames = check.Frames,
error = check.Error,
source = check.Source,
});
}
/// <summary>处理一条连接上的请求(串行,够用:任务本身由上层排队)</summary>
private static async Task ServeAsync(Stream pipe, WorkerState state, CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
var request = await HikWorkerPipe.ReadAsync<HikWorkerRequest>(pipe, ct).ConfigureAwait(false);
if (request is null) return; // 对端关闭
var response = await HandleAsync(request, state, ct).ConfigureAwait(false);
await HikWorkerPipe.WriteAsync(pipe, response, ct).ConfigureAwait(false);
if (state.ShutdownRequested) return;
}
}
private static async Task<HikWorkerResponse> HandleAsync(HikWorkerRequest request, WorkerState state,
CancellationToken ct)
{
try
{
switch (request.Op)
{
case HikWorkerOps.Probe:
return Ok(request, Probe());
case HikWorkerOps.Check:
return await CheckAsync(request, state, ct).ConfigureAwait(false);
case HikWorkerOps.Shutdown:
state.ShutdownRequested = true;
return Ok(request, new { message = "worker 正在退出" });
case HikWorkerOps.Download:
return await DownloadAsync(request, state, ct).ConfigureAwait(false);
default:
return Fail(request, $"未知操作:{request.Op}");
}
}
catch (OperationCanceledException)
{
return Fail(request, "任务已取消");
}
catch (Exception ex)
{
AppLog.Write($"[hik-worker] {request.Op} 失败:{ex.Message}");
return Fail(request, ex.Message);
}
}
/// <summary>自检:SDK 与 ffmpeg 是否就位、录像根目录(不触发 NET_DVR_Init,避免探测本身把进程搞崩)</summary>
private static object Probe()
{
var sdkDirs = new[]
{
Environment.GetEnvironmentVariable("YUNCANG_HIKSDK_DIR"),
Path.Combine(AppContext.BaseDirectory, "native", "HCNetSDK"),
Path.Combine(AppContext.BaseDirectory, "native"),
Path.Combine(AppContext.BaseDirectory, "HCNetSDK"),
};
var sdkDir = sdkDirs.FirstOrDefault(dir =>
!string.IsNullOrWhiteSpace(dir) && File.Exists(Path.Combine(dir, "HCNetSDK.dll")));
return new
{
version = typeof(HikWorker).Assembly.GetName().Version?.ToString() ?? "1.0.0",
baseDir = AppContext.BaseDirectory,
sdkFound = sdkDir is not null,
sdkDir,
ffmpegPath = HikFfmpegService.ResolveFfmpeg(),
videoRoot = AgentPaths.VideosRoot,
};
}
private static async Task<HikWorkerResponse> DownloadAsync(HikWorkerRequest request, WorkerState state,
CancellationToken ct)
{
if (request.Payload is not { ValueKind: JsonValueKind.Object } payload)
{
return Fail(request, "缺少任务参数");
}
var code = GetString(payload, "code") ?? "";
if (code.Length == 0) return Fail(request, "缺少运单号");
if (!payload.TryGetProperty("streams", out var streamsElement) || streamsElement.ValueKind != JsonValueKind.Array)
{
return Fail(request, "缺少 streams");
}
var streams = new List<PackStream>();
foreach (var item in streamsElement.EnumerateArray())
{
var stream = item.Deserialize<PackStream>(HikWorkerJson.Options);
if (stream is not null) streams.Add(stream);
}
if (streams.Count == 0) return Fail(request, "streams 为空");
var credentials = new Dictionary<int, NvrCredential>();
if (payload.TryGetProperty("credentials", out var credentialsElement)
&& credentialsElement.ValueKind == JsonValueKind.Array)
{
foreach (var item in credentialsElement.EnumerateArray())
{
var id = item.TryGetProperty("nvrId", out var idElement) ? idElement.GetInt32() : 0;
if (id <= 0) continue;
credentials[id] = new NvrCredential(
id,
GetString(item, "name") ?? "",
GetString(item, "host") ?? "",
item.TryGetProperty("port", out var portElement) ? portElement.GetInt32() : 8000,
GetString(item, "username") ?? "",
GetString(item, "password") ?? "");
}
}
var scanTime = payload.TryGetProperty("scanTime", out var scanElement)
&& scanElement.TryGetDateTimeOffset(out var parsed)
? parsed.LocalDateTime
: streams[0].StartTime.LocalDateTime;
var rootDir = GetString(payload, "rootDir");
if (string.IsNullOrWhiteSpace(rootDir)) rootDir = AgentPaths.VideosRoot;
// 缺凭据直接报错:下载阶段才发现会让用户白等
var missing = streams.Select(item => item.NvrId).Distinct()
.Where(id => !credentials.ContainsKey(id)).ToList();
if (missing.Count > 0)
{
return Fail(request, $"缺少录像机凭据:{string.Join("、", missing)}");
}
await state.Gate.WaitAsync(ct).ConfigureAwait(false);
try
{
AppLog.Write($"[hik-worker] 开始下载 {code}:{streams.Count} 路 → {rootDir}");
var result = await state.Download.DownloadByPlanAsync(
code,
streams,
scanTime,
rootDir!,
(nvrId, _) => Task.FromResult(credentials[nvrId]),
progress: null,
ct).ConfigureAwait(false);
AppLog.Write($"[hik-worker] 下载完成 {code}:{result.Merged ?? result.Segments.FirstOrDefault() ?? result.Folder}");
return Ok(request, new
{
folder = result.Folder,
merged = result.Merged,
segments = result.Segments,
warnings = result.Warnings,
});
}
finally
{
state.Gate.Release();
}
}
private static HikWorkerResponse Ok(HikWorkerRequest request, object data)
{
var element = JsonSerializer.SerializeToElement(data, HikWorkerJson.Options);
return new HikWorkerResponse(request.Id, true, null, element);
}
private static HikWorkerResponse Fail(HikWorkerRequest request, string error)
=> new(request.Id, false, error, null);
private static string? GetString(JsonElement element, string name)
=> element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
? value.GetString()
: null;
/// <summary>
/// 收局域网广播询问并单播应答(**询问-应答**,worker 从不主动公告)。
///
/// 只回「同一主体」的询问:主体不一致直接忽略,避免跨租户发现。
/// 应答里的 <see cref="HikWorkerPorts.Http"/> 就是桌面端要探测的取流端口。
/// </summary>
private static async Task RunLanResponderAsync(CancellationToken ct)
{
// 上一个 worker 退出后端口可能还没释放(重启/更新时常见),
// 以前直接 return,结果「本机明明有设备管理服务却探测不到」,只能走云端。
// 这里重试 30 次(约 60 秒),第一次失败必记,之后每 10 次记一次。
UdpClient? udp = null;
for (var attempt = 1; attempt <= 30 && !ct.IsCancellationRequested; attempt++)
{
try
{
udp = new UdpClient(new IPEndPoint(IPAddress.Parse(HikWorkerPorts.BindAddress), HikWorkerPorts.UdpQuery))
{
EnableBroadcast = true,
};
break;
}
catch (Exception ex)
{
udp?.Dispose();
udp = null;
if (attempt == 1 || attempt % 10 == 0)
{
AppLog.Write($"[hik-worker] 局域网应答监听 UDP {HikWorkerPorts.UdpQuery} 失败(第 {attempt} 次,2 秒后重试):{ex.Message}");
}
if (attempt == 30) break;
try
{
await Task.Delay(TimeSpan.FromSeconds(2), ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
return;
}
}
}
if (udp is null)
{
AppLog.Write($"[hik-worker] 局域网应答最终未能监听 UDP {HikWorkerPorts.UdpQuery}(该功能停用,本机会退化为云端取流)");
return;
}
using (udp)
{
AppLog.Write($"[hik-worker] 局域网应答已就绪:UDP {HikWorkerPorts.UdpQuery} → HTTP {HikWorkerPorts.Http}");
while (!ct.IsCancellationRequested)
{
UdpReceiveResult received;
try
{
received = await udp.ReceiveAsync(ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[hik-worker] 广播接收失败(继续):{ex.Message}");
continue;
}
try
{
if (!TryParseQuery(received.Buffer, out var wantedSubject, out var wantedServer, out var targets)) continue;
var config = AgentFiles.LoadConfig();
if (config is null || config.SubjectId <= 0) continue;
if (wantedSubject != config.SubjectId) continue;
// 主体相同还不够:主体 id 在各环境都从 1 开始,必须再比后端地址
var ownServer = HikWorkerDiscovery.NormalizeServer(config.ServerBaseUrl);
if (ownServer.Length == 0) continue;
if (!string.Equals(wantedServer, ownServer, StringComparison.Ordinal))
{
AppLog.Write($"[hik-worker] 询问来自别的环境({wantedServer}),本体 {ownServer},不应答");
continue;
}
// 询问里带了 NVR:先实测本机能不能连上,连不上就不应答
// (让查询机继续走「本机直连 NVR」,而不是把活派给一条走不通的路)
var reachable = new List<string>();
if (targets.Count > 0)
{
var results = await Task.WhenAll(targets.Select(item => ProbeAsync(item.Host, item.Port, ct)))
.ConfigureAwait(false);
for (var i = 0; i < targets.Count; i++)
{
if (results[i]) reachable.Add(targets[i].Host);
}
if (reachable.Count == 0)
{
AppLog.Write($"[hik-worker] 询问的 NVR 均不可达({string.Join("、", targets.Select(t => t.Host))}),不应答");
continue;
}
}
var reply = JsonSerializer.Serialize(new
{
type = HikWorkerDiscovery.ReplyType,
sn = config.DeviceSn,
subjectId = config.SubjectId,
server = ownServer,
port = HikWorkerPorts.Http,
reachable,
version = typeof(HikWorker).Assembly.GetName().Version?.ToString() ?? "1.0.0",
}, HikWorkerJson.Options);
var bytes = Encoding.UTF8.GetBytes(reply);
await udp.SendAsync(bytes, received.RemoteEndPoint, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception ex)
{
AppLog.Write($"[hik-worker] 广播应答失败:{ex.Message}");
}
}
}
}
private sealed record NvrProbeTarget(string Host, int Port);
/// <summary>
/// 解析询问报文。可选带 <c>nvrHosts: [{host, port}]</c> —— 带了就要先实测可达性再应答。
/// </summary>
private static bool TryParseQuery(byte[] buffer, out int subjectId, out string server,
out List<NvrProbeTarget> targets)
{
subjectId = 0;
server = string.Empty;
targets = new List<NvrProbeTarget>();
var text = Encoding.UTF8.GetString(buffer).TrimStart();
if (text.Length == 0 || text[0] != '{') return false;
try
{
using var doc = JsonDocument.Parse(text);
var root = doc.RootElement;
if (!root.TryGetProperty("type", out var type) || type.GetString() != HikWorkerDiscovery.QueryType)
{
return false;
}
// 不带 subjectId 的询问一律不答(宁可让对端走本机,也不跨主体泄露)
if (!root.TryGetProperty("subjectId", out var wanted) || !wanted.TryGetInt32(out subjectId))
{
return false;
}
if (subjectId <= 0) return false;
// 不带 server 的询问也不答:光靠 subjectId 分不清是哪个环境的库
server = HikWorkerDiscovery.NormalizeServer(GetString(root, "server"));
if (server.Length == 0) return false;
if (root.TryGetProperty("nvrHosts", out var hostsElement) && hostsElement.ValueKind == JsonValueKind.Array)
{
foreach (var item in hostsElement.EnumerateArray())
{
if (item.ValueKind != JsonValueKind.Object) continue;
var host = GetString(item, "host");
if (string.IsNullOrWhiteSpace(host)) continue;
var port = item.TryGetProperty("port", out var portElement) && portElement.TryGetInt32(out var parsed)
? parsed
: 8000;
targets.Add(new NvrProbeTarget(host, port));
}
}
return true;
}
catch
{
return false;
}
}
/// <summary>探测 NVR 端口(只判能不能连上,不发任何设备协议)</summary>
private static async Task<bool> ProbeAsync(string host, int port, CancellationToken ct)
{
try
{
using var tcp = new TcpClient();
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromMilliseconds(800));
await tcp.ConnectAsync(host, port, timeout.Token).ConfigureAwait(false);
return tcp.Connected;
}
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
{
return false;
}
catch
{
return false;
}
}
private static async Task<bool> DelayAsync(TimeSpan delay, CancellationToken ct)
{
try
{
await Task.Delay(delay, ct).ConfigureAwait(false);
return true;
}
catch (OperationCanceledException)
{
return false;
}
}
}