385 lines
12 KiB
Python
385 lines
12 KiB
Python
"""
|
|
GraphQL API using strawberry, served via FastAPI.
|
|
|
|
Primary API for MPR — all client interactions go through GraphQL.
|
|
Uses core.db for data access.
|
|
Types are generated from schema/ via modelgen — see api/schema/graphql.py.
|
|
"""
|
|
|
|
import os
|
|
from typing import List, Optional
|
|
from uuid import UUID
|
|
|
|
import strawberry
|
|
from strawberry.schema.config import StrawberryConfig
|
|
from strawberry.types import Info
|
|
|
|
from core.api.schema.graphql import (
|
|
CancelResultType,
|
|
ChunkJobType,
|
|
ChunkOutputFileType,
|
|
CreateChunkJobInput,
|
|
CreateJobInput,
|
|
DeleteResultType,
|
|
MediaAssetType,
|
|
ScanResultType,
|
|
SystemStatusType,
|
|
TranscodeJobType,
|
|
TranscodePresetType,
|
|
UpdateAssetInput,
|
|
)
|
|
from core.storage import BUCKET_IN, list_objects, upload_file
|
|
|
|
VIDEO_EXTS = {".mp4", ".mkv", ".avi", ".mov", ".webm", ".flv", ".wmv", ".m4v"}
|
|
AUDIO_EXTS = {".mp3", ".wav", ".flac", ".aac", ".ogg", ".m4a"}
|
|
MEDIA_EXTS = VIDEO_EXTS | AUDIO_EXTS
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Queries
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@strawberry.type
|
|
class Query:
|
|
@strawberry.field
|
|
def assets(
|
|
self,
|
|
info: Info,
|
|
status: Optional[str] = None,
|
|
search: Optional[str] = None,
|
|
) -> List[MediaAssetType]:
|
|
from core.db import list_assets
|
|
|
|
return list_assets(status=status, search=search)
|
|
|
|
@strawberry.field
|
|
def asset(self, info: Info, id: UUID) -> Optional[MediaAssetType]:
|
|
from core.db import get_asset
|
|
|
|
try:
|
|
return get_asset(id)
|
|
except Exception:
|
|
return None
|
|
|
|
@strawberry.field
|
|
def jobs(
|
|
self,
|
|
info: Info,
|
|
status: Optional[str] = None,
|
|
source_asset_id: Optional[UUID] = None,
|
|
) -> List[TranscodeJobType]:
|
|
from core.db import list_jobs
|
|
|
|
return list_jobs(status=status, source_asset_id=source_asset_id)
|
|
|
|
@strawberry.field
|
|
def job(self, info: Info, id: UUID) -> Optional[TranscodeJobType]:
|
|
from core.db import get_job
|
|
|
|
try:
|
|
return get_job(id)
|
|
except Exception:
|
|
return None
|
|
|
|
@strawberry.field
|
|
def presets(self, info: Info) -> List[TranscodePresetType]:
|
|
from core.db import list_presets
|
|
|
|
return list_presets()
|
|
|
|
@strawberry.field
|
|
def system_status(self, info: Info) -> SystemStatusType:
|
|
return SystemStatusType(status="ok", version="0.1.0")
|
|
|
|
@strawberry.field
|
|
def chunk_output_files(self, info: Info, job_id: str) -> List[ChunkOutputFileType]:
|
|
"""List output chunk files for a completed job from media/out/."""
|
|
from pathlib import Path
|
|
|
|
media_out = os.environ.get("MEDIA_OUT_DIR", "/app/media/out")
|
|
output_dir = Path(media_out) / "chunks" / job_id
|
|
if not output_dir.is_dir():
|
|
return []
|
|
return [
|
|
ChunkOutputFileType(
|
|
key=f.name,
|
|
size=f.stat().st_size,
|
|
url=f"/media/out/chunks/{job_id}/{f.name}",
|
|
)
|
|
for f in sorted(output_dir.iterdir())
|
|
if f.is_file()
|
|
]
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Mutations
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
@strawberry.type
|
|
class Mutation:
|
|
@strawberry.mutation
|
|
def scan_media_folder(self, info: Info) -> ScanResultType:
|
|
import logging
|
|
from pathlib import Path
|
|
|
|
from core.db import create_asset, get_asset_filenames
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Sync local media/in/ files to MinIO (handles fresh installs / pruned volumes)
|
|
local_media = Path("/app/media/in")
|
|
if local_media.is_dir():
|
|
existing_keys = {o["key"] for o in list_objects(BUCKET_IN)}
|
|
for f in local_media.iterdir():
|
|
if f.is_file() and f.suffix.lower() in MEDIA_EXTS:
|
|
if f.name not in existing_keys:
|
|
try:
|
|
upload_file(str(f), BUCKET_IN, f.name)
|
|
logger.info("Uploaded %s to MinIO", f.name)
|
|
except Exception as e:
|
|
logger.warning("Failed to upload %s: %s", f.name, e)
|
|
|
|
objects = list_objects(BUCKET_IN, extensions=MEDIA_EXTS)
|
|
existing = get_asset_filenames()
|
|
|
|
registered = []
|
|
skipped = []
|
|
|
|
for obj in objects:
|
|
if obj["filename"] in existing:
|
|
skipped.append(obj["filename"])
|
|
continue
|
|
try:
|
|
create_asset(
|
|
filename=obj["filename"],
|
|
file_path=obj["key"],
|
|
file_size=obj["size"],
|
|
)
|
|
registered.append(obj["filename"])
|
|
except Exception:
|
|
pass
|
|
|
|
return ScanResultType(
|
|
found=len(objects),
|
|
registered=len(registered),
|
|
skipped=len(skipped),
|
|
files=registered,
|
|
)
|
|
|
|
@strawberry.mutation
|
|
def create_job(self, info: Info, input: CreateJobInput) -> TranscodeJobType:
|
|
from pathlib import Path
|
|
|
|
from core.db import create_job, get_asset, get_preset
|
|
|
|
try:
|
|
source = get_asset(input.source_asset_id)
|
|
except Exception:
|
|
raise Exception("Source asset not found")
|
|
|
|
preset = None
|
|
preset_snapshot = {}
|
|
if input.preset_id:
|
|
try:
|
|
preset = get_preset(input.preset_id)
|
|
preset_snapshot = {
|
|
"name": preset.name,
|
|
"container": preset.container,
|
|
"video_codec": preset.video_codec,
|
|
"audio_codec": preset.audio_codec,
|
|
}
|
|
except Exception:
|
|
raise Exception("Preset not found")
|
|
|
|
if not preset and not input.trim_start and not input.trim_end:
|
|
raise Exception("Must specify preset_id or trim_start/trim_end")
|
|
|
|
output_filename = input.output_filename
|
|
if not output_filename:
|
|
stem = Path(source.filename).stem
|
|
ext = preset_snapshot.get("container", "mp4") if preset else "mp4"
|
|
output_filename = f"{stem}_output.{ext}"
|
|
|
|
job = create_job(
|
|
source_asset_id=source.id,
|
|
preset_id=preset.id if preset else None,
|
|
preset_snapshot=preset_snapshot,
|
|
trim_start=input.trim_start,
|
|
trim_end=input.trim_end,
|
|
output_filename=output_filename,
|
|
output_path=output_filename,
|
|
priority=input.priority or 0,
|
|
)
|
|
|
|
payload = {
|
|
"source_key": source.file_path,
|
|
"output_key": output_filename,
|
|
"preset": preset_snapshot or None,
|
|
"trim_start": input.trim_start,
|
|
"trim_end": input.trim_end,
|
|
"duration": source.duration,
|
|
}
|
|
|
|
executor_mode = os.environ.get("MPR_EXECUTOR", "local")
|
|
if executor_mode in ("lambda", "gcp"):
|
|
from core.jobs.executor import get_executor
|
|
|
|
get_executor().run(
|
|
job_type="transcode",
|
|
job_id=str(job.id),
|
|
payload=payload,
|
|
)
|
|
else:
|
|
from core.jobs.task import run_job
|
|
|
|
result = run_job.delay(
|
|
job_type="transcode",
|
|
job_id=str(job.id),
|
|
payload=payload,
|
|
)
|
|
job.celery_task_id = result.id
|
|
job.save(update_fields=["celery_task_id"])
|
|
|
|
return job
|
|
|
|
@strawberry.mutation
|
|
def cancel_job(self, info: Info, id: UUID) -> TranscodeJobType:
|
|
from core.db import get_job, update_job
|
|
|
|
try:
|
|
job = get_job(id)
|
|
except Exception:
|
|
raise Exception("Job not found")
|
|
|
|
if job.status not in ("pending", "processing"):
|
|
raise Exception(f"Cannot cancel job with status: {job.status}")
|
|
|
|
return update_job(job, status="cancelled")
|
|
|
|
@strawberry.mutation
|
|
def retry_job(self, info: Info, id: UUID) -> TranscodeJobType:
|
|
from core.db import get_job, update_job
|
|
|
|
try:
|
|
job = get_job(id)
|
|
except Exception:
|
|
raise Exception("Job not found")
|
|
|
|
if job.status != "failed":
|
|
raise Exception("Only failed jobs can be retried")
|
|
|
|
return update_job(job, status="pending", progress=0, error_message=None)
|
|
|
|
@strawberry.mutation
|
|
def update_asset(self, info: Info, id: UUID, input: UpdateAssetInput) -> MediaAssetType:
|
|
from core.db import get_asset, update_asset
|
|
|
|
try:
|
|
asset = get_asset(id)
|
|
except Exception:
|
|
raise Exception("Asset not found")
|
|
|
|
fields = {}
|
|
if input.comments is not None:
|
|
fields["comments"] = input.comments
|
|
if input.tags is not None:
|
|
fields["tags"] = input.tags
|
|
|
|
if fields:
|
|
asset = update_asset(asset, **fields)
|
|
|
|
return asset
|
|
|
|
@strawberry.mutation
|
|
def delete_asset(self, info: Info, id: UUID) -> DeleteResultType:
|
|
from core.db import delete_asset, get_asset
|
|
|
|
try:
|
|
asset = get_asset(id)
|
|
delete_asset(asset)
|
|
return DeleteResultType(ok=True)
|
|
except Exception:
|
|
raise Exception("Asset not found")
|
|
|
|
@strawberry.mutation
|
|
def create_chunk_job(self, info: Info, input: CreateChunkJobInput) -> ChunkJobType:
|
|
"""Create and dispatch a chunk pipeline job."""
|
|
import uuid
|
|
|
|
from core.db import get_asset
|
|
|
|
try:
|
|
source = get_asset(input.source_asset_id)
|
|
except Exception:
|
|
raise Exception("Source asset not found")
|
|
|
|
job_id = str(uuid.uuid4())
|
|
|
|
payload = {
|
|
"source_key": source.file_path,
|
|
"chunk_duration": input.chunk_duration,
|
|
"num_workers": input.num_workers,
|
|
"max_retries": input.max_retries,
|
|
"processor_type": input.processor_type,
|
|
"start_time": input.start_time,
|
|
"end_time": input.end_time,
|
|
}
|
|
|
|
executor_mode = os.environ.get("MPR_EXECUTOR", "local")
|
|
celery_task_id = None
|
|
|
|
if executor_mode in ("lambda", "gcp"):
|
|
from core.jobs.executor import get_executor
|
|
|
|
get_executor().run(
|
|
job_type="chunk",
|
|
job_id=job_id,
|
|
payload=payload,
|
|
)
|
|
else:
|
|
from core.jobs.task import run_job
|
|
|
|
result = run_job.delay(
|
|
job_type="chunk",
|
|
job_id=job_id,
|
|
payload=payload,
|
|
)
|
|
celery_task_id = result.id
|
|
|
|
return ChunkJobType(
|
|
id=uuid.UUID(job_id),
|
|
source_asset_id=input.source_asset_id,
|
|
chunk_duration=input.chunk_duration,
|
|
num_workers=input.num_workers,
|
|
max_retries=input.max_retries,
|
|
processor_type=input.processor_type,
|
|
status="pending",
|
|
progress=0.0,
|
|
priority=input.priority,
|
|
celery_task_id=celery_task_id,
|
|
)
|
|
|
|
@strawberry.mutation
|
|
def cancel_chunk_job(self, info: Info, celery_task_id: str) -> CancelResultType:
|
|
"""Cancel a running chunk job by revoking its Celery task."""
|
|
try:
|
|
from admin.mpr.celery import app as celery_app
|
|
|
|
celery_app.control.revoke(celery_task_id, terminate=True, signal="SIGTERM")
|
|
return CancelResultType(ok=True, message="Task revoked")
|
|
except Exception as e:
|
|
return CancelResultType(ok=False, message=str(e))
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Schema
|
|
# ---------------------------------------------------------------------------
|
|
|
|
schema = strawberry.Schema(
|
|
query=Query,
|
|
mutation=Mutation,
|
|
config=StrawberryConfig(auto_camel_case=False),
|
|
)
|