Files
mtusi2026lab3/src/messenger/store.py
T
2026-10-15 00:24:46 +03:00

302 lines
17 KiB
Python
Raw 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.
"""Хранилище на 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