Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

fix(media): 分片请求断开时终止转码进程

FriendlyPasser2283ab1c417f
diff --git a/docs/REUSE.md b/docs/REUSE.md
index d17281fc3..d45bf8d86 100644
--- a/docs/REUSE.md
+++ b/docs/REUSE.md
@@ -103,6 +103,14 @@ Peach 负责独立数据目录、首启、构建身份和资源清单。arm64
macOS 复用 FFmpeg 的 VideoToolbox H.264 编码及 H.264、HEVC、AV1 解码,沿用现有 `HardwareTranscoder` 的合成帧探测、命令尝试顺序和软件回退;不新增视频框架或 Python 运行依赖。`-allow_sw 0` 要求编码器实际使用硬件,AV1 硬解显式选择 FFmpeg 原生解码器,软件回退继续使用 dav1d。依据 [FFmpeg 硬件解码选项](https://ffmpeg.org/ffmpeg.html#Advanced-Video-options)和当前固定源码中的 `videotoolbox_av1.c`、`videotoolboxenc.c`;具体可用能力依赖设备与系统,不按 Intel 或 M 系列名称推断。抽帧的编码格式探测复用 `media_probe.probe_file`,按文件世代有界缓存,失败后在同一超时预算内软解。两种加速偏好复用 `media-processing.json`、`FileLock` 与原子写入,抽帧与播放各自保存;服务端新任务读取本机偏好,不调整浏览器解码器,不更改 ledger。桌面和手机自动化回归验证独立切换与保存恢复,合成片分别验收硬件可用路径及失败回退。
+## HLS 请求断开清理
+
+HLS 分片请求复用 Range 传输的 ASGI 断开监听、Python 3.14 的 `asyncio.wait` 与既有 `HlsSegmentService._run` 清理:请求断开时取消该请求的生成任务,终止并等待子进程退出,再移除临时分片。取消以单个请求为单位,同一播放会话的其他请求可继续生成;排队请求退出后不启动转码。
+
+进程管理沿用标准库的 [`asyncio.subprocess`](https://docs.python.org/3.14/library/asyncio-subprocess.html)(PSF 许可,无新增安装体积),不引入进程扫描库或 FFmpeg 命令包装层。当前树、REUSE 与 Git 历史的复用检索确认,分片和整片已具备会话取消,断开监听由传输层提供。临时文件与真实 Python 子进程回归覆盖断开退出、并发隔离、排队取消及同会话重试;macOS 的临时 HTTP 服务用合成 HEVC 和 FFmpeg 8.1.1 实测,断连后子进程退出、临时分片与登记清理完成。Windows 报告环境与真实 GPU 播放验收未取得。无新增依赖、生产入口或真实 ledger 写入。
+
+## 播放转码的硬件选择
+
整片 MP4 与 HLS 复用现有 FFmpeg 的 CUDA / NVENC、VAAPI、`scale_vaapi` 与 `hwupload`,不引入 Python 命令包装库。Windows 发行工具固定为 FFmpeg 9.0.2(GPL-3.0-or-later,来源清单见 `scripts/ffmpeg-sources.json`);Linux 镜像使用 Debian trixie 的 FFmpeg、`mesa-va-drivers` 与 `vainfo`,随 Debian 安全更新取得版本,不另行复制驱动代码。Mesa 按上游各组件许可证分发,驱动增加的镜像体积由构建决定,AMD 需要宿主机 amdgpu 与固件。设备参数和硬件解码接口依据 [FFmpeg 官方文档](https://ffmpeg.org/ffmpeg.html#Advanced-Video-options),驱动范围依据 [Debian VAAPI 说明](https://wiki.debian.org/HardwareVideoAcceleration)。
Peach 只保留设备选择、一次性合成帧探测、命令尝试顺序与失败回退;探测结果由两个服务共享。复用检索覆盖当前 NVENC 链、媒体工具解析器与 Git 历史,没有独立 VAAPI 路径。FFmpeg 已覆盖编解码与滤镜,ffmpeg-python 一类包装层不提供设备驱动或硬件可用性判定,因此沿用项目 subprocess 入口,不新增 Python 依赖。回归用合成输入与进程替身验证 Linux 节点选择、权限和超时、10-bit 转 NV12、整片及分片回退。2026-10-19 的 Windows NVENC 实测使用 640×360 合成帧完成探测,合成 10-bit HEVC 经整片 MP4 与 HLS 两条 CUDA / NVENC 路径输出 H.264 `yuv420p`;128×128 不满足该编码器的最低尺寸,因此探测统一用 640×360。目标 AMD GPU 的驱动初始化、解码与播放验收未取得。无生产入口或真实 ledger 写入。
diff --git a/src/peach/routes_media.py b/src/peach/routes_media.py
index d81ce40c5..f176ea6cb 100644
--- a/src/peach/routes_media.py
+++ b/src/peach/routes_media.py
@@ -29,6 +29,7 @@ from fastapi.responses import (
FileResponse, JSONResponse, PlainTextResponse, RedirectResponse, Response,
)
from starlette.staticfiles import StaticFiles
+from starlette.requests import ClientDisconnect
from . import (
avatar_face, avatar_online, avatar_picker, avatar_provider, follow_assets, follow_providers, images,
@@ -53,7 +54,9 @@ from .remote_media_cache import AVATAR_REFRESH_SECONDS, FAVICON_REFRESH_SECONDS,
from .preview_cache import PreviewCache
from .routes_auth import require_auth
from .segments import SegmentCancelled, SegmentUnavailable, build_hls_playlist
-from .streaming import BufferedFileResponse, CancellableFileResponse, SplicedMp4Response
+from .streaming import (
+ BufferedFileResponse, CancellableFileResponse, SplicedMp4Response, run_until_disconnect,
+)
from .transcodes import TranscodeCancelled, TranscodeNeedsSession, TranscodeUnavailable
router = APIRouter()
@@ -373,6 +376,14 @@ async def hls_segment(request: Request, id: int, index: int, session: str = "",
return JSONResponse({"error": "invalid session"}, status_code=400)
if state.stream_sessions.is_cancelled(session):
return Response(status_code=410, headers={"Cache-Control": "no-store"})
+ try:
+ return await run_until_disconnect(_hls_segment(request, id, index, session), request.receive)
+ except ClientDisconnect:
+ return Response(status_code=410, headers={"Cache-Control": "no-store"})
+
+
+async def _hls_segment(request: Request, id: int, index: int, session: str):
+ state = request.app.state
try:
loop = asyncio.get_running_loop()
resolved = await loop.run_in_executor(
diff --git a/src/peach/streaming.py b/src/peach/streaming.py
index 64c64e110..8f7d87d97 100644
--- a/src/peach/streaming.py
+++ b/src/peach/streaming.py
@@ -3,12 +3,13 @@ from __future__ import annotations
import asyncio
import logging
import threading
-from collections.abc import MutableSet
+from collections.abc import Awaitable, MutableSet
from pathlib import Path
from time import monotonic
from typing import Any
from starlette.responses import FileResponse, Response
+from starlette.requests import ClientDisconnect
from starlette.types import Receive, Scope, Send
RANGE_PREFIX = "bytes="
@@ -101,18 +102,28 @@ async def _wait_for_disconnect(receive: Receive) -> None:
return
-async def _send_until_disconnect(inner, scope: Scope, receive: Receive, send: Send) -> None:
- """跑 `inner` 发响应,客户端一断开就把它掐掉。"""
- respond = asyncio.ensure_future(inner(scope, receive, send))
+async def run_until_disconnect[T](operation: Awaitable[T], receive: Receive) -> T:
+ """等待请求的工作结果;客户端断开时取消工作,并等待其清理完成。"""
+ work = asyncio.ensure_future(operation)
watch = asyncio.ensure_future(_wait_for_disconnect(receive))
try:
- await asyncio.wait({respond, watch}, return_when=asyncio.FIRST_COMPLETED)
+ done, _ = await asyncio.wait({work, watch}, return_when=asyncio.FIRST_COMPLETED)
+ if work in done:
+ return work.result()
+ watch.result()
+ raise ClientDisconnect()
finally:
- respond.cancel()
+ work.cancel()
watch.cancel()
- await asyncio.gather(respond, watch, return_exceptions=True)
- if not respond.cancelled():
- respond.result()
+ await asyncio.gather(work, watch, return_exceptions=True)
+
+
+async def _send_until_disconnect(inner, scope: Scope, receive: Receive, send: Send) -> None:
+ """跑 `inner` 发响应,客户端一断开就把它掐掉。"""
+ try:
+ await run_until_disconnect(inner(scope, receive, send), receive)
+ except ClientDisconnect:
+ return
class BufferedFileResponse(FileResponse):
diff --git a/tests/test_streaming.py b/tests/test_streaming.py
index f6263b5d7..d126bbdc7 100644
--- a/tests/test_streaming.py
+++ b/tests/test_streaming.py
@@ -1,11 +1,20 @@
from __future__ import annotations
import asyncio
+import sys
+import tempfile
import unittest
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock, patch
+
+from starlette.requests import Request
from peach.streaming import CancellableFileResponse, StreamSessionRegistry
from peach.mp4index import segment_plan
-from peach.segments import build_hls_playlist
+from peach.routes_media import hls_segment
+from peach.segments import HlsSegmentService, build_hls_playlist
async def _collect(response, requested: bytes | None, method: str = "GET"):
@@ -31,6 +40,138 @@ async def _collect(response, requested: bytes | None, method: str = "GET"):
)
+class HlsDisconnectTests(unittest.IsolatedAsyncioTestCase):
+ """分片请求使用真实子进程验证断开、退出和并发请求的隔离。"""
+
+ async def asyncSetUp(self):
+ temporary = tempfile.TemporaryDirectory()
+ self.addCleanup(temporary.cleanup)
+ self.root = Path(temporary.name).resolve()
+ self.source = self.root / "clip.mp4"
+ self.source.write_bytes(b"source")
+ self.started = asyncio.Queue()
+ started = self.started
+
+ class Registry(StreamSessionRegistry):
+ def register_process(self, session, process):
+ registered = super().register_process(session, process)
+ if registered:
+ started.put_nowait(process)
+ return registered
+
+ self.registry = Registry()
+ self.service = HlsSegmentService(
+ Mock(ffmpeg=lambda: SimpleNamespace(path=Path(sys.executable))),
+ self.root / "cache", max_concurrent=1,
+ )
+ executor = ThreadPoolExecutor(max_workers=1)
+ self.addCleanup(executor.shutdown)
+ self.state = SimpleNamespace(
+ hls_service=self.service, stream_sessions=self.registry,
+ hls_plan_executor=executor,
+ )
+ self.child_code = "import time; time.sleep(60)"
+
+ def command(target):
+ target.write_bytes(b"segment")
+ return [sys.executable, "-c", self.child_code]
+
+ for patcher in (
+ patch("peach.routes_media._hls_plan", return_value=(
+ None, self.source, [(0, 6), (6, 6)], True,
+ )),
+ patch.object(self.service, "_attempts", return_value=[("process", command)]),
+ ):
+ patcher.start()
+ self.addCleanup(patcher.stop)
+ self.tasks = []
+
+ async def asyncTearDown(self):
+ for task in self.tasks:
+ task.cancel()
+ await asyncio.gather(*self.tasks, return_exceptions=True)
+ self.registry.cancel("shared")
+
+ def request(self, index=0):
+ disconnected = asyncio.Event()
+
+ async def receive():
+ await disconnected.wait()
+ return {"type": "http.disconnect"}
+
+ request = Request({"type": "http", "app": SimpleNamespace(state=self.state)}, receive)
+ task = asyncio.create_task(hls_segment(request, 1, index, "shared", {}))
+ self.tasks.append(task)
+ return task, disconnected
+
+ async def process(self):
+ return await asyncio.wait_for(self.started.get(), 5)
+
+ async def response(self, task):
+ return await asyncio.wait_for(asyncio.shield(task), 5)
+
+ async def test_disconnect_reaps_the_child_and_allows_the_slice_to_be_requested_again(self):
+ task, disconnected = self.request()
+ process = await self.process()
+ self.assertIsNone(process.returncode)
+ disconnected.set()
+ response = await self.response(task)
+ self.assertEqual(response.status_code, 410)
+ self.assertIsNotNone(process.returncode)
+ self.assertFalse(self.registry.is_cancelled("shared"))
+ self.assertEqual(list(self.root.rglob("*.tmp.ts")), [])
+ target = self.service.cached_path(self.source, 1, 0, transcode=True)
+ self.assertFalse(target.exists())
+
+ self.child_code = "pass"
+ retry, _ = self.request()
+ response = await self.response(retry)
+ self.assertEqual(response.status_code, 200)
+ self.assertEqual(Path(response.path).read_bytes(), b"segment")
+
+ async def test_disconnect_preserves_another_active_slice_in_the_same_session(self):
+ self.service = self.state.hls_service = HlsSegmentService(
+ self.service.resolver, self.root / "parallel", max_concurrent=2,
+ )
+ with patch.object(self.service, "_attempts", return_value=[(
+ "process", lambda target: [sys.executable, "-c", self.child_code],
+ )]):
+ first, disconnected = self.request(0)
+ first_process = await self.process()
+ second, _ = self.request(1)
+ second_process = await self.process()
+ disconnected.set()
+ self.assertEqual((await self.response(first)).status_code, 410)
+ self.assertIsNotNone(first_process.returncode)
+ self.assertIsNone(second_process.returncode)
+ self.assertFalse(second.done())
+ self.assertEqual(self.registry.cancel("shared"), 1)
+ self.assertEqual((await self.response(second)).status_code, 410)
+ self.assertIsNotNone(second_process.returncode)
+
+ async def test_disconnected_queued_slice_does_not_start_a_child(self):
+ first, _ = self.request(0)
+ process = await self.process()
+ second, disconnected = self.request(1)
+ disconnected.set()
+ self.assertEqual((await self.response(second)).status_code, 410)
+ self.assertTrue(self.started.empty())
+ self.assertIsNone(process.returncode)
+ self.assertEqual(self.registry.cancel("shared"), 1)
+ self.assertEqual((await self.response(first)).status_code, 410)
+ self.assertIsNotNone(process.returncode)
+
+ async def test_handler_cancellation_reaps_the_child_and_preserves_cancellation(self):
+ task, _ = self.request()
+ process = await self.process()
+ task.cancel()
+ with self.assertRaises(asyncio.CancelledError):
+ await task
+ self.assertIsNotNone(process.returncode)
+ self.assertEqual(list(self.root.rglob("*.tmp.ts")), [])
+ self.assertEqual(self.registry.cancel("shared"), 0)
+
+
class StreamSessionRegistryTests(unittest.IsolatedAsyncioTestCase):
async def test_cancel_stops_every_active_request_in_the_session(self):
registry = StreamSessionRegistry()