auto-commit for b5490b7b-d57f-4f53-9a99-bd8ed84027db

backend/models.py

@@ -175,6 +175,8 @@ class AppSettings(BaseModel):
     tmdb_api_key: str = ""
     radarr_url: str = ""
     radarr_api_key: str = ""
+    auto_transcode: str = "off"  # off | quick | abr
+    queue_paused: bool = False
 
 
 class AppSettingsPublic(BaseModel):
@@ -184,6 +186,27 @@ class AppSettingsPublic(BaseModel):
     tmdb_api_key: str = ""
     radarr_url: str = ""
     radarr_api_key: str = ""
+    auto_transcode: str = "off"
+    queue_paused: bool = False
+
+
+# ---------- Transcode Queue ----------
+class TranscodeJob(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    movie_id: str
+    movie_title: str = ""
+    quality: str = "abr"  # quick | abr
+    status: str = "pending"  # pending | running | done | failed | cancelled
+    error: str = ""
+    triggered_by: str = "manual"  # manual | auto
+    created_at: str = Field(default_factory=_now_iso)
+    started_at: Optional[str] = None
+    finished_at: Optional[str] = None
+
+
+class QueuePauseToggle(BaseModel):
+    paused: bool
 
 
 # ---------- Auth Tokens ----------

backend/server.py

@@ -23,6 +23,7 @@ from models import (
     RequestCreate, RequestUpdate, MovieRequest,
     AppSettings, AppSettingsPublic,
     TMDBSearchResult, RadarrMovieDTO,
+    TranscodeJob, QueuePauseToggle,
 )
 from auth import hash_password, verify_password, create_token, decode_token
 from seed import SAMPLE_MOVIES
@@ -158,6 +159,16 @@ async def on_startup():
     except Exception as e:
         logger.warning(f"progress unique index skipped: {e}")
 
+    # Reset any stuck "running" jobs from a previous backend crash
+    await db.transcode_queue.update_many(
+        {"status": "running"},
+        {"$set": {"status": "failed", "error": "Backend restarted while running"}},
+    )
+    await db.transcode_queue.create_index([("status", 1), ("created_at", 1)])
+
+    # Start the background transcode worker
+    asyncio.create_task(_transcode_worker())
+
 
 @app.on_event("shutdown")
 async def on_shutdown():
@@ -394,6 +405,12 @@ async def upload_video(
     )
     doc = movie.model_dump()
     await db.movies.insert_one(doc)
+
+    # Auto-enqueue transcode if enabled
+    s = await get_settings()
+    auto = s.get("auto_transcode", "off")
+    if auto in ("quick", "abr"):
+        await _enqueue_transcode(doc["id"], auto, triggered_by="auto")
     return _strip(doc)
 
 
@@ -469,27 +486,107 @@ async def _set_hls_status(movie_id: str, status: str, path: Optional[str] = None
         logger.warning(f"HLS {movie_id}: {error}")
 
 
-async def _run_transcode(movie_id: str, source: Path, quality: str):
-    out_dir = HLS_DIR / movie_id
-    # Clear any prior output before re-encoding
+async def _process_job(job: dict):
+    """Run a transcode job. Updates both movie.hls_status and the job row."""
+    movie = await db.movies.find_one({"id": job["movie_id"]}, {"_id": 0})
+    if not movie:
+        await db.transcode_queue.update_one(
+            {"id": job["id"]},
+            {"$set": {"status": "failed", "error": "Movie not found", "finished_at": datetime.now(timezone.utc).isoformat()}},
+        )
+        return
+    if movie.get("storage_type") not in ("local", "radarr") or not movie.get("storage_path"):
+        await db.transcode_queue.update_one(
+            {"id": job["id"]},
+            {"$set": {"status": "failed", "error": "Not a local/radarr movie", "finished_at": datetime.now(timezone.utc).isoformat()}},
+        )
+        return
+
+    source = Path(movie["storage_path"]) if movie["storage_type"] == "radarr" else VIDEOS_DIR / movie["storage_path"]
+    out_dir = HLS_DIR / job["movie_id"]
     import shutil as _sh
     _sh.rmtree(out_dir, ignore_errors=True)
 
+    last_error = {"msg": ""}
+
     async def cb(status, entry: Optional[str] = None, error: Optional[str] = None):
         if status == "done" and entry:
-            await _set_hls_status(movie_id, "done", path=entry)
+            await _set_hls_status(job["movie_id"], "done", path=entry)
         else:
-            await _set_hls_status(movie_id, status, error=error)
+            await _set_hls_status(job["movie_id"], status, error=error)
+        if error:
+            last_error["msg"] = error
 
-    if quality == "abr":
-        await transcode_abr(source, out_dir, cb)
-    else:
-        await transcode_quick(source, out_dir, cb)
+    try:
+        if job["quality"] == "abr":
+            await transcode_abr(source, out_dir, cb)
+        else:
+            await transcode_quick(source, out_dir, cb)
+    except Exception as e:
+        logger.exception("transcode crashed")
+        last_error["msg"] = str(e)
+        await _set_hls_status(job["movie_id"], "failed", error=str(e))
+
+    movie_after = await db.movies.find_one({"id": job["movie_id"]}, {"_id": 0, "hls_status": 1})
+    final_status = "done" if movie_after and movie_after.get("hls_status") == "done" else "failed"
+    await db.transcode_queue.update_one(
+        {"id": job["id"]},
+        {"$set": {
+            "status": final_status,
+            "error": last_error["msg"],
+            "finished_at": datetime.now(timezone.utc).isoformat(),
+        }},
+    )
+
+
+async def _transcode_worker():
+    """Single FIFO worker. Polls for pending jobs and runs them serially."""
+    logger.info("Transcode worker started")
+    while True:
+        try:
+            settings = await get_settings()
+            if settings.get("queue_paused", False):
+                await asyncio.sleep(15)
+                continue
+            job = await db.transcode_queue.find_one_and_update(
+                {"status": "pending"},
+                {"$set": {"status": "running", "started_at": datetime.now(timezone.utc).isoformat()}},
+                sort=[("created_at", 1)],
+                projection={"_id": 0},
+                return_document=True,
+            )
+            if not job:
+                await asyncio.sleep(8)
+                continue
+            await _set_hls_status(job["movie_id"], "running")
+            await _process_job(job)
+        except Exception:
+            logger.exception("Transcode worker error")
+            await asyncio.sleep(10)
+
+
+async def _enqueue_transcode(movie_id: str, quality: str, triggered_by: str = "manual") -> dict:
+    """Add a job to the queue. Returns the job document."""
+    movie = await db.movies.find_one({"id": movie_id}, {"_id": 0, "title": 1})
+    title = movie.get("title", "") if movie else ""
+    # Skip if a non-finished job for this movie already exists
+    existing = await db.transcode_queue.find_one(
+        {"movie_id": movie_id, "status": {"$in": ["pending", "running"]}},
+        {"_id": 0},
+    )
+    if existing:
+        return existing
+    job = TranscodeJob(
+        movie_id=movie_id, movie_title=title, quality=quality, triggered_by=triggered_by,
+    ).model_dump()
+    await db.transcode_queue.insert_one(job)
+    await _set_hls_status(movie_id, "pending")
+    return job
 
 
 @api.post("/movies/{movie_id}/transcode")
 async def trigger_transcode(movie_id: str, payload: Optional[dict] = None, user: dict = Depends(require_admin)):
-    """Body: {"quality": "quick"|"abr"} — default "quick"."""
+    """Body: {"quality": "quick"|"abr"} — default "quick". Adds to background queue."""
     quality = (payload or {}).get("quality", "quick")
     if quality not in ("quick", "abr"):
         raise HTTPException(status_code=400, detail="quality must be 'quick' or 'abr'")
@@ -498,11 +595,66 @@ async def trigger_transcode(movie_id: str, payload: Optional[dict] = None, user:
     if movie.get("storage_type") not in ("local", "radarr") or not movie.get("storage_path"):
         raise HTTPException(status_code=400, detail="Only local/radarr movies can be transcoded")
     if movie.get("hls_status") in ("running", "pending"):
-        raise HTTPException(status_code=409, detail="Already transcoding")
-    source = Path(movie["storage_path"]) if movie["storage_type"] == "radarr" else VIDEOS_DIR / movie["storage_path"]
-    await _set_hls_status(movie_id, "pending")
-    asyncio.create_task(_run_transcode(movie_id, source, quality))
-    return {"ok": True, "status": "pending", "quality": quality}
+        raise HTTPException(status_code=409, detail="Already transcoding or queued")
+    job = await _enqueue_transcode(movie_id, quality, triggered_by="manual")
+    return {"ok": True, "status": "pending", "quality": quality, "job_id": job["id"]}
+
+
+# ============ Transcode Queue endpoints ============
+@api.get("/transcode/queue", response_model=List[TranscodeJob])
+async def list_queue(status: Optional[str] = None, user: dict = Depends(require_admin)):
+    q: dict = {}
+    if status:
+        q["status"] = {"$in": status.split(",")}
+    rows = await db.transcode_queue.find(q, {"_id": 0}).sort("created_at", -1).to_list(500)
+    return rows
+
+
+@api.get("/transcode/queue/stats")
+async def queue_stats(user: dict = Depends(require_admin)):
+    pipeline = [{"$group": {"_id": "$status", "n": {"$sum": 1}}}]
+    out = {"pending": 0, "running": 0, "done": 0, "failed": 0, "cancelled": 0}
+    async for row in db.transcode_queue.aggregate(pipeline):
+        out[row["_id"]] = row["n"]
+    s = await get_settings()
+    out["paused"] = bool(s.get("queue_paused", False))
+    out["auto_transcode"] = s.get("auto_transcode", "off")
+    return out
+
+
+@api.delete("/transcode/queue/{job_id}")
+async def cancel_job(job_id: str, user: dict = Depends(require_admin)):
+    job = await db.transcode_queue.find_one({"id": job_id}, {"_id": 0})
+    if not job: raise HTTPException(status_code=404, detail="Job not found")
+    if job["status"] == "running":
+        raise HTTPException(status_code=400, detail="Cannot cancel a running job")
+    await db.transcode_queue.update_one({"id": job_id}, {"$set": {"status": "cancelled", "finished_at": datetime.now(timezone.utc).isoformat()}})
+    if job["status"] == "pending":
+        # Reset movie hls_status so a new transcode can be triggered
+        await db.movies.update_one({"id": job["movie_id"]}, {"$set": {"hls_status": None}})
+    return {"ok": True}
+
+
+@api.post("/transcode/queue/{job_id}/retry")
+async def retry_job(job_id: str, user: dict = Depends(require_admin)):
+    job = await db.transcode_queue.find_one({"id": job_id}, {"_id": 0})
+    if not job: raise HTTPException(status_code=404, detail="Job not found")
+    if job["status"] not in ("failed", "cancelled"):
+        raise HTTPException(status_code=400, detail="Only failed/cancelled jobs can be retried")
+    new_job = await _enqueue_transcode(job["movie_id"], job["quality"], triggered_by=job.get("triggered_by", "manual"))
+    return {"ok": True, "job_id": new_job["id"]}
+
+
+@api.post("/transcode/queue/clear")
+async def clear_finished(user: dict = Depends(require_admin)):
+    res = await db.transcode_queue.delete_many({"status": {"$in": ["done", "failed", "cancelled"]}})
+    return {"ok": True, "deleted": res.deleted_count}
+
+
+@api.post("/transcode/queue/pause")
+async def pause_queue(payload: QueuePauseToggle, user: dict = Depends(require_admin)):
+    await db.settings.update_one({"id": "app"}, {"$set": {"queue_paused": payload.paused}}, upsert=True)
+    return {"ok": True, "paused": payload.paused}
 
 
 @api.get("/movies/{movie_id}/hls/{filename:path}")
@@ -706,6 +858,8 @@ async def read_settings(user: dict = Depends(require_admin)):
         tmdb_api_key=s.get("tmdb_api_key", ""),
         radarr_url=s.get("radarr_url", ""),
         radarr_api_key=s.get("radarr_api_key", ""),
+        auto_transcode=s.get("auto_transcode", "off"),
+        queue_paused=bool(s.get("queue_paused", False)),
     )
 
 
@@ -720,6 +874,8 @@ async def update_settings(payload: AppSettings, user: dict = Depends(require_adm
         tmdb_api_key=doc.get("tmdb_api_key", ""),
         radarr_url=doc.get("radarr_url", ""),
         radarr_api_key=doc.get("radarr_api_key", ""),
+        auto_transcode=doc.get("auto_transcode", "off"),
+        queue_paused=bool(doc.get("queue_paused", False)),
     )
 
 
@@ -780,10 +936,10 @@ async def radarr_import(payload: dict, user: dict = Depends(require_admin)):
     movies = await asyncio.to_thread(radarr_client.list_movies, s["radarr_url"], s["radarr_api_key"])
     by_id = {m["radarr_id"]: m for m in movies}
     created = 0
+    auto = s.get("auto_transcode", "off")
     for rid in radarr_ids:
         m = by_id.get(int(rid))
         if not m or not m.get("has_file") or not m.get("file_path"): continue
-        # Skip if already imported
         if await db.movies.find_one({"radarr_id": m["radarr_id"]}, {"_id": 1}): continue
         movie = Movie(
             title=m["title"], description=m.get("overview", ""),
@@ -792,10 +948,12 @@ async def radarr_import(payload: dict, user: dict = Depends(require_admin)):
             poster_url=m.get("poster_url", ""),
             backdrop_url=m.get("poster_url", ""),
             video_url="", storage_type="radarr",
-            storage_path=m["file_path"],  # absolute path on Radarr-mounted storage
+            storage_path=m["file_path"],
             radarr_id=m["radarr_id"], tmdb_id=m.get("tmdb_id"),
         ).model_dump()
         await db.movies.insert_one(movie)
+        if auto in ("quick", "abr"):
+            await _enqueue_transcode(movie["id"], auto, triggered_by="auto")
         created += 1
     return {"ok": True, "imported": created}
 

backend/tests/test_phase4_queue.py

@@ -0,0 +1,329 @@
+"""Phase 4: Transcode Queue tests.
+
+Covers:
+- Queue stats & list (admin only)
+- Settings persistence for auto_transcode + queue_paused
+- Manual + auto enqueue
+- Worker FIFO processing
+- Cancel/Retry/Clear/Pause flows
+- 409 conflict guard
+- Pause idle behavior
+- Crash-recovery code path (running -> failed) by direct DB insert + restart
+"""
+import os
+import time
+import uuid
+import pytest
+import requests
+
+BASE_URL = os.environ["REACT_APP_BACKEND_URL"].rstrip("/")
+ADMIN_EMAIL = "admin@kino.local"
+ADMIN_PASSWORD = "kino-admin-2026"
+QTEST_VIDEO = "/tmp/qtest.mp4"
+
+
+# ---------- Fixtures ----------
+@pytest.fixture(scope="session")
+def api():
+    s = requests.Session()
+    return s
+
+
+@pytest.fixture(scope="session")
+def admin_token(api):
+    r = api.post(f"{BASE_URL}/api/auth/login",
+                 json={"email": ADMIN_EMAIL, "password": ADMIN_PASSWORD},
+                 headers={"Content-Type": "application/json"})
+    assert r.status_code == 200, r.text
+    return r.json()["access_token"]
+
+
+@pytest.fixture(scope="session")
+def member_token(api):
+    email = f"TEST_q_{uuid.uuid4().hex[:8]}@kino.local"
+    r = api.post(f"{BASE_URL}/api/auth/register",
+                 json={"email": email, "password": "pass1234", "name": "QTest"},
+                 headers={"Content-Type": "application/json"})
+    assert r.status_code == 200, r.text
+    return r.json()["access_token"]
+
+
+@pytest.fixture
+def admin_headers(admin_token):
+    return {"Authorization": f"Bearer {admin_token}"}
+
+
+@pytest.fixture
+def member_headers(member_token):
+    return {"Authorization": f"Bearer {member_token}"}
+
+
+def _set_settings(api, admin_headers, **kwargs):
+    """Helper: PUT /api/settings preserving existing keys, override with kwargs."""
+    cur = api.get(f"{BASE_URL}/api/settings", headers=admin_headers).json()
+    body = {
+        "tmdb_api_key": cur.get("tmdb_api_key", ""),
+        "radarr_url": cur.get("radarr_url", ""),
+        "radarr_api_key": cur.get("radarr_api_key", ""),
+        "auto_transcode": cur.get("auto_transcode", "off"),
+        "queue_paused": cur.get("queue_paused", False),
+    }
+    body.update(kwargs)
+    r = api.put(f"{BASE_URL}/api/settings", json=body,
+                headers={**admin_headers, "Content-Type": "application/json"})
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+def _upload_movie(api, admin_headers, title):
+    with open(QTEST_VIDEO, "rb") as f:
+        r = api.post(
+            f"{BASE_URL}/api/upload/video",
+            data={"title": title, "year": 2024, "rating": "NR", "genres": "Test"},
+            files={"file": (f"{title}.mp4", f, "video/mp4")},
+            headers=admin_headers,
+        )
+    assert r.status_code == 200, r.text
+    return r.json()
+
+
+# Cleanup at end of module
+@pytest.fixture(scope="module", autouse=True)
+def _cleanup(request):
+    yield
+    # best-effort: reset settings & clear queue via admin
+    try:
+        s = requests.Session()
+        tok = s.post(f"{BASE_URL}/api/auth/login",
+                     json={"email": ADMIN_EMAIL, "password": ADMIN_PASSWORD},
+                     headers={"Content-Type": "application/json"}).json()["access_token"]
+        h = {"Authorization": f"Bearer {tok}", "Content-Type": "application/json"}
+        s.put(f"{BASE_URL}/api/settings", json={
+            "tmdb_api_key": "", "radarr_url": "", "radarr_api_key": "",
+            "auto_transcode": "off", "queue_paused": False,
+        }, headers=h)
+        s.post(f"{BASE_URL}/api/transcode/queue/clear", headers=h)
+        # delete TEST_ movies created
+        movies = s.get(f"{BASE_URL}/api/movies?limit=500", headers=h).json()
+        for m in movies:
+            if m.get("title", "").startswith("TEST_Q_"):
+                s.delete(f"{BASE_URL}/api/movies/{m['id']}", headers=h)
+    except Exception:
+        pass
+
+
+# ---------- Tests ----------
+class TestQueueAuth:
+    def test_queue_list_admin_only(self, api, member_headers):
+        r = api.get(f"{BASE_URL}/api/transcode/queue", headers=member_headers)
+        assert r.status_code == 403
+
+    def test_queue_stats_admin_only(self, api, member_headers):
+        r = api.get(f"{BASE_URL}/api/transcode/queue/stats", headers=member_headers)
+        assert r.status_code == 403
+
+
+class TestQueueStatsAndSettings:
+    def test_stats_shape(self, api, admin_headers):
+        r = api.get(f"{BASE_URL}/api/transcode/queue/stats", headers=admin_headers)
+        assert r.status_code == 200
+        d = r.json()
+        for k in ("pending", "running", "done", "failed", "cancelled", "paused", "auto_transcode"):
+            assert k in d, f"missing {k}"
+        assert isinstance(d["paused"], bool)
+
+    def test_settings_persists_auto_and_paused(self, api, admin_headers):
+        d = _set_settings(api, admin_headers, auto_transcode="quick", queue_paused=False)
+        assert d["auto_transcode"] == "quick"
+        assert d["queue_paused"] is False
+        # GET to verify persistence
+        g = api.get(f"{BASE_URL}/api/settings", headers=admin_headers).json()
+        assert g["auto_transcode"] == "quick"
+        # reset
+        _set_settings(api, admin_headers, auto_transcode="off")
+
+
+class TestManualEnqueueAndWorker:
+    def test_upload_with_auto_off_no_job(self, api, admin_headers):
+        _set_settings(api, admin_headers, auto_transcode="off", queue_paused=False)
+        api.post(f"{BASE_URL}/api/transcode/queue/clear", headers=admin_headers)
+        movie = _upload_movie(api, admin_headers, "TEST_Q_off")
+        time.sleep(1)
+        # No job for this movie
+        rows = api.get(f"{BASE_URL}/api/transcode/queue", headers=admin_headers).json()
+        assert not any(j["movie_id"] == movie["id"] for j in rows)
+        # cleanup
+        api.delete(f"{BASE_URL}/api/movies/{movie['id']}", headers=admin_headers)
+
+    def test_manual_transcode_and_worker_runs(self, api, admin_headers):
+        _set_settings(api, admin_headers, auto_transcode="off", queue_paused=False)
+        movie = _upload_movie(api, admin_headers, "TEST_Q_manual")
+        mid = movie["id"]
+        r = api.post(f"{BASE_URL}/api/movies/{mid}/transcode",
+                     json={"quality": "quick"},
+                     headers={**admin_headers, "Content-Type": "application/json"})
+        assert r.status_code == 200, r.text
+        body = r.json()
+        assert body["status"] == "pending"
+        assert "job_id" in body
+        # movie hls_status pending
+        m = api.get(f"{BASE_URL}/api/movies/{mid}").json()
+        assert m["hls_status"] in ("pending", "running", "done")
+
+        # 409 conflict when re-triggering
+        r2 = api.post(f"{BASE_URL}/api/movies/{mid}/transcode",
+                      json={"quality": "quick"},
+                      headers={**admin_headers, "Content-Type": "application/json"})
+        assert r2.status_code == 409
+
+        # Wait for completion (worker polls every 8s; quick transcode of 3s clip <30s)
+        deadline = time.time() + 60
+        final = None
+        while time.time() < deadline:
+            m = api.get(f"{BASE_URL}/api/movies/{mid}").json()
+            if m.get("hls_status") in ("done", "failed"):
+                final = m["hls_status"]
+                break
+            time.sleep(2)
+        assert final == "done", f"hls did not complete; status={final}"
+
+        rows = api.get(f"{BASE_URL}/api/transcode/queue?status=done",
+                       headers=admin_headers).json()
+        assert any(j["movie_id"] == mid and j["status"] == "done" for j in rows)
+        # cleanup
+        api.delete(f"{BASE_URL}/api/movies/{mid}", headers=admin_headers)
+
+    def test_retry_done_job_returns_400(self, api, admin_headers):
+        rows = api.get(f"{BASE_URL}/api/transcode/queue?status=done",
+                       headers=admin_headers).json()
+        if not rows:
+            pytest.skip("No done jobs available for retry-400 test")
+        r = api.post(f"{BASE_URL}/api/transcode/queue/{rows[0]['id']}/retry",
+                     headers=admin_headers)
+        assert r.status_code == 400
+
+
+class TestAutoEnqueue:
+    def test_auto_quick_enqueues_on_upload(self, api, admin_headers):
+        _set_settings(api, admin_headers, auto_transcode="quick", queue_paused=True)
+        # paused so the job stays pending
+        movie = _upload_movie(api, admin_headers, "TEST_Q_auto")
+        mid = movie["id"]
+        time.sleep(1)
+        rows = api.get(f"{BASE_URL}/api/transcode/queue", headers=admin_headers).json()
+        match = [j for j in rows if j["movie_id"] == mid]
+        assert match, "Auto-enqueue did not create a job"
+        job = match[0]
+        assert job["quality"] == "quick"
+        assert job["triggered_by"] == "auto"
+        # While paused, should remain pending (worker polls every 15s when paused)
+        time.sleep(3)
+        rows2 = api.get(f"{BASE_URL}/api/transcode/queue", headers=admin_headers).json()
+        j2 = next(j for j in rows2 if j["movie_id"] == mid)
+        assert j2["status"] == "pending", f"Job should stay pending while paused, got {j2['status']}"
+
+        # Cancel the pending job
+        c = api.delete(f"{BASE_URL}/api/transcode/queue/{job['id']}", headers=admin_headers)
+        assert c.status_code == 200
+        # status -> cancelled, movie hls_status reset
+        rows3 = api.get(f"{BASE_URL}/api/transcode/queue", headers=admin_headers).json()
+        j3 = next(j for j in rows3 if j["id"] == job["id"])
+        assert j3["status"] == "cancelled"
+        m = api.get(f"{BASE_URL}/api/movies/{mid}").json()
+        assert m.get("hls_status") in (None, "")
+
+        # Retry cancelled job creates new pending job
+        rt = api.post(f"{BASE_URL}/api/transcode/queue/{job['id']}/retry",
+                      headers=admin_headers)
+        assert rt.status_code == 200, rt.text
+        new_id = rt.json()["job_id"]
+        assert new_id != job["id"]
+
+        # Cancel again to clean up
+        api.delete(f"{BASE_URL}/api/transcode/queue/{new_id}", headers=admin_headers)
+
+        # Reset settings
+        _set_settings(api, admin_headers, auto_transcode="off", queue_paused=False)
+        api.delete(f"{BASE_URL}/api/movies/{mid}", headers=admin_headers)
+
+
+class TestCancelRunningRejected:
+    def test_cancel_running_returns_400(self, api, admin_headers):
+        # Inject a fake "running" row directly via... we don't have DB access here.
+        # Instead, attempt an actual run: upload, manual transcode, poll for running
+        _set_settings(api, admin_headers, auto_transcode="off", queue_paused=False)
+        movie = _upload_movie(api, admin_headers, "TEST_Q_running")
+        mid = movie["id"]
+        r = api.post(f"{BASE_URL}/api/movies/{mid}/transcode",
+                     json={"quality": "quick"},
+                     headers={**admin_headers, "Content-Type": "application/json"})
+        assert r.status_code == 200
+        job_id = r.json()["job_id"]
+
+        # Poll for running status (worker idles up to 8s)
+        deadline = time.time() + 30
+        saw_running = False
+        while time.time() < deadline:
+            rows = api.get(f"{BASE_URL}/api/transcode/queue", headers=admin_headers).json()
+            j = next((x for x in rows if x["id"] == job_id), None)
+            if j and j["status"] == "running":
+                saw_running = True
+                # Try to cancel -> 400
+                c = api.delete(f"{BASE_URL}/api/transcode/queue/{job_id}", headers=admin_headers)
+                assert c.status_code == 400
+                break
+            if j and j["status"] in ("done", "failed"):
+                break
+            time.sleep(0.5)
+
+        # Wait for completion before cleanup
+        deadline = time.time() + 60
+        while time.time() < deadline:
+            m = api.get(f"{BASE_URL}/api/movies/{mid}").json()
+            if m.get("hls_status") in ("done", "failed"):
+                break
+            time.sleep(2)
+        api.delete(f"{BASE_URL}/api/movies/{mid}", headers=admin_headers)
+        if not saw_running:
+            pytest.skip("Could not catch a 'running' job in time window — non-deterministic")
+
+
+class TestClearFinished:
+    def test_clear_removes_finished(self, api, admin_headers):
+        before = api.get(f"{BASE_URL}/api/transcode/queue/stats",
+                         headers=admin_headers).json()
+        r = api.post(f"{BASE_URL}/api/transcode/queue/clear", headers=admin_headers)
+        assert r.status_code == 200
+        d = r.json()
+        assert "deleted" in d
+        # after clear, done/failed/cancelled = 0
+        after = api.get(f"{BASE_URL}/api/transcode/queue/stats",
+                        headers=admin_headers).json()
+        assert after["done"] == 0
+        assert after["failed"] == 0
+        assert after["cancelled"] == 0
+
+
+class TestPauseToggle:
+    def test_pause_endpoint_sets_flag(self, api, admin_headers):
+        r = api.post(f"{BASE_URL}/api/transcode/queue/pause",
+                     json={"paused": True},
+                     headers={**admin_headers, "Content-Type": "application/json"})
+        assert r.status_code == 200
+        assert r.json()["paused"] is True
+        s = api.get(f"{BASE_URL}/api/transcode/queue/stats",
+                    headers=admin_headers).json()
+        assert s["paused"] is True
+        # reset
+        api.post(f"{BASE_URL}/api/transcode/queue/pause",
+                 json={"paused": False},
+                 headers={**admin_headers, "Content-Type": "application/json"})
+
+
+class TestNicePrefix:
+    def test_transcode_module_uses_nice(self):
+        """Code-level: ffmpeg commands prefixed with `nice -n 19`."""
+        src = open("/app/backend/transcode.py").read()
+        assert "\"nice\", \"-n\", \"19\"" in src
+        # appears in both quick and abr
+        assert src.count("\"nice\", \"-n\", \"19\"") >= 2

backend/transcode.py

@@ -58,6 +58,7 @@ async def transcode_quick(source: Path, out_dir: Path, on_status: Callable[...,
         return
     out_dir.mkdir(parents=True, exist_ok=True)
     cmd = [
+        "nice", "-n", "19",
         "ffmpeg", "-y", "-i", str(source),
         "-c:v", "copy", "-c:a", "copy",
         "-bsf:v", "h264_mp4toannexb",
@@ -87,7 +88,7 @@ async def transcode_abr(source: Path, out_dir: Path, on_status: Callable[..., Aw
         fc_parts.append(f"[v{i}]scale=w=-2:h={h}[v{i}out]")
     filter_complex = ";".join(fc_parts)
 
-    cmd: List[str] = ["ffmpeg", "-y", "-i", str(source), "-filter_complex", filter_complex]
+    cmd: List[str] = ["nice", "-n", "19", "ffmpeg", "-y", "-i", str(source), "-filter_complex", filter_complex]
 
     for i, (_h, vb, maxr, buf, _ab) in enumerate(variants):
         cmd += [