Skeleton contracts / contracts (pull_request) Canceled after 0s
- Перенесён минимум lab1; переход 1 → 2: password при регистрации, Basic только на POST /auth/sessions, Bearer вместо X-User-Id, logout. - PostgreSQL — источник истины: users, chats, chat_members, messages, sessions; миграции с PK/FK/UNIQUE/CHECK и индексами, атомарное создание чата, scrypt для паролей, SHA-256 токенов в БД. - Valkey — кэш проверенных сессий с TTL, tombstone при logout, обход кэша и окно недоверия при отказе. - Ограниченные пулы и таймауты PostgreSQL/Valkey, 503 при отказе БД. - compose.yaml с Docker secrets и именованным томом, restart hook, собственные тесты, EXPLAIN на 110 тыс. сообщений, замер пользы кэша, заполненный REPORT.md и evidence/. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
272 lines
12 KiB
Python
272 lines
12 KiB
Python
"""Работа с PostgreSQL: пользователи, чаты, сообщения, сессии.
|
||
|
||
Источник истины — база данных. В памяти процесса состояния нет, поэтому
|
||
перезапуск API (и самой БД с сохранённым volume) не теряет данные.
|
||
"""
|
||
import datetime as dt
|
||
import logging
|
||
import time
|
||
import uuid
|
||
from pathlib import Path
|
||
|
||
import psycopg
|
||
from psycopg.rows import dict_row
|
||
from psycopg_pool import ConnectionPool
|
||
|
||
log = logging.getLogger("messenger.store")
|
||
|
||
EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc)
|
||
MIGRATIONS_LOCK_ID = 727001 # произвольный номер advisory-блокировки для миграций
|
||
|
||
|
||
class Conflict(Exception):
|
||
pass
|
||
|
||
|
||
class UnknownMember(Exception):
|
||
pass
|
||
|
||
|
||
def format_ts(value):
|
||
"""datetime -> RFC 3339 UTC с микросекундами и суффиксом Z."""
|
||
return value.astimezone(dt.timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
||
|
||
|
||
def to_micros(value):
|
||
delta = value - EPOCH
|
||
return (delta.days * 86400 + delta.seconds) * 1_000_000 + delta.microseconds
|
||
|
||
|
||
def from_micros(micros):
|
||
return EPOCH + dt.timedelta(microseconds=micros)
|
||
|
||
|
||
def _user(row):
|
||
# Пароль/hash и сессионные данные никогда не входят в User.
|
||
return {
|
||
"id": str(row["id"]),
|
||
"username": row["username"],
|
||
"display_name": row["display_name"],
|
||
"created_at": format_ts(row["created_at"]),
|
||
}
|
||
|
||
|
||
def _chat(row):
|
||
return {
|
||
"id": str(row["id"]),
|
||
"title": row["title"],
|
||
"member_ids": [str(m) for m in row["member_ids"]],
|
||
"created_at": format_ts(row["created_at"]),
|
||
}
|
||
|
||
|
||
def _message(row):
|
||
return {
|
||
"id": str(row["id"]),
|
||
"chat_id": str(row["chat_id"]),
|
||
"sender_id": str(row["sender_id"]),
|
||
"text": row["text"],
|
||
"created_at": format_ts(row["created_at"]),
|
||
}
|
||
|
||
|
||
CHAT_COLUMNS = """c.id, c.title, c.created_at,
|
||
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids"""
|
||
|
||
|
||
class Store:
|
||
def __init__(self, conninfo, pool_size=10, statement_timeout_ms=5000):
|
||
# Ограниченный пул: не более pool_size соединений; ожидание свободного — до 5 с,
|
||
# затем PoolTimeout → 503. statement_timeout обрывает зависший SQL.
|
||
# check: перед выдачей соединение проверяется. После перезапуска PostgreSQL
|
||
# «мёртвые» соединения отбрасываются, и запрос не получает ложный 503.
|
||
self.pool = ConnectionPool(
|
||
conninfo, min_size=1, max_size=pool_size, timeout=5,
|
||
kwargs={"row_factory": dict_row,
|
||
"options": "-c statement_timeout=%d" % statement_timeout_ms},
|
||
open=False,
|
||
check=ConnectionPool.check_connection)
|
||
|
||
# --- запуск ---
|
||
def open(self, wait_seconds=60):
|
||
"""Ждём готовности БД (она может стартовать дольше API) и открываем пул."""
|
||
self.pool.open()
|
||
deadline = time.monotonic() + wait_seconds
|
||
while True:
|
||
try:
|
||
with self.pool.connection() as conn:
|
||
conn.execute("SELECT 1")
|
||
return
|
||
except Exception as exc:
|
||
if time.monotonic() > deadline:
|
||
raise
|
||
log.info("database is not ready yet (%s), retrying", type(exc).__name__)
|
||
time.sleep(1)
|
||
|
||
def close(self):
|
||
self.pool.close()
|
||
|
||
def migrate(self, directory):
|
||
"""Применяет *.sql по порядку имён; каждая миграция — одна транзакция, один раз."""
|
||
files = sorted(Path(directory).glob("*.sql"))
|
||
with self.pool.connection() as conn:
|
||
# Advisory-блокировка (сессионная): несколько процессов не применят миграции одновременно.
|
||
conn.autocommit = True
|
||
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATIONS_LOCK_ID,))
|
||
try:
|
||
conn.execute("""CREATE TABLE IF NOT EXISTS schema_migrations (
|
||
version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())""")
|
||
done = {r["version"] for r in conn.execute("SELECT version FROM schema_migrations")}
|
||
for path in files:
|
||
if path.name in done:
|
||
continue
|
||
# Каждая миграция и её отметка — одна транзакция: либо целиком, либо никак.
|
||
with conn.transaction():
|
||
conn.execute(path.read_text(encoding="utf-8"))
|
||
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
|
||
log.info("migration applied: %s", path.name)
|
||
log.info("schema version: %s", files[-1].name if files else "none")
|
||
finally:
|
||
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATIONS_LOCK_ID,))
|
||
conn.autocommit = False
|
||
|
||
def ping(self):
|
||
with self.pool.connection() as conn:
|
||
conn.execute("SELECT 1")
|
||
|
||
# --- пользователи ---
|
||
def create_user(self, username, display_name, password_hash):
|
||
try:
|
||
with self.pool.connection() as conn:
|
||
row = conn.execute(
|
||
"""INSERT INTO users (id, username, display_name, password_hash, created_at)
|
||
VALUES (%s, %s, %s, %s, clock_timestamp())
|
||
RETURNING id, username, display_name, created_at""",
|
||
(uuid.uuid4(), username, display_name, password_hash)).fetchone()
|
||
except psycopg.errors.UniqueViolation:
|
||
# Уникальность гарантирует сама БД — гонка двух регистраций безопасна.
|
||
raise Conflict()
|
||
return _user(row)
|
||
|
||
def get_credentials(self, username):
|
||
with self.pool.connection() as conn:
|
||
row = conn.execute(
|
||
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
|
||
(username,)).fetchone()
|
||
if row is None:
|
||
return None, None
|
||
return _user(row), row["password_hash"]
|
||
|
||
# --- сессии ---
|
||
def create_session(self, user_id, token_hash, ttl_seconds):
|
||
with self.pool.connection() as conn:
|
||
row = conn.execute(
|
||
"""INSERT INTO sessions (token_hash, user_id, created_at, expires_at)
|
||
VALUES (%s, %s, now(), now() + make_interval(secs => %s))
|
||
RETURNING expires_at""",
|
||
(token_hash, user_id, ttl_seconds)).fetchone()
|
||
return row["expires_at"]
|
||
|
||
def get_session_user(self, token_hash):
|
||
"""(пользователь, expires_at) действующей сессии или None (неизвестна/истекла/отозвана)."""
|
||
with self.pool.connection() 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 (_user(row), row["expires_at"]) if row else None
|
||
|
||
def revoke_session(self, token_hash):
|
||
with self.pool.connection() as conn:
|
||
conn.execute(
|
||
"UPDATE sessions SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
|
||
(token_hash,))
|
||
|
||
# --- чаты ---
|
||
def create_chat(self, title, member_ids):
|
||
"""Чат и его участники создаются в одной транзакции (атомарно)."""
|
||
chat_id = uuid.uuid4()
|
||
# Блок `with pool.connection()` = одна транзакция: COMMIT при выходе без исключения,
|
||
# ROLLBACK при любом исключении. Чат без участников (или наоборот) не появится.
|
||
try:
|
||
with self.pool.connection() as conn:
|
||
found = conn.execute(
|
||
"SELECT count(*) AS n FROM users WHERE id = ANY(%s::uuid[])", (member_ids,)).fetchone()["n"]
|
||
if found != len(member_ids):
|
||
raise UnknownMember()
|
||
conn.execute(
|
||
"INSERT INTO chats (id, title, created_at) VALUES (%s, %s, clock_timestamp())",
|
||
(chat_id, title))
|
||
with conn.cursor() as cur:
|
||
cur.executemany(
|
||
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
|
||
[(chat_id, m, i) for i, m in enumerate(member_ids)])
|
||
row = conn.execute("SELECT " + CHAT_COLUMNS + " FROM chats c WHERE c.id = %s", (chat_id,)).fetchone()
|
||
except psycopg.errors.ForeignKeyViolation:
|
||
# Внешний ключ — последняя линия защиты: транзакция откатывается целиком.
|
||
raise UnknownMember()
|
||
return _chat(row)
|
||
|
||
def get_chat_for(self, user_id, chat_id):
|
||
"""Чат, если пользователь — участник; иначе None (чужой и несуществующий неразличимы)."""
|
||
with self.pool.connection() as conn:
|
||
row = conn.execute(
|
||
"SELECT " + CHAT_COLUMNS + """ FROM chats c
|
||
WHERE c.id = %s AND EXISTS (
|
||
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)""",
|
||
(chat_id, user_id)).fetchone()
|
||
return _chat(row) if row else None
|
||
|
||
def list_chats(self, user_id, after, limit):
|
||
params = [user_id]
|
||
where = ""
|
||
if after:
|
||
where = "AND (c.created_at, c.id) > (%s, %s::uuid)"
|
||
params += [from_micros(after[0]), after[1]]
|
||
params.append(limit + 1) # +1 запись: узнаём, есть ли следующая страница
|
||
with self.pool.connection() as conn:
|
||
rows = conn.execute(
|
||
"SELECT " + CHAT_COLUMNS + """ FROM chats c
|
||
JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s
|
||
WHERE true """ + where + " ORDER BY c.created_at, c.id LIMIT %s", params).fetchall()
|
||
return self._page(rows, limit, _chat)
|
||
|
||
# --- сообщения ---
|
||
def add_message(self, user_id, chat_id, text):
|
||
with self.pool.connection() as conn:
|
||
# FOR UPDATE по строке чата: вставки в один чат идут по очереди, поэтому
|
||
# created_at растёт в порядке фиксации и keyset-курсор не пропускает записи.
|
||
allowed = conn.execute(
|
||
"""SELECT 1 FROM chats c WHERE c.id = %s AND EXISTS (
|
||
SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = %s)
|
||
FOR UPDATE OF c""", (chat_id, user_id)).fetchone()
|
||
if allowed is None:
|
||
return None
|
||
row = conn.execute(
|
||
"""INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||
VALUES (%s, %s, %s, %s, clock_timestamp())
|
||
RETURNING id, chat_id, sender_id, text, created_at""",
|
||
(uuid.uuid4(), chat_id, user_id, text)).fetchone()
|
||
return _message(row)
|
||
|
||
def list_messages(self, chat_id, after, limit):
|
||
params = [chat_id]
|
||
where = ""
|
||
if after:
|
||
where = "AND (created_at, id) > (%s, %s::uuid)"
|
||
params += [from_micros(after[0]), after[1]]
|
||
params.append(limit + 1)
|
||
with self.pool.connection() as conn:
|
||
rows = conn.execute(
|
||
"SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s "
|
||
+ where + " ORDER BY created_at, id LIMIT %s", params).fetchall()
|
||
return self._page(rows, limit, _message)
|
||
|
||
@staticmethod
|
||
def _page(rows, limit, convert):
|
||
has_more = len(rows) > limit
|
||
rows = rows[:limit]
|
||
last = (to_micros(rows[-1]["created_at"]), str(rows[-1]["id"])) if rows and has_more else None
|
||
return [convert(r) for r in rows], last
|