"""Брокер заданий: 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)