From 91f1b3c06ee0de34efd3992efcd90bd8cf861a9e Mon Sep 17 00:00:00 2001 From: Khamid Date: Fri, 30 Oct 2026 21:43:16 +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=20X-Instance-Id,=20=D0=BE=D0=B1=D1=89=D1=83=D1=8E=20?= =?UTF-8?q?=D0=B8=D0=B4=D0=B5=D0=BC=D0=BF=D0=BE=D1=82=D0=B5=D0=BD=D1=82?= =?UTF-8?q?=D0=BD=D0=BE=D1=81=D1=82=D1=8C=20=D0=B8=20=D1=81=D1=82=D1=80?= =?UTF-8?q?=D0=BE=D0=B3=D0=B8=D0=B9=20=D1=80=D0=B0=D0=B7=D0=B1=D0=BE=D1=80?= =?UTF-8?q?=20=D1=82=D0=B5=D0=BB=D0=B0=20=D0=B7=D0=B0=D0=BF=D1=80=D0=BE?= =?UTF-8?q?=D1=81=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- migrations/0001_init.sql | 39 ++++ migrations/0002_idempotency.sql | 12 ++ requirements.txt | 24 +++ src/config.py | 47 +++++ src/errors.py | 38 ++++ src/healthcheck.py | 11 ++ src/main.py | 326 ++++++++++++++++++++++++++++++++ src/migrate.py | 48 +++++ src/schemas.py | 42 ++++ src/security.py | 45 +++++ src/sessions.py | 47 +++++ src/store.py | 216 +++++++++++++++++++++ 12 files changed, 895 insertions(+) create mode 100644 migrations/0001_init.sql create mode 100644 migrations/0002_idempotency.sql create mode 100644 requirements.txt create mode 100644 src/config.py create mode 100644 src/errors.py create mode 100644 src/healthcheck.py create mode 100644 src/main.py create mode 100644 src/migrate.py create mode 100644 src/schemas.py create mode 100644 src/security.py create mode 100644 src/sessions.py create mode 100644 src/store.py diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..e5d90b81 --- /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/migrations/0002_idempotency.sql b/migrations/0002_idempotency.sql new file mode 100644 index 00000000..05093b65 --- /dev/null +++ b/migrations/0002_idempotency.sql @@ -0,0 +1,12 @@ +-- Результат отправки сообщения по Idempotency-Key. Только новая таблица: версия API без неё продолжает работать. + +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id), + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'), + -- проверка отложена до COMMIT: ключ вставляется раньше сообщения, чтобы занять его первым + message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED, + created_at timestamptz NOT NULL DEFAULT now(), + -- область уникальности из контракта: пользователь + метод + путь чата + ключ + PRIMARY KEY (user_id, chat_id, key) +); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..bfe01add --- /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 00000000..5a74ceb8 --- /dev/null +++ b/src/config.py @@ -0,0 +1,47 @@ +import os +import socket +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") +VERSION = os.getenv("APP_VERSION", "dev") +# имя контейнера совпадает с коротким id, по нему scripts/stop-one.sh находит реплику; в lab7 заменить на alias +INSTANCE_ID = socket.gethostname() +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") +# сколько хранить результат отправки сообщения по Idempotency-Key, контракт требует не менее 24 часов +IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400")) + +# пул соединений с 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/errors.py b/src/errors.py new file mode 100644 index 00000000..62f6c873 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,38 @@ +from fastapi.responses import JSONResponse + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str, headers=None): + self.status = status + self.code = code + self.message = message + self.headers = headers + + +def invalid(message: str) -> ApiError: + return ApiError(400, "invalid_request", message) + + +def bad_credentials() -> ApiError: + # один и тот же ответ для неизвестного username и неверного пароля + return ApiError( + 401, "unauthorized", "Неверное имя пользователя или пароль", + {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) + + +def unauthorized() -> ApiError: + return ApiError( + 401, "unauthorized", "Нужен действующий Bearer-токен", + {"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + +def not_found() -> ApiError: + # одинаковый ответ для несуществующего и чужого объекта + return ApiError(404, "not_found", "Объект не найден") + + +def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse: + body = {"error": {"code": code, "message": message, "request_id": request_id}} + return JSONResponse(body, status_code=status, headers=headers) diff --git a/src/healthcheck.py b/src/healthcheck.py new file mode 100644 index 00000000..a9bcca4d --- /dev/null +++ b/src/healthcheck.py @@ -0,0 +1,11 @@ +"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200.""" +import os +import sys +import urllib.request + +port = os.getenv("APP_PORT", "8080") +try: + with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response: + sys.exit(0 if response.status == 200 else 1) +except Exception: + sys.exit(1) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..c46e6665 --- /dev/null +++ b/src/main.py @@ -0,0 +1,326 @@ +import base64 +import json +import logging +import re +import sys +import time +import uuid +from contextlib import asynccontextmanager +from dataclasses import dataclass +from datetime import datetime, timedelta, timezone +from typing import Annotated +from uuid import UUID + +import psycopg +import redis +import uvicorn +from fastapi import Depends, FastAPI, Path, Query, Request, Response +from fastapi.exceptions import RequestValidationError +from pydantic import ValidationError +from starlette.exceptions import HTTPException + +import config +import security +from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized +from schemas import UUID_PATTERN, CreateChat, CreateMessage, CreateUser +from sessions import Sessions +from store import TIME_FORMAT, IdempotencyConflict, Store, UnknownMember, UsernameTaken, timestamp + +logging.basicConfig( + level=config.LOG_LEVEL.upper(), + format="%(asctime)s %(levelname)s %(name)s: %(message)s", + stream=sys.stdout, +) +log = logging.getLogger("messenger") + +if config.SESSION_STORE != "redis": + sys.exit("поддерживается только SESSION_STORE=redis") + +USERNAME = re.compile(r"[a-z0-9_]{3,32}") +IDEMPOTENCY_KEY = re.compile(r"[A-Za-z0-9._:-]{1,128}") +ChatId = Annotated[str, Path(pattern=UUID_PATTERN)] + +store = Store(config.database_url()) +sessions = Sessions(config.cache_url()) + + +@asynccontextmanager +async def lifespan(app: FastAPI): + store.open() + log.info( + "started env=%s version=%s instance=%s listen=%s:%d session_ttl=%ds db_pool_max=%d", + config.ENV, config.VERSION, config.INSTANCE_ID, config.HOST, config.PORT, + config.SESSION_TTL_SECONDS, config.DB_POOL_MAX_SIZE, + ) + yield + store.close() + sessions.close() + log.info("stopped") + + +app = FastAPI(title="MTUSI Messenger lab3", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None) + + +@app.middleware("http") +async def request_context(request: Request, call_next): + request_id = uuid.uuid4().hex + request.state.request_id = request_id + started = time.perf_counter() + try: + response = await call_next(request) + except Exception: + log.exception("unhandled error request_id=%s", request_id) + response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера") + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = config.INSTANCE_ID + # балансировщик проверяет готовность каждую секунду, эти запросы видны только на уровне debug + level = logging.DEBUG if request.url.path.startswith("/health/") else logging.INFO + # в лог идут только метод, путь и код ответа: тела запросов, пароли и токены не пишем + log.log( + level, "%s %s status=%d duration_ms=%.1f request_id=%s", + request.method, request.url.path, response.status_code, + (time.perf_counter() - started) * 1000, request_id, + ) + return response + + +@app.exception_handler(ApiError) +async def on_api_error(request: Request, exc: ApiError): + return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers) + + +@app.exception_handler(RequestValidationError) +async def on_validation_error(request: Request, exc: RequestValidationError): + first = exc.errors()[0] + where = ".".join(str(part) for part in first["loc"]) + return error_response(request.state.request_id, 400, "invalid_request", f"{where}: {first['msg']}") + + +@app.exception_handler(HTTPException) +async def on_http_error(request: Request, exc: HTTPException): + # сюда попадают ошибки самого фреймворка: неизвестный путь, неподдерживаемый метод + if exc.status_code == 404: + code, message = "not_found", "Объект не найден" + else: + code, message = "invalid_request", "Запрос не поддерживается" + return error_response(request.state.request_id, exc.status_code, code, message, exc.headers) + + +# OperationalError — нет связи с PostgreSQL, не дождались соединения из пула или сработал statement_timeout +@app.exception_handler(psycopg.OperationalError) +async def on_database_down(request: Request, exc: Exception): + log.warning("postgres unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id) + return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен") + + +@app.exception_handler(redis.RedisError) +async def on_cache_down(request: Request, exc: Exception): + log.warning("redis unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id) + return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен") + + +@dataclass +class Session: + user_id: str + token: str + + +def current_session(request: Request) -> Session: + # X-User-Id из lab1 здесь не читается вообще, Basic на бизнес-запросах тоже не принимается + token = security.parse_bearer(request.headers.get("Authorization")) + if token is None: + raise unauthorized() + # если Redis недоступен, здесь будет исключение и ответ 503: без проверки сессии запрос дальше не идёт + user_id = sessions.user_id(token) + if user_id is None: + raise unauthorized() + return Session(user_id, token) + + +def idempotency_key(request: Request) -> str: + key = request.headers.get("Idempotency-Key", "") + if not IDEMPOTENCY_KEY.fullmatch(key): + raise invalid("Нужен заголовок Idempotency-Key: 1-128 символов A-Z a-z 0-9 . _ : -") + return key + + +def json_body(model): + """Разбирает тело запроса зависимостью, чтобы это происходило после проверки токена.""" + + async def parse(request: Request): + content_type = request.headers.get("Content-Type", "").split(";")[0].strip().lower() + if content_type != "application/json": + raise invalid("Нужен Content-Type: application/json") + try: + # decode строгий: контракт допускает только UTF-8, а json.loads сам угадал бы UTF-16 + data = json.loads((await request.body()).decode("utf-8")) + except (ValueError, RecursionError): + raise invalid("Тело запроса должно быть корректным JSON в UTF-8") + try: + return model.model_validate(data) + except ValidationError as exc: + first = exc.errors()[0] + where = ".".join(str(part) for part in ("body", *first["loc"])) + raise invalid(f"{where}: {first['msg']}") + + return parse + + +def encode_cursor(scope: str, created_at: str, item_id: str) -> str: + raw = json.dumps([scope, created_at, item_id]) + return base64.urlsafe_b64encode(raw.encode()).decode() + + +def decode_cursor(scope: str, cursor): + """Возвращает ключ (created_at, id) последней выданной записи или None для первой страницы.""" + if cursor is None: + return None + try: + # validate=True: символ вне алфавита base64 — ошибка, а не пропускается молча + cursor_scope, created_at, item_id = json.loads(base64.b64decode(cursor, altchars=b"-_", validate=True)) + # время и id принимаются только в том виде, в котором их выдаёт сам сервер + moment = datetime.strptime(created_at, TIME_FORMAT).replace(tzinfo=timezone.utc) + time_ok = moment.strftime(TIME_FORMAT) == created_at + id_ok = str(UUID(item_id)) == item_id + except (TypeError, ValueError, AttributeError): + raise invalid("Некорректный cursor") + # cursor действует только для того списка, в котором был выдан + if cursor_scope != scope or not time_ok or not id_ok: + raise invalid("Некорректный cursor") + # у одной позиции есть ровно одна запись cursor: другое оформление JSON или base64 не принимается + if encode_cursor(scope, created_at, item_id) != cursor: + raise invalid("Некорректный cursor") + return [moment, item_id] + + +def page(scope: str, items: list, has_more: bool) -> dict: + next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more else None + return {"items": items, "next_cursor": next_cursor} + + +@app.get("/health/live") +def liveness(): + return {"status": "ok"} + + +@app.get("/health/ready") +def readiness(): + # без PostgreSQL и Redis обязательные запросы не выполнить, поэтому обе зависимости критичны + store.ping() + sessions.ping() + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def register_user(body: CreateUser = Depends(json_body(CreateUser))): + try: + return store.create_user(body.username, body.display_name, security.hash_password(body.password)) + except UsernameTaken: + raise ApiError(409, "conflict", "Такой username уже занят") + + +@app.post("/api/v1/auth/sessions", status_code=201) +def create_session(request: Request): + credentials = security.parse_basic(request.headers.get("Authorization")) + if credentials is None: + raise bad_credentials() + username, password = credentials + user, password_hash = None, None + # username, который не мог быть зарегистрирован, в БД не ищем, но пароль всё равно сверяем с пустышкой + if USERNAME.fullmatch(username): + user, password_hash = store.get_credentials(username) + if not security.verify_password(password_hash, password): + raise bad_credentials() + token = sessions.create(user["id"]) + expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS) + return {"token": token, "token_type": "Bearer", "expires_at": timestamp(expires_at), "user": user} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def revoke_session(session: Session = Depends(current_session)): + sessions.revoke(session.token) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def get_me(session: Session = Depends(current_session)): + user = store.get_user(session.user_id) + if user is None: + raise unauthorized() + return user + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(session: Session = Depends(current_session), body: CreateChat = Depends(json_body(CreateChat))): + member_ids = [str(UUID(member)) for member in body.member_ids] + if len(set(member_ids)) != len(member_ids): + raise invalid("member_ids содержит повторы") + if session.user_id not in member_ids: + raise invalid("Создатель чата должен быть в member_ids") + try: + return store.create_chat(body.title, member_ids) + except UnknownMember: + raise invalid("В member_ids есть несуществующий пользователь") + + +@app.get("/api/v1/chats") +def list_chats( + limit: int = Query(50, ge=1, le=100), + cursor: str | None = Query(None, min_length=1), + session: Session = Depends(current_session), +): + scope = "chats:" + session.user_id + items, has_more = store.list_chats(session.user_id, decode_cursor(scope, cursor), limit) + return page(scope, items, has_more) + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: ChatId, session: Session = Depends(current_session)): + chat = store.get_chat(str(UUID(chat_id)), session.user_id) + if chat is None: + raise not_found() + return chat + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def send_message( + chat_id: ChatId, + session: Session = Depends(current_session), + key: str = Depends(idempotency_key), + body: CreateMessage = Depends(json_body(CreateMessage)), +): + # отправитель берётся из сессии, в теле запроса его нет + try: + message = store.add_message(str(UUID(chat_id)), session.user_id, body.text, key) + except IdempotencyConflict: + raise ApiError(409, "conflict", "Этот Idempotency-Key уже использован с другим сообщением") + if message is None: + raise not_found() + return message + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + chat_id: ChatId, + limit: int = Query(50, ge=1, le=100), + cursor: str | None = Query(None, min_length=1), + session: Session = Depends(current_session), +): + chat_id = str(UUID(chat_id)) + scope = "messages:" + chat_id + result = store.list_messages(chat_id, session.user_id, decode_cursor(scope, cursor), limit) + if result is None: + raise not_found() + items, has_more = result + return page(scope, items, has_more) + + +if __name__ == "__main__": + uvicorn.run( + app, + host=config.HOST, + port=config.PORT, + log_level=config.LOG_LEVEL, + access_log=False, + timeout_graceful_shutdown=config.SHUTDOWN_TIMEOUT, + ) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..216b5a73 --- /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/schemas.py b/src/schemas.py new file mode 100644 index 00000000..5bc1e11a --- /dev/null +++ b/src/schemas.py @@ -0,0 +1,42 @@ +from typing import Annotated + +from pydantic import BaseModel, ConfigDict, Field, field_validator + +# только запись 8-4-4-4-12: UUID из Python принял бы ещё скобки, urn: и строку без дефисов +UUID_PATTERN = r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$" +Uuid = Annotated[str, Field(pattern=UUID_PATTERN)] + + +def not_blank(value: str) -> str: + if not value.strip(): + raise ValueError("строка не может состоять только из пробелов") + # PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8 + if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value): + raise ValueError("строка содержит недопустимые символы") + return value + + +class StrictModel(BaseModel): + # лишние поля в JSON считаются ошибкой + model_config = ConfigDict(extra="forbid") + + +class CreateUser(StrictModel): + username: str = Field(pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + _not_blank = field_validator("display_name", "password")(not_blank) + + +class CreateChat(StrictModel): + title: str = Field(min_length=1, max_length=100) + member_ids: list[Uuid] = Field(min_length=1, max_length=100) + + _title = field_validator("title")(not_blank) + + +class CreateMessage(StrictModel): + text: str = Field(min_length=1, max_length=4000) + + _text = field_validator("text")(not_blank) diff --git a/src/security.py b/src/security.py new file mode 100644 index 00000000..73d7baa3 --- /dev/null +++ b/src/security.py @@ -0,0 +1,45 @@ +import base64 + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток +hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username +DUMMY_HASH = hasher.hash("no-such-user-password") + + +def hash_password(password: str) -> str: + return hasher.hash(password) + + +def verify_password(password_hash, password: str) -> bool: + try: + return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None + except (VerificationError, InvalidHashError): + return False + + +def parse_basic(header): + """Разбирает Authorization: Basic base64(username:password). Возвращает пару или None.""" + scheme, _, value = (header or "").partition(" ") + if scheme.lower() != "basic": + return None + try: + decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8") + except ValueError: + # три случая сразу: не ASCII в заголовке (сам ValueError), неверный base64 и байты не в UTF-8 + # (их исключения — подклассы ValueError) + return None + # двоеточие в пароле допустимо, поэтому делим только по первому + username, colon, password = decoded.partition(":") + if not colon: + return None + return username, password + + +def parse_bearer(header): + scheme, _, token = (header or "").partition(" ") + if scheme.lower() != "bearer" or not token.strip(): + return None + return token.strip() diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 00000000..150fc8ef --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,47 @@ +import hashlib +import secrets + +import redis +from redis.backoff import NoBackoff +from redis.retry import Retry + +import config + + +class Sessions: + """Сессии лежат только в Redis: ключ session:, значение id пользователя, TTL ставит сам Redis.""" + + def __init__(self, url: str): + pool = redis.BlockingConnectionPool.from_url( + url, + max_connections=config.CACHE_POOL_MAX_SIZE, + timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения + socket_timeout=config.CACHE_TIMEOUT, + socket_connect_timeout=config.CACHE_TIMEOUT, + decode_responses=True, + # одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается + retry=Retry(NoBackoff(), 1), + ) + self.client = redis.Redis(connection_pool=pool) + + @staticmethod + def key(token: str) -> str: + # сам токен в Redis не хранится: по дампу нельзя войти от чужого имени + return "session:" + hashlib.sha256(token.encode()).hexdigest() + + def create(self, user_id: str) -> str: + token = secrets.token_urlsafe(32) # 256 бит случайности + self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS) + return token + + def user_id(self, token: str): + return self.client.get(self.key(token)) + + def revoke(self, token: str) -> None: + self.client.delete(self.key(token)) + + def ping(self) -> None: + self.client.ping() + + def close(self) -> None: + self.client.close() diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..87c739ad --- /dev/null +++ b/src/store.py @@ -0,0 +1,216 @@ +import uuid +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 + + +class IdempotencyConflict(Exception): + pass + + +# ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz +TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ" + + +def timestamp(value) -> str: + return value.astimezone(timezone.utc).strftime(TIME_FORMAT) + + +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, key: str): + """Отправляет сообщение один раз на ключ. Повтор с тем же текстом возвращает исходное сообщение.""" + message_id = uuid.uuid4() + # ключ и сообщение пишутся в одной транзакции: при сбое не остаётся ни того, ни другого + with self.pool.connection() as conn: + if not self._is_member(conn, chat_id, sender_id): + return None + # параллельный запрос с тем же ключом ждёт здесь, пока первая транзакция не завершится; + # строка возвращается, только если ключ свободен или его срок вышел + claimed = conn.execute( + "INSERT INTO idempotency_keys (user_id, chat_id, key, message_id) VALUES (%s, %s, %s, %s) " + "ON CONFLICT (user_id, chat_id, key) DO UPDATE " + "SET message_id = EXCLUDED.message_id, created_at = now() " + "WHERE idempotency_keys.created_at < now() - make_interval(secs => %s) " + "RETURNING message_id", + (sender_id, chat_id, key, message_id, config.IDEMPOTENCY_TTL_SECONDS), + ).fetchone() + if claimed: + row = conn.execute( + "INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) " + "RETURNING id, chat_id, sender_id, text, created_at", + (message_id, chat_id, sender_id, text), + ).fetchone() + return message_json(row) + row = conn.execute( + "SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at FROM idempotency_keys k " + "JOIN messages m ON m.id = k.message_id WHERE k.user_id = %s AND k.chat_id = %s AND k.key = %s", + (sender_id, chat_id, key), + ).fetchone() + if row["text"] != text: + raise IdempotencyConflict() + 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