跨公司下载:云端中转成片(分片上传 + Range 下载)

A(查询机)和 B(仓库)不同网络、B 无公网 IP。B 出站领任务后把成片传回云端中转,
A 再从云端取回本地 —— 全程不需要任何一方有公网入口。

云端
- POST /api/web/edge/download      建任务(按主体选在线设备 → 下发 download)
- GET  /api/web/edge/download/:id  查进度(queued/uploading/done/failed)
- GET  /api/web/edge/download/:id/file  取成片,支持 Range(浏览器播放要拖动进度条)
- POST /api/scanner/tasks/:id/upload  设备分片上传(原始字节流,不是 base64)
- bodyParser 对该上传路由禁用:否则原始请求体会被解析掉
- 成片落 run/edge-files(run/ 属部署保留目录,不会被发布覆盖)
- 每次建任务顺手清理过期文件;元数据按主体校验,越权一律 404

桌面端
- AgentHost 新增 download 任务执行:worker 拉流合并 → 分片上传 → 传完删本地临时文件
- 失败时把 uploadTaskId 带回云端,立刻落 failed,查询机不用干等到超时
- ApiClient 新增建任务 / 查状态 / 取文件 / 分片上传
- PlaybackDownloadService 改为三级选路:
  LAN 设备管理服务 → 云端中转 → 本机直连

实测(真实 NVR)
  建任务 → 设备拉流 1.9MB → 上传 → 下载:7.5 秒,字节数一致,ftypisom
  Range: bytes=0-99 → HTTP 206 + Content-Range 正确

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
liufumingren 2026-10-22 00:30:09 +08:00
parent 290f29e547
commit 993c7acd30
8 changed files with 674 additions and 6 deletions

View File

@ -47,9 +47,43 @@ class DeviceEdgeController extends Controller {
const body = ctx.request.body || {};
await ctx.service.edgeTask.submitResult(id, body);
// 跨网下载失败时,设备把 uploadTaskId 带回来 —— 立刻落 failed,
// 查询机不用干等到超时。
if (body.ok === false && body.uploadTaskId) {
await ctx.service.edgeTask.markFailed(String(body.uploadTaskId), body.error || '设备下载失败');
}
ctx.logger.info('[edge] 设备 %s 回任务 %s:ok=%s', ctx.state.scanner.sn, id, body.ok);
ctx.body = { ok: true };
}
/**
* 上传成片分片(跨网下载用)
*
* `POST /api/scanner/tasks/:id/upload?last=0|1`,body 是**原始字节**。
* 用原始流而不是 JSON/base64:几 MB 的分片做 base64 会膨胀 33%,没有意义。
* 该路由已在 config.bodyParser.ignore 里排除,所以这里直接读 `ctx.req`。
*
* ⚠️ 分片必须按顺序追加(设备侧是顺序读文件的),不校验 seq 是为了少一次往返。
*/
async upload() {
const { ctx } = this;
const id = String(ctx.params.id || '').trim();
if (!id) ctx.throw(400, '缺少任务 id');
const last = String(ctx.query.last || '0') === '1';
try {
const meta = await ctx.service.edgeTask.appendChunk(id, ctx.req, { last });
ctx.body = { ok: true, data: { size: meta.size, state: meta.state } };
} catch (err) {
ctx.logger.warn('[edge] 上传分片失败 %s:%s', id, err.message);
// 上传失败要落状态,否则查询机要白等两分钟
await ctx.service.edgeTask.markFailed(id, err.message);
ctx.throw(500, `上传失败:${err.message}`);
}
}
}
module.exports = DeviceEdgeController;

View File

