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;
///
/// 海康取流的**隔离子进程**(--hik-worker)。
///
/// 只有它加载 HCNetSDK 并持有 NVR 会话池( 的 _sessions);
/// 扫码服务主进程通过命名管道派任务。这样 SDK 崩掉只会杀掉本进程,
/// 重启即可恢复,收码/上报完全不受影响。
///
/// ⚠️ 跑在 Session 0(LocalSystem):没有桌面,PlayM4 渲染窗口之类的功能永远不在这里做。
///
public static class HikWorker
{
/// worker 入口;返回进程退出码
public static async Task 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; }
}
/// 校验某时段有没有录像(真拉一小段,与桌面端本地校验同一套实现)
private static async Task 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,
});
}
/// 处理一条连接上的请求(串行,够用:任务本身由上层排队)
private static async Task ServeAsync(Stream pipe, WorkerState state, CancellationToken ct)
{
while (!ct.IsCancellationRequested)
{
var request = await HikWorkerPipe.ReadAsync(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 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);
}
}
/// 自检:SDK 与 ffmpeg 是否就位、录像根目录(不触发 NET_DVR_Init,避免探测本身把进程搞崩)
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 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();
foreach (var item in streamsElement.EnumerateArray())
{
var stream = item.Deserialize(HikWorkerJson.Options);
if (stream is not null) streams.Add(stream);
}
if (streams.Count == 0) return Fail(request, "streams 为空");
var credentials = new Dictionary();
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;
///
/// 收局域网广播询问并单播应答(**询问-应答**,worker 从不主动公告)。
///
/// 只回「同一主体」的询问:主体不一致直接忽略,避免跨租户发现。
/// 应答里的 就是桌面端要探测的取流端口。
///
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();
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);
///
/// 解析询问报文。可选带 nvrHosts: [{host, port}] —— 带了就要先实测可达性再应答。
///
private static bool TryParseQuery(byte[] buffer, out int subjectId, out string server,
out List targets)
{
subjectId = 0;
server = string.Empty;
targets = new List();
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;
}
}
/// 探测 NVR 端口(只判能不能连上,不发任何设备协议)
private static async Task 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 DelayAsync(TimeSpan delay, CancellationToken ct)
{
try
{
await Task.Delay(delay, ct).ConfigureAwait(false);
return true;
}
catch (OperationCanceledException)
{
return false;
}
}
}