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;
///
/// 取流服务对外提供的极简 HTTP 接口(TCP )。
///
/// 端点:
///
/// - GET /health —— 连通性 + 身份(同 LAN 判定就靠它)
/// - POST /probe —— 我这台机器能不能连到指定 NVR(查询机据此决定要不要把活派过来)
/// - POST /download —— 下发下载计划,立即返回 taskId(后台执行)
/// - GET /download/{id} —— 查进度 / 结果
/// - GET /download/{id}/file —— 取成片,**传完立即删除**
///
///
/// 为什么不用 HttpListener:绑定非 localhost 需要 urlacl(安装时要多一步提权操作),
/// 而这几个端点的报文都很简单,直接 TcpListener + 手写 HTTP 更可控。
///
public sealed class EdgeHttpService
{
/// 单次下载请求体的上限(流计划带几十个通道也远小于它)
private const int MaxBodyBytes = 4 * 1024 * 1024;
/// 探测 NVR 的超时
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 _subjectGuard;
/// 主体校验:返回 false 直接 403(避免跨主体取流)
public EdgeHttpService(EdgeDownloadTasks tasks, SemaphoreSlim downloadGate, Func 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 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);
}
/// 主体校验:优先看请求头,缺省按"不允许"处理
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);
}
///
/// 校验该时段有没有录像:**真拉一小段**(与桌面端本地的校验同一套实现)。
///
/// 查询机会先在局域网问"谁能服务这台 NVR",拿到应答后把校验也交给它,
/// 这样多台查询机不会各自登录一次 NVR。
///
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 streams;
Dictionary 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>(HikWorkerJson.Options) ?? new List()
: new List();
if (streams.Count == 0) throw new InvalidOperationException("缺少 streams");
credentials = new Dictionary();
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(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);
}
/// 流式返回成片;**写完立即删除**,查询机那边才负责落盘
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);
}
/// 读一个 HTTP 请求(只支持 Content-Length,够我们这些端点用)
private static async Task 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(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;
}