"""Хранилище на PostgreSQL. С lab2 источник истины — база данных, а не память процесса. Методы и их смысл те же, что у InMemoryStore из lab1, поэтому api.py почти не изменился. Модуль по-прежнему ничего не знает про HTTP: он хранит данные и соблюдает правила. Все SQL-запросы параметризованные: значения передаются отдельно от текста запроса (%s), поэтому ввод пользователя никогда не становится частью SQL (нет SQL-инъекций). """ import logging import uuid from contextlib import contextmanager from dataclasses import dataclass from datetime import datetime, timezone import psycopg from psycopg import errors as pg_errors from psycopg_pool import ConnectionPool, PoolTimeout from .errors import Conflict, InvalidRequest, NotFound, Unavailable log = logging.getLogger("messenger.store") @dataclass(frozen=True) class User: id: str username: str display_name: str created_at: str @dataclass(frozen=True) class Chat: id: str title: str member_ids: tuple[str, ...] created_at: str @dataclass(frozen=True) class Message: id: str chat_id: str sender_id: str text: str created_at: str def sort_key(item) -> tuple[str, str]: """Порядок по контракту: (created_at, id) по возрастанию. Из этой пары строится курсор.""" return item.created_at, item.id def ts(value: datetime) -> str: """Время из БД -> строка RFC 3339 в UTC с Z и микросекундами (как в lab1).""" return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ") # Свободный текст (display_name, title, text) хранится в БД как байты UTF-8 (bytea), а не text: # тип text в PostgreSQL не может содержать символ U+0000, а контракт его не запрещает. # См. migrations/003_text_as_bytes.sql. Перед записью кодируем, после чтения декодируем. def to_db(value: str) -> bytes: return value.encode("utf-8") def from_db(value) -> str: return bytes(value).decode("utf-8") def _user(row) -> User: return User(str(row[0]), row[1], from_db(row[2]), ts(row[3])) def _chat(row) -> Chat: return Chat(str(row[0]), from_db(row[1]), tuple(str(m) for m in row[3]), ts(row[2])) def _message(row) -> Message: return Message(str(row[0]), str(row[1]), str(row[2]), from_db(row[3]), ts(row[4])) # Участники чата всегда в одном порядке (по UUID), чтобы POST и GET отвечали одинаково. _CHAT_COLUMNS = """c.id, c.title, c.created_at, ARRAY(SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id)""" class PostgresStore: def __init__(self, pool: ConnectionPool): self.pool = pool @contextmanager def _conn(self, timeout: float | None = None): """Соединение из пула. В конце блока — COMMIT, при исключении — ROLLBACK. Если база недоступна (нет соединения, истёк таймаут пула или запроса), клиент получает 503 без подробностей, а не 500 со stack trace. """ try: with self.pool.connection(timeout=timeout) as conn: yield conn except (psycopg.OperationalError, PoolTimeout) as exc: log.warning("PostgreSQL недоступен: %s", type(exc).__name__) raise Unavailable("Хранилище временно недоступно") from None except psycopg.DataError as exc: # База отвергла само значение (например, недопустимый символ): это ошибка входа -> 400, # а не внутренняя ошибка сервера (500). log.warning("PostgreSQL отверг значение: %s", type(exc).__name__) raise InvalidRequest("Недопустимое значение в запросе") from None def ping(self, timeout: float = 1.0) -> None: """Проверка готовности: короткий таймаут, чтобы healthcheck (3 с) успел получить 503.""" with self._conn(timeout) as conn: conn.execute("SELECT 1") # --- пользователи --- def create_user(self, username: str, display_name: str, password_hash: str) -> User: try: with self._conn() as conn: row = conn.execute( """INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s) RETURNING id, username, display_name, created_at""", (uuid.uuid4(), username, to_db(display_name), password_hash)).fetchone() except pg_errors.UniqueViolation: # Не «проверить, потом вставить» (между этими шагами успеет вклиниться другой запрос), # а сразу вставить: уникальный индекс в БД пропустит ровно одну регистрацию. raise Conflict("Имя пользователя уже занято") from None return _user(row) def get_credentials(self, username: str) -> tuple[User, str] | None: """Пользователь и hash его пароля — только для проверки при входе.""" with self._conn() as conn: row = conn.execute( """SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s""", (username,)).fetchone() return None if row is None else (_user(row), row[4]) # --- чаты --- def create_chat(self, creator_id: str, title: str, member_ids: list[str]) -> Chat: if len(set(member_ids)) != len(member_ids): raise InvalidRequest("Участники чата повторяются") if creator_id not in member_ids: raise InvalidRequest("Создатель чата должен входить в member_ids") members = sorted(uuid.UUID(m) for m in member_ids) chat_id = uuid.uuid4() try: with self._conn() as conn: # Одна транзакция: чат и все участники записываются вместе или не записываются вовсе. with conn.transaction(): self._check_members_exist(conn, members) created_at = conn.execute( "INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at", (chat_id, to_db(title))).fetchone()[0] with conn.cursor() as cur: cur.executemany("INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", [(chat_id, m) for m in members]) except pg_errors.ForeignKeyViolation: # Сюда попадаем, только если проверка выше пропустила несуществующего участника. # Транзакция уже откатилась: строки чата в базе не осталось. raise InvalidRequest("Среди участников есть несуществующий пользователь") from None return Chat(str(chat_id), title, tuple(str(m) for m in members), ts(created_at)) @staticmethod def _check_members_exist(conn, members: list[uuid.UUID]) -> None: found = conn.execute("SELECT count(*) FROM users WHERE id = ANY(%s)", (members,)).fetchone()[0] if found != len(members): raise InvalidRequest("Среди участников есть несуществующий пользователь") def get_chat(self, user_id: str, chat_id: str) -> Chat: with self._conn() as conn: row = conn.execute( f"""SELECT {_CHAT_COLUMNS} FROM chats c WHERE c.id = %s AND EXISTS ( SELECT 1 FROM chat_members cm WHERE cm.chat_id = c.id AND cm.user_id = %s)""", (uuid.UUID(chat_id), uuid.UUID(user_id))).fetchone() if row is None: # Один и тот же ответ для «чата нет» и «чат чужой»: # посторонний не должен узнать, что такой чат существует. raise NotFound("Чат не найден") return _chat(row) def list_chats(self, user_id: str, after: tuple[datetime, uuid.UUID] | None, limit: int): query = f"""SELECT {_CHAT_COLUMNS} FROM chat_members me JOIN chats c ON c.id = me.chat_id WHERE me.user_id = %s {{after}} ORDER BY c.created_at, c.id LIMIT %s""" params: list = [uuid.UUID(user_id)] if after is None: query = query.format(after="") else: query = query.format(after="AND (c.created_at, c.id) > (%s, %s)") params += [after[0], after[1]] with self._conn() as conn: rows = conn.execute(query, (*params, limit + 1)).fetchall() return [_chat(r) for r in rows[:limit]], len(rows) > limit # --- сообщения --- def add_message(self, user_id: str, chat_id: str, text: str, idempotency_key: str, request_hash: bytes) -> tuple[Message, bool]: """Сохраняет сообщение ровно один раз на ключ. Возвращает (сообщение, это_повтор). Ключ и SHA-256 тела запроса лежат прямо в строке сообщения, а уникальное ограничение (chat_id, sender_id, idempotency_key) не даёт записать второе сообщение с тем же ключом. Поэтому само сообщение и «запомненный результат» — одна строка и один INSERT: они сохраняются атомарно, по отдельности их записать нельзя. Два одновременных запроса с одним ключом (даже через разные реплики): PostgreSQL заставляет второй INSERT ждать, пока завершится транзакция первого. Первый закоммитил — у второго ON CONFLICT DO NOTHING ничего не вставляет, и он читает готовую строку. Первый откатился (ошибка, 5xx) — второй просто вставляет: неудача ключ не «занимает». """ chat, user = uuid.UUID(chat_id), uuid.UUID(user_id) with self._conn() as conn: # Один SQL-оператор: вставка произойдёт, только если отправитель — участник чата. # Отправитель берётся из сессии, а не из тела запроса. row = conn.execute( """INSERT INTO messages (id, chat_id, sender_id, text, idempotency_key, request_hash) SELECT %s, cm.chat_id, cm.user_id, %s, %s, %s FROM chat_members cm WHERE cm.chat_id = %s AND cm.user_id = %s ON CONFLICT (chat_id, sender_id, idempotency_key) DO NOTHING RETURNING id, chat_id, sender_id, text, created_at""", (uuid.uuid4(), to_db(text), idempotency_key, request_hash, chat, user)).fetchone() if row is not None: return _message(row), False # новое сообщение # Ничего не вставилось: либо пользователь не участник чата, либо ключ уже использован. # Повтор тоже заново проверяет доступ (сессию уже проверил middleware). member = conn.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat, user)).fetchone() if member is None: raise NotFound("Чат не найден") saved = conn.execute( """SELECT id, chat_id, sender_id, text, created_at, request_hash FROM messages WHERE chat_id = %s AND sender_id = %s AND idempotency_key = %s""", (chat, user, idempotency_key)).fetchone() if saved is None: # Не должно случаться (строка с ключом есть, раз INSERT ничего не вставил). # Ответ 503 ничего не фиксирует: клиент повторит запрос с тем же ключом. raise Unavailable("Повторите запрос") if bytes(saved[5]) != request_hash: raise Conflict("Idempotency-Key уже использован с другим телом запроса") return _message(saved[:5]), True # тот же ответ, что и в первый раз def list_messages(self, user_id: str, chat_id: str, after: tuple[datetime, uuid.UUID] | None, limit: int): chat, user = uuid.UUID(chat_id), uuid.UUID(user_id) # Keyset-пагинация: «следующие limit записей после ключа», а не OFFSET. # С индексом (chat_id, created_at, id) база сразу встаёт на нужное место индекса # и читает только limit+1 строк, сколько бы сообщений ни было в чате. if after is None: query = """SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s ORDER BY created_at, id LIMIT %s""" params = (chat, limit + 1) else: query = """SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s""" params = (chat, after[0], after[1], limit + 1) with self._conn() as conn: member = conn.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat, user)).fetchone() if member is None: raise NotFound("Чат не найден") rows = conn.execute(query, params).fetchall() return [_message(r) for r in rows[:limit]], len(rows) > limit # --- сессии (источник истины; Valkey — только кэш, см. sessions.py) --- def create_session(self, token_hash: bytes, user_id: str, ttl_seconds: int) -> datetime: with self._conn() as conn, conn.transaction(): # Заодно убираем у этого пользователя истёкшие и отозванные сессии: они уже не нужны. conn.execute("""DELETE FROM sessions WHERE user_id = %s AND (expires_at <= now() OR revoked_at IS NOT NULL)""", (uuid.UUID(user_id),)) # Срок жизни считает часами PostgreSQL — теми же, по которым он потом проверяется. return conn.execute( """INSERT INTO sessions (token_hash, user_id, expires_at) VALUES (%s, %s, now() + make_interval(secs => %s)) RETURNING expires_at""", (token_hash, uuid.UUID(user_id), ttl_seconds)).fetchone()[0] def get_session(self, token_hash: bytes) -> tuple[User, datetime] | None: """Пользователь действующей сессии: не отозвана и не истекла. Иначе None.""" with self._conn() as conn: row = conn.execute( """SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at FROM sessions s JOIN users u ON u.id = s.user_id WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()""", (token_hash,)).fetchone() return None if row is None else (_user(row), row[4]) def revoke_session(self, token_hash: bytes) -> bool: with self._conn() as conn: cur = conn.execute("UPDATE sessions SET revoked_at = now() " "WHERE token_hash = %s AND revoked_at IS NULL", (token_hash,)) return cur.rowcount == 1