@ -1,6 +1,8 @@
'use strict';
const { Controller } = require('egg');
const fs = require('fs');
const path = require('path');
/**
* web 用户端:边缘能力(`/api/web/edge/*`)
@ -35,6 +37,131 @@ class WebEdgeController extends Controller {
ctx.body = { ok: true, data };
}
/**
* POST /api/web/edge/download { code }
*
* 跨网下载:云端让能访问 NVR 的扫码服务去拉流合并,传回云端中转,
* 查询机拿到 `taskId` 后再取文件(不会占住这个请求)。
*/
async download() {
const { ctx } = this;
const body = ctx.request.body || {};
const code = String(body.code || ctx.query.code || '').trim();
if (!code) ctx.throw(422, '缺少运单号');
const data = await ctx.service.edgeTask.createDownloadTask({
subjectId: ctx.state.subjectId,
code,
});
ctx.logger.info('[edge] 主体 %s 跨网下载 %s → %s', ctx.state.subjectId, code, data.state);
ctx.body = { ok: true, data };
}
/**
* GET /api/web/edge/download/:taskId —— 查进度
*
* 只能查自己主体创建的任务(元数据里记了 subjectId)。
*/
async downloadStatus() {
const { ctx } = this;
const meta = await this.requireOwnTask(ctx.params.taskId);
ctx.body = {
ok: true,
data: {
state: meta.state,
size: meta.size || 0,
error: meta.error || null,
scannerSn: meta.scannerSn || null,
},
};
}
/**
* GET /api/web/edge/download/:taskId/file —— 取成片
*
* 支持 `Range`(浏览器 `<video>` 拖动进度条要用),鉴权同样按主体。
*/
async downloadFile() {
const { ctx } = this;
const meta = await this.requireOwnTask(ctx.params.taskId);
if (meta.state !== 'done') {
ctx.status = 409;
ctx.body = { ok: false, message: meta.state === 'failed' ? (meta.error || '下载失败') : '文件还没准备好' };
return;
}
const file = ctx.service.edgeTask.filePath(ctx.params.taskId);
let stat;
try {
stat = await fs.promises.stat(file);
} catch (err) {
ctx.status = 404;
ctx.body = { ok: false, message: '文件已过期或被清理' };
return;
}
const total = stat.size;
const range = parseRange(ctx.headers.range, total);
ctx.type = 'video/mp4';
ctx.set('Accept-Ranges', 'bytes');
ctx.set('Content-Disposition',
`attachment; filename="${encodeURIComponent(meta.code || 'video')}.mp4"`);
if (!range) {
ctx.set('Content-Length', String(total));
ctx.body = fs.createReadStream(file);
return;
}
ctx.status = 206;
ctx.set('Content-Range', `bytes ${range.start}-${range.end}/${total}`);
ctx.set('Content-Length', String(range.end - range.start + 1));
ctx.body = fs.createReadStream(file, { start: range.start, end: range.end });
}
/** 取任务元数据并校验主体;不存在/越权一律 404(不泄露"存在但不是你的") */
async requireOwnTask(taskIdRaw) {
const { ctx } = this;
const taskId = String(taskIdRaw || '').trim();
if (!taskId) ctx.throw(400, '缺少任务 id');
const meta = await ctx.service.edgeTask.readMeta(taskId);
if (!meta || Number(meta.subjectId) !== Number(ctx.state.subjectId)) {
ctx.throw(404, '任务不存在或已过期');
}
return meta;
}
}
/**
* 解析 `Range: bytes=start-end`
* @return {{start:number,end:number}|null} 非法或不支持时返回 null(走整文件)
*/
function parseRange(header, total) {
const text = String(header || '').trim();
const match = /^bytes=(\d*)-(\d*)$/.exec(text);
if (!match) return null;
let start = match[1] === '' ? null : Number(match[1]);
let end = match[2] === '' ? null : Number(match[2]);
if (start === null && end === null) return null;
if (start === null) {
// bytes=-N:最后 N 字节
start = Math.max(total - end, 0);
end = total - 1;
} else if (end === null || end >= total) {
end = total - 1;
}
if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= total) return null;
return { start, end };
}
module.exports = WebEdgeController;

View File

