packServer/desktop/Services/Agent/EdgeHttpService.cs
liufumingren 46e4f12802 desktop: 取流子进程隔离 + 局域网询问应答 + 跨网下载
把海康取流从扫码服务主进程拆到 --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>
2026-10-21 22:48:09 +08:00

533 lines
19 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.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;
}