From 6fba9410d501cab788883dbccbd664c6417023d3 Mon Sep 17 00:00:00 2001 From: Sergey Lyakhonov Date: Fri, 9 Oct 2026 14:16:37 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=BE?= =?UTF-8?q?=D0=B2=D0=B0=D0=BB=20=D1=83=D1=80=D0=BE=D0=B2=D0=B5=D0=BD=D1=8C?= =?UTF-8?q?=203:=20PostgreSQL,=20=D0=BF=D0=B0=D1=80=D0=BE=D0=BB=D0=B8=20?= =?UTF-8?q?=D0=B8=20=D1=81=D0=BE=D1=85=D1=80=D0=B0=D0=BD=D1=8F=D0=B5=D0=BC?= =?UTF-8?q?=D1=8B=D0=B5=20=D1=81=D0=B5=D1=81=D1=81=D0=B8=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitattributes | 4 + Dockerfile | 30 +-- Makefile | 7 + compose.yaml | 38 ++++ evidence/level3.json | 50 +++++ infra/schema.md | 9 + migrations/001_initial.sql | 33 +++ requirements.lock.txt | 24 +++ requirements.txt | 5 +- scripts/bootstrap.py | 15 ++ scripts/restart.cmd | 3 + scripts/restart.sh | 5 + src/app.py | 25 ++- src/config.py | 10 + src/migrate.py | 19 ++ src/models.py | 14 +- src/routes/chats.py | 12 +- src/routes/common.py | 48 ++--- src/routes/health.py | 29 +-- src/routes/messages.py | 8 +- src/routes/users.py | 82 ++++---- src/storage.py | 398 ++++++++++++++----------------------- student-tests/README.md | 2 + student-tests/test_lab2.py | 43 ++++ 24 files changed, 532 insertions(+), 381 deletions(-) create mode 100644 .gitattributes create mode 100644 compose.yaml create mode 100644 evidence/level3.json create mode 100644 infra/schema.md create mode 100644 migrations/001_initial.sql create mode 100644 requirements.lock.txt create mode 100644 scripts/bootstrap.py create mode 100644 scripts/restart.cmd create mode 100755 scripts/restart.sh create mode 100644 src/config.py create mode 100644 src/migrate.py create mode 100644 student-tests/README.md create mode 100644 student-tests/test_lab2.py diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..1a0e3e83 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,4 @@ +*.sh text eol=lf +*.py text eol=lf +*.sql text eol=lf +Dockerfile text eol=lf diff --git a/Dockerfile b/Dockerfile index 17aaadbb..c6cdf61c 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,26 +1,12 @@ -# syntax=docker/dockerfile:1 -FROM python:3.11-slim-bookworm - +FROM python:3.11.10-slim-bookworm WORKDIR /app - -# Create non-root user +# Приложение работает без прав root. RUN groupadd -r appuser && useradd -r -g appuser appuser - -# Install dependencies first for layer caching -COPY requirements.txt . -RUN pip install --no-cache-dir -r requirements.txt - -# Copy application source -COPY src/ ./src/ - -# Switch to non-root user +COPY requirements.lock.txt . +RUN pip install --no-cache-dir -r requirements.lock.txt +COPY src/ src/ +COPY migrations/ migrations/ USER appuser - -# Healthcheck -HEALTHCHECK --interval=30s --timeout=5s --start-period=5s --retries=3 \ - CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/live')" || exit 1 - +HEALTHCHECK --interval=5s --timeout=5s --start-period=15s --retries=5 CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')" EXPOSE 8080 - -# Uvicorn handles SIGTERM gracefully (default timeout 10s) -CMD ["python", "-m", "uvicorn", "src.app:app", "--host", "0.0.0.0", "--port", "8080", "--log-level", "info"] +CMD ["sh", "-c", "python -m src.migrate && exec python -m uvicorn src.app:app --host 0.0.0.0 --port 8080 --timeout-graceful-shutdown 8"] diff --git a/Makefile b/Makefile index 9ecb223e..e5aeef8c 100644 --- a/Makefile +++ b/Makefile @@ -24,3 +24,10 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +.PHONY: student-test bootstrap +bootstrap: + $(PYTHON) scripts/bootstrap.py + +student-test: + $(PYTHON) student-tests/test_lab2.py --base-url "$(BASE_URL)" diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..0a528533 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,38 @@ +name: lyakhonov-lab2 +services: + db: + image: postgres:16.6-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/db_password + secrets: [db_password] + volumes: [postgres_data:/var/lib/postgresql/data] + healthcheck: + test: [CMD-SHELL, "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 30 + cpus: 1 + mem_limit: 512m + api: + build: . + image: lyakhonov-messenger:lab2 + environment: + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + secrets: [database_url] + ports: ["127.0.0.1:8080:8080"] + depends_on: + db: + condition: service_healthy + cpus: 1 + mem_limit: 512m + stop_grace_period: 10s +secrets: + db_password: + file: ./secrets/db_password + database_url: + file: ./secrets/database_url +volumes: + postgres_data: diff --git a/evidence/level3.json b/evidence/level3.json new file mode 100644 index 00000000..0c1021ec --- /dev/null +++ b/evidence/level3.json @@ -0,0 +1,50 @@ +{ + "commands": [ + { + "command": "python scripts/check_contract.py", + "output": "PASS: offline skeleton structure, local refs and Python syntax; application NOT tested." + }, + { + "command": "python tests/smoke.py", + "output": "PASS: lab2 public API scenario; infrastructure and grading evidence remain separate." + }, + { + "command": "python student-tests/test_lab2.py", + "output": "PASS: strict validation, access, cursor binding, 100 messages / 10 clients, complete pagination" + }, + { + "command": "python tests/resilience.py --mode persistence --action-script scripts/restart.cmd", + "output": "Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.\nPASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence." + } + ], + "before": [ + { + "Name": "/lyakhonov-lab2-api-1", + "RestartCount": 0, + "started_at": "2026-10-09T11:15:56.676676381Z", + "image": "lyakhonov-messenger:lab2" + }, + { + "Name": "/lyakhonov-lab2-db-1", + "RestartCount": 0, + "started_at": "2026-10-09T11:15:56.130807797Z", + "image": "postgres:16.6-alpine" + } + ], + "after": [ + { + "Name": "/lyakhonov-lab2-api-1", + "RestartCount": 0, + "started_at": "2026-10-09T11:16:33.449311224Z", + "image": "lyakhonov-messenger:lab2" + }, + { + "Name": "/lyakhonov-lab2-db-1", + "RestartCount": 0, + "started_at": "2026-10-09T11:16:33.058063917Z", + "image": "postgres:16.6-alpine" + } + ], + "migration_repeat": "PASS: repeated migration completed without applying migration twice", + "migration_versions": "001_initial.sql" +} diff --git a/infra/schema.md b/infra/schema.md new file mode 100644 index 00000000..f1508363 --- /dev/null +++ b/infra/schema.md @@ -0,0 +1,9 @@ +# Схема PostgreSQL + +Пользователь имеет уникальное имя и хеш Argon2id. Чат и строки участников создаются в одной транзакции; ошибка любого FK откатывает весь чат. Сообщение связано с чатом, отправителем и членством составным FK. Удаление данных через API отсутствует. + +Сессия хранит SHA-256 случайного 256-битного токена и абсолютное время окончания; SHA-256 применяется к токену, а пароль обрабатывается Argon2id. Logout удаляет строку. Внешний API не возвращает хеши. + +Индекс messages_history_idx (chat_id, created_at, id) обслуживает WHERE chat_id = ? AND (created_at,id) > (?,?) ORDER BY created_at,id LIMIT ?. Запрашиваются limit+1 строка, чтобы определить наличие следующей страницы. PostgreSQL timestamptz сохраняет микросекунды; UUID разрешает совпадения времени. Между страницами нет общего snapshot. + +Миграции выполняются под advisory lock в транзакции; schema_migrations предотвращает повторное применение. Пул ограничен десятью подключениями и 32 ожидающими; получение подключения — 3 секунды, statement_timeout — 3 секунды, lock_timeout — 2 секунды. diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..2ee14af7 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,33 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username varchar(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name varchar(100) NOT NULL CHECK (length(btrim(display_name)) > 0), + password_hash text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title varchar(100) NOT NULL CHECK (length(btrim(title)) > 0), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats(id), + user_id uuid NOT NULL REFERENCES users(id), + PRIMARY KEY (chat_id, user_id) +); +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats(id), + sender_id uuid NOT NULL REFERENCES users(id), + text varchar(4000) NOT NULL CHECK (length(btrim(text)) > 0), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id) +); +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); +CREATE TABLE sessions ( + token_hash char(64) PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users(id), + expires_at timestamptz NOT NULL +); +CREATE INDEX sessions_expiry_idx ON sessions (expires_at); diff --git a/requirements.lock.txt b/requirements.lock.txt new file mode 100644 index 00000000..c6fe6332 --- /dev/null +++ b/requirements.lock.txt @@ -0,0 +1,24 @@ +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi==23.1.0 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +click==8.5.0 +fastapi==0.115.0 +h11==0.16.0 +httptools==0.8.0 +idna==3.20 +psycopg==3.2.3 +psycopg-binary==3.2.3 +psycopg-pool==3.2.4 +pycparser==3.1 +pydantic==2.9.2 +pydantic_core==2.23.4 +python-dotenv==1.2.4 +PyYAML==6.0.3 +starlette==0.38.6 +typing_extensions==4.16.0 +uvicorn==0.32.0 +uvloop==0.23.0 +watchfiles==1.3.0 +websockets==17.2 diff --git a/requirements.txt b/requirements.txt index c2ddff62..9553a2dc 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,6 @@ fastapi==0.115.0 uvicorn[standard]==0.32.0 pydantic==2.9.2 -python-multipart==0.0.12 -matplotlib==3.9.2 +psycopg[binary]==3.2.3 +psycopg-pool==3.2.4 +argon2-cffi==23.1.0 diff --git a/scripts/bootstrap.py b/scripts/bootstrap.py new file mode 100644 index 00000000..e1fd52c4 --- /dev/null +++ b/scripts/bootstrap.py @@ -0,0 +1,15 @@ +"""Создать локальные секреты, не перезаписывая существующие.""" +from pathlib import Path +import secrets + +root = Path(__file__).resolve().parents[1] +folder = root / 'secrets' +folder.mkdir(exist_ok=True) +password_file = folder / 'db_password' +if not password_file.exists(): + password_file.write_text(secrets.token_hex(24), encoding='utf-8') +url_file = folder / 'database_url' +if not url_file.exists(): + password = password_file.read_text(encoding='utf-8').strip() + url_file.write_text(f'postgresql://messenger:{password}@db:5432/messenger', encoding='utf-8') +print('Локальные секреты готовы; значения не выводятся.') diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..a79be87e --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,3 @@ +@echo off +cd /d "%~dp0.." +docker compose restart db api diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..b9b8009c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Перезапускаем реальные процессы, сохраняя именованные тома. +docker compose restart db api diff --git a/src/app.py b/src/app.py index 31ab0839..9cd3046b 100644 --- a/src/app.py +++ b/src/app.py @@ -1,4 +1,8 @@ import uuid +from contextlib import asynccontextmanager +import psycopg +from psycopg_pool import PoolTimeout +from starlette.concurrency import run_in_threadpool from fastapi import FastAPI, Request from fastapi.exceptions import RequestValidationError @@ -13,7 +17,24 @@ from src.storage import storage def create_app() -> FastAPI: """Создать и настроить приложение FastAPI.""" - app = FastAPI(title="MTUSI Messenger Lab1", version="1.1.0") + @asynccontextmanager + async def lifespan(app): + await run_in_threadpool(storage.pool.open, wait=True) + try: + yield + finally: + await run_in_threadpool(storage.pool.close) + + app = FastAPI(title="MTUSI Messenger Lab2", version="1.2.0", lifespan=lifespan) + + @app.exception_handler(psycopg.OperationalError) + @app.exception_handler(psycopg.errors.QueryCanceled) + @app.exception_handler(PoolTimeout) + async def dependency_error(request, exc): + return JSONResponse(status_code=503, content=ErrorResponse(error={ + "code": "unavailable", "message": "хранилище временно недоступно", + "request_id": request.state.request_id}).model_dump(), + headers={"X-Request-Id": request.state.request_id}) @app.middleware("http") async def add_request_id(request: Request, call_next): @@ -50,7 +71,7 @@ def create_app() -> FastAPI: return JSONResponse( status_code=exc.status_code, content=exc.detail, - headers={"X-Request-Id": request_id}, + headers={"X-Request-Id": request_id, **(exc.headers or {})}, ) return JSONResponse( status_code=exc.status_code, diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..30d65e7a --- /dev/null +++ b/src/config.py @@ -0,0 +1,10 @@ +"""Настройки окружения и чтение секретов из файлов.""" +import os +from pathlib import Path + + +def setting(name, default=None): + path = os.getenv(name + '_FILE') + if path: + return Path(path).read_text(encoding='utf-8').strip() + return os.getenv(name, default) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..69dacbfe --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,19 @@ +"""Версионируемые миграции: одна транзакция, блокировка от параллельного запуска.""" +from pathlib import Path +import psycopg +from src.config import setting + + +def main(): + with psycopg.connect(setting('DATABASE_URL'), connect_timeout=5) as conn: + conn.execute('SELECT pg_advisory_xact_lock(2301002)') + conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY)') + for path in sorted(Path('/app/migrations' if Path('/app/migrations').exists() else 'migrations').glob('*.sql')): + if not conn.execute('SELECT 1 FROM schema_migrations WHERE version=%s', (path.name,)).fetchone(): + conn.execute(path.read_text(encoding='utf-8')) + conn.execute('INSERT INTO schema_migrations VALUES (%s)', (path.name,)) + print('Применена миграция:', path.name) + + +if __name__ == '__main__': + main() diff --git a/src/models.py b/src/models.py index 17793696..ff3e5fc8 100644 --- a/src/models.py +++ b/src/models.py @@ -1,5 +1,6 @@ from datetime import datetime, timezone from typing import Optional +import uuid from pydantic import BaseModel, ConfigDict, Field, field_validator @@ -36,8 +37,9 @@ class User(BaseModel): class CreateUser(BaseModel): """Данные для создания пользователя.""" - model_config = ConfigDict(extra="forbid") + model_config = ConfigDict(extra="forbid", strict=True) + password: str = Field(..., min_length=12, max_length=128) username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") display_name: str = Field(..., min_length=1, max_length=100) @@ -60,11 +62,17 @@ class Chat(BaseModel): class CreateChat(BaseModel): """Данные для создания чата.""" - model_config = ConfigDict(extra="forbid") + model_config = ConfigDict(extra="forbid", strict=True) title: str = Field(..., min_length=1, max_length=100) member_ids: list[str] = Field(..., min_length=1, max_length=100) + @field_validator("member_ids") + @classmethod + def valid_members(cls, values): + """Проверить UUID и привести их к единому представлению.""" + return [str(uuid.UUID(value)) for value in values] + @field_validator("title") @classmethod def title_not_whitespace_only(cls, v: str) -> str: @@ -85,7 +93,7 @@ class Message(BaseModel): class CreateMessage(BaseModel): """Данные для отправки сообщения.""" - model_config = ConfigDict(extra="forbid") + model_config = ConfigDict(extra="forbid", strict=True) text: str = Field(..., min_length=1, max_length=4000) diff --git a/src/routes/chats.py b/src/routes/chats.py index 8484a934..4014fcf2 100644 --- a/src/routes/chats.py +++ b/src/routes/chats.py @@ -10,14 +10,14 @@ router = APIRouter() @router.post("/api/v1/chats", response_model=Chat, status_code=201) -async def create_chat( +def create_chat( request: Request, body: CreateChat, x_user_id: str | None = Header(None, alias="X-User-Id"), ): """Создать чат. Создатель обязательно должен входить в member_ids.""" request_id = get_request_id(request) - require_user(request, x_user_id) + x_user_id = require_user(request) try: chat = storage.create_chat(body.title, body.member_ids, x_user_id) @@ -35,7 +35,7 @@ async def create_chat( @router.get("/api/v1/chats", response_model=ChatPage) -async def list_chats( +def list_chats( request: Request, x_user_id: str | None = Header(None, alias="X-User-Id"), limit: int = 50, @@ -43,7 +43,7 @@ async def list_chats( ): """Список чатов текущего пользователя с курсорной пагинацией.""" request_id = get_request_id(request) - require_user(request, x_user_id) + x_user_id = require_user(request) if limit < 1 or limit > 100: raise HTTPException( @@ -62,14 +62,14 @@ async def list_chats( @router.get("/api/v1/chats/{chat_id}", response_model=Chat) -async def get_chat( +def get_chat( request: Request, chat_id: UUID, x_user_id: str | None = Header(None, alias="X-User-Id"), ): """Получить чат по id. Доступен только участникам чата (чужой — 404).""" request_id = get_request_id(request) - require_user(request, x_user_id) + x_user_id = require_user(request) chat_id_str = str(chat_id) chat = storage.get_chat(chat_id_str) diff --git a/src/routes/common.py b/src/routes/common.py index a99fb871..a671491d 100644 --- a/src/routes/common.py +++ b/src/routes/common.py @@ -1,37 +1,29 @@ -"""Общие утилиты для всех роутов API. - -Вынесено сюда, чтобы не повторять в каждом файле роутов (DRY). -""" +"""Общие ошибки и проверка Bearer-сессии; X-User-Id не используется.""" from fastapi import HTTPException, Request - from src.models import ErrorResponse from src.storage import storage -def make_error(code: str, message: str, request_id: str) -> ErrorResponse: - """Собрать стандартный ответ об ошибке по контракту API.""" - return ErrorResponse(error={"code": code, "message": message, "request_id": request_id}) +def make_error(code, message, request_id): + return ErrorResponse(error={'code': code, 'message': message, 'request_id': request_id}) -def get_request_id(request: Request) -> str: - """Достать X-Request-Id из middleware. Если нет — сгенерировать новый.""" - return getattr(request.state, "request_id", "") or str(id(request)) +def get_request_id(request): + return request.state.request_id -def require_user(request: Request, x_user_id: str | None) -> str: - """Проверить, что пользователь передал валидный X-User-Id. - Возвращает user_id или выбрасывает HTTPException(401). - """ - request_id = get_request_id(request) - if not x_user_id: - raise HTTPException( - status_code=401, - detail=make_error("unauthorized", "отсутствует идентификатор пользователя", request_id).model_dump(), - ) - user = storage.get_user(x_user_id) - if not user: - raise HTTPException( - status_code=401, - detail=make_error("unauthorized", "недействительный идентификатор пользователя", request_id).model_dump(), - ) - return x_user_id +def unauthorized(request, basic=False): + challenge = 'Basic realm="messenger", charset="UTF-8"' if basic else 'Bearer realm="messenger"' + raise HTTPException(401, detail=make_error('unauthorized', 'неверные учётные данные', get_request_id(request)).model_dump(), headers={'WWW-Authenticate': challenge}) + + +def require_user(request: Request, ignored=None): + authorization = request.headers.get('Authorization', '') + parts = authorization.split() + if len(parts) != 2 or parts[0].lower() != 'bearer': + unauthorized(request) + user_id = storage.session_user(parts[1]) + if not user_id: + unauthorized(request) + request.state.token = parts[1] + return user_id diff --git a/src/routes/health.py b/src/routes/health.py index 1940e52a..2f2caafb 100644 --- a/src/routes/health.py +++ b/src/routes/health.py @@ -1,30 +1,21 @@ +"""Жизнь процесса и готовность критичного хранилища проверяются отдельно.""" from fastapi import APIRouter - from src.models import Health from src.storage import storage - router = APIRouter() -@router.get("/health/live") -async def liveness() -> Health: - """Проверка жизни процесса. Всегда возвращает 200, если процесс работает.""" - return Health(status="ok") +@router.get('/health/live') +def liveness(): + return Health() -@router.get("/health/ready") -async def readiness() -> Health: - """Проверка готовности принимать трафик. - - Для lab1 возвращает 200, так как нет внешних зависимостей. - В следующих лабах здесь будет проверка БД и других сервисов. - """ - return Health(status="ok") +@router.get('/health/ready') +def readiness(): + storage.ready() + return Health() -@router.get("/stats") -async def stats(): - """Текущая статистика сервера: количество пользователей, чатов, сообщений, - а также метрики rate limiting'а для наблюдения за деградацией. - """ +@router.get('/stats') +def stats(): return storage.get_stats() diff --git a/src/routes/messages.py b/src/routes/messages.py index d9af564d..c2b1adef 100644 --- a/src/routes/messages.py +++ b/src/routes/messages.py @@ -10,7 +10,7 @@ router = APIRouter() @router.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201) -async def create_message( +def create_message( request: Request, chat_id: UUID, body: CreateMessage, @@ -18,7 +18,7 @@ async def create_message( ): """Отправить сообщение в чат. Отправитель определяется по X-User-Id.""" request_id = get_request_id(request) - require_user(request, x_user_id) + x_user_id = require_user(request) chat_id_str = str(chat_id) chat = storage.get_chat(chat_id_str) @@ -39,7 +39,7 @@ async def create_message( @router.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) -async def list_messages( +def list_messages( request: Request, chat_id: UUID, x_user_id: str | None = Header(None, alias="X-User-Id"), @@ -48,7 +48,7 @@ async def list_messages( ): """История сообщений чата с курсорной пагинацией. Доступно только участникам.""" request_id = get_request_id(request) - require_user(request, x_user_id) + x_user_id = require_user(request) chat_id_str = str(chat_id) chat = storage.get_chat(chat_id_str) diff --git a/src/routes/users.py b/src/routes/users.py index 2f7aee76..4709e263 100644 --- a/src/routes/users.py +++ b/src/routes/users.py @@ -1,51 +1,49 @@ -from fastapi import APIRouter, Header, HTTPException, Request - +"""Регистрация, вход, текущий пользователь и отзыв сессии.""" +import base64 +import binascii +from fastapi import APIRouter, Request, Response, HTTPException from src.models import CreateUser, User -from src.routes.common import get_request_id, make_error -from src.storage import ConflictError, LimitExceeded, storage +from src.routes.common import get_request_id, make_error, require_user, unauthorized +from src.storage import ConflictError, storage router = APIRouter() -@router.post("/api/v1/users", response_model=User, status_code=201) -async def register_user(request: Request, body: CreateUser): - """Создать нового пользователя. Публичный endpoint, не требует авторизации.""" - request_id = get_request_id(request) +@router.post('/api/v1/users', response_model=User, status_code=201) +def register_user(request: Request, body: CreateUser): try: - user = storage.create_user(body.username, body.display_name) - return user - except ConflictError as e: - raise HTTPException( - status_code=409, - detail=make_error("conflict", str(e), request_id).model_dump(), - ) - except LimitExceeded as e: - raise HTTPException( - status_code=429, - detail=make_error("rate_limited", str(e), request_id).model_dump(), - ) + return storage.create_user(body.username,body.display_name,body.password) + except ConflictError as exc: + raise HTTPException(409,detail=make_error('conflict',str(exc),get_request_id(request)).model_dump()) -@router.get("/api/v1/users/me", response_model=User) -async def current_user( - request: Request, - x_user_id: str | None = Header(None, alias="X-User-Id"), -): - """Получить текущего пользователя по заголовку X-User-Id. +@router.post('/api/v1/auth/sessions', status_code=201) +async def login(request: Request): + if await request.body(): + raise HTTPException(400, detail=make_error('invalid_request','тело запроса не допускается',get_request_id(request)).model_dump()) + parts = request.headers.get('Authorization','').split() + try: + if len(parts) != 2 or parts[0].lower() != 'basic': + unauthorized(request, basic=True) + username,password = base64.b64decode(parts[1],validate=True).decode('utf-8').split(':',1) + username.encode('ascii') + except (ValueError, UnicodeError, binascii.Error): + unauthorized(request,basic=True) + # Вычисление KDF и синхронные запросы выполняются вне цикла событий. + from starlette.concurrency import run_in_threadpool + result = await run_in_threadpool(storage.login,username,password) + if not result: + unauthorized(request,basic=True) + return result - Это учебный механизм: любой клиент может выдать себя за другого, - зная UUID пользователя. Настоящая аутентификация появится позже. - """ - request_id = get_request_id(request) - if not x_user_id: - raise HTTPException( - status_code=401, - detail=make_error("unauthorized", "отсутствует идентификатор пользователя", request_id).model_dump(), - ) - user = storage.get_user(x_user_id) - if not user: - raise HTTPException( - status_code=401, - detail=make_error("unauthorized", "недействительный идентификатор пользователя", request_id).model_dump(), - ) - return user + +@router.get('/api/v1/users/me',response_model=User) +def current_user(request: Request): + return storage.get_user(require_user(request)) + + +@router.delete('/api/v1/auth/sessions/current',status_code=204) +def logout(request: Request): + require_user(request) + storage.logout(request.state.token) + return Response(status_code=204) diff --git a/src/storage.py b/src/storage.py index 6fc74edf..ae62eeea 100644 --- a/src/storage.py +++ b/src/storage.py @@ -1,55 +1,60 @@ +"""PostgreSQL — источник истины; каждый контекст подключения завершает транзакцию.""" import base64 import binascii -from datetime import datetime +from datetime import datetime, timezone +import hashlib import json import os +import secrets import threading -import time import uuid -from src.models import Chat, Message, User, utc_now - +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, VerificationError, InvalidHashError +from psycopg.errors import UniqueViolation, ForeignKeyViolation +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool +from src.config import setting +from src.models import User, Chat, Message _CURSOR_FIELDS = {"scope", "resource_id", "created_at", "id"} +PASSWORDS = PasswordHasher() +DUMMY_HASH = PASSWORDS.hash('synthetic-dummy-password') -class StorageLimits: - """Лимиты хранилища для защиты от перегрузки (трек 2).""" +class ValidationError(Exception): + """Неверный запрос.""" + + +class ConflictError(Exception): + """Имя уже занято.""" + + +class LimitExceeded(Exception): + """Перегрузка сервера.""" + + +class NotFoundError(Exception): + """Объект отсутствует или недоступен.""" + + +def timestamp(value): + return value.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z') + + +def public_row(row): + return {k: timestamp(v) if isinstance(v, datetime) else str(v) if isinstance(v, uuid.UUID) else v + for k, v in row.items() if k != 'password_hash'} + + +class PostgresStorage: def __init__(self): - self.max_users = int(os.getenv("MAX_USERS", "1000")) - self.max_chats = int(os.getenv("MAX_CHATS", "1000")) - self.max_messages_total = int(os.getenv("MAX_MESSAGES", "10000")) - self.max_messages_per_chat = int(os.getenv("MAX_MESSAGES_PER_CHAT", "1000")) - self.max_request_queue = int(os.getenv("MAX_REQUEST_QUEUE", "100")) - self.max_messages_per_second = float(os.getenv("MAX_MESSAGES_PER_SECOND", "10.0")) - - -class InMemoryStorage: - """Хранилище данных в оперативной памяти. - - Все данные живут внутри одного процесса и исчезают при перезапуске. - Это требование текущей лабораторной — научиться работать с контейнерами - без внешних баз данных. - - Для защиты от гонок используется threading.RLock. - """ - def __init__(self): - self._users: dict[str, User] = {} - self._users_by_username: dict[str, str] = {} - self._chats: dict[str, Chat] = {} - self._messages: dict[str, Message] = {} - self._chat_messages: dict[str, list[str]] = {} - self._lock = threading.RLock() - self._limits = StorageLimits() - self._request_count = 0 - - # Token bucket для ограничения сообщений в секунду (трек 2) - self._message_tokens = self._limits.max_messages_per_second - self._last_token_update = time.monotonic() - - # Метрики для наблюдения за деградацией - self._rate_limited_count = 0 - self._total_message_attempts = 0 + self.pool = ConnectionPool(setting('DATABASE_URL', ''), min_size=1, max_size=10, + timeout=3, max_waiting=32, open=False, check=ConnectionPool.check_connection, + kwargs={'row_factory': dict_row, 'connect_timeout': 3, + 'options': '-c statement_timeout=3000 -c lock_timeout=2000'}) + self._lock = threading.Lock() + self._requests = 0 @staticmethod def _encode_cursor(scope: str, resource_id: str, created_at: str, item_id: str) -> str: @@ -95,245 +100,132 @@ class InMemoryStorage: try: uuid.UUID(payload["resource_id"]) uuid.UUID(payload["id"]) - datetime.strptime(payload["created_at"], "%Y-%m-%dT%H:%M:%SZ") + datetime.fromisoformat(payload["created_at"].replace("Z", "+00:00")) except ValueError: raise ValidationError("некорректный cursor") return payload["created_at"], payload["id"] - # --- Пользователи --- - def create_user(self, username: str, display_name: str) -> User: - """Создать пользователя. Проверяет лимит и уникальность username.""" - with self._lock: - if len(self._users) >= self._limits.max_users: - raise LimitExceeded("превышен лимит пользователей") - if username in self._users_by_username: - raise ConflictError(f"username '{username}' уже занят") + def create_user(self, username, display_name, password): + password_hash = PASSWORDS.hash(password) + try: + with self.pool.connection() 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, display_name, password_hash)).fetchone() + return User(**public_row(row)) + except UniqueViolation: + raise ConflictError('имя пользователя уже занято') from None - user = User( - id=str(uuid.uuid4()), - username=username, - display_name=display_name, - created_at=utc_now(), - ) - self._users[user.id] = user - self._users_by_username[user.username] = user.id - return user + def get_user(self, user_id): + 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(**public_row(row)) if row else None - def get_user(self, user_id: str) -> User | None: - """Найти пользователя по UUID.""" - with self._lock: - return self._users.get(user_id) + def login(self, username, password): + with self.pool.connection() as conn: + row = conn.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone() + try: + PASSWORDS.verify(row['password_hash'] if row else DUMMY_HASH, password) + except (VerifyMismatchError, VerificationError, InvalidHashError): + return None + if not row: + return None + token = secrets.token_urlsafe(32) + with self.pool.connection() as conn: + session = conn.execute("INSERT INTO sessions VALUES (%s,%s,clock_timestamp() + %s * interval '1 second') RETURNING expires_at", + (self.token_hash(token), row['id'], int(os.getenv('SESSION_TTL_SECONDS', '3600')))).fetchone() + return {'token': token, 'token_type': 'Bearer', 'expires_at': timestamp(session['expires_at']), 'user': User(**public_row(row)).model_dump()} - # --- Чаты --- + @staticmethod + def token_hash(token): + return hashlib.sha256(token.encode()).hexdigest() - def create_chat(self, title: str, member_ids: list[str], creator_id: str) -> Chat: - """Создать чат. Проверяет существование участников и лимиты.""" - with self._lock: - if len(self._chats) >= self._limits.max_chats: - raise LimitExceeded("превышен лимит чатов") + def session_user(self, token): + with self.pool.connection() as conn: + row = conn.execute('SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at > clock_timestamp()', (self.token_hash(token),)).fetchone() + return str(row['user_id']) if row else None - seen = set() - for mid in member_ids: - if mid not in self._users: - raise ValidationError(f"пользователь {mid} не существует") - if mid in seen: - raise ValidationError("дублирующиеся member_ids") - seen.add(mid) + def logout(self, token): + with self.pool.connection() as conn: + conn.execute('DELETE FROM sessions WHERE token_hash=%s', (self.token_hash(token),)) - if creator_id not in seen: - raise ValidationError("создатель должен входить в member_ids") + def create_chat(self, title, member_ids, creator_id): + if len(set(member_ids)) != len(member_ids) or creator_id not in member_ids: + raise ValidationError('неверный список участников') + chat_id = uuid.uuid4() + try: + with self.pool.connection() as conn: + row = conn.execute('INSERT INTO chats (id,title) VALUES (%s,%s) RETURNING *', (chat_id,title)).fetchone() + for member in member_ids: + conn.execute('INSERT INTO chat_members VALUES (%s,%s)', (chat_id,member)) + return Chat(**public_row(row), member_ids=sorted(member_ids)) + except ForeignKeyViolation: + raise ValidationError('участник не существует') from None - chat = Chat( - id=str(uuid.uuid4()), - title=title, - member_ids=member_ids, - created_at=utc_now(), - ) - self._chats[chat.id] = chat - self._chat_messages[chat.id] = [] - return chat - - def get_chat(self, chat_id: str) -> Chat | None: - """Найти чат по UUID.""" - with self._lock: - return self._chats.get(chat_id) - - def list_chats_for_user(self, user_id: str, cursor: str | None, limit: int) -> tuple[list[Chat], str | None]: - """Список чатов пользователя с курсорной пагинацией.""" - with self._lock: - chats = [ - chat for chat in self._chats.values() - if user_id in chat.member_ids - ] - chats.sort(key=lambda c: (c.created_at, c.id)) + def get_chat(self, chat_id): + with self.pool.connection() as conn: + row = conn.execute('SELECT * FROM chats WHERE id=%s', (chat_id,)).fetchone() + if not row: + return None + members = conn.execute('SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id', (chat_id,)).fetchall() + return Chat(**public_row(row), member_ids=[str(x['user_id']) for x in members]) + def list_chats_for_user(self, user_id, cursor, limit): + with self.pool.connection() as conn: + params = [user_id] + boundary = '' if cursor is not None: - cursor_time, cursor_id = self._decode_cursor(cursor, "chats", user_id) - cursor_chat = self._chats.get(cursor_id) - if ( - cursor_chat is None - or user_id not in cursor_chat.member_ids - or cursor_chat.created_at != cursor_time - ): - raise ValidationError("некорректный cursor") - chats = [ - c for c in chats - if (c.created_at, c.id) > (cursor_time, cursor_id) - ] + when, item = self._decode_cursor(cursor, 'chats', user_id) + marker = conn.execute('SELECT c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s', (item,user_id)).fetchone() + if not marker or timestamp(marker['created_at']) != when: + raise ValidationError('некорректный cursor') + boundary = ' AND (c.created_at,c.id) > (%s,%s)' + params += [when,item] + rows = conn.execute('SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s' + boundary + ' ORDER BY c.created_at,c.id LIMIT %s', params+[limit+1]).fetchall() + page = [self.get_chat(str(row['id'])) for row in rows[:limit]] + next_cursor = self._encode_cursor('chats',user_id,page[-1].created_at,page[-1].id) if len(rows)>limit else None + return page,next_cursor - page = chats[:limit] - next_cursor = None - if len(page) == limit and len(chats) > limit: - last = page[-1] - next_cursor = self._encode_cursor("chats", user_id, last.created_at, last.id) - - return page, next_cursor - - # --- Сообщения --- - - def _refill_message_tokens(self): - """Пополнить токены bucket'а пропорционально прошедшему времени.""" - now = time.monotonic() - elapsed = now - self._last_token_update - if elapsed > 0: - self._message_tokens = min( - self._limits.max_messages_per_second, - self._message_tokens + elapsed * self._limits.max_messages_per_second, - ) - self._last_token_update = now - - def acquire_message_token(self) -> bool: - """Попытаться взять токен из bucket'а для отправки сообщения. - - Возвращает True, если токен есть и сообщение можно отправить. - False означает превышение rate limit → 429. - """ - with self._lock: - self._total_message_attempts += 1 - self._refill_message_tokens() - if self._message_tokens >= 1.0: - self._message_tokens -= 1.0 - return True - self._rate_limited_count += 1 - return False - - def create_message(self, chat_id: str, sender_id: str, text: str) -> Message: - """Отправить сообщение. Проверяет лимиты и права доступа.""" - with self._lock: - chat = self._chats.get(chat_id) - if not chat: - raise NotFoundError("чат не найден") - if sender_id not in chat.member_ids: - raise NotFoundError("чат не найден") - - chat_msg_ids = self._chat_messages.get(chat_id, []) - if len(chat_msg_ids) >= self._limits.max_messages_per_chat: - raise LimitExceeded("превышен лимит сообщений в чате") - if len(self._messages) >= self._limits.max_messages_total: - raise LimitExceeded("превышен общий лимит сообщений") - - # Проверяем rate limit (сообщений в секунду) - if not self.acquire_message_token(): - raise LimitExceeded("превышен лимит сообщений в секунду") - - msg = Message( - id=str(uuid.uuid4()), - chat_id=chat_id, - sender_id=sender_id, - text=text, - created_at=utc_now(), - ) - self._messages[msg.id] = msg - chat_msg_ids.append(msg.id) - return msg - - def list_messages(self, chat_id: str, cursor: str | None, limit: int) -> tuple[list[Message], str | None]: - """История сообщений чата с курсорной пагинацией.""" - with self._lock: - chat_msg_ids = self._chat_messages.get(chat_id, []) - messages = [self._messages[mid] for mid in chat_msg_ids] - messages.sort(key=lambda m: (m.created_at, m.id)) + def create_message(self, chat_id, sender_id, text): + with self.pool.connection() as conn: + row = conn.execute('INSERT INTO messages (id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *', (uuid.uuid4(),chat_id,sender_id,text)).fetchone() + return Message(**public_row(row)) + def list_messages(self, chat_id, cursor, limit): + with self.pool.connection() as conn: + params = [chat_id] + boundary = '' if cursor is not None: - cursor_time, cursor_id = self._decode_cursor(cursor, "messages", chat_id) - cursor_message = self._messages.get(cursor_id) - if ( - cursor_message is None - or cursor_message.chat_id != chat_id - or cursor_message.created_at != cursor_time - ): - raise ValidationError("некорректный cursor") - messages = [ - m for m in messages - if (m.created_at, m.id) > (cursor_time, cursor_id) - ] + when,item = self._decode_cursor(cursor,'messages',chat_id) + marker = conn.execute('SELECT created_at FROM messages WHERE id=%s AND chat_id=%s', (item,chat_id)).fetchone() + if not marker or timestamp(marker['created_at']) != when: + raise ValidationError('некорректный cursor') + boundary = ' AND (created_at,id) > (%s,%s)' + params += [when,item] + rows = conn.execute('SELECT * FROM messages WHERE chat_id=%s' + boundary + ' ORDER BY created_at,id LIMIT %s', params+[limit+1]).fetchall() + page = [Message(**public_row(row)) for row in rows[:limit]] + next_cursor = self._encode_cursor('messages',chat_id,page[-1].created_at,page[-1].id) if len(rows)>limit else None + return page,next_cursor - page = messages[:limit] - next_cursor = None - if len(page) == limit and len(messages) > limit: - last = page[-1] - next_cursor = self._encode_cursor("messages", chat_id, last.created_at, last.id) + def ready(self): + with self.pool.connection() as conn: + conn.execute('SELECT 1 FROM schema_migrations LIMIT 1') - return page, next_cursor - - # --- Очередь запросов (трек 2: управляемая деградация) --- - - def acquire_request_slot(self) -> bool: - """Занять слот в очереди запросов. False = переполнение → 503.""" + def acquire_request_slot(self): with self._lock: - if self._request_count >= self._limits.max_request_queue: + if self._requests >= 100: return False - self._request_count += 1 + self._requests += 1 return True def release_request_slot(self): - """Освободить слот в очереди запросов.""" with self._lock: - self._request_count = max(0, self._request_count - 1) + self._requests -= 1 - # --- Статистика --- - - def get_stats(self) -> dict: - """Текущая статистика хранилища и метрики деградации.""" - with self._lock: - self._refill_message_tokens() - return { - "users": len(self._users), - "chats": len(self._chats), - "messages": len(self._messages), - "requests_in_flight": self._request_count, - "rate_limit": { - "max_messages_per_second": self._limits.max_messages_per_second, - "available_tokens": round(self._message_tokens, 2), - }, - "metrics": { - "total_message_attempts": self._total_message_attempts, - "rate_limited_count": self._rate_limited_count, - }, - } + def get_stats(self): + with self.pool.connection() as conn: + return {table: conn.execute('SELECT count(*) AS n FROM '+table).fetchone()['n'] for table in ('users','chats','messages')} -class ValidationError(Exception): - """Неверные входные данные — HTTP 400.""" - pass - - -class NotFoundError(Exception): - """Ресурс не найден или недоступен — HTTP 404.""" - pass - - -class ConflictError(Exception): - """Конфликт, например дублирующийся username — HTTP 409.""" - pass - - -class LimitExceeded(Exception): - """Превышен лимит ресурсов — HTTP 429 или 503.""" - pass - - -# Единственное хранилище на весь процесс -storage = InMemoryStorage() +storage = PostgresStorage() diff --git a/student-tests/README.md b/student-tests/README.md new file mode 100644 index 00000000..265b2559 --- /dev/null +++ b/student-tests/README.md @@ -0,0 +1,2 @@ +# Собственные проверки лабораторной 2 +Исходные test_lab1.py, test_degradation.py и metrics_collector.py перенесены как история реализации lab1 и не являются проверками lab2: в них используется X-User-Id. Актуальные проверки lab2 описаны в REPORT.md. diff --git a/student-tests/test_lab2.py b/student-tests/test_lab2.py new file mode 100644 index 00000000..eeabd214 --- /dev/null +++ b/student-tests/test_lab2.py @@ -0,0 +1,43 @@ +"""Негативные сценарии, курсоры и конкурентная запись через реальный HTTP API.""" +import concurrent.futures +import sys +import uuid +from pathlib import Path +from urllib.parse import quote +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'tests')) +from client import Client, arguments, check, run + + +def main(): + args=arguments('Собственные проверки лабораторной 2') + c=Client(args.base_url,args.ca_file) + alice,bob,eve,chat=c.bootstrap() + path='/api/v1/chats/'+chat['id']+'/messages' + c.call('POST','/api/v1/users',400,body={'username':'short','display_name':'Тест','password':'short'}) + c.call('POST',path,400,actor=alice,body={'text':'hello','sender_id':bob['id']}) + c.call('POST',path,400,actor=alice,body={'text':' '}) + c.call('GET','/api/v1/chats/not-a-uuid',400,actor=alice) + c.call('POST',path,404,actor=eve,body={'text':'чужое'}) + with concurrent.futures.ThreadPoolExecutor(max_workers=10) as pool: + sent=list(pool.map(lambda i: c.message(alice,chat,'Параллельное '+str(i))['json'],range(100))) + expected={m['id'] for m in sent} + received=[] + cursor=None + while True: + url=path+'?limit=7'+('&cursor='+quote(cursor,safe='') if cursor else '') + page=c.call('GET',url,actor=bob,schema='MessagePage')['json'] + received.extend(m['id'] for m in page['items']) + cursor=page['next_cursor'] + if cursor is None: + break + check(len(received)==100 and set(received)==expected,'потеря или дубликат сообщения') + page=c.call('GET',path+'?limit=1',actor=alice,schema='MessagePage')['json'] + other=c.call('POST','/api/v1/chats',201,actor=alice,body={'title':'Другой','member_ids':[alice['id']]},schema='Chat')['json'] + c.call('GET','/api/v1/chats/'+other['id']+'/messages?cursor='+quote(page['next_cursor'],safe=''),400,actor=alice) + for bad in ['', 'not-base64', 'e30=']: + c.call('GET',path+'?cursor='+quote(bad,safe=''),400,actor=alice) + print('PASS: strict validation, access, cursor binding, 100 messages / 10 clients, complete pagination') + + +if __name__=='__main__': + run(main)