@ -107,6 +107,10 @@ module.exports = (app) => {
// 边缘能力:查询机在局域网找不到「设备管理服务」时,来这里问云端
// (云端转给打包仓库那台扫码服务,由它真拉一段确认有没有录像)
router.post('/api/web/edge/check', apiAuth, subjectAuth, controller.web.edge.check);
// 跨网下载:创建任务 → 查进度 → 取成片(支持 Range)
router.post('/api/web/edge/download', apiAuth, subjectAuth, controller.web.edge.download);
router.get('/api/web/edge/download/:taskId', apiAuth, subjectAuth, controller.web.edge.downloadStatus);
router.get('/api/web/edge/download/:taskId/file', apiAuth, subjectAuth, controller.web.edge.downloadFile);
// ---------- 视频接入:NVR / 摄像头 / 工作台(只碰本主体的数据;仅主体管理员)----------
// 拉取通道 = 前端调本机软件(localhost:17300/api/hik/channels)→ 勾选 → POST /nvrs/:id/channels 落库
@ -209,6 +213,8 @@ module.exports = (app) => {
// 边缘任务通道:设备主动出站领任务(跨公司取流用,云端从不反向连设备)
router.post('/api/scanner/tasks/poll', scannerAuth, controller.device.edge.poll);
router.post('/api/scanner/tasks/:id/result', scannerAuth, controller.device.edge.result);
// 成片分片上传(原始字节流,bodyParser 已在 config 里对该路由禁用)
router.post('/api/scanner/tasks/:id/upload', scannerAuth, controller.device.edge.upload);
// 上报(写)额外检查主体是否过期/停用:过期后返回 403 subject_expired,设备暂停推送并靠心跳探测续期
router.post('/api/scan/channels', scannerAuth, subjectActive, controller.device.scan.reportChannels);
router.get('/api/scan/channels', scannerAuth, controller.device.scan.channels);

View File

@ -2,6 +2,9 @@
const { Service } = require('egg');
const crypto = require('crypto');
const fs = require('fs');
const fsp = require('fs/promises');
const path = require('path');
/**
* 云端「边缘任务」通道
@ -30,6 +33,12 @@ const DEFAULT_WAIT_MS = 8000;
/** 同一主体最多试几台设备(多仓库时逐个试,连不上 NVR 的会被跳过) */
const MAX_DEVICES = 2;
/** 中转成片的保留时间:够查询机下完即可,过期自动清理 */
const FILE_TTL_MS = 2 * 60 * 60 * 1000;
/** 成片元数据 TTL(秒) */
const META_TTL_SECONDS = 2 * 60 * 60;
class EdgeTaskService extends Service {
get redis() {
return this.app.redis;
@ -47,6 +56,203 @@ class EdgeTaskService extends Service {
return `${this.prefix}edge:result:${taskId}`;
}
// ==================== 跨网下载:文件中转 ====================
/** 成片存放目录(`run/` 本来就在部署保留目录里,不会被发布覆盖) */
get storageDir() {
return path.join(this.app.config.baseDir, 'run', 'edge-files');
}
/** 成片路径 */
filePath(taskId) {
return path.join(this.storageDir, `${sanitizeId(taskId)}.mp4`);
}
/** 上传中的临时文件(收完最后一个分片才改名,避免被下到半个文件) */
partPath(taskId) {
return `${this.filePath(taskId)}.part`;
}
metaKey(taskId) {
return `${this.prefix}edge:dl:${sanitizeId(taskId)}`;
}
async writeMeta(taskId, meta) {
await this.redis.setex(this.metaKey(taskId), META_TTL_SECONDS, JSON.stringify(meta));
}
async readMeta(taskId) {
const raw = await this.redis.get(this.metaKey(taskId));
if (!raw) return null;
try {
return JSON.parse(raw);
} catch (err) {
return null;
}
}
/**
* 创建跨网下载任务:算回放计划 → 下发给设备 → 等它把成片传上来
*
* 返回的 `taskId` 就是后续查状态 / 取文件的凭据,**只对同主体可见**。
*
* @param {object} params
* @param {number} params.subjectId
* @param {string} params.code 运单号
* @return {Promise<object>} { state, taskId?, message? }
*/
async createDownloadTask({ subjectId, code }) {
// 顺手清一遍过期成片:现场没人会来打扫,靠每次新建任务时收敛
await this.cleanupFiles().catch(() => 0);
const plan = await this.ctx.service.pack.query({ subjectId, code });
const streams = (plan && plan.streams) || [];
if (streams.length === 0) return { state: 'no-plan', message: '这个运单没有可下载的回放' };
const scanners = await this.onlineScanners(subjectId);
if (scanners.length === 0) return { state: 'no-device', message: '没有在线的扫码服务' };
// 凭据:同一台 NVR 只取一次(多路可能来自同一台)
const credentials = [];
const seen = new Set();
for (const stream of streams) {
const id = Number(stream.nvrId);
if (!id || seen.has(id)) continue;
seen.add(id);
const credential = await this.ctx.service.nvr.credentialOf(id, subjectId);
if (!credential.password) {
return { state: 'no-credential', message: `录像机「${credential.name}」没有保存密码` };
}
credentials.push({
nvrId: id,
name: credential.name,
host: credential.host,
port: credential.port,
username: credential.username,
password: credential.password,
});
}
const scanTime = (plan.records && plan.records[0] && plan.records[0].scanTime) || streams[0].startTime;
const payload = { code, streams, credentials, scanTime, rootDir: null };
let lastError = null;
for (const scanner of scanners) {
const target = crypto.randomUUID();
const task = await this.enqueue(scanner.id, 'download', Object.assign({}, payload, { uploadTaskId: target }));
const meta = {
taskId: task.id,
uploadTaskId: target,
subjectId: Number(subjectId),
code,
scannerId: Number(scanner.id),
scannerSn: scanner.sn,
state: 'queued',
size: 0,
createdAt: new Date().toISOString(),
error: null,
};
// 元数据挂在 **上传 id** 上:设备回传时用的是这个 id
await this.writeMeta(target, meta);
// 队列任务 id 也映射一份,方便按任务查
await this.writeMeta(task.id, meta);
const ready = await this.waitUpload(target, 120000);
if (ready && ready.state === 'done') {
return { state: 'ok', taskId: target, size: ready.size, scannerSn: scanner.sn };
}
lastError = (ready && ready.error) || '设备没有完成上传';
await this.markFailed(target, lastError);
}
return { state: 'no-device', message: lastError };
}
/** 设备侧:追加一个分片(顺序追加,最后一片触发改名) */
async appendChunk(uploadTaskId, stream, { last = false } = {}) {
const meta = await this.readMeta(uploadTaskId);
if (!meta) throw new Error('上传任务不存在或已过期');
await fsp.mkdir(this.storageDir, { recursive: true });
const part = this.partPath(uploadTaskId);
await new Promise((resolve, reject) => {
const out = fs.createWriteStream(part, { flags: 'a' });
stream.pipe(out);
out.on('finish', resolve);
out.on('error', reject);
stream.on('error', reject);
});
const size = (await fsp.stat(part)).size;
meta.size = size;
meta.state = last ? 'done' : 'uploading';
if (last) {
await fsp.rename(part, this.filePath(uploadTaskId));
meta.uploadedAt = new Date().toISOString();
}
await this.writeMeta(uploadTaskId, meta);
return meta;
}
/** 设备侧:上传失败(或下载失败)时把状态落到 failed,查询机不用干等 */
async markFailed(uploadTaskId, message) {
const meta = await this.readMeta(uploadTaskId);
if (!meta) return;
meta.state = 'failed';
meta.error = message || '下载失败';
await this.writeMeta(uploadTaskId, meta);
}
/** 查询机侧:等设备传完 */
async waitUpload(uploadTaskId, timeoutMs) {
const deadline = Date.now() + Math.max(0, Number(timeoutMs) || 0);
for (;;) {
const meta = await this.readMeta(uploadTaskId);
if (meta && (meta.state === 'done' || meta.state === 'failed')) return meta;
if (Date.now() >= deadline) return meta;
await sleep(300);
}
}
/**
* 清理过期成片(由定时任务或取文件后调用)
* 只删超过 FILE_TTL 的文件,正在被下载的不动。
*/
async cleanupFiles() {
let entries;
try {
entries = await fsp.readdir(this.storageDir);
} catch (err) {
return 0;
}
const now = Date.now();
let removed = 0;
for (const name of entries) {
const full = path.join(this.storageDir, name);
try {
const stat = await fsp.stat(full);
if (now - stat.mtimeMs > FILE_TTL_MS) {
await fsp.unlink(full);
removed++;
}
} catch (err) {
// 删不掉就下次再试
}
}
return removed;
}
/**
* 同主体里最近有心跳的扫码服务(可代取的候选,按心跳时间倒序)
* @param {number} subjectId
@ -248,4 +454,10 @@ function sleep(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
/** 只允许十六进制/短横线,防止拼路径穿越 */
function sanitizeId(value) {
const text = String(value || '').trim().toLowerCase();
return /^[a-z0-9-]{8,64}$/.test(text) ? text : crypto.createHash('sha1').update(text).digest('hex');
}
module.exports = EdgeTaskService;

View File

@ -208,6 +208,12 @@ module.exports = (appInfo) => {
ttl: Number(env.CACHE_TTL || 300),
};
// 跨网取流的分片上传是**原始字节流**(不是 JSON),必须跳过 bodyParser,
// 否则请求体会被解析成空,控制器里读 ctx.req 也拿不到数据(或直接超时)。
config.bodyParser = {
ignore: ctx => /^\/api\/scanner\/tasks\/[^/]+\/upload$/.test(ctx.path),
};
// 登录页的自助注册(生产环境建议关掉:REGISTER_ENABLED=false,改用 npm run user:pass 建号)
config.register = {
enable: !/^(0|false|no|off)$/i.test(String(env.REGISTER_ENABLED || 'true')),

View File

@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.Json;
using System.Threading;
@ -507,7 +508,7 @@ public static class AgentHost
AppLog.Write($"[edge] 领到任务 {task.Id}({task.Type})");
var (result, ok) = await ExecuteEdgeTaskAsync(worker, task, ct).ConfigureAwait(false);
var (result, ok) = await ExecuteEdgeTaskAsync(api, settings, worker, task, ct).ConfigureAwait(false);
await api.SubmitEdgeTaskResultAsync(settings.DeviceToken, task.Id, result, ct)
.ConfigureAwait(false);
@ -527,8 +528,8 @@ public static class AgentHost
}
/// <summary>执行一个边缘任务;返回要回传给云端的结果对象</summary>
private static async Task<(object Result, bool Ok)> ExecuteEdgeTaskAsync(HikWorkerSupervisor worker,
ApiClient.EdgeTask task, CancellationToken ct)
private static async Task<(object Result, bool Ok)> ExecuteEdgeTaskAsync(ApiClient api, AppSettings settings,
HikWorkerSupervisor worker, ApiClient.EdgeTask task, CancellationToken ct)
{
try
{
@ -552,6 +553,44 @@ public static class AgentHost
}, true);
}
case "download":
{
var uploadTaskId = task.Payload.ValueKind == JsonValueKind.Object
? ReadString(task.Payload, "uploadTaskId") ?? ""
: "";
try
{
var data = await worker.DownloadAsync(task.Payload, ct).ConfigureAwait(false);
var file = ReadString(data, "merged")
?? ReadFirstSegment(data);
if (string.IsNullOrEmpty(file) || !File.Exists(file))
{
return (new { ok = false, error = "没有生成成片", uploadTaskId }, false);
}
if (uploadTaskId.Length == 0)
{
return (new { ok = false, error = "任务缺少 uploadTaskId", uploadTaskId }, false);
}
var size = await api.UploadEdgeFileAsync(settings.DeviceToken, uploadTaskId, file, ct)
.ConfigureAwait(false);
TryDeleteFile(file);
return (new { ok = true, size, uploadTaskId }, true);
}
catch (OperationCanceledException)
{
throw;
}
catch (Exception ex)
{
return (new { ok = false, error = ex.Message, uploadTaskId }, false);
}
}
default:
return (new { ok = false, error = $"不支持的任务类型:{task.Type}" }, false);
}
@ -566,6 +605,36 @@ public static class AgentHost
}
}
/// <summary>下载结果是多段时取第一段(合并失败才会走到)</summary>
private static string? ReadFirstSegment(JsonElement? data)
{
if (data is not { ValueKind: JsonValueKind.Object } element) return null;
if (!element.TryGetProperty("segments", out var segments) || segments.ValueKind != JsonValueKind.Array)
{
return null;
}
foreach (var item in segments.EnumerateArray())
{
var value = item.ValueKind == JsonValueKind.String ? item.GetString() : null;
if (!string.IsNullOrWhiteSpace(value)) return value;
}
return null;
}
/// <summary>传完就删:现场机器不会有人来清理临时成片</summary>
private static void TryDeleteFile(string path)
{
try
{
if (File.Exists(path)) File.Delete(path);
}
catch (Exception ex)
{
AppLog.Write($"[edge] 清理成片失败({path}):{ex.Message}");
}
}
/// <summary>把 worker 自检结果落到状态里(失败只标记不可用,不影响扫码)</summary>
private static void ApplyHikProbe(AgentHikStatus status, JsonElement? probe)
{
@ -595,6 +664,10 @@ public static class AgentHost
? value.GetString()
: null;
/// <summary>读 worker 返回的字符串字段(data 可能为 null)</summary>
private static string? ReadString(JsonElement? data, string name)
=> data is { } element ? ReadString(element, name) : null;
private static void SaveDiscovered(ScanService scan)
{
var devices = scan.DiscoveredDevices

View File

@ -1,7 +1,9 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using System.Threading;
@ -403,6 +405,123 @@ public sealed class ApiClient
ReadSubjectState(data.Value));
}
/// <summary>
/// 上传成片(分片,原始字节)
///
/// 用原始流而不是 base64:4MB 分片做 base64 会多 1.3MB,没有意义。
/// 用不限时的客户端:上行慢时单个分片可能超过 15 秒。
/// </summary>
/// <returns>已上传的总字节数</returns>
public async Task<long> UploadEdgeFileAsync(string deviceToken, string uploadTaskId, string filePath,
CancellationToken ct = default)
{
const int chunkSize = 4 * 1024 * 1024;
await using var stream = File.OpenRead(filePath);
var total = stream.Length;
var buffer = new byte[chunkSize];
long sent = 0;
while (sent < total)
{
var read = await stream.ReadAsync(buffer.AsMemory(0, chunkSize), ct).ConfigureAwait(false);
if (read <= 0) break;
sent += read;
var last = sent >= total;
using var request = new HttpRequestMessage(HttpMethod.Post,
$"{BaseUrl}/api/scanner/tasks/{uploadTaskId}/upload?last={(last ? 1 : 0)}");
request.Headers.TryAddWithoutValidation("Authorization", $"Bearer {deviceToken}");
request.Content = new ByteArrayContent(buffer, 0, read);
request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
using var response = await LongPollHttp.SendAsync(request, ct).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
var text = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
throw new ApiException($"上传分片失败(HTTP {(int)response.StatusCode}):{text}");
}
}
return sent;
}
/// <summary>跨网下载任务状态</summary>
public sealed record EdgeDownloadStatus(string State, long Size, string? Error, string? ScannerSn);
/// <summary>
/// 创建跨网下载任务(`POST /api/web/edge/download`)
///
/// 云端让能访问 NVR 的设备去拉流合并、传回中转;这里只拿到任务 id。
/// </summary>
public async Task<(string State, string? TaskId, string? Message)> EdgeDownloadCreateAsync(
string token, int subjectId, string code, CancellationToken ct = default)
{
using var response = await SendAuthorizedAsync(HttpMethod.Post, "/api/web/edge/download",
token, subjectId, JsonSerializer.Serialize(new { code }), "云端下载录像", ct).ConfigureAwait(false);
var text = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
var (data, _) = ReadEnvelope(response, text);
if (data is null || data.Value.ValueKind != JsonValueKind.Object) return ("unknown", null, null);
return (GetString(data.Value, "state") ?? "unknown",
GetString(data.Value, "taskId"),
GetString(data.Value, "message"));
}
/// <summary>查跨网下载进度</summary>
public async Task<EdgeDownloadStatus?> EdgeDownloadStatusAsync(string token, int subjectId, string taskId,
CancellationToken ct = default)
{
using var response = await SendAuthorizedAsync(HttpMethod.Get,
$"/api/web/edge/download/{Uri.EscapeDataString(taskId)}", token, subjectId, null,
"查云端下载进度", ct).ConfigureAwait(false);
var text = await response.Content.ReadAsStringAsync(ct).ConfigureAwait(false);
var (data, _) = ReadEnvelope(response, text);
if (data is null || data.Value.ValueKind != JsonValueKind.Object) return null;
return new EdgeDownloadStatus(
GetString(data.Value, "state") ?? "",
data.Value.TryGetProperty("size", out var size) && size.TryGetInt64(out var parsed) ? parsed : 0,
GetString(data.Value, "error"),
GetString(data.Value, "scannerSn"));
}
/// <summary>把云端中转的成片取回本地(整文件;要断点续传再按需求加 Range)</summary>
public async Task<long> DownloadEdgeFileAsync(string token, int subjectId, string taskId, string savePath,
CancellationToken ct = default)
{
using var request = new HttpRequestMessage(HttpMethod.Get,
$"{BaseUrl}/api/web/edge/download/{Uri.EscapeDataString(taskId)}/file");
request.Headers.TryAddWithoutValidation("Authorization", $"Bearer {token}");
request.Headers.TryAddWithoutValidation("X-Subject-Id", subjectId.ToString());
using var response = await LongPollHttp.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, ct)
.ConfigureAwait(false);
response.EnsureSuccessStatusCode();
var dir = Path.GetDirectoryName(savePath);
if (!string.IsNullOrEmpty(dir)) Directory.CreateDirectory(dir);
await using var source = await response.Content.ReadAsStreamAsync(ct).ConfigureAwait(false);
await using var target = File.Create(savePath);
var buffer = new byte[81920];
long total = 0;
while (true)
{
var read = await source.ReadAsync(buffer, ct).ConfigureAwait(false);
if (read == 0) break;
await target.WriteAsync(buffer.AsMemory(0, read), ct).ConfigureAwait(false);
total += read;
}
await target.FlushAsync(ct).ConfigureAwait(false);
return total;
}
/// <summary>云端校验结论</summary>
/// <param name="State">ok / no-plan / no-device / no-credential</param>
/// <param name="HasVideo">true/false 可用;null 表示云端也判断不了</param>

