把海康取流从扫码服务主进程拆到 --hik-worker 子进程,原生 SDK 崩溃
不再连带扫码收码;新增局域网询问-应答与跨网下载通道。
隔离与守护
- 新增 HikWorker(子进程):独占 HCNetSDK 与 NVR 会话池
- 新增 HikWorkerSupervisor(主进程):懒启动、管道通信、
5 分钟内失败 3 次熔断 10 分钟
- 管道协议为 [4 字节长度][JSON],进程退出即知,不占端口
- ServiceInstaller 复制 native(HCNetSDK/ffmpeg),先删后拷,
避免 SDK 升级残留旧 DLL;安装时放行 TCP 17311 / UDP 17310
局域网询问-应答(不是主动公告)
- UDP 17310 收询问,只回同 subjectId;带了 nvrHosts 时先实测可达,
连不上就不应答,让查询机继续走本机
- 应答带 TCP 17311,查询机一次连接即可判定是否同 LAN
跨网下载
- TCP 17311 提供 /health、/probe、/download、/download/{id}
- 除 /health 外均要求 X-Edge-Subject 且与配置主体一致
- 成片在传输完成后立即删除,另有 done 10 分钟 / failed 15 分钟
TTL 兜底,避免现场磁盘被临时文件吃满
桌面端选路
- DownloadAsync 先探 NVR 8000(600ms):通则沿用原有本机直连,
不通才广播找取流服务,取回后落到本机录像目录
- DownloadByPlanAsync 拆分:不查库、不需要用户令牌,
供只有设备令牌的服务端复用
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
533 lines
19 KiB
C#
533 lines
19 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Diagnostics;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Net;
|
||
using System.Net.Sockets;
|
||
using System.Text;
|
||
using System.Text.Json;
|
||
using System.Threading;
|
||
using System.Threading.Tasks;
|
||
|
||
namespace YuncangTrace.LocalService.Services;
|
||
|
||
/// <summary>
|
||
/// 取流服务对外提供的极简 HTTP 接口(TCP <see cref="HikWorkerPorts.Http"/>)。
|
||
///
|
||
/// 端点:
|
||
/// <list type="bullet">
|
||
/// <item><c>GET /health</c> —— 连通性 + 身份(同 LAN 判定就靠它)</item>
|
||
/// <item><c>POST /probe</c> —— 我这台机器能不能连到指定 NVR(查询机据此决定要不要把活派过来)</item>
|
||
/// <item><c>POST /download</c> —— 下发下载计划,立即返回 taskId(后台执行)</item>
|
||
/// <item><c>GET /download/{id}</c> —— 查进度 / 结果</item>
|
||
/// <item><c>GET /download/{id}/file</c> —— 取成片,**传完立即删除**</item>
|
||
/// </list>
|
||
///
|
||
/// 为什么不用 HttpListener:绑定非 localhost 需要 urlacl(安装时要多一步提权操作),
|
||
/// 而这几个端点的报文都很简单,直接 TcpListener + 手写 HTTP 更可控。
|
||
/// </summary>
|
||
public sealed class EdgeHttpService
|
||
{
|
||
/// <summary>单次下载请求体的上限(流计划带几十个通道也远小于它)</summary>
|
||
private const int MaxBodyBytes = 4 * 1024 * 1024;
|
||
|
||
/// <summary>探测 NVR 的超时</summary>
|
||
private static readonly TimeSpan ProbeTimeout = TimeSpan.FromMilliseconds(800);
|
||
|
||
private readonly EdgeDownloadTasks _tasks;
|
||
private readonly SemaphoreSlim _downloadGate;
|
||
private readonly Func<int, bool> _subjectGuard;
|
||
|
||
/// <param name="subjectGuard">主体校验:返回 false 直接 403(避免跨主体取流)</param>
|
||
public EdgeHttpService(EdgeDownloadTasks tasks, SemaphoreSlim downloadGate, Func<int, bool> subjectGuard)
|
||
{
|
||
_tasks = tasks;
|
||
_downloadGate = downloadGate;
|
||
_subjectGuard = subjectGuard;
|
||
}
|
||
|
||
public async Task RunAsync(PlaybackDownloadService download, CancellationToken ct)
|
||
{
|
||
TcpListener listener;
|
||
try
|
||
{
|
||
listener = new TcpListener(IPAddress.Any, HikWorkerPorts.Http);
|
||
listener.Start();
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 取流端口 {HikWorkerPorts.Http} 监听失败(跨网取流不可用):{ex.Message}");
|
||
return;
|
||
}
|
||
|
||
AppLog.Write($"[edge] 取流接口已就绪:TCP {HikWorkerPorts.Http}");
|
||
|
||
// 每分钟清理一次过期临时文件
|
||
_ = Task.Run(async () =>
|
||
{
|
||
while (!ct.IsCancellationRequested)
|
||
{
|
||
try
|
||
{
|
||
await Task.Delay(TimeSpan.FromMinutes(1), ct).ConfigureAwait(false);
|
||
_tasks.Cleanup();
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
break;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 清理任务异常:{ex.Message}");
|
||
}
|
||
}
|
||
}, CancellationToken.None);
|
||
|
||
try
|
||
{
|
||
while (!ct.IsCancellationRequested)
|
||
{
|
||
TcpClient client;
|
||
try
|
||
{
|
||
client = await listener.AcceptTcpClientAsync(ct).ConfigureAwait(false);
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
break;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 接受连接失败(继续):{ex.Message}");
|
||
continue;
|
||
}
|
||
|
||
_ = Task.Run(() => HandleAsync(client, download, ct), CancellationToken.None);
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
try
|
||
{
|
||
listener.Stop();
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
}
|
||
}
|
||
|
||
private sealed record HttpRequest(string Method, string Path, Dictionary<string, string> Headers, byte[] Body);
|
||
|
||
private async Task HandleAsync(TcpClient client, PlaybackDownloadService download, CancellationToken ct)
|
||
{
|
||
try
|
||
{
|
||
using (client)
|
||
using (var stream = client.GetStream())
|
||
using (var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct))
|
||
{
|
||
timeout.CancelAfter(TimeSpan.FromMinutes(5));
|
||
|
||
var request = await ReadRequestAsync(stream, timeout.Token).ConfigureAwait(false);
|
||
if (request is null) return;
|
||
|
||
await RouteAsync(stream, request, download, timeout.Token).ConfigureAwait(false);
|
||
}
|
||
}
|
||
catch (OperationCanceledException)
|
||
{
|
||
// 超时/取消:不记日志(探测连接本来就短)
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
AppLog.Write($"[edge] 请求处理失败:{ex.Message}");
|
||
}
|
||
}
|
||
|
||
private async Task RouteAsync(Stream stream, HttpRequest request, PlaybackDownloadService download,
|
||
CancellationToken ct)
|
||
{
|
||
var path = request.Path.Split('?')[0];
|
||
|
||
if (path.Equals("/health", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var config = AgentFiles.LoadConfig();
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
service = "yuncang-edge",
|
||
sn = config?.DeviceSn,
|
||
subjectId = config?.SubjectId,
|
||
port = HikWorkerPorts.Http,
|
||
}, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
// 除 health 外都要校验主体
|
||
if (!CheckSubject(request, out var subjectError))
|
||
{
|
||
await WriteJsonAsync(stream, 403, "Forbidden", new { ok = false, error = subjectError }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (path.Equals("/probe", StringComparison.OrdinalIgnoreCase)
|
||
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
await HandleProbeAsync(stream, request, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (path.Equals("/download", StringComparison.OrdinalIgnoreCase)
|
||
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
await HandleDownloadAsync(stream, request, download, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (path.StartsWith("/download/", StringComparison.OrdinalIgnoreCase)
|
||
&& request.Method.Equals("GET", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var rest = path["/download/".Length..];
|
||
var isFile = rest.EndsWith("/file", StringComparison.OrdinalIgnoreCase);
|
||
var id = isFile ? rest[..^"/file".Length] : rest;
|
||
|
||
var task = _tasks.Get(id);
|
||
if (task is null)
|
||
{
|
||
await WriteJsonAsync(stream, 404, "Not Found", new { ok = false, error = "任务不存在或已过期" }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (isFile)
|
||
{
|
||
await WriteFileAsync(stream, task, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
taskId = task.Id,
|
||
state = task.State,
|
||
progress = task.Progress,
|
||
size = task.Size,
|
||
error = task.Error,
|
||
}, ct).ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
await WriteJsonAsync(stream, 404, "Not Found", new { ok = false, error = "未知接口" }, ct)
|
||
.ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>主体校验:优先看请求头,缺省按"不允许"处理</summary>
|
||
private bool CheckSubject(HttpRequest request, out string error)
|
||
{
|
||
error = "";
|
||
|
||
if (!request.Headers.TryGetValue("x-edge-subject", out var raw) || !int.TryParse(raw, out var subjectId))
|
||
{
|
||
error = "缺少 X-Edge-Subject";
|
||
return false;
|
||
}
|
||
|
||
if (!_subjectGuard(subjectId))
|
||
{
|
||
error = "主体不匹配";
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private static async Task HandleProbeAsync(Stream stream, HttpRequest request, CancellationToken ct)
|
||
{
|
||
string host;
|
||
int port = 8000;
|
||
|
||
try
|
||
{
|
||
using var doc = JsonDocument.Parse(request.Body);
|
||
host = doc.RootElement.TryGetProperty("nvrHost", out var h) ? h.GetString() ?? "" : "";
|
||
if (doc.RootElement.TryGetProperty("nvrPort", out var p) && p.TryGetInt32(out var parsed)) port = parsed;
|
||
}
|
||
catch
|
||
{
|
||
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = "请求体不是合法 JSON" }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(host) || port is <= 0 or > 65535)
|
||
{
|
||
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = "nvrHost/nvrPort 不合法" }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
var sw = Stopwatch.StartNew();
|
||
var reachable = false;
|
||
try
|
||
{
|
||
using var tcp = new TcpClient();
|
||
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
|
||
timeout.CancelAfter(ProbeTimeout);
|
||
await tcp.ConnectAsync(host, port, timeout.Token).ConfigureAwait(false);
|
||
reachable = tcp.Connected;
|
||
}
|
||
catch (OperationCanceledException) when (!ct.IsCancellationRequested)
|
||
{
|
||
reachable = false;
|
||
}
|
||
catch (Exception)
|
||
{
|
||
reachable = false;
|
||
}
|
||
|
||
await WriteJsonAsync(stream, 200, "OK", new
|
||
{
|
||
ok = true,
|
||
reachable,
|
||
latencyMs = sw.ElapsedMilliseconds,
|
||
}, ct).ConfigureAwait(false);
|
||
}
|
||
|
||
private async Task HandleDownloadAsync(Stream stream, HttpRequest request, PlaybackDownloadService download,
|
||
CancellationToken ct)
|
||
{
|
||
string code;
|
||
List<PackStream> streams;
|
||
Dictionary<int, NvrCredential> credentials;
|
||
DateTime scanTime;
|
||
|
||
try
|
||
{
|
||
using var doc = JsonDocument.Parse(request.Body);
|
||
var root = doc.RootElement;
|
||
|
||
code = root.TryGetProperty("code", out var c) ? c.GetString() ?? "" : "";
|
||
if (code.Length == 0) throw new InvalidOperationException("缺少运单号");
|
||
|
||
streams = root.TryGetProperty("streams", out var s)
|
||
? s.Deserialize<List<PackStream>>(HikWorkerJson.Options) ?? new List<PackStream>()
|
||
: new List<PackStream>();
|
||
if (streams.Count == 0) throw new InvalidOperationException("缺少 streams");
|
||
|
||
credentials = new Dictionary<int, NvrCredential>();
|
||
if (root.TryGetProperty("credentials", out var cr) && cr.ValueKind == JsonValueKind.Array)
|
||
{
|
||
foreach (var item in cr.EnumerateArray())
|
||
{
|
||
var id = item.TryGetProperty("nvrId", out var idElement) ? idElement.GetInt32() : 0;
|
||
if (id <= 0) continue;
|
||
|
||
credentials[id] = new NvrCredential(
|
||
id,
|
||
ReadString(item, "name") ?? "",
|
||
ReadString(item, "host") ?? "",
|
||
item.TryGetProperty("port", out var portElement) ? portElement.GetInt32() : 8000,
|
||
ReadString(item, "username") ?? "",
|
||
ReadString(item, "password") ?? "");
|
||
}
|
||
}
|
||
|
||
var missing = streams.Select(item => item.NvrId).Distinct()
|
||
.Where(id => !credentials.ContainsKey(id)).ToList();
|
||
if (missing.Count > 0) throw new InvalidOperationException($"缺少录像机凭据:{string.Join("、", missing)}");
|
||
|
||
scanTime = root.TryGetProperty("scanTime", out var st) && st.TryGetDateTimeOffset(out var parsed)
|
||
? parsed.LocalDateTime
|
||
: streams[0].StartTime.LocalDateTime;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = ex.Message }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
var task = _tasks.Create(code);
|
||
var workDir = _tasks.WorkDirectory(task.Id);
|
||
|
||
// 后台执行:接口立刻返回,查询机轮询 /download/{id}
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
task.State = "running";
|
||
task.Progress = "开始下载";
|
||
AppLog.Write($"[edge] 任务 {task.Id} 开始:{code},{streams.Count} 路");
|
||
|
||
await _downloadGate.WaitAsync(CancellationToken.None).ConfigureAwait(false);
|
||
try
|
||
{
|
||
var result = await download.DownloadByPlanAsync(
|
||
code,
|
||
streams,
|
||
scanTime,
|
||
workDir,
|
||
(nvrId, _) => Task.FromResult(credentials[nvrId]),
|
||
new Progress<string>(text => task.Progress = text),
|
||
CancellationToken.None).ConfigureAwait(false);
|
||
|
||
var file = result.Merged
|
||
?? result.Segments.FirstOrDefault();
|
||
if (string.IsNullOrEmpty(file) || !File.Exists(file))
|
||
{
|
||
_tasks.Fail(task, "下载完成但没有生成成片");
|
||
AppLog.Write($"[edge] 任务 {task.Id} 失败:没有生成成片");
|
||
return;
|
||
}
|
||
|
||
_tasks.Finish(task, file);
|
||
AppLog.Write($"[edge] 任务 {task.Id} 完成:{file}({task.Size / 1024 / 1024} MB),等待查询机取走");
|
||
}
|
||
finally
|
||
{
|
||
_downloadGate.Release();
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
_tasks.Fail(task, ex.Message);
|
||
AppLog.Write($"[edge] 任务 {task.Id} 失败:{ex.Message}");
|
||
}
|
||
}, CancellationToken.None);
|
||
|
||
await WriteJsonAsync(stream, 200, "OK", new { ok = true, taskId = task.Id }, ct).ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>流式返回成片;**写完立即删除**,查询机那边才负责落盘</summary>
|
||
private async Task WriteFileAsync(Stream stream, EdgeDownloadTask task, CancellationToken ct)
|
||
{
|
||
if (task.State != "done" || string.IsNullOrEmpty(task.FilePath) || !File.Exists(task.FilePath))
|
||
{
|
||
await WriteJsonAsync(stream, 409, "Conflict", new { ok = false, error = "任务还没完成", state = task.State }, ct)
|
||
.ConfigureAwait(false);
|
||
return;
|
||
}
|
||
|
||
var fileInfo = new FileInfo(task.FilePath);
|
||
var name = Path.GetFileName(task.FilePath);
|
||
|
||
var header = "HTTP/1.1 200 OK\r\n"
|
||
+ "Content-Type: video/mp4\r\n"
|
||
+ $"Content-Length: {fileInfo.Length}\r\n"
|
||
+ $"Content-Disposition: attachment; filename=\"{Uri.EscapeDataString(name)}\"\r\n"
|
||
+ "Connection: close\r\n\r\n";
|
||
|
||
await stream.WriteAsync(Encoding.UTF8.GetBytes(header), ct).ConfigureAwait(false);
|
||
|
||
try
|
||
{
|
||
using var file = File.OpenRead(task.FilePath);
|
||
await file.CopyToAsync(stream, 81920, ct).ConfigureAwait(false);
|
||
await stream.FlushAsync(ct).ConfigureAwait(false);
|
||
}
|
||
finally
|
||
{
|
||
// 无论传完还是中途断开,都释放磁盘:现场机器不会有人来打扫
|
||
_tasks.Delivered(task);
|
||
AppLog.Write($"[edge] 任务 {task.Id} 已投递并清理");
|
||
}
|
||
}
|
||
|
||
private static async Task WriteJsonAsync(Stream stream, int status, string reason, object payload,
|
||
CancellationToken ct)
|
||
{
|
||
var body = JsonSerializer.SerializeToUtf8Bytes(payload, HikWorkerJson.Options);
|
||
var header = $"HTTP/1.1 {status} {reason}\r\n"
|
||
+ "Content-Type: application/json; charset=utf-8\r\n"
|
||
+ $"Content-Length: {body.Length}\r\n"
|
||
+ "Connection: close\r\n\r\n";
|
||
|
||
await stream.WriteAsync(Encoding.UTF8.GetBytes(header), ct).ConfigureAwait(false);
|
||
await stream.WriteAsync(body, ct).ConfigureAwait(false);
|
||
await stream.FlushAsync(ct).ConfigureAwait(false);
|
||
}
|
||
|
||
/// <summary>读一个 HTTP 请求(只支持 Content-Length,够我们这些端点用)</summary>
|
||
private static async Task<HttpRequest?> ReadRequestAsync(Stream stream, CancellationToken ct)
|
||
{
|
||
var buffer = new MemoryStream();
|
||
var chunk = new byte[4096];
|
||
var headerEnd = -1;
|
||
|
||
while (headerEnd < 0 && buffer.Length < 64 * 1024)
|
||
{
|
||
var read = await stream.ReadAsync(chunk, ct).ConfigureAwait(false);
|
||
if (read == 0) return null;
|
||
|
||
buffer.Write(chunk, 0, read);
|
||
headerEnd = FindHeaderEnd(buffer.GetBuffer(), (int)buffer.Length);
|
||
}
|
||
|
||
if (headerEnd < 0) return null;
|
||
|
||
var all = buffer.GetBuffer();
|
||
var headerText = Encoding.UTF8.GetString(all, 0, headerEnd);
|
||
var lines = headerText.Split("\r\n", StringSplitOptions.None);
|
||
if (lines.Length == 0) return null;
|
||
|
||
var requestLine = lines[0].Split(' ');
|
||
if (requestLine.Length < 2) return null;
|
||
|
||
var method = requestLine[0];
|
||
var path = requestLine[1];
|
||
|
||
var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
||
for (var i = 1; i < lines.Length; i++)
|
||
{
|
||
var index = lines[i].IndexOf(':');
|
||
if (index <= 0) continue;
|
||
headers[lines[i][..index].Trim()] = lines[i][(index + 1)..].Trim();
|
||
}
|
||
|
||
var contentLength = headers.TryGetValue("Content-Length", out var raw)
|
||
&& int.TryParse(raw, out var parsed)
|
||
? parsed
|
||
: 0;
|
||
|
||
if (contentLength is < 0 or > MaxBodyBytes) return null;
|
||
|
||
var bodyStart = headerEnd + 4;
|
||
var body = new byte[contentLength];
|
||
var available = (int)buffer.Length - bodyStart;
|
||
if (available > 0) Array.Copy(all, bodyStart, body, 0, Math.Min(available, contentLength));
|
||
|
||
var remaining = contentLength - Math.Min(available, contentLength);
|
||
var offset = Math.Min(available, contentLength);
|
||
while (remaining > 0)
|
||
{
|
||
var read = await stream.ReadAsync(body.AsMemory(offset, remaining), ct).ConfigureAwait(false);
|
||
if (read == 0) break;
|
||
offset += read;
|
||
remaining -= read;
|
||
}
|
||
|
||
return new HttpRequest(method, path, headers, body);
|
||
}
|
||
|
||
private static int FindHeaderEnd(byte[] buffer, int length)
|
||
{
|
||
for (var i = 0; i + 3 < length; i++)
|
||
{
|
||
if (buffer[i] == '\r' && buffer[i + 1] == '\n' && buffer[i + 2] == '\r' && buffer[i + 3] == '\n')
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
private static string? ReadString(JsonElement element, string name)
|
||
=> element.TryGetProperty(name, out var value) && value.ValueKind == JsonValueKind.String
|
||
? value.GetString()
|
||
: null;
|
||
}
|