"""Worker do Publicador: UMA thread, UM job por vez, na ordem de chegada. Máquina de estados do job: queued → running → done | failed | needs_login queued → canceled (só pelo /cancel, antes de começar) Persistente: os jobs ficam no SQLite. Se o serviço cair com um job em `running`, na subida ele vira `failed` com "interrompido — tente de novo" (db.py) — não dá para saber se o vídeo chegou à rede. """ from __future__ import annotations import logging import threading import time from typing import Callable from .db import Database, now from .platforms.base import Progress, PublishError, PublishResult log = logging.getLogger("publisher.worker") Execute = Callable[[dict, Progress], PublishResult] class Worker: def __init__(self, db: Database, execute: Execute, maintenance: Callable[[], None] | None = None, idle_wait_s: float = 2.0, maintenance_every_s: float = 3600.0): self.db = db self.execute = execute self.maintenance = maintenance self.idle_wait_s = idle_wait_s self.maintenance_every_s = maintenance_every_s self._wake = threading.Event() self._stop = threading.Event() self._thread: threading.Thread | None = None self._current: str | None = None self._last_maintenance = 0.0 @property def busy(self) -> bool: return self._current is not None def start(self) -> None: if self._thread and self._thread.is_alive(): return self._stop.clear() self._thread = threading.Thread(target=self._loop, name="publisher-worker", daemon=True) self._thread.start() def stop(self, timeout: float = 5) -> None: self._stop.set() self._wake.set() if self._thread: self._thread.join(timeout) def wake(self) -> None: self._wake.set() def _loop(self) -> None: while not self._stop.is_set(): try: if not self.run_once(): if self.maintenance and time.time() - self._last_maintenance > self.maintenance_every_s: self._last_maintenance = time.time() self.maintenance() self._wake.wait(self.idle_wait_s) self._wake.clear() except Exception: # noqa: BLE001 - o laço não pode morrer log.exception("erro no laço do worker") time.sleep(self.idle_wait_s) def _set(self, job_id: str, **fields) -> None: columns = ", ".join(f"{name} = ?" for name in fields) self.db.run(f"UPDATE jobs SET {columns}, updated_at = ? WHERE job_id = ?", *fields.values(), now(), job_id) def run_once(self) -> bool: """Pega o job mais antigo da fila e roda até o fim. False = fila vazia.""" row = self.db.get("SELECT * FROM jobs WHERE status = 'queued' ORDER BY created_at, rowid LIMIT 1") if not row: return False job_id = row["job_id"] # Reserva atômica: se alguém cancelou entre o SELECT e aqui, não roda. claimed = self.db.run("UPDATE jobs SET status = 'running', step = 'Começando…', progress = 0, error = NULL, " "updated_at = ? WHERE job_id = ? AND status = 'queued'", now(), job_id) if claimed.rowcount != 1: return True self._current = job_id last = [0.0] def progress(step: str, fraction: float) -> None: # Grava no máximo ~2x por segundo (o upload chama muito). if time.time() - last[0] < 0.5 and fraction < 1: return last[0] = time.time() self._set(job_id, step=step[:200], progress=max(0.0, min(1.0, float(fraction)))) try: result = self.execute(row, progress) except PublishError as exc: status = "needs_login" if exc.kind in ("needs_login", "expired") else "failed" self._set(job_id, status=status, error=exc.message, step="Precisa entrar de novo" if status == "needs_login" else "Falhou") log.info("job %s: %s (%s)", job_id, status, exc.message) except Exception as exc: # noqa: BLE001 log.exception("job %s falhou com erro inesperado", job_id) self._set(job_id, status="failed", step="Falhou", error=f"Erro inesperado no Publicador ({type(exc).__name__}: {str(exc)[:200]}). Tente de novo.") else: self._set(job_id, status="done", step=result.step[:200], progress=1.0, remote_id=result.remote_id, url=result.url, draft=1 if result.draft else 0, error=None) log.info("job %s: concluído (%s)", job_id, result.url or result.remote_id or "sem link") finally: self._current = None return True