packServer/desktop/Services/Agent/EdgeHttpService.cs
liufumingren 85db722384 修复:A→B 的 POST 全部无效(JsonContent 不带 Content-Length)
边端是手写的 HTTP 读取,只认 Content-Length;而 A 侧一直用
JsonContent.Create(),它产生的是 chunked 请求 —— 边端把 body 读成空,
/check 直接 400,界面就显示「设备管理服务无响应,改由本机校验」。
也就是说局域网共用取流池这条路,用真实客户端从来没成功过,
此前只有 curl 验证过所以一直没暴露。

- EdgeClient 改用 StringContent(显式 Content-Length)
- 边端遇到 chunked 请求时明确记一行,不再让调用方看到「空 body」的怪错误

实测:JsonContent → 400 contentLength=null;StringContent → 200 contentLength=186

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

651 lines
24 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.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 == 0
&& headers.TryGetValue("Transfer-Encoding", out var transferEncoding)
&& transferEncoding.Contains("chunked", StringComparison.OrdinalIgnoreCase))
{
// 手写解析只认 Content-Length:真遇到 chunked 就明说,别让调用方看到「空 body」的怪错误
AppLog.Write($"[edge] 收到 chunked 请求 {method} {path}(不支持,请用 Content-Length)");
return null;
}
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;
}