Цвылев Александр Вадимович
313af3a070
POST /tracks/{id}/optimize enqueues a transcode; GET /stream/{id}?quality=
serves a cached Opus rendition (miss → master + background warm); GET
/stream/{id}/hls/{playlist.m3u8,segment} serves the worker-generated HLS
rendition (AAC-in-TS), with ?token= propagated onto segment URLs for players
that can't set headers. Hexagonal: Transcoder port, FfmpegTranscoder adapter,
TranscodeService + cache-path helpers, transcode_track worker (idempotent),
schemas + deps wiring. ffmpeg already in the image.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
97 lines
3.9 KiB
Python
97 lines
3.9 KiB
Python
"""Enqueue helper — submit a job to the arq queue from the request cycle.
|
|
|
|
A short-lived pool per call keeps things simple (enqueues are rare, admin-driven
|
|
actions). Redis being down degrades to a clean 503 rather than a crash
|
|
(graceful degradation)."""
|
|
|
|
import uuid
|
|
from typing import Any
|
|
|
|
from arq import create_pool
|
|
from arq.connections import RedisSettings
|
|
|
|
from app.core.config import get_settings
|
|
from app.core.logging import get_logger
|
|
from app.domain.errors import DependencyUnavailableError
|
|
|
|
log = get_logger("worker.queue")
|
|
|
|
|
|
async def enqueue(function: str, **kwargs: Any) -> str:
|
|
"""Enqueue ``function`` by name, returning the job id. Raises
|
|
:class:`DependencyUnavailableError` if the queue can't be reached."""
|
|
settings = get_settings()
|
|
try:
|
|
pool = await create_pool(RedisSettings.from_dsn(str(settings.redis_url)))
|
|
except Exception as exc:
|
|
raise DependencyUnavailableError("Task queue (Redis) is unavailable.") from exc
|
|
try:
|
|
job = await pool.enqueue_job(function, **kwargs)
|
|
finally:
|
|
await pool.aclose()
|
|
if job is None:
|
|
raise DependencyUnavailableError("Could not enqueue job.")
|
|
return str(job.job_id)
|
|
|
|
|
|
async def enqueue_download(job_id: uuid.UUID) -> None:
|
|
"""Best-effort enqueue of a download job for the worker.
|
|
|
|
The job row is already persisted as ``queued``, so this is a follow-up, not a
|
|
barrier: if the queue is unreachable we log and move on (graceful
|
|
degradation) — the job stays ``queued`` and can be retried later. Deferred a
|
|
few seconds so the request's DB transaction commits before the worker reads
|
|
the row (same reason as :func:`enqueue_enrich`)."""
|
|
try:
|
|
await enqueue("download_track", job_id=str(job_id), _defer_by=3)
|
|
except DependencyUnavailableError:
|
|
log.warning("download_enqueue_failed", job_id=str(job_id))
|
|
|
|
|
|
async def enqueue_materialize(job_id: uuid.UUID) -> None:
|
|
"""Best-effort enqueue of a materialize job for the worker (plan: Model C
|
|
lazy materialization). Same deferred-commit reasoning as
|
|
:func:`enqueue_download` — the job row stays ``queued`` and can be retried
|
|
if the queue is unreachable."""
|
|
try:
|
|
await enqueue("materialize_track", job_id=str(job_id), _defer_by=3)
|
|
except DependencyUnavailableError:
|
|
log.warning("materialize_enqueue_failed", job_id=str(job_id))
|
|
|
|
|
|
async def enqueue_transcode(
|
|
track_id: uuid.UUID, *, quality: str = "high", hls: bool = True
|
|
) -> str:
|
|
"""Enqueue a transcode job (§6.6). Unlike the best-effort follow-ups below,
|
|
this is user/stream-driven, so it surfaces a job id (and a 503 via the caller
|
|
if the queue is down) rather than swallowing failures."""
|
|
return await enqueue(
|
|
"transcode_track", track_id=str(track_id), quality=quality, hls=hls
|
|
)
|
|
|
|
|
|
async def enqueue_transcode_quiet(
|
|
track_id: uuid.UUID, *, quality: str = "high", hls: bool = False
|
|
) -> None:
|
|
"""Best-effort transcode enqueue for a streaming cache miss — never blocks or
|
|
fails the play (the master is served meanwhile)."""
|
|
try:
|
|
await enqueue_transcode(track_id, quality=quality, hls=hls)
|
|
except DependencyUnavailableError:
|
|
log.warning("transcode_enqueue_failed", track_id=str(track_id))
|
|
|
|
|
|
async def enqueue_enrich(track_id: uuid.UUID) -> None:
|
|
"""Best-effort enqueue of metadata enrichment for a freshly stored track.
|
|
|
|
The track is already persisted, so enrichment is a follow-up, not a barrier:
|
|
if the queue is unreachable we log and move on (graceful degradation). The
|
|
track stays ``metadata_status=pending`` and can be re-enriched later.
|
|
|
|
Deferred a few seconds so the caller's DB transaction is committed before the
|
|
worker looks the track up (the upload request commits only after it returns)."""
|
|
try:
|
|
await enqueue("enrich_track", track_id=str(track_id), _defer_by=5)
|
|
except DependencyUnavailableError:
|
|
log.warning("enrich_enqueue_failed", track_id=str(track_id))
|