packServer/desktop/Services/Agent/EdgeHttpService.cs
liufumingren 63b70c6ad5 补上边端取流的请求级日志,并让 A 侧连接失败自动重试一次
现场表现:查询提示「设备管理服务无响应,改由本机校验」,但边端和 A 侧
都没留下任何痕迹 —— /check 这条路径原来只在异常时记一行,成功完全静默,
A 侧拿到非 2xx 也只返回 null。

- 边端 /check 每次记一行(通道、时间窗、hasRecord、帧数、来源、耗时)
- 主体不符被拒时记录路径、原因和本体主体
- A 侧 EdgeClient:非 2xx 记录状态码+响应体;传输层异常(worker 重启后
  连接池里的死连接)自动重试一次,取成片同理

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

642 lines
24 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;
using YuncangTrace.LocalService.Services.Hik;
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 SemaphoreSlim _checkGate = new(4, 4);
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, HikPlaybackService playback,
CancellationToken ct)
{
TcpListener listener;
try
{
listener = new TcpListener(IPAddress.Parse(HikWorkerPorts.BindAddress), 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, playback, 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,
HikPlaybackService playback, 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, playback, timeout.Token).ConfigureAwait(false);
}
}
catch (OperationCanceledException)
{
// 超时/取消:不记日志(探测连接本来就短)
}
catch (Exception ex)
{
AppLog.Write($"[edge] 请求处理失败:{ex.Message}");
}
}
private async Task RouteAsync(Stream stream, HttpRequest request, PlaybackDownloadService download,
HikPlaybackService playback, 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))
{
var config = AgentFiles.LoadConfig();
AppLog.Write($"[edge] 拒绝 {request.Method} {path}:{subjectError}"
+ $"(本体主体 {(config is null ? "无" : config.SubjectId.ToString())})");
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("/check", StringComparison.OrdinalIgnoreCase)
&& request.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
{
await HandleCheckAsync(stream, request, playback, 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);
}
/// <summary>
/// 校验该时段有没有录像:**真拉一小段**(与桌面端本地的校验同一套实现)。
///
/// 查询机会先在局域网问"谁能服务这台 NVR",拿到应答后把校验也交给它,
/// 这样多台查询机不会各自登录一次 NVR。
/// </summary>
private async Task HandleCheckAsync(Stream stream, HttpRequest request, HikPlaybackService playback,
CancellationToken ct)
{
string host;
int port = 8000;
string username;
string password;
int channelNo;
DateTimeOffset start;
DateTimeOffset end;
try
{
using var doc = JsonDocument.Parse(request.Body);
var root = doc.RootElement;
host = ReadString(root, "nvrHost") ?? "";
username = ReadString(root, "username") ?? "";
password = ReadString(root, "password") ?? "";
if (root.TryGetProperty("nvrPort", out var portElement) && portElement.TryGetInt32(out var parsedPort))
{
port = parsedPort;
}
if (!root.TryGetProperty("channelNo", out var channelElement) || !channelElement.TryGetInt32(out channelNo))
{
throw new InvalidOperationException("缺少 channelNo");
}
if (!root.TryGetProperty("startTime", out var startElement) || !startElement.TryGetDateTimeOffset(out start)
|| !root.TryGetProperty("endTime", out var endElement) || !endElement.TryGetDateTimeOffset(out end))
{
throw new InvalidOperationException("startTime/endTime 不合法");
}
if (string.IsNullOrWhiteSpace(host) || port is <= 0 or > 65535)
{
throw new InvalidOperationException("nvrHost/nvrPort 不合法");
}
}
catch (Exception ex)
{
await WriteJsonAsync(stream, 400, "Bad Request", new { ok = false, error = ex.Message }, ct)
.ConfigureAwait(false);
return;
}
await _checkGate.WaitAsync(ct).ConfigureAwait(false);
try
{
var check = await playback.CheckAsync(host, port, username, password, channelNo, start, end, ct)
.ConfigureAwait(false);
AppLog.Write($"[edge] 校验 {host}:{port} 通道 {channelNo} "
+ $"{start:HH:mm:ss}~{end:HH:mm:ss} → hasRecord={check.HasRecord}"
+ $"({check.Source},{check.Frames} 帧{(string.IsNullOrEmpty(check.Error) ? "" : "," + check.Error)})");
await WriteJsonAsync(stream, 200, "OK", new
{
ok = true,
hasRecord = check.HasRecord,
frames = check.Frames,
error = check.Error,
source = check.Source,
}, ct).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
AppLog.Write($"[edge] 校验失败 {host}:{port} 通道 {channelNo}:{ex.Message}");
await WriteJsonAsync(stream, 200, "OK", new
{
ok = true,
hasRecord = false,
frames = 0,
error = ex.Message,
source = "",
}, ct).ConfigureAwait(false);
}
finally
{
_checkGate.Release();
}
}
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;
}