forked from mtusi2026/mtusi2026lab7
226 lines
10 KiB
Python
226 lines
10 KiB
Python
"""Брокер заданий: Redis Streams с consumer group (lab5).
|
||
|
||
Почему это durable at-least-once очередь (подробно — REPORT.md):
|
||
|
||
* сервис `broker` — отдельный Redis с AOF и `appendfsync always`: ответ на XADD
|
||
приходит только после fsync записи в журнал. Успешный XADD — наш аналог
|
||
publisher confirm: сообщение переживёт рестарт/падение брокера с volume;
|
||
* `maxmemory-policy noeviction`: поток никогда не вытесняется (при нехватке
|
||
памяти XADD получит ошибку, строка outbox останется и будет опубликована позже);
|
||
* consumer group: XREADGROUP выдаёт сообщение одному consumer и кладёт его в
|
||
PEL (pending entries list) до XACK. Consumer ack — отдельная граница: worker
|
||
делает XACK только ПОСЛЕ устойчивого эффекта (COMMIT результата в PostgreSQL);
|
||
* упавший consumer: его сообщения остаются в PEL. Тот же consumer после
|
||
рестарта контейнера (то же имя) читает свой PEL с id 0; иначе любой живой
|
||
consumer забирает их XAUTOCLAIM после JOB_CLAIM_IDLE_SECONDS простоя.
|
||
|
||
В сообщении — только JSON по contracts/jobs.schema.json (ID и служебные поля):
|
||
ни байтов файла, ни credentials, ни URL, ни filename.
|
||
"""
|
||
import json
|
||
import logging
|
||
from typing import Dict, List, Optional, Tuple
|
||
|
||
import redis
|
||
|
||
from .tls import redis_tls_kwargs
|
||
|
||
log = logging.getLogger("messenger.broker")
|
||
|
||
FIELD = "job"
|
||
|
||
|
||
class BrokerUnavailable(Exception):
|
||
"""Брокер недоступен/таймаут/ошибка записи."""
|
||
|
||
|
||
class Delivery:
|
||
__slots__ = ("message_id", "raw", "deliveries")
|
||
|
||
def __init__(self, message_id: str, raw: Optional[str], deliveries: int = 1) -> None:
|
||
self.message_id = message_id
|
||
self.raw = raw
|
||
self.deliveries = deliveries
|
||
|
||
def payload(self) -> Optional[dict]:
|
||
if self.raw is None:
|
||
return None
|
||
try:
|
||
data = json.loads(self.raw)
|
||
except (TypeError, ValueError):
|
||
return None
|
||
return data if isinstance(data, dict) else None
|
||
|
||
|
||
def _s(value) -> str:
|
||
return value.decode("utf-8", "replace") if isinstance(value, (bytes, bytearray)) else str(value)
|
||
|
||
|
||
class Broker:
|
||
def __init__(self, url: str, stream: str, group: str, timeout: float = 2.0,
|
||
block_ms: int = 2000) -> None:
|
||
self.stream = stream
|
||
self.group = group
|
||
self.timeout = timeout
|
||
self.block_ms = block_ms
|
||
common = dict(socket_connect_timeout=timeout, health_check_interval=15,
|
||
retry_on_timeout=False, decode_responses=False,
|
||
# lab7: rediss:// через broker-gate — mTLS (identity api/worker).
|
||
**redis_tls_kwargs("BROKER"))
|
||
# Обычные команды: короткий таймаут сокета -> быстрый BrokerUnavailable.
|
||
self.client = redis.Redis.from_url(url, socket_timeout=timeout, **common)
|
||
# Блокирующий XREADGROUP: таймаут сокета больше времени блокировки.
|
||
self.blocking = redis.Redis.from_url(url, socket_timeout=timeout + block_ms / 1000.0, **common)
|
||
self._group_ready = False
|
||
|
||
def close(self) -> None:
|
||
for c in (self.client, self.blocking):
|
||
try:
|
||
c.close()
|
||
except Exception:
|
||
pass
|
||
|
||
# -------------------------------------------------------------- producer
|
||
|
||
def ensure_group(self) -> None:
|
||
"""Идемпотентно: поток + группа с позиции 0 (сообщения, опубликованные до
|
||
создания группы, тоже будут доставлены)."""
|
||
if self._group_ready:
|
||
return
|
||
try:
|
||
self.client.xgroup_create(self.stream, self.group, id="0", mkstream=True)
|
||
log.info("broker: created stream %s group %s", self.stream, self.group)
|
||
except redis.ResponseError as exc:
|
||
if "BUSYGROUP" not in str(exc):
|
||
raise BrokerUnavailable() from exc
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
self._group_ready = True
|
||
|
||
def publish(self, payload: Dict) -> str:
|
||
"""XADD; возврат = подтверждение приёма брокером (AOF fsync always)."""
|
||
body = json.dumps(payload, separators=(",", ":"), sort_keys=True)
|
||
try:
|
||
self.ensure_group()
|
||
return _s(self.client.xadd(self.stream, {FIELD: body}))
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
|
||
# -------------------------------------------------------------- consumer
|
||
|
||
@staticmethod
|
||
def _parse(entries) -> List[Delivery]:
|
||
out = []
|
||
for message_id, fields in entries or []:
|
||
if fields is None: # запись удалена из потока, но осталась в PEL
|
||
out.append(Delivery(_s(message_id), None))
|
||
continue
|
||
raw = fields.get(FIELD.encode()) if isinstance(fields, dict) else None
|
||
out.append(Delivery(_s(message_id), _s(raw) if raw is not None else None))
|
||
return out
|
||
|
||
def read(self, consumer: str, own_pending: bool = False) -> List[Delivery]:
|
||
"""Одно сообщение (prefetch = 1 на consumer). own_pending: свой PEL с id 0 —
|
||
сообщения, полученные прошлой инкарнацией этого consumer и не подтверждённые."""
|
||
try:
|
||
self.ensure_group()
|
||
if own_pending:
|
||
resp = self.client.xreadgroup(self.group, consumer, {self.stream: "0"}, count=1)
|
||
else:
|
||
resp = self.blocking.xreadgroup(self.group, consumer, {self.stream: ">"},
|
||
count=1, block=self.block_ms)
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
result = []
|
||
for _stream, entries in resp or []:
|
||
result.extend(self._parse(entries))
|
||
return result
|
||
|
||
def autoclaim(self, consumer: str, min_idle_ms: int) -> List[Delivery]:
|
||
"""Забрать одно сообщение, которое другой consumer держит дольше min_idle_ms."""
|
||
try:
|
||
self.ensure_group()
|
||
resp = self.client.xautoclaim(self.stream, self.group, consumer, min_idle_ms,
|
||
start_id="0-0", count=1)
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
entries = resp[1] if resp and len(resp) > 1 else []
|
||
deliveries = self._parse(entries)
|
||
for d in deliveries:
|
||
d.deliveries = self.delivery_count(d.message_id)
|
||
return deliveries
|
||
|
||
def delivery_count(self, message_id: str) -> int:
|
||
try:
|
||
info = self.client.xpending_range(self.stream, self.group, message_id, message_id, 1)
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
return int(info[0]["times_delivered"]) if info else 1
|
||
|
||
def ack(self, message_id: str) -> None:
|
||
try:
|
||
self.client.xack(self.stream, self.group, message_id)
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
|
||
# -------------------------------------------------------- housekeeping
|
||
|
||
def trim_acknowledged(self) -> int:
|
||
"""XTRIM MINID: удалить только записи, которые уже доставлены И подтверждены
|
||
(id меньше самого старого pending и не больше last-delivered-id группы).
|
||
Недоставленные и неподтверждённые записи никогда не удаляются."""
|
||
try:
|
||
groups = self.client.xinfo_groups(self.stream)
|
||
if not groups:
|
||
return 0
|
||
bounds = []
|
||
for g in groups:
|
||
last = _s(g.get("last-delivered-id") or g.get(b"last-delivered-id") or "0-0")
|
||
bounds.append(_increment(last))
|
||
pending = self.client.xpending(self.stream, _s(g["name"]))
|
||
if pending and pending.get("pending"):
|
||
bounds.append(_s(pending["min"]))
|
||
minid = min(bounds, key=_id_key)
|
||
if minid == "0-0" or minid == "0-1":
|
||
return 0
|
||
return int(self.client.xtrim(self.stream, minid=minid, approximate=False) or 0)
|
||
except redis.ResponseError:
|
||
return 0
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
|
||
def stats(self) -> Dict:
|
||
"""Длина потока, pending (в обработке/не подтверждено), lag (ещё не выдано)."""
|
||
try:
|
||
length = int(self.client.xlen(self.stream))
|
||
out = {"stream": self.stream, "length": length, "groups": []}
|
||
for g in self.client.xinfo_groups(self.stream):
|
||
out["groups"].append({
|
||
"name": _s(g["name"]),
|
||
"consumers": int(g["consumers"]),
|
||
"pending": int(g["pending"]),
|
||
"lag": g.get("lag"),
|
||
"last_delivered_id": _s(g["last-delivered-id"]),
|
||
})
|
||
return out
|
||
except redis.ResponseError:
|
||
return {"stream": self.stream, "length": 0, "groups": []}
|
||
except redis.RedisError as exc:
|
||
raise BrokerUnavailable() from exc
|
||
|
||
def ping(self) -> bool:
|
||
try:
|
||
return bool(self.client.ping())
|
||
except redis.RedisError:
|
||
return False
|
||
|
||
|
||
def _id_key(message_id: str) -> Tuple[int, int]:
|
||
ms, _, seq = message_id.partition("-")
|
||
return int(ms), int(seq or 0)
|
||
|
||
|
||
def _increment(message_id: str) -> str:
|
||
ms, seq = _id_key(message_id)
|
||
return "%d-%d" % (ms, seq + 1)
|