Gerador de vídeos narrativos (Godot + FFmpeg), painel Next.js, serviço de voz, Clipador de lives e Publicador para YouTube, TikTok e Instagram. Inclui a leitura das visualizações dos posts para o Dashboard e o botão "Publicar no <rede>" nos cartões das publicações. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
114 lines
4.8 KiB
Python
114 lines
4.8 KiB
Python
"""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
|