Files
mtusi2026lab7-fork/src/broker.py

226 lines
10 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Брокер заданий: 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)