forked from mtusi2026/mtusi2026lab3
302 lines
17 KiB
Python
302 lines
17 KiB
Python
"""Хранилище на 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
|