View File

@ -105,8 +105,10 @@ public sealed class PlaybackDownloadService
.Distinct()
.ToList();
// 选路:局域网里有设备管理服务就交给它(共用它的 NVR 会话池,避免多机各自登录),
// 没有才由本机自己连 NVR。
// 选路(三级):
// ① 局域网有设备管理服务 → 交给它(共用它的 NVR 会话池)
// ② 没有 → 问云端,由能访问 NVR 的仓库设备代取、中转回来
// ③ 云端也不行 → 本机自己连 NVR(仓库内操作员的常规路径)
var peer = _gateway is null
? null
: await _gateway.FindAsync(nvrs, ct).ConfigureAwait(false);
@ -119,8 +121,17 @@ public sealed class PlaybackDownloadService
if (viaEdge is not null) return viaEdge;
_gateway?.Invalidate();
progress?.Report("设备管理服务执行失败,改由本机直连录像机…");
progress?.Report("设备管理服务执行失败,改由云端中转…");
}
else
{
progress?.Report("局域网没有设备管理服务,改由云端中转…");
}
var viaCloud = await TryDownloadViaCloudAsync(code, scanTime, progress, ct).ConfigureAwait(false);
if (viaCloud is not null) return viaCloud;
progress?.Report("云端也不可用,改由本机直连录像机…");
return await DownloadByPlanAsync(
code,
@ -132,6 +143,86 @@ public sealed class PlaybackDownloadService
ct).ConfigureAwait(false);
}
/// <summary>
/// 跨公司路径:云端建任务 → 仓库设备拉流并上传 → 本机把成片取回落盘。
///
/// 返回 null 表示「云端不可用/没有在线设备」,调用方降级到本机直连。
/// </summary>
private async Task<PlaybackDownloadResult?> TryDownloadViaCloudAsync(string code, DateTime scanTime,
IProgress<string>? progress, CancellationToken ct)
{
var api = _api?.Invoke();
var token = _token?.Invoke();
var subjectId = _subjectId?.Invoke() ?? 0;
if (api is null || string.IsNullOrWhiteSpace(token) || subjectId <= 0) return null;
string state;
string? taskId;
string? message;
try
{
(state, taskId, message) = await api.EdgeDownloadCreateAsync(token!, subjectId, code, ct)
.ConfigureAwait(false);
}
catch (Exception ex)
{
progress?.Report($"云端建任务失败:{ex.Message}");
return null;
}
if (state != "ok" || string.IsNullOrEmpty(taskId))
{
progress?.Report($"云端无法代取:{message ?? state}");
return null;
}
progress?.Report("仓库设备正在拉流并上传…");
var deadline = DateTime.UtcNow.AddMinutes(15);
var lastState = "";
while (DateTime.UtcNow < deadline)
{
ct.ThrowIfCancellationRequested();
var status = await api.EdgeDownloadStatusAsync(token!, subjectId, taskId, ct).ConfigureAwait(false);
if (status is null) return null;
if (status.State == "failed")
{
throw new InvalidOperationException(status.Error ?? "云端下载失败");
}
if (status.State == "done") break;
if (status.State != lastState)
{
lastState = status.State;
progress?.Report(status.State == "uploading"
? $"正在上传成片({status.Size / 1024.0 / 1024.0:0.0} MB)…"
: "等待仓库设备开始下载…");
}
await Task.Delay(TimeSpan.FromSeconds(1), ct).ConfigureAwait(false);
}
if (lastState != "" && lastState != "done" && DateTime.UtcNow >= deadline)
{
throw new InvalidOperationException("等待云端下载超时(15 分钟)");
}
var folder = VideoStorage.FolderFor(_root(), scanTime);
Directory.CreateDirectory(folder);
var target = Path.Combine(folder, $"{Sanitize(code)}_云端_{DateTime.Now:yyyyMMdd_HHmmss}.mp4");
progress?.Report("正在从云端取回成片…");
var size = await api.DownloadEdgeFileAsync(token!, subjectId, taskId!, target, ct).ConfigureAwait(false);
progress?.Report($"已保存:{target}({size / 1024.0 / 1024.0:0.0} MB)");
return new PlaybackDownloadResult(folder, target, new[] { target }, new List<string>());
}
/// <summary>
/// 交给设备管理服务:派任务 → 轮询 → 把成片拉回本机。
///