From 551c763d5ee684d5fa500c4088832be4d7c6f67e Mon Sep 17 00:00:00 2001 From: Khamid Date: Thu, 8 Oct 2026 18:54:34 +0300 Subject: [PATCH] =?UTF-8?q?=D0=94=D0=BE=D0=B1=D0=B0=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20=D0=BC=D0=B8=D0=B3=D1=80=D0=B0=D1=86=D0=B8=D0=B8=20?= =?UTF-8?q?=D0=B8=20=D1=85=D1=80=D0=B0=D0=BD=D0=B8=D0=BB=D0=B8=D1=89=D0=B5?= =?UTF-8?q?=20=D0=BD=D0=B0=20PostgreSQL?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- migrations/0001_init.sql | 39 ++++++++ requirements.txt | 24 +++++ src/config.py | 41 +++++++++ src/migrate.py | 48 ++++++++++ src/store.py | 186 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 338 insertions(+) create mode 100644 migrations/0001_init.sql create mode 100644 requirements.txt create mode 100644 src/config.py create mode 100644 src/migrate.py create mode 100644 src/store.py diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 0000000..e5d90b8 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,39 @@ +-- Пользователи, чаты, участники и сообщения. + +CREATE TABLE users ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_at timestamptz NOT NULL DEFAULT now() +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id), + -- порядок участника в исходном запросе, чтобы member_ids возвращались как были переданы + position integer NOT NULL, + PRIMARY KEY (chat_id, user_id) +); + +-- список чатов пользователя: поиск по user_id, первичный ключ начинается с chat_id и для этого не подходит +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT now() +); + +-- история чата читается запросом +-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4 +-- индекс в том же порядке даёт и фильтр, и сортировку без чтения всей истории +CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..bfe01ad --- /dev/null +++ b/requirements.txt @@ -0,0 +1,24 @@ +# Прямые зависимости +fastapi==0.143.0 +uvicorn==0.54.0 +psycopg[binary,pool]==3.3.6 +redis==8.1.0 +argon2-cffi==25.1.0 +# Транзитивные, зафиксированы по pip freeze в python:3.13.16-slim-bookworm +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +click==8.5.0 +h11==0.16.0 +idna==3.20 +opentelemetry-api==1.45.1 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +pycparser==3.1 +pydantic==2.13.5 +pydantic_core==2.46.5 +starlette==1.7.0 +typing-inspection==0.4.4 +typing_extensions==4.16.0 diff --git a/src/config.py b/src/config.py new file mode 100644 index 0000000..acf48cb --- /dev/null +++ b/src/config.py @@ -0,0 +1,41 @@ +import os +from pathlib import Path + +HOST = os.getenv("APP_HOST", "0.0.0.0") +PORT = int(os.getenv("APP_PORT", "8080")) +ENV = os.getenv("APP_ENV", "lab") +LOG_LEVEL = os.getenv("LOG_LEVEL", "info").lower() +# docker stop по умолчанию ждёт 10 секунд, поэтому укладываемся с запасом +SHUTDOWN_TIMEOUT = int(os.getenv("SHUTDOWN_TIMEOUT", "8")) + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +SESSION_STORE = os.getenv("SESSION_STORE", "redis") + +# пул соединений с PostgreSQL и таймауты, всё в секундах +DB_POOL_MIN_SIZE = int(os.getenv("DB_POOL_MIN_SIZE", "2")) +DB_POOL_MAX_SIZE = int(os.getenv("DB_POOL_MAX_SIZE", "10")) +DB_POOL_TIMEOUT = float(os.getenv("DB_POOL_TIMEOUT", "3")) +DB_CONNECT_TIMEOUT = int(os.getenv("DB_CONNECT_TIMEOUT", "3")) +DB_STATEMENT_TIMEOUT = int(os.getenv("DB_STATEMENT_TIMEOUT", "5")) + +CACHE_POOL_MAX_SIZE = int(os.getenv("CACHE_POOL_MAX_SIZE", "20")) +CACHE_TIMEOUT = float(os.getenv("CACHE_TIMEOUT", "2")) + + +def read_secret(name: str) -> str: + """Значение берётся из файла, путь к которому лежит в NAME_FILE. Для отладки без Docker подойдёт и сама NAME.""" + path = os.getenv(name + "_FILE") + if path and Path(path).is_file(): + return Path(path).read_text().strip() + value = os.getenv(name) + if not value: + raise SystemExit(f"не задан {name}_FILE или {name}") + return value + + +def database_url() -> str: + return read_secret("DATABASE_URL") + + +def cache_url() -> str: + return read_secret("CACHE_URL") diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 0000000..216b5a7 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,48 @@ +"""Применяет SQL-миграции из каталога migrations по порядку имён. Повторный запуск ничего не меняет.""" +import os +import sys +import time +from pathlib import Path + +import psycopg + +import config + +MIGRATIONS_DIR = Path(os.getenv("MIGRATIONS_DIR", "migrations")) +LOCK_ID = 20260201 # любое постоянное число: два мигратора не должны работать одновременно + + +def connect(attempts=30): + for attempt in range(attempts): + try: + return psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT) + except psycopg.OperationalError: + if attempt == attempts - 1: + raise + time.sleep(1) + + +def main(): + files = sorted(MIGRATIONS_DIR.glob("*.sql")) + if not files: + sys.exit(f"в {MIGRATIONS_DIR} нет миграций") + with connect() as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,)) + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + "version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())" + ) + applied = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")} + for path in files: + if path.name in applied: + print("уже применена:", path.name) + continue + # миграция и отметка о ней в одной транзакции: либо всё, либо ничего + with conn.transaction(): + conn.execute(path.read_text()) + conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,)) + print("применена:", path.name) + + +if __name__ == "__main__": + main() diff --git a/src/store.py b/src/store.py new file mode 100644 index 0000000..815b3a4 --- /dev/null +++ b/src/store.py @@ -0,0 +1,186 @@ +from datetime import timezone + +from psycopg import errors +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +import config + + +class UsernameTaken(Exception): + pass + + +class UnknownMember(Exception): + pass + + +def timestamp(value) -> str: + # ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz + return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ") + + +def user_json(row) -> dict: + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": timestamp(row["created_at"]), + } + + +def chat_json(row) -> dict: + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": [str(member) for member in row["member_ids"]], + "created_at": timestamp(row["created_at"]), + } + + +def message_json(row) -> dict: + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": timestamp(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: + """Все данные мессенджера в PostgreSQL. Значения в запросы попадают только через параметры %s.""" + + def __init__(self, url: str): + self.pool = ConnectionPool( + url, + min_size=config.DB_POOL_MIN_SIZE, + max_size=config.DB_POOL_MAX_SIZE, + timeout=config.DB_POOL_TIMEOUT, # сколько запрос ждёт свободное соединение + kwargs={ + "connect_timeout": config.DB_CONNECT_TIMEOUT, + "options": f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT * 1000}", + "row_factory": dict_row, + }, + # перед выдачей соединение проверяется, поэтому после перезапуска БД мёртвые соединения не достаются запросам + check=ConnectionPool.check_connection, + open=False, + ) + + def open(self) -> None: + # не ждём БД: если она недоступна, сервер стартует и отвечает 503 + self.pool.open(wait=False) + + def close(self) -> None: + self.pool.close() + + def ping(self) -> None: + with self.pool.connection() as conn: + conn.execute("SELECT 1") + + def create_user(self, username: str, display_name: str, password_hash: str) -> dict: + with self.pool.connection() as conn: + try: + row = conn.execute( + "INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s) " + "RETURNING id, username, display_name, created_at", + (username, display_name, password_hash), + ).fetchone() + except errors.UniqueViolation: + # уникальность проверяет сама БД, поэтому два одновременных запроса не создадут двух пользователей + raise UsernameTaken() + return user_json(row) + + def get_user(self, user_id: str): + with self.pool.connection() as conn: + row = conn.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,) + ).fetchone() + return user_json(row) if row else None + + def get_credentials(self, username: str): + """Пользователь и hash его пароля или (None, None).""" + 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_json(row), row["password_hash"] + + def create_chat(self, title: str, member_ids: list) -> dict: + # блок with — одна транзакция: commit при выходе, rollback при любом исключении + with self.pool.connection() as conn: + chat = conn.execute( + "INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at", (title,) + ).fetchone() + try: + with conn.cursor() as cursor: + cursor.executemany( + "INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)", + [(chat["id"], member, position) for position, member in enumerate(member_ids)], + ) + except errors.ForeignKeyViolation: + # участника нет в users: транзакция откатывается вместе с уже вставленным чатом + raise UnknownMember() + return chat_json({**chat, "member_ids": member_ids}) + + def get_chat(self, chat_id: str, user_id: str): + with self.pool.connection() as conn: + row = conn.execute( + f"SELECT {CHAT_COLUMNS} FROM chats c " + "JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE c.id = %s", + (user_id, chat_id), + ).fetchone() + return chat_json(row) if row else None + + def list_chats(self, user_id: str, after, limit: int): + query = f"SELECT {CHAT_COLUMNS} FROM chats c JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s" + params = [user_id] + if after: + query += " AND (c.created_at, c.id) > (%s, %s)" + params += after + query += " ORDER BY c.created_at, c.id LIMIT %s" + with self.pool.connection() as conn: + rows = conn.execute(query, params + [limit + 1]).fetchall() + return [chat_json(row) for row in rows[:limit]], len(rows) > limit + + def add_message(self, chat_id: str, sender_id: str, text: str): + with self.pool.connection() as conn: + if not self._is_member(conn, chat_id, sender_id): + return None + row = conn.execute( + "INSERT INTO messages (chat_id, sender_id, text) VALUES (%s, %s, %s) " + "RETURNING id, chat_id, sender_id, text, created_at", + (chat_id, sender_id, text), + ).fetchone() + return message_json(row) + + def list_messages(self, chat_id: str, user_id: str, after, limit: int): + query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s" + params = [chat_id] + if after: + # keyset: продолжаем с записи после cursor, а не пропускаем N строк + query += " AND (created_at, id) > (%s, %s)" + params += after + query += " ORDER BY created_at, id LIMIT %s" + with self.pool.connection() as conn: + if not self._is_member(conn, chat_id, user_id): + return None + # limit + 1: лишняя строка показывает, есть ли следующая страница + rows = conn.execute(query, params + [limit + 1]).fetchall() + return [message_json(row) for row in rows[:limit]], len(rows) > limit + + @staticmethod + def _is_member(conn, chat_id: str, user_id: str) -> bool: + row = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id) + ).fetchone() + return row is not None