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>
126 lines
5.3 KiB
Python
126 lines
5.3 KiB
Python
"""Fila de trabalho: concorrência limitada, fila limitada POR CHAVE, timeout de espera e de execução.
|
|
|
|
- A cota de espera é por `owner` (o `keyId` de quem chamou): uma chave cheia recebe `QueueFull`, as outras
|
|
continuam entrando. Homologação e produção usam o mesmo serviço com chaves diferentes; o teste de uma não
|
|
pode recusar a doação paga da outra.
|
|
- A vaga de execução (CPU) é global, mas é entregue em rodízio entre as chaves que estão esperando, e a chave
|
|
que acabou de rodar vai para o fim: cada chave espera no máximo o trabalho em curso e um de cada outra chave
|
|
ativa, e não a fila inteira da outra. Por isso o timeout de espera precisa ser >= 2x o de execução.
|
|
- A vaga só é devolvida quando a thread realmente termina — mesmo que o cliente já tenha recebido 504 —,
|
|
para o limite de CPU ser real e não só aparente.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from collections import deque
|
|
from collections.abc import Callable
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from typing import TypeVar
|
|
|
|
from .errors import QueueFull, QueueTimeout, SynthesisTimeout
|
|
|
|
T = TypeVar("T")
|
|
|
|
|
|
class WorkQueue:
|
|
def __init__(self, max_concurrency: int, max_queue_per_key: int, queue_timeout_s: float, run_timeout_s: float):
|
|
self.max_concurrency = max_concurrency
|
|
self.max_queue_per_key = max_queue_per_key
|
|
self.queue_timeout_s = queue_timeout_s
|
|
self.run_timeout_s = run_timeout_s
|
|
self._free = max_concurrency
|
|
# owner → esperas em ordem de chegada. A ordem do dict é o rodízio: quem é atendido vai para o fim.
|
|
self._waiters: dict[str, deque[asyncio.Future[None]]] = {}
|
|
self._executor = ThreadPoolExecutor(max_workers=max_concurrency, thread_name_prefix="work")
|
|
self.running = 0
|
|
|
|
@property
|
|
def waiting(self) -> int:
|
|
"""Total esperando, somadas todas as chaves."""
|
|
return sum(len(waiters) for waiters in self._waiters.values())
|
|
|
|
def waiting_for(self, owner: str) -> int:
|
|
waiters = self._waiters.get(owner)
|
|
return len(waiters) if waiters else 0
|
|
|
|
def is_full(self, owner: str) -> bool:
|
|
"""Verdadeiro quando um `run` novo DESTA chave seria recusado com QueueFull."""
|
|
return self._free == 0 and self.waiting_for(owner) >= self.max_queue_per_key
|
|
|
|
async def _acquire(self, owner: str) -> None:
|
|
if self._free > 0 and not self._waiters:
|
|
self._free -= 1
|
|
return
|
|
waiter: asyncio.Future[None] = asyncio.get_running_loop().create_future()
|
|
self._waiters.setdefault(owner, deque()).append(waiter)
|
|
try:
|
|
# asyncio.wait não cancela o future no timeout: dá para ver se a vaga chegou no último instante.
|
|
await asyncio.wait({waiter}, timeout=self.queue_timeout_s)
|
|
except BaseException: # cliente desistiu (CancelledError) enquanto esperava
|
|
self._abandon(owner, waiter)
|
|
raise
|
|
if not waiter.done():
|
|
self._abandon(owner, waiter)
|
|
raise QueueTimeout()
|
|
|
|
def _abandon(self, owner: str, waiter: asyncio.Future[None]) -> None:
|
|
if waiter.done() and not waiter.cancelled():
|
|
self._release() # a vaga já tinha sido entregue a esta espera: passa adiante
|
|
return
|
|
waiter.cancel()
|
|
waiters = self._waiters.get(owner)
|
|
if waiters is not None:
|
|
try:
|
|
waiters.remove(waiter)
|
|
except ValueError:
|
|
pass
|
|
if not waiters:
|
|
del self._waiters[owner]
|
|
|
|
def _release(self, finished_owner: str | None = None) -> None:
|
|
"""Entrega a vaga à próxima chave do rodízio; sem ninguém esperando, ela volta a ficar livre."""
|
|
if finished_owner is not None and finished_owner in self._waiters and len(self._waiters) > 1:
|
|
self._waiters[finished_owner] = self._waiters.pop(finished_owner) # quem acabou de rodar vai para o fim
|
|
while self._waiters:
|
|
owner = next(iter(self._waiters))
|
|
waiters = self._waiters.pop(owner)
|
|
waiter = waiters.popleft()
|
|
if waiters:
|
|
self._waiters[owner] = waiters # volta para o fim do rodízio
|
|
if not waiter.done():
|
|
waiter.set_result(None)
|
|
return
|
|
self._free += 1
|
|
|
|
async def run(self, fn: Callable[[], T], owner: str) -> T:
|
|
if self.is_full(owner):
|
|
raise QueueFull()
|
|
await self._acquire(owner)
|
|
|
|
self.running += 1
|
|
future = asyncio.get_running_loop().run_in_executor(self._executor, fn)
|
|
released = False
|
|
|
|
def _finish(_: object = None) -> None:
|
|
self.running -= 1
|
|
self._release(owner)
|
|
|
|
try:
|
|
return await asyncio.wait_for(asyncio.shield(future), timeout=self.run_timeout_s)
|
|
except asyncio.TimeoutError:
|
|
future.add_done_callback(_finish)
|
|
released = True
|
|
raise SynthesisTimeout() from None
|
|
except asyncio.CancelledError:
|
|
# Cliente desistiu no meio: a thread segue, então a vaga só volta quando ela terminar.
|
|
future.add_done_callback(_finish)
|
|
released = True
|
|
raise
|
|
finally:
|
|
if not released:
|
|
_finish()
|
|
|
|
def shutdown(self) -> None:
|
|
self._executor.shutdown(wait=False, cancel_futures=True)
|