"""Job and queue route handlers.""" from __future__ import annotations from typing import Any from backend.routes.common import handle_request from backend.routes.params import int_or_default, optional_str from backend.services.event_stream_service import get_default_event_bus from backend.services.generation_job_retry_service import GenerationJobRetryService from backend.services.queue_service import QueueService from core.audit_service import AuditService from core.identity import RequestContext from core.security import require_authenticated, require_task_retry, require_write from database.db_helper import Database, load_database_settings from database.repositories.job_repository import JobRepository def list_jobs( ctx: RequestContext, query: dict[str, Any] | None = None, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() params = query or {} def action() -> dict[str, Any]: require_authenticated(ctx) return queue_service.list_jobs( status=optional_str(params.get("status")), workflow_id=optional_str(params.get("workflow_id")), profile_id=optional_str(params.get("profile_id")), page=int_or_default(params.get("page"), 1), page_size=int_or_default(params.get("page_size"), 30), ).to_dict() return handle_request(ctx, action) def get_job( ctx: RequestContext, task_id: str, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() def action() -> dict[str, Any]: require_authenticated(ctx) return queue_service.get_job(task_id).to_dict() return handle_request(ctx, action) def cancel_job( ctx: RequestContext, task_id: str, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() def action() -> dict[str, Any]: require_write(ctx) return queue_service.cancel_job(task_id, ctx).to_dict() return handle_request(ctx, action) def retry_job( ctx: RequestContext, task_id: str, payload: dict[str, Any] | None = None, service: GenerationJobRetryService | None = None, ) -> dict: retry_service = service or _create_generation_job_retry_service() def action() -> dict[str, Any]: require_task_retry(ctx) return retry_service.retry_job(task_id, ctx, overrides=payload or {}).to_dict() return handle_request(ctx, action) def retry_dead_letter_jobs( ctx: RequestContext, payload: dict[str, Any] | None = None, service: GenerationJobRetryService | None = None, ) -> dict: retry_service = service or _create_generation_job_retry_service() params = payload or {} def action() -> dict[str, Any]: require_task_retry(ctx) return retry_service.retry_dead_letters(ctx, limit=int_or_default(params.get("limit"), 5)) return handle_request(ctx, action) def move_failed_jobs_to_dead_letter( ctx: RequestContext, payload: dict[str, Any] | None = None, service: QueueService | None = None, ) -> dict: queue_service = service or _create_queue_service() params = payload or {} def action() -> dict[str, Any]: require_task_retry(ctx) return queue_service.move_failed_to_dead_letter(ctx, limit=int_or_default(params.get("limit"), 50)) return handle_request(ctx, action) def _create_queue_service() -> QueueService: database = Database(load_database_settings()) return QueueService( repository=JobRepository(database), audit_service=AuditService(database), event_bus=get_default_event_bus(), ) def _create_generation_job_retry_service() -> GenerationJobRetryService: # Import lazily so route discovery does not construct provider runtimes. from backend.routes.node_routes import _create_generation_service generation_service = _create_generation_service() return GenerationJobRetryService( queue_service=generation_service.queue_service, generation_service=generation_service, )