peter
47af4d5c05
Deep-review round 5, over round 4's own fixes. - Sessions are keyed by rating_key alone while a session's DIRECTORY is per (key, offset, tag), and the artifact URL carried no session identity — so once a seek-restart or a second viewer of the same item took the registry slot, the old viewer's request for `seg_12.ts` was answered 200 with the new session's twelfth segment: bytes from a different `-ss` offset under `-copyts`, on a timeline the client is not on. Wrong content with a success status is the one failure a player cannot notice, and round 4's reclaim-on-404 could never fire on it. The id is in the path now (so the playlist's relative names resolve back into the same session), a mismatch is a 404, and the player reclaims at the playhead. The entry playlist's auto-start is gone with it: it could only ever begin at 0, silently discarding the viewer's position. - Round 4 exempted paused viewers from the reaper by keeping EVERY finished session for the full ten-minute idle window — one whole segmented copy of a film per item, on the volume the download center shares. The signal it needed already existed: an open player checkpoints its position every 10 s whether or not it is playing, so that route now touches the session and the periodic pass is back on the short rule. - POST /session's opportunistic reap was never scoped to the key being started: it walked the whole registry with the 30 s finished rule, so pressing play on ANY item — even a direct-play one, the call ran before that early return — killed another viewer's paused session. It is gone; the periodic pass owns reaping. - A segment that can never arrive no longer polls out the full 20 s: the producer's handle is passed to `wait_for`, so a finished ffmpeg answers at once. This is a sync route, so each such wait parked a threadpool worker AND a pooled DB connection, and an ordinary seek past the produced region was enough to do it. - The DataError handler's re-raise branch — the half that keeps a genuine DataError a 500 — is pinned, so simplifying it to an unconditional 422 cannot pass in silence. Six regression tests (two route-level, in the DB lane), each mutation-checked red on the assertion it is named after. pytest 1124, vitest 999.
113 lines
4.2 KiB
Python
113 lines
4.2 KiB
Python
"""The playback-session route's mode routing (E6 S1b).
|
|
|
|
`POST /stream/{rk}/session` is the single switch that decides how an item plays: a browser-native
|
|
file is served raw (`mode:"direct"`), everything else (re)starts an HLS session — and a
|
|
`playable="transcode"` item (non-h264: HEVC/VP9/AV1/…) must take that HLS path with the video
|
|
RE-ENCODED, not stream-copied. That routing replaced a former `HTTP 501`, and the only thing that
|
|
tells `start_session` to re-encode is the `transcode=` flag this route derives from `it.playable`.
|
|
The command-builder itself is unit-tested in `test_plex_stream.py`; here we pin the ROUTE decision
|
|
(no ffmpeg spawned — `start_session` is stubbed to echo the flag it was handed).
|
|
|
|
DB lane (`db` fixture) — skipped when no Postgres is reachable.
|
|
"""
|
|
|
|
from types import SimpleNamespace
|
|
|
|
from fastapi.testclient import TestClient
|
|
|
|
import app.state as state
|
|
from app.auth import current_user
|
|
from app.db import get_db
|
|
from app.main import app
|
|
from app.models import PlexItem, PlexLibrary, User
|
|
from app.plex import paths as plex_paths
|
|
from app.plex import stream as plex_stream
|
|
|
|
|
|
def _item(db, *, playable, rating_key="m1"):
|
|
lib = PlexLibrary(plex_key="1", title="Movies", kind="movie", enabled=True)
|
|
db.add(lib)
|
|
db.flush()
|
|
it = PlexItem(
|
|
rating_key=rating_key,
|
|
library_id=lib.id,
|
|
kind="movie",
|
|
title="A Movie",
|
|
file_path="/media/a.mkv",
|
|
playable=playable,
|
|
)
|
|
db.add(it)
|
|
db.commit()
|
|
return it
|
|
|
|
|
|
def _user(db, email="play@example.com"):
|
|
u = User(email=email)
|
|
db.add(u)
|
|
db.flush()
|
|
return u
|
|
|
|
|
|
def _post(db, user, monkeypatch, rating_key, *, captured):
|
|
"""Drive the endpoint with ffmpeg stubbed out. `start_session` records the `transcode` flag it
|
|
was called with into `captured` and returns a stand-in session echoing it back."""
|
|
monkeypatch.setattr(state, "_configured_cache", True) # pass the request gate
|
|
monkeypatch.setattr(plex_stream, "reap_idle", lambda: None)
|
|
monkeypatch.setattr(plex_paths, "local_media_path", lambda db_, fp: "/local/a.mkv")
|
|
|
|
def fake_start(db_, it, start, audio, aoff, multi, transcode=False):
|
|
captured["transcode"] = transcode
|
|
return SimpleNamespace(
|
|
id="sid",
|
|
media_start_s=start,
|
|
entry="index.m3u8",
|
|
transcode=transcode,
|
|
hw=False,
|
|
tonemap=False,
|
|
)
|
|
|
|
monkeypatch.setattr(plex_stream, "start_session", fake_start)
|
|
app.dependency_overrides[get_db] = lambda: db
|
|
app.dependency_overrides[current_user] = lambda: user
|
|
try:
|
|
return TestClient(app).post(f"/api/plex/stream/{rating_key}/session")
|
|
finally:
|
|
app.dependency_overrides.clear()
|
|
|
|
|
|
def test_transcode_item_routes_to_an_hls_reencode_session(db, monkeypatch):
|
|
# A non-h264 item (formerly HTTP 501) now plays: mode=hls, transcode=True threaded to start_session.
|
|
it = _item(db, playable="transcode")
|
|
user = _user(db)
|
|
captured: dict = {}
|
|
resp = _post(db, user, monkeypatch, it.rating_key, captured=captured)
|
|
assert resp.status_code == 200, resp.text
|
|
body = resp.json()
|
|
assert body["mode"] == "hls"
|
|
assert body["transcode"] is True
|
|
assert captured["transcode"] is True # start_session was told to re-encode
|
|
|
|
|
|
def test_remux_item_stays_a_stream_copy_session(db, monkeypatch):
|
|
# A remux (h264) item takes the SAME HLS path but must NOT re-encode.
|
|
it = _item(db, playable="remux", rating_key="m2")
|
|
user = _user(db, "remux@example.com")
|
|
captured: dict = {}
|
|
resp = _post(db, user, monkeypatch, it.rating_key, captured=captured)
|
|
assert resp.status_code == 200, resp.text
|
|
body = resp.json()
|
|
assert body["mode"] == "hls"
|
|
assert body["transcode"] is False
|
|
assert captured["transcode"] is False
|
|
|
|
|
|
def test_direct_item_never_opens_a_session(db, monkeypatch):
|
|
# A browser-native file is served raw — start_session is never reached, so no transcode decision.
|
|
it = _item(db, playable="direct", rating_key="m3")
|
|
user = _user(db, "direct@example.com")
|
|
captured: dict = {}
|
|
resp = _post(db, user, monkeypatch, it.rating_key, captured=captured)
|
|
assert resp.status_code == 200, resp.text
|
|
assert resp.json()["mode"] == "direct"
|
|
assert "transcode" not in captured # start_session not called
|