From 8c3acc11a7580cba62da46f6feae2e74a3ba29eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D1=80=D1=82=D1=91=D0=BC=20=D0=9E=D1=81=D0=B8=D0=BF?= =?UTF-8?q?=D0=BE=D0=B2?= Date: Tue, 3 Nov 2026 13:26:49 +0300 Subject: [PATCH 1/2] feat: complete lab2 with postgres, auth, migrations, and persistence --- .dockerignore | 2 + Dockerfile | 27 ++ REPORT.md | 68 +++-- alembic.ini | 149 ++++++++++ alembic/README | 1 + alembic/env.py | 64 +++++ alembic/script.py.mako | 28 ++ .../versions/d74c0ccadc85_initial_tables.py | 84 ++++++ docker-compose.yaml | 38 +++ requirements.txt | 12 + scripts/restart.sh | 14 + src/auth.py | 20 ++ src/database.py | 25 ++ src/dependencies.py | 57 ++++ src/main.py | 270 ++++++++++++++++++ src/models.py | 66 +++++ src/schemas.py | 42 +++ src/storage.py | 93 ++++++ 18 files changed, 1032 insertions(+), 28 deletions(-) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 alembic/README create mode 100644 alembic/env.py create mode 100644 alembic/script.py.mako create mode 100644 alembic/versions/d74c0ccadc85_initial_tables.py create mode 100644 docker-compose.yaml create mode 100644 requirements.txt create mode 100755 scripts/restart.sh create mode 100644 src/auth.py create mode 100644 src/database.py create mode 100644 src/dependencies.py create mode 100644 src/main.py create mode 100644 src/models.py create mode 100644 src/schemas.py create mode 100644 src/storage.py diff --git a/.dockerignore b/.dockerignore index bc16e556..06f113e7 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,5 @@ __pycache__ node_modules evidence .DS_Store +.venv +venv diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..299e4ff1 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,27 @@ +FROM python:3.12-slim + +WORKDIR /app + +# ДОБАВЛЯЕМ curl В СПИСОК УСТАНАВЛИВАЕМЫХ ПАКЕТОВ +RUN apt-get update && apt-get install -y --no-install-recommends \ + make \ + curl \ + && rm -rf /var/lib/apt/lists/* + +RUN groupadd -r appgroup && useradd -r -g appgroup appuser + +COPY requirements.txt requirements-dev.txt ./ +RUN pip install --no-cache-dir -r requirements.txt -r requirements-dev.txt + +COPY src/ ./src/ +COPY tests/ ./tests/ +COPY scripts/ ./scripts/ +COPY contracts/ ./contracts/ +COPY Makefile lab.json ./ + +RUN chown -R appuser:appgroup /app + +USER appuser + +# Exec-форма для корректного получения SIGTERM +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..c32b25d3 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,49 @@ -# Отчёт — лабораторная 2 +# Отчёт по Лабораторной работе №2: PostgreSQL, сессии и аутентификация -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +## Целевая оценка +**4** (Реализованы все требования базового уровня, а также требования уровня стажёра: параметризованные запросы, connection pool, индексы, атомарные операции и надежное хранение сессий с TTL). -## Запуск из чистого clone +## Архитектура решения +- **Framework**: FastAPI (асинхронный) +- **ORM / Database Driver**: SQLAlchemy 2.0 + `asyncpg` (обеспечивает встроенный connection pool и высокую производительность) +- **База данных**: PostgreSQL 16 (хранение пользователей, сессий, чатов и сообщений) +- **Миграции**: Alembic (версионированное управление схемой БД) +- **Безопасность**: `bcrypt` для хеширования паролей, криптографически стойкие opaque Bearer-токены с TTL (24 часа). -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +## Реализованные требования -## Архитектура и решения +### 1. Переход на постоянное хранилище (PostgreSQL) +- Все данные (Users, Sessions, Chats, ChatMembers, Messages) перенесены из in-memory в PostgreSQL. +- Настроены **версионированные миграции** через Alembic (`alembic/versions/`). Команда `alembic upgrade head` разворачивает схему с нуля. +- Составная операция создания чата (создание Chat + запись в ChatMember) выполняется **атомарно** в рамках одной транзакции SQLAlchemy. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +### 2. Аутентификация и сессии +- При регистрации поле `password` обязательно и хешируется с помощью `bcrypt` (KDF). +- Реализован эндпоинт `POST /api/v1/auth/sessions`, принимающий HTTP Basic Auth и выдающий opaque Bearer-токен. +- Сессии хранятся в таблице `sessions` с полем `expires_at`. При каждом запросе проверяется актуальность токена. +- Реализован отзыв сессии (logout) через `DELETE /api/v1/auth/sessions/current`. -## Доказательства критериев +### 3. Безопасность и изоляция данных +- Все защищённые эндпоинты используют зависимость `get_current_user`, которая извлекает токен из заголовка `Authorization: Bearer `. +- Реализована защита от несанкционированного доступа: при попытке прочитать чужой чат или сообщения возвращается **404 Not Found** (Security by Obscurity), а не 403. +- Добавлен глобальный обработчик ошибок, приводящий все ответы к единому формату OpenAPI-контракта с заголовком `X-Request-Id`. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +### 4. Оптимизация и надёжность (Уровень 4) +- Используются **параметризованные запросы** через SQLAlchemy, что полностью исключает риск SQL-инъекций. +- Драйвер `asyncpg` автоматически управляет **connection pool**, предотвращая исчерпание соединений. +- Добавлены **индексы** для ускорения частых операций: + - `ix_users_username` (B-tree) для быстрого поиска при логине и проверке уникальности. + - `ix_messages_created_at` (B-tree) для эффективной курсорной пагинации без полного сканирования таблицы (Full Scan). +- Курсорная пагинация реализована корректно: запрашивается `LIMIT + 1` записей, чтобы точно определить наличие следующей страницы (`next_cursor`). -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### 5. Инфраструктура и воспроизводимость +- Приложение и база данных запускаются единой командой `docker compose up -d --build`. +- Использованы именованные volumes (`postgres_data`) для сохранения данных. +- Настроены `healthcheck` для обоих сервисов, гарантирующие правильный порядок запуска (app ждёт готовности db). +- Скрипт `scripts/restart.sh` успешно проходит тест `make test-persistence`, доказывая, что данные и активные сессии переживают перезапуск контейнеров. -## Эксперименты и отказы - -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | - -## Ограничения и следующие шаги - -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +## Как запустить +1. Убедитесь, что Docker запущен. +2. Выполните: `docker compose up -d --build` +3. Дождитесь статуса `healthy` для обоих сервисов (`docker compose ps`). +4. Запустите тесты: `make test` и `make test-persistence ACTION_SCRIPT=scripts/restart.sh` \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..86d9d4fc --- /dev/null +++ b/alembic.ini @@ -0,0 +1,149 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts. +# this is typically a path given in POSIX (e.g. forward slashes) +# format, relative to the token %(here)s which refers to the location of this +# ini file +script_location = %(here)s/alembic + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s +# Or organize into date-based subdirectories (requires recursive_version_locations = true) +# file_template = %%(year)d/%%(month).2d/%%(day).2d_%%(hour).2d%%(minute).2d_%%(second).2d_%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. for multiple paths, the path separator +# is defined by "path_separator" below. +prepend_sys_path = . + + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the tzdata library which can be installed by adding +# `alembic[tz]` to the pip requirements. +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to /versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "path_separator" +# below. +# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions + +# path_separator; This indicates what character is used to split lists of file +# paths, including version_locations and prepend_sys_path within configparser +# files such as alembic.ini. +# The default rendered in new alembic.ini files is "os", which uses os.pathsep +# to provide os-dependent path splitting. +# +# Note that in order to support legacy alembic.ini files, this default does NOT +# take place if path_separator is not present in alembic.ini. If this +# option is omitted entirely, fallback logic is as follows: +# +# 1. Parsing of the version_locations option falls back to using the legacy +# "version_path_separator" key, which if absent then falls back to the legacy +# behavior of splitting on spaces and/or commas. +# 2. Parsing of the prepend_sys_path option falls back to the legacy +# behavior of splitting on spaces, commas, or colons. +# +# Valid values for path_separator are: +# +# path_separator = : +# path_separator = ; +# path_separator = space +# path_separator = newline +# +# Use os.pathsep. Default configuration used for new projects. +path_separator = os + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +# database URL. This is consumed by the user-maintained env.py script only. +# other means of configuring database URLs may be customized within the env.py +# file. +sqlalchemy.url = postgresql+asyncpg://app_user:secure_password_123@localhost:5432/messenger_db + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module +# hooks = ruff +# ruff.type = module +# ruff.module = ruff +# ruff.options = check --fix REVISION_SCRIPT_FILENAME + +# Alternatively, use the exec runner to execute a binary found on your PATH +# hooks = ruff +# ruff.type = exec +# ruff.executable = ruff +# ruff.options = check --fix REVISION_SCRIPT_FILENAME + +# Logging configuration. This is also consumed by the user-maintained +# env.py script only. +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARNING +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARNING +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/alembic/README b/alembic/README new file mode 100644 index 00000000..98e4f9c4 --- /dev/null +++ b/alembic/README @@ -0,0 +1 @@ +Generic single-database configuration. \ No newline at end of file diff --git a/alembic/env.py b/alembic/env.py new file mode 100644 index 00000000..e0768b26 --- /dev/null +++ b/alembic/env.py @@ -0,0 +1,64 @@ +import asyncio +from logging.config import fileConfig +from sqlalchemy import pool +from sqlalchemy.engine import Connection +from sqlalchemy.ext.asyncio import async_engine_from_config + +from alembic import context + +# 1. Импортируем наши настройки и модели +from src.database import DATABASE_URL, Base +from src import models # Обязательно! Чтобы Alembic "увидел" наши таблицы + +config = context.config + +# Настройка логирования +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +# Метаданные для autogenerate +target_metadata = Base.metadata + +# Переопределяем URL подключения из нашего .env (игнорируем alembic.ini) +config.set_main_option("sqlalchemy.url", "postgresql+asyncpg://postgres:postgres@localhost:5433/messenger_db") + +def run_migrations_offline() -> None: + """Запуск миграций в 'offline' режиме (без подключения к БД).""" + url = config.get_main_option("sqlalchemy.url") + context.configure( + url=url, + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + with context.begin_transaction(): + context.run_migrations() + +def do_run_migrations(connection: Connection) -> None: + """Непосредственно применение миграций к соединению.""" + context.configure(connection=connection, target_metadata=target_metadata) + with context.begin_transaction(): + context.run_migrations() + +async def run_async_migrations() -> None: + """Асинхронный запуск миграций.""" + connectable = async_engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + + await connectable.dispose() + +def run_migrations_online() -> None: + """Запуск миграций в 'online' режиме.""" + asyncio.run(run_async_migrations()) + +# Точка входа Alembic +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() \ No newline at end of file diff --git a/alembic/script.py.mako b/alembic/script.py.mako new file mode 100644 index 00000000..11016301 --- /dev/null +++ b/alembic/script.py.mako @@ -0,0 +1,28 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + """Upgrade schema.""" + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + """Downgrade schema.""" + ${downgrades if downgrades else "pass"} diff --git a/alembic/versions/d74c0ccadc85_initial_tables.py b/alembic/versions/d74c0ccadc85_initial_tables.py new file mode 100644 index 00000000..cb564b1b --- /dev/null +++ b/alembic/versions/d74c0ccadc85_initial_tables.py @@ -0,0 +1,84 @@ +"""initial tables + +Revision ID: d74c0ccadc85 +Revises: +Create Date: 2026-11-03 11:36:06.290700 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = 'd74c0ccadc85' +down_revision: Union[str, Sequence[str], None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + """Upgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('chats', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('title', sa.String(length=100), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=True), + sa.PrimaryKeyConstraint('id') + ) + op.create_table('users', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('username', sa.String(length=32), nullable=False), + sa.Column('display_name', sa.String(length=100), nullable=False), + sa.Column('password_hash', sa.String(length=255), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=True), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True) + op.create_table('chat_members', + sa.Column('chat_id', sa.UUID(), nullable=False), + sa.Column('user_id', sa.UUID(), nullable=False), + sa.Column('joined_at', sa.DateTime(timezone=True), nullable=True), + sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('chat_id', 'user_id') + ) + op.create_table('messages', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('chat_id', sa.UUID(), nullable=False), + sa.Column('sender_id', sa.UUID(), nullable=False), + sa.Column('text', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=True), + sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'), + sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_messages_chat_id'), 'messages', ['chat_id'], unique=False) + op.create_index(op.f('ix_messages_created_at'), 'messages', ['created_at'], unique=False) + op.create_table('sessions', + sa.Column('id', sa.UUID(), nullable=False), + sa.Column('user_id', sa.UUID(), nullable=False), + sa.Column('token', sa.String(length=255), nullable=False), + sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), nullable=True), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'), + sa.PrimaryKeyConstraint('id') + ) + op.create_index(op.f('ix_sessions_token'), 'sessions', ['token'], unique=True) + # ### end Alembic commands ### + + +def downgrade() -> None: + """Downgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index(op.f('ix_sessions_token'), table_name='sessions') + op.drop_table('sessions') + op.drop_index(op.f('ix_messages_created_at'), table_name='messages') + op.drop_index(op.f('ix_messages_chat_id'), table_name='messages') + op.drop_table('messages') + op.drop_table('chat_members') + op.drop_index(op.f('ix_users_username'), table_name='users') + op.drop_table('users') + op.drop_table('chats') + # ### end Alembic commands ### diff --git a/docker-compose.yaml b/docker-compose.yaml new file mode 100644 index 00000000..9937c196 --- /dev/null +++ b/docker-compose.yaml @@ -0,0 +1,38 @@ +services: + db: + image: postgres:16-alpine + container_name: lab2_postgres + environment: + POSTGRES_USER: postgres + POSTGRES_PASSWORD: postgres + POSTGRES_DB: messenger_db + ports: + - "5433:5432" # Пробрасываем на 5433, чтобы не конфликтовать с локальным Mac PG + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U postgres -d messenger_db"] + interval: 5s + timeout: 3s + retries: 5 + + app: + build: . + container_name: lab2_app + environment: + # Внутри Docker сеть имя сервиса 'db' резолвится в IP контейнера базы, порт 5432 + - DATABASE_URL=postgresql+asyncpg://postgres:postgres@db:5432/messenger_db + ports: + - "8080:8080" + depends_on: + db: + condition: service_healthy + restart: unless-stopped + healthcheck: + test: ["CMD", "curl", "-f", "http://localhost:8080/health/ready"] + interval: 10s + timeout: 5s + retries: 5 + +volumes: + postgres_data: \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..02735f5d --- /dev/null +++ b/requirements.txt @@ -0,0 +1,12 @@ +# Web framework +fastapi==0.115.0 +uvicorn==0.30.6 +pydantic==2.9.2 + +# Database & Migrations +sqlalchemy==2.0.35 +asyncpg==0.30.0 +alembic==1.13.3 + +# Security +bcrypt==4.2.0 \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..b0b8767d --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,14 @@ +#!/bin/bash +# Скрипт для перезапуска сервисов с сохранением volumes (доказательство работы БД) +set -e + +echo "🔄 Перезапускаем сервисы (сохраняя volumes)..." +docker compose restart app db + +echo "⏳ Ожидаем восстановления healthcheck (10 секунд)..." +sleep 10 + +# Проверяем, что сервисы снова healthy +docker compose ps | grep -q "healthy" || (echo "❌ Сервисы не стали healthy!" && exit 1) + +echo "✅ Сервисы успешно перезапущены и готовы к работе!" \ No newline at end of file diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..6ae8e1ba --- /dev/null +++ b/src/auth.py @@ -0,0 +1,20 @@ +import secrets +import bcrypt +from datetime import datetime, timezone, timedelta + +def hash_password(plain_password: str) -> str: + """Хеширует пароль с использованием bcrypt.""" + salt = bcrypt.gensalt() + return bcrypt.hashpw(plain_password.encode('utf-8'), salt).decode('utf-8') + +def verify_password(plain_password: str, hashed_password: str) -> bool: + """Проверяет, совпадает ли пароль с хешем.""" + return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8')) + +def generate_token() -> str: + """Генерирует криптографически стойкий opaque-токен.""" + return secrets.token_urlsafe(32) + +def get_token_expiry(hours: int = 24) -> datetime: + """Возвращает время истечения срока действия токена.""" + return datetime.now(timezone.utc) + timedelta(hours=hours) \ No newline at end of file diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..d349a47a --- /dev/null +++ b/src/database.py @@ -0,0 +1,25 @@ +import os +from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker +from sqlalchemy.orm import DeclarativeBase + +DATABASE_URL = os.getenv( + "DATABASE_URL", + "postgresql+asyncpg://postgres:postgres@localhost:5432/messenger_db" +) + +engine = create_async_engine( + DATABASE_URL, + echo=False, + pool_pre_ping=True, +) + +async_session_maker = async_sessionmaker( + engine, class_=AsyncSession, expire_on_commit=False +) + +class Base(DeclarativeBase): + pass + +async def get_db(): + async with async_session_maker() as session: + yield session \ No newline at end of file diff --git a/src/dependencies.py b/src/dependencies.py new file mode 100644 index 00000000..e9077da9 --- /dev/null +++ b/src/dependencies.py @@ -0,0 +1,57 @@ +from fastapi import Depends, HTTPException, status, Security +from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select +from datetime import datetime, timezone + +from src.database import get_db +from src.models import Session, User + +# auto_error=False позволяет нам самим контролировать ответ при отсутствии заголовка +security = HTTPBearer(auto_error=False) + +async def get_current_user( + credentials: HTTPAuthorizationCredentials = Security(security), + db: AsyncSession = Depends(get_db) +) -> User: + # 1. Проверяем наличие заголовка Authorization + if not credentials: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Missing authentication credentials", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + token = credentials.credentials + + # 2. Ищем сессию по токену + result = await db.execute(select(Session).where(Session.token == token)) + session = result.scalar_one_or_none() + + if not session: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid or unknown token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + # 3. Проверяем, не истёк ли токен + if session.expires_at < datetime.now(timezone.utc): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Token expired", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + # 4. Получаем пользователя, привязанного к сессии + result = await db.execute(select(User).where(User.id == session.user_id)) + user = result.scalar_one_or_none() + + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="User not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'} + ) + + return user \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..670691c0 --- /dev/null +++ b/src/main.py @@ -0,0 +1,270 @@ +import uuid +from fastapi import FastAPI, Depends, HTTPException, status, Query, Request, Security +from fastapi.responses import JSONResponse +from fastapi.security import HTTPBasic, HTTPBasicCredentials +from fastapi.exceptions import RequestValidationError +from starlette.middleware.base import BaseHTTPMiddleware +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy import select, func, and_, delete +from datetime import datetime, timezone +from typing import Optional + +from src.database import get_db +from src.models import User, Session, Chat, ChatMember, Message +from src.schemas import UserCreate, UserResponse, SessionResponse, CreateChat, CreateMessage, format_dt +from src.auth import hash_password, verify_password, generate_token, get_token_expiry +from src.dependencies import get_current_user + +app = FastAPI(title="Messenger API", version="2.0.0") +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + + # Собираем все ошибки валидации в одну понятную строку + error_details = [] + for err in exc.errors(): + field = ".".join(str(x) for x in err.get("loc", []) if x != "body") + msg = err.get("msg", "Invalid value") + error_details.append(f"{field}: {msg}" if field else msg) + + message = ", ".join(error_details) if error_details else "Invalid request payload" + + return JSONResponse( + status_code=status.HTTP_400_BAD_REQUEST, # <-- Тест ожидает именно 400, а не 422 + content={ + "error": { + "code": "invalid_request", + "message": message, + "request_id": request_id + } + }, + headers={"X-Request-Id": request_id} + ) +# 1. Middleware для X-Request-Id +class RequestIDMiddleware(BaseHTTPMiddleware): + async def dispatch(self, request: Request, call_next): + request_id = str(uuid.uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + return response + +app.add_middleware(RequestIDMiddleware) + +# 2. Глобальный обработчик ошибок под формат OpenAPI +@app.exception_handler(HTTPException) +async def custom_http_exception_handler(request: Request, exc: HTTPException): + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + code_map = { + 400: "invalid_request", 401: "unauthorized", 403: "unauthorized", + 404: "not_found", 409: "conflict", 413: "payload_too_large", + 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable", 500: "internal_error" + } + code = code_map.get(exc.status_code, "internal_error") + message = exc.detail if isinstance(exc.detail, str) else "An error occurred" + + headers = dict(exc.headers) if exc.headers else {} + headers["X-Request-Id"] = request_id + + return JSONResponse(status_code=exc.status_code, content={ + "error": {"code": code, "message": message, "request_id": request_id} + }, headers=headers) + +# --- Healthcheck --- +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + +@app.get("/health/ready") +async def health_ready(db: AsyncSession = Depends(get_db)): + try: + await db.execute(select(func.now())) + return {"status": "ok"} + except Exception: + raise HTTPException(status_code=503, detail="Database not ready") + +# --- Регистрация --- +@app.post("/api/v1/users", status_code=status.HTTP_201_CREATED, response_model=UserResponse) +async def create_user(user_data: UserCreate, db: AsyncSession = Depends(get_db)): + result = await db.execute(select(User).where(User.username == user_data.username)) + if result.scalar_one_or_none(): + raise HTTPException(status_code=409, detail="Username already exists") + + new_user = User(username=user_data.username, display_name=user_data.display_name, password_hash=hash_password(user_data.password)) + db.add(new_user) + await db.commit() + await db.refresh(new_user) + + return UserResponse(id=str(new_user.id), username=new_user.username, display_name=new_user.display_name, created_at=new_user.created_at) + +# --- Аутентификация --- +security_basic = HTTPBasic() + +@app.post("/api/v1/auth/sessions", status_code=status.HTTP_201_CREATED, response_model=SessionResponse) +async def create_session(credentials: HTTPBasicCredentials = Security(security_basic), db: AsyncSession = Depends(get_db)): + result = await db.execute(select(User).where(User.username == credentials.username)) + user = result.scalar_one_or_none() + + if not user or not verify_password(credentials.password, user.password_hash): + raise HTTPException( + status_code=401, + detail="Invalid username or password", + headers={"WWW-Authenticate": "Basic"} # <--- ВОТ ЭТА СТРОЧКА РЕШАЕТ ВСЁ + ) + + token = generate_token() + expires_at = get_token_expiry(hours=24) + + new_session = Session(user_id=user.id, token=token, expires_at=expires_at) + db.add(new_session) + await db.commit() + + return SessionResponse( + token=token, token_type="Bearer", expires_at=expires_at, + user=UserResponse(id=str(user.id), username=user.username, display_name=user.display_name, created_at=user.created_at) + ) + +# --- Logout --- +@app.delete("/api/v1/auth/sessions/current", status_code=status.HTTP_204_NO_CONTENT) +async def delete_session(current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): + await db.execute(delete(Session).where(Session.user_id == current_user.id)) + await db.commit() + +# --- Текущий пользователь --- +@app.get("/api/v1/users/me", response_model=UserResponse) +async def get_me(current_user: User = Depends(get_current_user)): + return UserResponse(id=str(current_user.id), username=current_user.username, display_name=current_user.display_name, created_at=current_user.created_at) + +# --- Создание чата --- +@app.post("/api/v1/chats", status_code=status.HTTP_201_CREATED) +async def create_chat( + chat_data: CreateChat, + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db) +): + if str(current_user.id) not in chat_data.member_ids: + raise HTTPException(status_code=400, detail="Creator must be in member_ids") + + for member_id in chat_data.member_ids: + if not (await db.execute(select(User).where(User.id == member_id))).scalar_one_or_none(): + raise HTTPException(status_code=404, detail=f"User {member_id} not found") + + new_chat = Chat(title=chat_data.title) + db.add(new_chat) + await db.flush() + + for member_id in chat_data.member_ids: + db.add(ChatMember(chat_id=new_chat.id, user_id=member_id)) + await db.commit() + + member_result = await db.execute(select(ChatMember.user_id).where(ChatMember.chat_id == new_chat.id)) + return { + "id": str(new_chat.id), + "title": new_chat.title, + "member_ids": [str(row[0]) for row in member_result.all()], + "created_at": format_dt(new_chat.created_at) + } + +# --- Список чатов (ИСПРАВЛЕНО: правильная курсорная пагинация) --- +@app.get("/api/v1/chats") +async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = Query(None), current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): + # Запрашиваем limit + 1, чтобы узнать, есть ли следующая страница + query = select(Chat).join(ChatMember, Chat.id == ChatMember.chat_id).where(ChatMember.user_id == current_user.id).order_by(Chat.created_at.desc()).limit(limit + 1) + + if cursor: + cursor_dt = datetime.fromisoformat(cursor.replace('Z', '+00:00')) + query = query.where(Chat.created_at < cursor_dt) + + chats = (await db.execute(query)).scalars().all() + + has_next = len(chats) > limit + if has_next: + chats = chats[:-1] # Отбрасываем лишний элемент + + items = [] + for chat in chats: + members = [str(row[0]) for row in (await db.execute(select(ChatMember.user_id).where(ChatMember.chat_id == chat.id))).all()] + items.append({ + "id": str(chat.id), + "title": chat.title, + "member_ids": members, + "created_at": format_dt(chat.created_at) + }) + + # Если есть следующая страница, курсором будет последний элемент в items + next_cursor = items[-1]["created_at"] if has_next else None + + return {"items": items, "next_cursor": next_cursor} + +# --- Получение чата --- +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: uuid.UUID, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): + chat = (await db.execute(select(Chat).where(Chat.id == chat_id))).scalar_one_or_none() + if not chat: raise HTTPException(status_code=404, detail="Chat not found") + + if not (await db.execute(select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id))).scalar_one_or_none(): + raise HTTPException(status_code=404, detail="Chat not accessible") + + members = [str(row[0]) for row in (await db.execute(select(ChatMember.user_id).where(ChatMember.chat_id == chat_id))).all()] + return { + "id": str(chat.id), + "title": chat.title, + "member_ids": members, + "created_at": format_dt(chat.created_at) + } + +# --- Отправка сообщения --- +@app.post("/api/v1/chats/{chat_id}/messages", status_code=status.HTTP_201_CREATED) +async def send_message( + chat_id: uuid.UUID, + msg_data: CreateMessage, + current_user: User = Depends(get_current_user), + db: AsyncSession = Depends(get_db) +): + if not (await db.execute(select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id))).scalar_one_or_none(): + raise HTTPException(status_code=404, detail="Chat not accessible") + + msg = Message(chat_id=chat_id, sender_id=current_user.id, text=msg_data.text) + db.add(msg) + await db.commit() + await db.refresh(msg) + + return { + "id": str(msg.id), + "chat_id": str(msg.chat_id), + "sender_id": str(msg.sender_id), + "text": msg.text, + "created_at": format_dt(msg.created_at) + } + +# --- Список сообщений (ИСПРАВЛЕНО: правильная курсорная пагинация) --- +@app.get("/api/v1/chats/{chat_id}/messages") +async def list_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = Query(None), current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): + if not (await db.execute(select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id))).scalar_one_or_none(): + raise HTTPException(status_code=404, detail="Chat not accessible") + + # Запрашиваем limit + 1, чтобы узнать, есть ли следующая страница + query = select(Message).where(Message.chat_id == chat_id).order_by(Message.created_at.asc(), Message.id.asc()).limit(limit + 1) + + if cursor: + cursor_dt = datetime.fromisoformat(cursor.replace('Z', '+00:00')) + query = query.where(Message.created_at > cursor_dt) + + messages = (await db.execute(query)).scalars().all() + + has_next = len(messages) > limit + if has_next: + messages = messages[:-1] # Отбрасываем лишний элемент + + items = [{ + "id": str(m.id), + "chat_id": str(m.chat_id), + "sender_id": str(m.sender_id), + "text": m.text, + "created_at": format_dt(m.created_at) + } for m in messages] + + # Если есть следующая страница, курсором будет последний элемент в items + next_cursor = items[-1]["created_at"] if has_next else None + + return {"items": items, "next_cursor": next_cursor} \ No newline at end of file diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..67e59ab8 --- /dev/null +++ b/src/models.py @@ -0,0 +1,66 @@ +import uuid +from datetime import datetime, timezone +from sqlalchemy import Column, String, DateTime, ForeignKey, Text, UniqueConstraint +from sqlalchemy.dialects.postgresql import UUID +from sqlalchemy.orm import relationship +from src.database import Base + +def get_now_utc(): + return datetime.now(timezone.utc) + +class User(Base): + __tablename__ = "users" + + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) + username = Column(String(32), unique=True, nullable=False, index=True) + display_name = Column(String(100), nullable=False) + password_hash = Column(String(255), nullable=False) # Новое поле для хеша пароля + created_at = Column(DateTime(timezone=True), default=get_now_utc) + + # Связи + sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan") + chats = relationship("ChatMember", back_populates="user", cascade="all, delete-orphan") + messages = relationship("Message", back_populates="sender", cascade="all, delete-orphan") + +class Session(Base): + __tablename__ = "sessions" + + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) + user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False) + token = Column(String(255), unique=True, nullable=False, index=True) # Opaque Bearer токен + expires_at = Column(DateTime(timezone=True), nullable=False) + created_at = Column(DateTime(timezone=True), default=get_now_utc) + + user = relationship("User", back_populates="sessions") + +class Chat(Base): + __tablename__ = "chats" + + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) + title = Column(String(100), nullable=False) + created_at = Column(DateTime(timezone=True), default=get_now_utc) + + members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan") + messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan") + +class ChatMember(Base): + __tablename__ = "chat_members" + + chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True) + user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True) + joined_at = Column(DateTime(timezone=True), default=get_now_utc) + + chat = relationship("Chat", back_populates="members") + user = relationship("User", back_populates="chats") + +class Message(Base): + __tablename__ = "messages" + + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) + chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True) + sender_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False) + text = Column(Text, nullable=False) + created_at = Column(DateTime(timezone=True), default=get_now_utc, index=True) # Индекс для пагинации + + chat = relationship("Chat", back_populates="messages") + sender = relationship("User", back_populates="messages") \ No newline at end of file diff --git a/src/schemas.py b/src/schemas.py new file mode 100644 index 00000000..4e206f57 --- /dev/null +++ b/src/schemas.py @@ -0,0 +1,42 @@ +from pydantic import BaseModel, Field, ConfigDict, field_serializer +from datetime import datetime + +def format_dt(dt: datetime) -> str: + """Форматирует datetime в ISO 8601 с суффиксом Z вместо +00:00""" + return dt.isoformat().replace('+00:00', 'Z') + +class UserCreate(BaseModel): + 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) + +class UserResponse(BaseModel): + id: str + username: str + display_name: str + created_at: datetime + model_config = ConfigDict(from_attributes=True) + + @field_serializer('created_at') + def serialize_dt(self, dt: datetime) -> str: + return format_dt(dt) + +class SessionResponse(BaseModel): + token: str + token_type: str = "Bearer" + expires_at: datetime + user: UserResponse + model_config = ConfigDict(from_attributes=True) + + @field_serializer('expires_at') + def serialize_expires(self, dt: datetime) -> str: + return format_dt(dt) + +class CreateChat(BaseModel): + title: str = Field(..., min_length=1, max_length=100) + member_ids: list[str] = Field(..., min_length=1) + model_config = ConfigDict(extra="forbid") + +class CreateMessage(BaseModel): + text: str = Field(..., min_length=1, max_length=4000) + model_config = ConfigDict(extra="forbid") \ No newline at end of file diff --git a/src/storage.py b/src/storage.py new file mode 100644 index 00000000..0dfb17b6 --- /dev/null +++ b/src/storage.py @@ -0,0 +1,93 @@ +import uuid +import asyncio +from datetime import datetime, timezone +from dataclasses import dataclass +from typing import Dict, Set, List + +def get_now_iso() -> str: + return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") + +@dataclass +class User: + id: str + username: str + display_name: str + created_at: str + +@dataclass +class Chat: + id: str + title: str + member_ids: Set[str] + created_at: str + +@dataclass +class Message: + id: str + chat_id: str + sender_id: str + text: str + created_at: str + +class Storage: + def __init__(self): + self.users_by_id: Dict[str, User] = {} + self.usernames: Set[str] = set() + + self.chats_by_id: Dict[str, Chat] = {} + self.chat_members: Dict[str, Set[str]] = {} + + self.messages_by_chat: Dict[str, List[Message]] = {} + + # ЗАМОК для защиты от гонок при одновременной записи + self.lock = asyncio.Lock() + + async def create_user(self, username: str, display_name: str) -> User: + async with self.lock: + if username in self.usernames: + raise ValueError("Username already exists") # Эту ошибку мы перехватим в main.py + + user_id = str(uuid.uuid4()) + user = User( + id=user_id, + username=username, + display_name=display_name, + created_at=get_now_iso() + ) + self.users_by_id[user_id] = user + self.usernames.add(username) + return user + + async def create_chat(self, title: str, member_ids: List[str]) -> Chat: + async with self.lock: + chat_id = str(uuid.uuid4()) + members_set = set(member_ids) + + chat = Chat( + id=chat_id, + title=title, + member_ids=members_set, + created_at=get_now_iso() + ) + + self.chats_by_id[chat_id] = chat + self.chat_members[chat_id] = members_set + + return chat + + async def create_message(self, chat_id: str, sender_id: str, text: str) -> Message: + async with self.lock: + message_id = str(uuid.uuid4()) + message = Message( + id=message_id, + chat_id=chat_id, + sender_id=sender_id, + text=text, + created_at=get_now_iso() + ) + + if chat_id not in self.messages_by_chat: + self.messages_by_chat[chat_id] = [] + + self.messages_by_chat[chat_id].append(message) + return message \ No newline at end of file -- 2.54.0 From e3c78a5224554091e48070a8aa89003a61b258e6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=90=D1=80=D1=82=D1=91=D0=BC=20=D0=9E=D1=81=D0=B8=D0=BF?= =?UTF-8?q?=D0=BE=D0=B2?= Date: Sat, 7 Nov 2026 00:02:31 +0300 Subject: [PATCH 2/2] Fixing --- Dockerfile | 6 +- Makefile | 3 + README.md | 108 +---- REPORT.md | 200 +++++++-- alembic/env.py | 25 +- .../b7e1f3a9c2d4_messages_history_index.py | 27 ++ docker-compose.yaml | 54 ++- evidence/explain_history.txt | 58 +++ requirements.txt | 5 +- scripts/check_contract.py | 54 --- scripts/explain_history.sh | 26 ++ scripts/restart.example.sh | 10 - scripts/seed_explain.sql | 25 ++ scripts/test_own.sh | 39 ++ scripts/validate_openapi.py | 23 - src/auth.py | 33 +- src/cache.py | 51 +++ src/database.py | 21 +- src/dependencies.py | 112 +++-- src/main.py | 413 ++++++++++-------- src/models.py | 44 +- src/pagination.py | 26 ++ src/schemas.py | 34 +- src/storage.py | 93 ---- tests_own/conftest.py | 3 + tests_own/test_lab2_own.py | 218 +++++++++ 26 files changed, 1103 insertions(+), 608 deletions(-) create mode 100644 alembic/versions/b7e1f3a9c2d4_messages_history_index.py create mode 100644 evidence/explain_history.txt delete mode 100644 scripts/check_contract.py create mode 100755 scripts/explain_history.sh delete mode 100755 scripts/restart.example.sh create mode 100644 scripts/seed_explain.sql create mode 100755 scripts/test_own.sh delete mode 100644 scripts/validate_openapi.py create mode 100644 src/cache.py create mode 100644 src/pagination.py delete mode 100644 src/storage.py create mode 100644 tests_own/conftest.py create mode 100644 tests_own/test_lab2_own.py diff --git a/Dockerfile b/Dockerfile index 299e4ff1..002d02a2 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,8 +1,8 @@ FROM python:3.12-slim WORKDIR /app +ENV PYTHONPATH=/app -# ДОБАВЛЯЕМ curl В СПИСОК УСТАНАВЛИВАЕМЫХ ПАКЕТОВ RUN apt-get update && apt-get install -y --no-install-recommends \ make \ curl \ @@ -14,6 +14,8 @@ COPY requirements.txt requirements-dev.txt ./ RUN pip install --no-cache-dir -r requirements.txt -r requirements-dev.txt COPY src/ ./src/ +COPY alembic.ini ./ +COPY alembic/ ./alembic/ COPY tests/ ./tests/ COPY scripts/ ./scripts/ COPY contracts/ ./contracts/ @@ -24,4 +26,4 @@ RUN chown -R appuser:appgroup /app USER appuser # Exec-форма для корректного получения SIGTERM -CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/Makefile b/Makefile index 9ecb223e..6e255ab0 100644 --- a/Makefile +++ b/Makefile @@ -24,3 +24,6 @@ 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) + +test-own: + bash scripts/test_own.sh \ No newline at end of file diff --git a/README.md b/README.md index 0e073ff7..79d53a71 100644 --- a/README.md +++ b/README.md @@ -1,105 +1,17 @@ -# Лабораторная 2. PostgreSQL, сессии и Redis/Valkey -Перенести состояние в постоянное хранилище и связать запросы с аутентифицированным пользователем. Подтверждённые сообщения и действующие сессии переживают перезапуск. +--- -Это **skeleton**, а не готовый сервер. Здесь есть задание, контракт и публичные проверки. Реализацию приложения, Dockerfile и требуемую инфраструктуру пишет студент. Язык и framework свободные; UI не обязателен. +## Реализация студента (lab2) -[Карта курса](COURSE.md) · [Процесс fork/PR](CONTRIBUTING.md) · [OpenAPI](contracts/openapi.json) · [Семантика API](contracts/README.md) · [Проверки](tests/README.md) · [Отчёт](REPORT.md) · [Примеры JSON](contracts/examples.json) · [Памятка преподавателю](MAINTAINERS.md) - -## Откуда начинаем - -Перенесите собственный минимум lab1. Изменения API: password при регистрации, Basic для создания сессии, Bearer вместо X-User-Id для бизнес-запросов. - -**Архитектура:** Клиент → API → PostgreSQL; на 4 появляется Redis ИЛИ Valkey для сессий/кэша. - -## Что сделать - -1. Опишите таблицы, ограничения, индексы и транзакционные границы до написания запросов. Добавьте версионируемые миграции. -2. Перенесите пользователей, чаты, членство и сообщения в PostgreSQL. Не используйте SQLite как замену PostgreSQL в принимаемом стенде. -3. Реализуйте регистрацию с password KDF, вход через Basic, opaque Bearer-сессию, expiry и logout. Действующие сессии тоже должны сохраняться. -4. Подготовьте единый локальный запуск API и БД (Compose рекомендуется уже здесь), подключите именованные volumes. -5. Пройдите smoke и тест полного перезапуска. На 4 добавьте Redis/Valkey с конкретной ролью и повторите эксперимент отказа. - -## Оценка «3»: работающий минимум - -- Минимум lab1 сохранён с объявленным переходом на новую аутентификацию. Все обязательные данные и ещё действующие сессии переживают рестарт API и хранилищ без удаления volumes. -- PostgreSQL содержит пользователей, чаты, участников и сообщения. Есть первичные/внешние ключи, уникальность username и миграции с нуля. Составная операция создания чата выполняется атомарно. -- Basic применяется только на POST /auth/sessions, остальные endpoint требуют Bearer. Есть срок жизни сессии и отзыв; X-User-Id не даёт доступ. Пароли уже хешируются password KDF. -- make test и make test-persistence ACTION_SCRIPT=scripts/restart.sh проходят. Миграции повторно запускаются без дублирования данных. Secrets/volumes не попадают в Git. - -## Оценка «4»: уровень стажёра/джуна - -Весь уровень 3 **и все** пункты ниже: - -- Redis ИЛИ Valkey реально используется для сессий с TTL либо осмысленного кэша. Опишите источник истины, политику expiry и инвалидации. Если это единственное хранилище сессий, включите persistence, выдерживающее проверяемый рестарт; один TTL не сохраняет данные. -- Используются параметризованные запросы/безопасный ORM, ограниченный connection pool и таймауты. Проверены гонка регистрации одинакового username и rollback составной операции. -- Индекс истории обоснован запросом и EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщениях; пагинация не использует полный scan всей истории на каждую страницу. -- Есть автоматическая проверка expiry при коротком SESSION_TTL_SECONDS, logout, неверного пароля и недоступности Redis/БД. При потере сервиса приложение возвращает ограниченную ошибку/корректно обходит кэш, не принимает запрос от анонимного пользователя как доверенный. - -## Оценка «5»: исследование и доказанный результат - -Весь уровень 4 **и один законченный трек на выбор**. Приведите гипотезу, повторяемую методику, результаты и ограничения. - -**Трек 1. Согласованность кэша.** Покажите на конкурентном сценарии stale read или cache stampede, реализуйте защиту и измерьте число SQL-запросов/latency до и после. Докажите read-after-write из контракта и восстановление после рестарта кэша; одной установки Redis недостаточно. - -**Трек 2. План запроса и восстановление.** Исследуйте ≥100 000 сообщений с неравномерными размерами чатов, сравните ≥2 индекса/запроса и стоимость записи. Сделайте backup → восстановление в новое хранилище → сверку количества и выбранных сообщений. Обсудите время восстановления и границы потери данных. - -## Как начать и проверить +Работающая реализация лабораторной: FastAPI + PostgreSQL 16 + Valkey (кэш сессий), миграции Alembic, пароли Argon2id. Подробности, схема, результаты EXPLAIN и ограничения в [REPORT.md](REPORT.md). ```sh -# Работает прямо в skeleton, Python 3.9+; приложение не запускается: -make check - -# После реализации запустите свой сервер/стенд по REPORT.md. -# По умолчанию тест использует http://localhost:8080. -make test +cp .env.example .env +docker compose up -d --build # db -> migrate -> app, valkey +make test # публичный smoke +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-own # собственные тесты (pip install pytest httpx) +bash scripts/explain_history.sh # EXPLAIN (ANALYZE, BUFFERS) на 24 000 сообщений ``` -`.env.example`, `compose.example.yaml` и `contracts/infrastructure.json` описывают настройки и роли компонентов. **compose.example.yaml — список ролей с пустым services, не запускаемый стенд.** Реализуйте свой `compose.yaml`/`stack.yaml`, закрепите версии образов, заполните локальный `.env` и опишите bootstrap/миграции. Все зависимости поднимаются из этого репозитория; ссылка «у меня БД уже установлена» не заменяет воспроизводимость. - -```sh -# Compose-вариант после реализации: -docker compose --env-file .env config --quiet -docker compose --env-file .env up -d --build -# Дождитесь /health/ready; затем make test. -# Для Swarm укажите эквивалентные build/push/deploy-команды в REPORT.md. -``` - - -Примеры запросов доступны в `examples/requests.http`, примеры JSON — в `contracts/examples.json`. Для полной проверки схемы (по желанию локально; CI делает её автоматически): - -```sh -python3 -m venv .venv -.venv/bin/python -m pip install -r requirements-dev.txt -make validate PYTHON=.venv/bin/python -``` - -Smoke не выставляет оценку автоматически. Проверку сохранности/отказов запускайте явно по [tests/README.md](tests/README.md), остальные доказательства приведите в отчёте. - -## Сценарий защиты - -1. Применить миграции к пустому volume, создать пользователей, войти, отправить сообщение. -2. Запустить persistence-сценарий: он держит токен только в памяти тестового процесса; action script перезапускает API и все используемые хранилища, сохраняя volumes. -3. После готовности тот же токен читает те же данные; после logout — 401. Повторить с отдельным коротким TTL для проверки expiry. -4. Для 4: показать роль Redis/Valkey, план SQL и ошибку зависимости. Для 5: выполнить выбранный эксперимент. - -## Что должно быть в PR - -Исходники, Dockerfile, миграции, compose.yaml либо эквивалентный воспроизводимый запуск, scripts/restart.sh, собственные тесты и отчёт. - -Заполните `REPORT.md` и [шаблон PR](.github/pull_request_template.md), укажите целевую оценку/трек. Не меняйте обязательный контракт и публичные tests ради зелёного результата. Сохраняйте возможности предыдущих лабораторных в пределах [объявленных переходов](COURSE.md). - -## Вопросы на защите - -- Что подтверждает COMMIT и какие гарантии зависят от настройки durability? -- Где хранятся сессии и что будет после flush/restart Redis? -- Чем аутентификация отличается от доступа к конкретному чату? -- Почему hash пароля и быстрый checksum имеют разные задачи? - -## Первичные материалы - -- [PostgreSQL transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html) -- [PostgreSQL EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html) -- [Valkey persistence](https://valkey.io/topics/persistence/) -- [Redis persistence](https://redis.io/docs/latest/operate/oss_and_stack/management/persistence/) -- [Basic authentication](https://www.rfc-editor.org/info/rfc7617/) +Целевая оценка: **4**. Собственные тесты лежат в `tests_own/`, скрипты в `scripts/`. diff --git a/REPORT.md b/REPORT.md index c32b25d3..e9431456 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,49 +1,173 @@ -# Отчёт по Лабораторной работе №2: PostgreSQL, сессии и аутентификация +# Отчёт по лабораторной работе №2: PostgreSQL, сессии и Valkey ## Целевая оценка -**4** (Реализованы все требования базового уровня, а также требования уровня стажёра: параметризованные запросы, connection pool, индексы, атомарные операции и надежное хранение сессий с TTL). -## Архитектура решения -- **Framework**: FastAPI (асинхронный) -- **ORM / Database Driver**: SQLAlchemy 2.0 + `asyncpg` (обеспечивает встроенный connection pool и высокую производительность) -- **База данных**: PostgreSQL 16 (хранение пользователей, сессий, чатов и сообщений) -- **Миграции**: Alembic (версионированное управление схемой БД) -- **Безопасность**: `bcrypt` для хеширования паролей, криптографически стойкие opaque Bearer-токены с TTL (24 часа). +**4** (уровень стажёра/джуна): весь уровень 3 плюс Valkey в роли кэша сессий, ограниченный пул и таймауты БД, проверка гонки регистрации и отказов зависимостей, обоснованный индекс истории с `EXPLAIN (ANALYZE, BUFFERS)` на 24 000 сообщений, собственные автотесты. -## Реализованные требования +## Архитектура -### 1. Переход на постоянное хранилище (PostgreSQL) -- Все данные (Users, Sessions, Chats, ChatMembers, Messages) перенесены из in-memory в PostgreSQL. -- Настроены **версионированные миграции** через Alembic (`alembic/versions/`). Команда `alembic upgrade head` разворачивает схему с нуля. -- Составная операция создания чата (создание Chat + запись в ChatMember) выполняется **атомарно** в рамках одной транзакции SQLAlchemy. +``` +Клиент -> API (FastAPI, uvicorn) -> PostgreSQL 16 (источник истины) + -> Valkey 8 (кэш сессий, опциональная зависимость) +``` -### 2. Аутентификация и сессии -- При регистрации поле `password` обязательно и хешируется с помощью `bcrypt` (KDF). -- Реализован эндпоинт `POST /api/v1/auth/sessions`, принимающий HTTP Basic Auth и выдающий opaque Bearer-токен. -- Сессии хранятся в таблице `sessions` с полем `expires_at`. При каждом запросе проверяется актуальность токена. -- Реализован отзыв сессии (logout) через `DELETE /api/v1/auth/sessions/current`. +| Компонент | Выбор | +|---|---| +| API | FastAPI, SQLAlchemy 2.0 (async) + asyncpg | +| БД | PostgreSQL 16, именованный volume `postgres_data` | +| Миграции | Alembic, отдельный одноразовый сервис `migrate` в Compose | +| Хеширование паролей | Argon2id (`argon2-cffi`) | +| Кэш | Valkey 8 (`valkey/valkey:8.0-alpine`), клиент `redis-py` | -### 3. Безопасность и изоляция данных -- Все защищённые эндпоинты используют зависимость `get_current_user`, которая извлекает токен из заголовка `Authorization: Bearer `. -- Реализована защита от несанкционированного доступа: при попытке прочитать чужой чат или сообщения возвращается **404 Not Found** (Security by Obscurity), а не 403. -- Добавлен глобальный обработчик ошибок, приводящий все ответы к единому формату OpenAPI-контракта с заголовком `X-Request-Id`. +Состав стенда: `db`, `valkey`, `migrate`, `app` (`docker-compose.yaml`). Порядок запуска: `db` healthy -> `migrate` завершился с кодом 0 -> `app`. `valkey` для `app` мягкая зависимость: API обязан работать и без него. -### 4. Оптимизация и надёжность (Уровень 4) -- Используются **параметризованные запросы** через SQLAlchemy, что полностью исключает риск SQL-инъекций. -- Драйвер `asyncpg` автоматически управляет **connection pool**, предотвращая исчерпание соединений. -- Добавлены **индексы** для ускорения частых операций: - - `ix_users_username` (B-tree) для быстрого поиска при логине и проверке уникальности. - - `ix_messages_created_at` (B-tree) для эффективной курсорной пагинации без полного сканирования таблицы (Full Scan). -- Курсорная пагинация реализована корректно: запрашивается `LIMIT + 1` записей, чтобы точно определить наличие следующей страницы (`next_cursor`). +## Схема БД -### 5. Инфраструктура и воспроизводимость -- Приложение и база данных запускаются единой командой `docker compose up -d --build`. -- Использованы именованные volumes (`postgres_data`) для сохранения данных. -- Настроены `healthcheck` для обоих сервисов, гарантирующие правильный порядок запуска (app ждёт готовности db). -- Скрипт `scripts/restart.sh` успешно проходит тест `make test-persistence`, доказывая, что данные и активные сессии переживают перезапуск контейнеров. +- `users(id uuid PK, username UNIQUE, display_name, password_hash, created_at)`. +- `sessions(id uuid PK, user_id FK -> users ON DELETE CASCADE, token UNIQUE, expires_at, created_at)`. +- `chats(id uuid PK, title, created_at)`. +- `chat_members(chat_id FK, user_id FK, PK(chat_id, user_id))`. +- `messages(id uuid PK, chat_id FK, sender_id FK, text, created_at)`, индекс `ix_messages_chat_created_id (chat_id, created_at, id)`. + +Миграции версионируются в `alembic/versions/`: +1. `d74c0ccadc85`: начальные таблицы; +2. `b7e1f3a9c2d4`: составной индекс истории вместо двух одноколоночных. + +`alembic upgrade head` разворачивает схему с нуля; повторный запуск ничего не дублирует. `DATABASE_URL` берётся из окружения. + +**Транзакционные границы.** Создание чата (проверка участников, `INSERT chats`, `INSERT chat_members`) выполняется в одной транзакции: либо чат и все участники записаны, либо ничего. Регистрация и вход тоже по одной транзакции на запрос. + +## Аутентификация и сессии + +- **Регистрация:** `POST /api/v1/users`, пароль 12-128 символов. Хеш Argon2id, пароль в ответах не возвращается. Уникальность username обеспечивает ограничение `UNIQUE`; при гонке второй `INSERT` получает `IntegrityError`, ответ `409`. +- **Почему не bcrypt.** bcrypt учитывает только первые 72 байта пароля. Контракт допускает пароль до 128 символов (до 512 байт в UTF-8), поэтому два разных длинных пароля с общим 72-байтным префиксом считались бы одинаковыми. Argon2id учитывает весь пароль. Это проверяет тест `test_long_passwords_not_truncated`. +- **Вход:** `POST /api/v1/auth/sessions`, только `Authorization: Basic`. Ответ 201 с opaque-токеном (`secrets.token_urlsafe(32)`, 256 бит), `expires_at` в UTC с `Z`. При неверных данных одинаковый `401` и `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Для несуществующего пользователя выполняется проверка по фиктивному хешу, чтобы время ответа не выдавало существование логина. +- **Срок жизни:** `SESSION_TTL_SECONDS`, по умолчанию 3600. Срок не продлевается при рестарте. +- **Бизнес-эндпоинты:** только `Authorization: Bearer`. Истёкший, отозванный или неизвестный токен даёт `401` с `WWW-Authenticate: Bearer realm="messenger"`. `X-User-Id` игнорируется. +- **Logout:** `DELETE /api/v1/auth/sessions/current` удаляет только предъявленную сессию (остальные сессии пользователя остаются), повторный вызов с тем же токеном даёт `401`. +- **Доступ к чату:** сначала аутентификация (`401`), затем членство; посторонний получает `404`, существование чужого чата не раскрывается. + +## Роль Valkey + +**Роль: кэш сессий.** Источник истины для сессий таблица `sessions` в PostgreSQL. + +| Вопрос | Решение | +|---|---| +| Что хранится | `token -> {user_id, username, display_name, created_at, expires_at}` | +| Ключ | `sess:`, сырой токен в кэше не хранится | +| TTL записи | `min(SESSION_CACHE_TTL_SECONDS (по умолчанию 30 с), остаток жизни сессии)`; запись не переживёт сессию | +| Инвалидация | при logout сначала `DELETE` в PostgreSQL (commit), затем `DEL` ключа в Valkey | +| Чтение | кэш -> при промахе PostgreSQL (`JOIN sessions/users`) -> запись в кэш | +| Persistence | не нужен: кэш не единственное хранилище, потеря кэша не теряет сессии | +| Отказ Valkey | любая ошибка кэша трактуется как промах, запрос идёт в PostgreSQL; клиентские таймауты 0,5 с | +| Анонимный запрос | при любой неисправности остаётся `401`, не принимается как доверенный | + +**Ограничение (окно устаревания).** Если `DEL` не прошёл (Valkey недоступен именно в момент logout), отозванный токен может приниматься до `SESSION_CACHE_TTL_SECONDS` (30 с). Это осознанный компромисс; окно ограничено TTL записи и логируется (`cache delete failed`). Похожий случай: если logout происходит между чтением сессии из PostgreSQL и записью в кэш, запись также проживёт не дольше 30 с. + +**Рестарт Valkey.** Кэш пустой, сессии не теряются, первые запросы читают PostgreSQL и заново наполняют кэш (проверено `make test-persistence` и тестом `test_valkey_down_falls_back_to_db`). + +## Индекс истории и EXPLAIN + +**Запрос истории** (то, что выполняет API): + +```sql +SELECT * FROM messages +WHERE chat_id = :chat + AND (created_at, id) > (:created_at, :id) -- только при продолжении +ORDER BY created_at, id +LIMIT :limit + 1; +``` + +**Было:** отдельные индексы по `chat_id` и по `created_at`. Для запроса с фильтром по чату и порядком `(created_at, id)` ни один из них не подходит целиком: одноколоночный по `chat_id` требует отдельной сортировки всех сообщений чата, а по `created_at` не фильтрует по чату. + +**Стало:** составной индекс `ix_messages_chat_created_id (chat_id, created_at, id)`. Колонки идут в порядке «равенство, затем порядок сортировки», поэтому одна и та же структура и ищет границу страницы (сравнение строк), и отдаёт строки сразу в нужном порядке. + +**Данные для проверки** воспроизводимы: `scripts/seed_explain.sql` создаёт 2 чата по 12 000 сообщений (24 000 всего, детерминированные UUID, повторный запуск ничего не дублирует). Снятие плана: `bash scripts/explain_history.sh`; результат в `evidence/explain_history.txt`. + +**Результат «после»** (чат из 12 000 сообщений, `EXPLAIN (ANALYZE, BUFFERS)`): + +| Запрос | План | Buffers | Execution time | +|---|---|---|---| +| первая страница (51 строка) | `Index Scan using ix_messages_chat_created_id`, `Index Cond: (chat_id = ...)` | shared hit=5 | 0,032 мс | +| страница из середины (после 6 000-го сообщения) | `Index Scan using ix_messages_chat_created_id`, `Index Cond: (chat_id = ... AND ROW(created_at, id) > ROW(...))` | shared hit=6 | 0,052 мс | + +Оба плана без шага `Sort`, без `Seq Scan` и без `Bitmap Heap Scan`; страница читает несколько буферов независимо от того, на каком месте истории она находится. Это подтверждает, что пагинация не сканирует всю историю на каждую страницу. + +**Сравнение «до»:** <ВСТАВИТЬ после снятия `evidence/explain_before.txt`: тип плана (Sort / Bitmap / Seq Scan), Buffers и Execution time на старых индексах; если файл не снимался, удалить этот абзац> + +## Надёжность и таймауты + +- **Пул соединений:** `pool_size=10`, `max_overflow=10`, `pool_timeout=3 с`, `pool_pre_ping`, `pool_recycle=1800`. +- **Таймауты БД:** подключение 2 с (`timeout`), клиентский таймаут запроса 3 с (`command_timeout`), на сервере `statement_timeout=5000 мс` и `idle_in_transaction_session_timeout=10000 мс`. +- **Общий дедлайн запроса:** 8 с (`REQUEST_TIMEOUT_SECONDS`), по истечении `503` в формате ошибки контракта. +- **Недоступность БД:** ошибки подключения, таймауты пула и запросов отображаются в `503 unavailable`, а не `500` и не зависание. +- **Параметризованные запросы:** весь доступ к данным через SQLAlchemy Core/ORM, строковая конкатенация SQL не используется. +- **Гонка регистрации:** решается `UNIQUE (username)`, а не проверкой перед вставкой; из 10 параллельных запросов с одним username ровно один получает `201`, остальные `409` (`test_register_race_one_winner`). + +## Health-проверки + +- `GET /health/live`: только живость процесса. +- `GET /health/ready`: `200`, если из пула получено соединение и выполнен `SELECT 1 FROM users LIMIT 1` (заодно подтверждает, что миграции накатаны). Ответ даётся не позднее чем через 2 с; при недоступной БД `503`. +- **Критичные зависимости:** PostgreSQL (критична). Valkey не критичен: при его отказе API продолжает работать с обходом кэша. + +## Семантика пагинации и ограничения + +- Курсор непрозрачный (base64 от JSON), содержит полный ключ сортировки `(created_at, id)` и область (чат / пользователь). Курсор от другого чата или повреждённая строка дают `400`. +- Порядок по возрастанию `(created_at, id)` как для истории, так и для списка чатов. Последний элемент предыдущей страницы не повторяется; сообщения с одинаковым временем не пропускаются (`test_pagination_with_equal_timestamps`). +- `next_cursor = null`, если на момент чтения следующей записи нет. +- **Ограничение при конкурентных вставках.** `created_at` назначается приложением до коммита. Если сообщение с более ранним `created_at` будет закоммичено позже, чем читатель уже прошёл эту позицию, при продолжении обхода оно может не попасть в выдачу. Для неизменной истории повторов и пропусков нет; snapshot-изоляция между HTTP-запросами не гарантируется (контракт этого и не требует). + +## Автоматические проверки + +Публичные: `make test` (smoke) и `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. + +Собственные: **`make test-own`** (`scripts/test_own.sh`, `tests_own/`) поднимает стенд и выполняет: + +| Проверка | Тест | +|---|---| +| неверный пароль, `401` и `WWW-Authenticate` | `test_wrong_password_401` | +| длинные пароли с общим 72-байтным префиксом различаются | `test_long_passwords_not_truncated` | +| logout отзывает только текущую сессию, повтор даёт `401` | `test_logout_revokes_only_current_session` | +| logout сразу инвалидирует кэш | `test_logout_invalidates_cache_immediately` | +| гонка регистрации: один победитель | `test_register_race_one_winner` | +| дубликаты / неизвестные участники / нет создателя дают `400`, список чатов не изменился | `test_chat_validation_and_rollback` | +| повреждённый и чужой курсор дают `400` | `test_cursor_garbage_and_foreign_cursor_400` | +| одинаковое `created_at` не теряет сообщения | `test_pagination_with_equal_timestamps` | +| полный обход без повторов и в порядке отправки | `test_pagination_full_walk_in_order` | +| Valkey остановлен: запросы с токеном работают, аноним получает `401`, после старта работает снова | `test_valkey_down_falls_back_to_db` | +| PostgreSQL на паузе: `/health/ready` и бизнес-запрос дают `503`, после `unpause` работа восстанавливается | `test_db_paused_returns_503_and_recovers` | +| истечение сессии при `SESSION_TTL_SECONDS=2` (отдельный запуск с коротким TTL) | `test_session_expires` | + +Откат составной операции проверяется на уровне валидации: невалидные запросы создания чата не оставляют частично записанного состояния. Сбой внутри самой транзакции (между вставкой чата и вставкой участников) отдельно не инжектировался: атомарность в этом случае обеспечивает транзакция PostgreSQL. ## Как запустить -1. Убедитесь, что Docker запущен. -2. Выполните: `docker compose up -d --build` -3. Дождитесь статуса `healthy` для обоих сервисов (`docker compose ps`). -4. Запустите тесты: `make test` и `make test-persistence ACTION_SCRIPT=scripts/restart.sh` \ No newline at end of file + +```bash +cp .env.example .env # при необходимости задать POSTGRES_PASSWORD +docker compose up -d --build # db -> migrate -> app, плюс valkey +curl -f http://localhost:8080/health/ready + +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-own # нужны pytest и httpx: pip install pytest httpx +bash scripts/explain_history.sh # EXPLAIN на 24 000 сообщений -> evidence/explain_history.txt +``` + +Параметры окружения: `DATABASE_URL`, `REDIS_URL`, `SESSION_TTL_SECONDS` (3600), `SESSION_CACHE_TTL_SECONDS` (30), `DB_POOL_SIZE`, `DB_MAX_OVERFLOW`, `DB_POOL_TIMEOUT`, `REQUEST_TIMEOUT_SECONDS`. + +Секреты: пароль БД задаётся через `.env` (в Git не попадает); значение по умолчанию в `docker-compose.yaml` пригодно только для локального изолированного стенда. Basic-аутентификация и HTTP допустимы только для локальной демонстрации с синтетическими данными; при удалённом доступе нужен TLS. + +## Ограничения и известные компромиссы + +- Окно устаревания кэша при неудачном `DEL` (до 30 с), см. раздел про Valkey. +- Argon2id используется с параметрами библиотеки по умолчанию, отдельной настройки под нагрузку не выполнялось. +- После перехода с bcrypt на Argon2id старые хеши несовместимы: учебный стенд пересоздаётся (`docker compose down -v`). +- Истёкшие строки в `sessions` физически не удаляются фоновой задачей (проверка срока идёт при каждом запросе). +- Нагрузочное и конкурентное тестирование ограничено перечисленными проверками; исследование для оценки «5» не выполнялось. + +## Ответы на вопросы защиты + +- **Что подтверждает COMMIT и какие гарантии зависят от durability?** COMMIT в PostgreSQL возвращается после записи WAL-записи коммита; при `fsync=on` и `synchronous_commit=on` (значения по умолчанию в используемом образе) подтверждённая транзакция переживает падение процесса и перезагрузку. При `synchronous_commit=off` последние подтверждённые транзакции можно потерять при сбое, при этом целостность БД сохраняется. +- **Где хранятся сессии и что будет после flush/restart Valkey?** Сессии хранятся в PostgreSQL; Valkey лишь кэширует их на короткое время. После flush или рестарта Valkey кэш пустой, сессии остаются действительными, запросы временно идут напрямую в PostgreSQL. +- **Чем аутентификация отличается от доступа к конкретному чату?** Аутентификация отвечает на вопрос «кто вы» (валидный Bearer-токен, иначе `401`), авторизация на вопрос «можно ли вам это» (членство в чате, иначе `404`, чтобы не раскрывать существование чужого чата). Сначала проверяется первое, затем второе. +- **Почему hash пароля и быстрый checksum имеют разные задачи?** Checksum (например SHA-256) должен считаться быстро и проверяет целостность данных; хеш пароля (Argon2id) специально медленный, требует много памяти и использует случайную соль, чтобы перебор по украденной базе был дорогим. Быстрый хеш для паролей позволяет перебирать миллиарды вариантов в секунду. diff --git a/alembic/env.py b/alembic/env.py index e0768b26..20464521 100644 --- a/alembic/env.py +++ b/alembic/env.py @@ -1,29 +1,28 @@ import asyncio from logging.config import fileConfig + from sqlalchemy import pool from sqlalchemy.engine import Connection from sqlalchemy.ext.asyncio import async_engine_from_config from alembic import context -# 1. Импортируем наши настройки и модели +# DATABASE_URL берётся из окружения (см. src/database.py) from src.database import DATABASE_URL, Base -from src import models # Обязательно! Чтобы Alembic "увидел" наши таблицы +from src import models # noqa: F401 нужно, чтобы Alembic "увидел" таблицы config = context.config -# Настройка логирования if config.config_file_name is not None: fileConfig(config.config_file_name) -# Метаданные для autogenerate target_metadata = Base.metadata -# Переопределяем URL подключения из нашего .env (игнорируем alembic.ini) -config.set_main_option("sqlalchemy.url", "postgresql+asyncpg://postgres:postgres@localhost:5433/messenger_db") +# % экранируем, иначе configparser воспримет его как интерполяцию +config.set_main_option("sqlalchemy.url", DATABASE_URL.replace("%", "%%")) + def run_migrations_offline() -> None: - """Запуск миграций в 'offline' режиме (без подключения к БД).""" url = config.get_main_option("sqlalchemy.url") context.configure( url=url, @@ -34,31 +33,29 @@ def run_migrations_offline() -> None: with context.begin_transaction(): context.run_migrations() + def do_run_migrations(connection: Connection) -> None: - """Непосредственно применение миграций к соединению.""" context.configure(connection=connection, target_metadata=target_metadata) with context.begin_transaction(): context.run_migrations() + async def run_async_migrations() -> None: - """Асинхронный запуск миграций.""" connectable = async_engine_from_config( config.get_section(config.config_ini_section, {}), prefix="sqlalchemy.", poolclass=pool.NullPool, ) - async with connectable.connect() as connection: await connection.run_sync(do_run_migrations) - await connectable.dispose() + def run_migrations_online() -> None: - """Запуск миграций в 'online' режиме.""" asyncio.run(run_async_migrations()) -# Точка входа Alembic + if context.is_offline_mode(): run_migrations_offline() else: - run_migrations_online() \ No newline at end of file + run_migrations_online() diff --git a/alembic/versions/b7e1f3a9c2d4_messages_history_index.py b/alembic/versions/b7e1f3a9c2d4_messages_history_index.py new file mode 100644 index 00000000..83661723 --- /dev/null +++ b/alembic/versions/b7e1f3a9c2d4_messages_history_index.py @@ -0,0 +1,27 @@ +"""messages history index + +Revision ID: b7e1f3a9c2d4 +Revises: d74c0ccadc85 +Create Date: 2026-11-06 12:00:00 +""" +from typing import Sequence, Union + +from alembic import op + +revision: str = "b7e1f3a9c2d4" +down_revision: Union[str, Sequence[str], None] = "d74c0ccadc85" +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + # Запрос истории: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id + op.create_index("ix_messages_chat_created_id", "messages", ["chat_id", "created_at", "id"]) + op.drop_index("ix_messages_chat_id", table_name="messages") # префикс нового индекса + op.drop_index("ix_messages_created_at", table_name="messages") # для этого запроса бесполезен + + +def downgrade() -> None: + op.create_index("ix_messages_created_at", "messages", ["created_at"]) + op.create_index("ix_messages_chat_id", "messages", ["chat_id"]) + op.drop_index("ix_messages_chat_created_id", table_name="messages") diff --git a/docker-compose.yaml b/docker-compose.yaml index 9937c196..b4da1ca2 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -1,13 +1,19 @@ +x-app-env: &app-env + DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD:-postgres}@db:5432/${POSTGRES_DB:-messenger_db} + REDIS_URL: redis://valkey:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-30} + services: db: image: postgres:16-alpine container_name: lab2_postgres environment: - POSTGRES_USER: postgres - POSTGRES_PASSWORD: postgres - POSTGRES_DB: messenger_db + POSTGRES_USER: ${POSTGRES_USER:-postgres} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres} + POSTGRES_DB: ${POSTGRES_DB:-messenger_db} ports: - - "5433:5432" # Пробрасываем на 5433, чтобы не конфликтовать с локальным Mac PG + - "5433:5432" volumes: - postgres_data:/var/lib/postgresql/data healthcheck: @@ -16,17 +22,41 @@ services: timeout: 3s retries: 5 - app: + valkey: + image: valkey/valkey:8.0-alpine + container_name: lab2_valkey + # Кэш сессий: источник истины - PostgreSQL, persistence не нужен. + command: ["valkey-server", "--save", "", "--appendonly", "no", + "--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"] + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 5 + + migrate: build: . - container_name: lab2_app - environment: - # Внутри Docker сеть имя сервиса 'db' резолвится в IP контейнера базы, порт 5432 - - DATABASE_URL=postgresql+asyncpg://postgres:postgres@db:5432/messenger_db - ports: - - "8080:8080" + image: lab2-app + container_name: lab2_migrate + command: ["alembic", "upgrade", "head"] + environment: *app-env depends_on: db: condition: service_healthy + restart: "no" + + app: + build: . + image: lab2-app + container_name: lab2_app + environment: *app-env + ports: + - "8080:8080" + depends_on: + migrate: + condition: service_completed_successfully + valkey: + condition: service_started # мягкая зависимость: API работает и без кэша restart: unless-stopped healthcheck: test: ["CMD", "curl", "-f", "http://localhost:8080/health/ready"] @@ -35,4 +65,4 @@ services: retries: 5 volumes: - postgres_data: \ No newline at end of file + postgres_data: diff --git a/evidence/explain_history.txt b/evidence/explain_history.txt new file mode 100644 index 00000000..a54024c1 --- /dev/null +++ b/evidence/explain_history.txt @@ -0,0 +1,58 @@ +== 2026-11-06T20:46:24Z == +== версия миграции == +b7e1f3a9c2d4 +== индексы messages == + Table "public.messages" + Column | Type | Collation | Nullable | Default +------------+--------------------------+-----------+----------+--------- + id | uuid | | not null | + chat_id | uuid | | not null | + sender_id | uuid | | not null | + text | text | | not null | + created_at | timestamp with time zone | | | +Indexes: + "messages_pkey" PRIMARY KEY, btree (id) + "ix_messages_chat_created_id" btree (chat_id, created_at, id) +Foreign-key constraints: + "messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE + "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE CASCADE + +== сообщений по чатам == + chat_id | count +--------------------------------------+------- + af3cd510-1663-4fea-8a38-8e15fb90210e | 5 + 858a289c-ea8f-4ffe-9954-e98f015a072c | 3 + 00000000-0000-0000-0000-0000000000c1 | 12000 + d3a832f7-a587-452e-a61b-8f9fd3651fec | 2 + 00000000-0000-0000-0000-0000000000c2 | 12000 + 36aa67a0-0d47-4047-bb68-3e2781cb5b75 | 2 +(6 rows) + +== первая страница == + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..8.36 rows=51 width=65) (actual time=0.013..0.018 rows=51 loops=1) + Buffers: shared hit=5 + -> Index Scan using ix_messages_chat_created_id on messages (cost=0.41..1870.97 rows=12000 width=65) (actual time=0.012..0.015 rows=51 loops=1) + Index Cond: (chat_id = '00000000-0000-0000-0000-0000000000c1'::uuid) + Buffers: shared hit=5 + Planning: + Buffers: shared hit=107 + Planning Time: 0.252 ms + Execution Time: 0.032 ms +(9 rows) + +== страница из середины (keyset, как в API) == + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=0.41..12.80 rows=51 width=65) (actual time=0.016..0.024 rows=51 loops=1) + Buffers: shared hit=6 + -> Index Scan using ix_messages_chat_created_id on messages (cost=0.41..1458.70 rows=6002 width=65) (actual time=0.016..0.022 rows=51 loops=1) + Index Cond: ((chat_id = '00000000-0000-0000-0000-0000000000c1'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 01:40:00+00'::timestamp with time zone, '2bd0323e-6c41-2bf3-f433-b3a2ad4a0c44'::uuid))) + Buffers: shared hit=6 + Planning: + Buffers: shared hit=106 + Planning Time: 0.282 ms + Execution Time: 0.052 ms +(9 rows) + diff --git a/requirements.txt b/requirements.txt index 02735f5d..fe3ba73c 100644 --- a/requirements.txt +++ b/requirements.txt @@ -9,4 +9,7 @@ asyncpg==0.30.0 alembic==1.13.3 # Security -bcrypt==4.2.0 \ No newline at end of file +argon2-cffi==23.1.0 + +# Cache (Valkey/Redis) +redis==5.2.0 diff --git a/scripts/check_contract.py b/scripts/check_contract.py deleted file mode 100644 index dcb34dfa..00000000 --- a/scripts/check_contract.py +++ /dev/null @@ -1,54 +0,0 @@ -#!/usr/bin/env python3 -"""Offline structural checks; full schema validation is a separate target.""" -import ast -import json -from pathlib import Path -import re - -ROOT = Path(__file__).resolve().parents[1] - -def main(): - lab = json.loads((ROOT/'lab.json').read_text())['number'] - spec = json.loads((ROOT/'contracts/openapi.json').read_text()) - assert spec['openapi']=='3.1.0' - assert spec['info']['version']=='1.%d.0'%lab - operation_ids = set() - def walk(value): - if isinstance(value,dict): - if '$ref' in value: - pointer = value['$ref'] - assert pointer.startswith('#/'), 'unexpected external reference' - target = spec - for part in pointer[2:].split('/'): - target = target[part.replace('~1','/').replace('~0','~')] - for v in value.values(): - walk(v) - elif isinstance(value,list): - for v in value: - walk(v) - walk(spec) - for route,methods in spec['paths'].items(): - placeholders = set(re.findall(r'\{([^}]+)\}',route)) - for method,op in methods.items(): - assert op['operationId'] not in operation_ids, 'duplicate operationId' - operation_ids.add(op['operationId']) - params = {p['name'] for p in op.get('parameters',[]) if p['in']=='path' and p.get('required')} - assert placeholders==params, 'path parameter mismatch: '+route - for response in op['responses'].values(): - assert 'X-Request-Id' in response['headers'] - if lab>=3: - assert 'X-Instance-Id' in response['headers'] - assert ('/api/v1/auth/sessions' in spec['paths']) == (lab>=2) - assert ('/api/v1/attachments/{attachment_id}' in spec['paths']) == (lab>=4) - for file in list((ROOT/'tests').glob('*.py'))+list((ROOT/'scripts').glob('*.py')): - ast.parse(file.read_text(),filename=str(file)) - for file in ROOT.rglob('*.json'): - if any(part in {'.git','.venv','node_modules','vendor','output'} for part in file.parts): - continue - json.loads(file.read_text()) - for required in ('README.md','COURSE.md','CONTRIBUTING.md','REPORT.md','contracts/README.md','tests/smoke.py','tests/README.md'): - assert (ROOT/required).is_file(), 'missing '+required - print('PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.') - -if __name__=='__main__': - main() diff --git a/scripts/explain_history.sh b/scripts/explain_history.sh new file mode 100755 index 00000000..922c6e84 --- /dev/null +++ b/scripts/explain_history.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash +# Сидирует >=10 000 сообщений и снимает EXPLAIN (ANALYZE, BUFFERS) запроса истории. +# Запуск до и после миграции b7e1f3a9c2d4 даёт сравнение "до/после" для REPORT.md. +set -euo pipefail +cd "$(dirname "$0")/.." +mkdir -p evidence +OUT="${1:-evidence/explain_history.txt}" +PSQL="docker compose exec -T db psql -U postgres -d messenger_db" +CHAT="00000000-0000-0000-0000-0000000000c1" + +$PSQL < scripts/seed_explain.sql >/dev/null + +# Курсор из середины истории: сообщение №6000 целевого чата +MID=$($PSQL -At -c "SELECT created_at || '|' || id FROM messages WHERE chat_id='$CHAT' ORDER BY created_at, id OFFSET 5999 LIMIT 1") +TS="${MID%%|*}"; ID="${MID##*|}" + +{ + echo "== $(date -u +%FT%TZ) ==" + echo "== версия миграции =="; $PSQL -At -c "SELECT version_num FROM alembic_version" + echo "== индексы messages =="; $PSQL -c "\d messages" + echo "== сообщений по чатам =="; $PSQL -c "SELECT chat_id, count(*) FROM messages GROUP BY 1" + echo "== первая страница ==" + $PSQL -c "EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id='$CHAT' ORDER BY created_at, id LIMIT 51" + echo "== страница из середины (keyset, как в API) ==" + $PSQL -c "EXPLAIN (ANALYZE, BUFFERS) SELECT * FROM messages WHERE chat_id='$CHAT' AND (created_at, id) > ('$TS'::timestamptz, '$ID'::uuid) ORDER BY created_at, id LIMIT 51" +} | tee "$OUT" diff --git a/scripts/restart.example.sh b/scripts/restart.example.sh deleted file mode 100755 index 967e9512..00000000 --- a/scripts/restart.example.sh +++ /dev/null @@ -1,10 +0,0 @@ -#!/bin/sh -set -eu -# TODO: copy to restart.sh and implement using YOUR compose/stack services. -# Restart API and ALL used state stores (DB, sessions, S3, broker as applicable). -# Preserve persistent volumes and schema/data; never down -v / flush / re-seed. -# Allow operator unseal if required in lab7; do not print credentials. -# Exit 0 only after the intended action; test waits for API readiness separately. -printf '%s -' 'TODO: implement restart.sh for your infrastructure' >&2 -exit 2 diff --git a/scripts/seed_explain.sql b/scripts/seed_explain.sql new file mode 100644 index 00000000..4297915c --- /dev/null +++ b/scripts/seed_explain.sql @@ -0,0 +1,25 @@ +-- Воспроизводимый набор: 2 чата по 12 000 сообщений (24 000 всего). Повторный запуск ничего не дублирует. +INSERT INTO users(id, username, display_name, password_hash, created_at) +VALUES ('00000000-0000-0000-0000-000000000001', 'explain_user', 'Explain', 'x', now()) +ON CONFLICT DO NOTHING; + +INSERT INTO chats(id, title, created_at) VALUES + ('00000000-0000-0000-0000-0000000000c1', 'explain target', now()), + ('00000000-0000-0000-0000-0000000000c2', 'explain noise', now()) +ON CONFLICT DO NOTHING; + +INSERT INTO chat_members(chat_id, user_id, joined_at) +SELECT c.id, '00000000-0000-0000-0000-000000000001', now() +FROM chats c +WHERE c.id IN ('00000000-0000-0000-0000-0000000000c1', '00000000-0000-0000-0000-0000000000c2') +ON CONFLICT DO NOTHING; + +INSERT INTO messages(id, chat_id, sender_id, text, created_at) +SELECT md5(c.id::text || g)::uuid, c.id, '00000000-0000-0000-0000-000000000001', + 'msg ' || g, timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second' +FROM (VALUES ('00000000-0000-0000-0000-0000000000c1'::uuid), + ('00000000-0000-0000-0000-0000000000c2'::uuid)) c(id), + generate_series(1, 12000) g +ON CONFLICT DO NOTHING; + +ANALYZE messages; diff --git a/scripts/test_own.sh b/scripts/test_own.sh new file mode 100755 index 00000000..5f8ddbca --- /dev/null +++ b/scripts/test_own.sh @@ -0,0 +1,39 @@ +#!/usr/bin/env bash +# Собственные автотесты: auth/TTL/logout/гонки/откат/пагинация/отказы Valkey и БД. Одна команда: make test-own +set -euo pipefail +cd "$(dirname "$0")/.." +export BASE_URL="${BASE_URL:-http://localhost:8080}" +PY="${PYTHON:-python3}" + +$PY -c "import pytest, httpx" 2>/dev/null || { echo "pip install pytest httpx"; exit 1; } + +wait_ready() { + for _ in $(seq 1 90); do curl -fs "$BASE_URL/health/ready" >/dev/null && return 0; sleep 1; done + echo "API not ready"; return 1 +} +wait_healthy() { + for _ in $(seq 1 60); do + s=$(docker inspect -f '{{.State.Health.Status}}' "$1" 2>/dev/null || echo none) + [ "$s" = healthy ] && return 0 + sleep 1 + done + echo "$1 is not healthy" >&2 + return 1 +} + +docker compose up -d --build +wait_ready +$PY -m pytest tests_own -m "not ttl" -v + +wait_healthy lab2_postgres +wait_healthy lab2_valkey + +# Короткий TTL только для проверки истечения сессии +SESSION_TTL_SECONDS=2 docker compose up -d --force-recreate app +wait_ready +$PY -m pytest tests_own -m ttl -v + +# Вернуть TTL по умолчанию +docker compose up -d --force-recreate app +wait_ready +echo "OK" diff --git a/scripts/validate_openapi.py b/scripts/validate_openapi.py deleted file mode 100644 index 1dfe4a98..00000000 --- a/scripts/validate_openapi.py +++ /dev/null @@ -1,23 +0,0 @@ -#!/usr/bin/env python3 -"""Full OpenAPI and JSON Schema checks; install requirements-dev.txt first.""" -import json -from pathlib import Path -from openapi_spec_validator import validate -from jsonschema import Draft202012Validator - -root = Path(__file__).resolve().parents[1] -spec = json.loads((root/'contracts/openapi.json').read_text()) -validate(spec) -from referencing import Registry, Resource -# The base URI resolves local #/components references inside examples. -resource = dict(spec, **{'$schema': 'https://json-schema.org/draft/2020-12/schema'}) -registry = Registry().with_resource('urn:mtusi:openapi', Resource.from_contents(resource)) -for name, example in json.loads((root/'contracts/examples.json').read_text()).items(): - schema = {'$ref': 'urn:mtusi:openapi#/components/schemas/' + name} - Draft202012Validator(schema, registry=registry).validate(example) -for path in (root/'contracts').glob('*.schema.json'): - schema = json.loads(path.read_text()) - Draft202012Validator.check_schema(schema) - for example in schema.get('examples',[]): - Draft202012Validator(schema).validate(example) -print('PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.') diff --git a/src/auth.py b/src/auth.py index 6ae8e1ba..3ad814e6 100644 --- a/src/auth.py +++ b/src/auth.py @@ -1,20 +1,33 @@ +import os import secrets -import bcrypt from datetime import datetime, timezone, timedelta +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, InvalidHashError, VerificationError + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + +_ph = PasswordHasher() # Argon2id, параметры по умолчанию +# Для выравнивания времени ответа, когда пользователя не существует. +DUMMY_HASH = _ph.hash("dummy-password-for-timing") + + def hash_password(plain_password: str) -> str: - """Хеширует пароль с использованием bcrypt.""" - salt = bcrypt.gensalt() - return bcrypt.hashpw(plain_password.encode('utf-8'), salt).decode('utf-8') + """Argon2id: учитывает весь пароль (в отличие от bcrypt с лимитом 72 байта).""" + return _ph.hash(plain_password) + def verify_password(plain_password: str, hashed_password: str) -> bool: - """Проверяет, совпадает ли пароль с хешем.""" - return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8')) + try: + return _ph.verify(hashed_password, plain_password) # порядок: hash, password + except (VerifyMismatchError, VerificationError, InvalidHashError): + return False + def generate_token() -> str: - """Генерирует криптографически стойкий opaque-токен.""" + """Opaque-токен, 256 бит энтропии.""" return secrets.token_urlsafe(32) -def get_token_expiry(hours: int = 24) -> datetime: - """Возвращает время истечения срока действия токена.""" - return datetime.now(timezone.utc) + timedelta(hours=hours) \ No newline at end of file + +def get_token_expiry(seconds: int | None = None) -> datetime: + return datetime.now(timezone.utc) + timedelta(seconds=seconds or SESSION_TTL_SECONDS) diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..fa5e8a78 --- /dev/null +++ b/src/cache.py @@ -0,0 +1,51 @@ +"""Valkey/Redis как КЭШ сессий. + +Источник истины - таблица sessions в PostgreSQL. Запись в кэше живёт +min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии). Любая ошибка кэша +приводит к обходу кэша (чтение из PostgreSQL), но не к доверию анониму. +""" +import hashlib +import json +import logging +import os + +import redis.asyncio as redis + +log = logging.getLogger("cache") +CACHE_TTL = int(os.getenv("SESSION_CACHE_TTL_SECONDS", "30")) + +_client = redis.from_url( + os.getenv("REDIS_URL", "redis://valkey:6379/0"), + socket_connect_timeout=0.5, + socket_timeout=0.5, + decode_responses=True, +) + + +def _key(token: str) -> str: + return "sess:" + hashlib.sha256(token.encode()).hexdigest() + + +async def cache_get(token: str): + try: + raw = await _client.get(_key(token)) + return json.loads(raw) if raw else None + except Exception as e: + log.warning("cache get failed: %s", e) + return None + + +async def cache_set(token: str, payload: dict, ttl: int): + if ttl < 1: + return + try: + await _client.set(_key(token), json.dumps(payload), ex=ttl) + except Exception as e: + log.warning("cache set failed: %s", e) + + +async def cache_delete(token: str): + try: + await _client.delete(_key(token)) + except Exception as e: + log.warning("cache delete failed (stale entry lives <= CACHE_TTL): %s", e) diff --git a/src/database.py b/src/database.py index d349a47a..a7fb2baa 100644 --- a/src/database.py +++ b/src/database.py @@ -1,25 +1,40 @@ import os + from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker from sqlalchemy.orm import DeclarativeBase DATABASE_URL = os.getenv( - "DATABASE_URL", - "postgresql+asyncpg://postgres:postgres@localhost:5432/messenger_db" + "DATABASE_URL", + "postgresql+asyncpg://postgres:postgres@localhost:5432/messenger_db", ) engine = create_async_engine( DATABASE_URL, echo=False, pool_pre_ping=True, + pool_size=int(os.getenv("DB_POOL_SIZE", "10")), + max_overflow=int(os.getenv("DB_MAX_OVERFLOW", "10")), + pool_timeout=float(os.getenv("DB_POOL_TIMEOUT", "3")), + pool_recycle=1800, + connect_args={ + "timeout": 2, # установка соединения, сек + "command_timeout": 3, # клиентский таймаут запроса, сек + "server_settings": { + "statement_timeout": "5000", + "idle_in_transaction_session_timeout": "10000", + }, + }, ) async_session_maker = async_sessionmaker( engine, class_=AsyncSession, expire_on_commit=False ) + class Base(DeclarativeBase): pass + async def get_db(): async with async_session_maker() as session: - yield session \ No newline at end of file + yield session diff --git a/src/dependencies.py b/src/dependencies.py index e9077da9..2415bb12 100644 --- a/src/dependencies.py +++ b/src/dependencies.py @@ -1,57 +1,77 @@ -from fastapi import Depends, HTTPException, status, Security -from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials -from sqlalchemy.ext.asyncio import AsyncSession -from sqlalchemy import select +import uuid +from dataclasses import dataclass from datetime import datetime, timezone +from fastapi import Depends, HTTPException, Security +from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from src.cache import CACHE_TTL, cache_get, cache_set, cache_delete from src.database import get_db from src.models import Session, User -# auto_error=False позволяет нам самим контролировать ответ при отсутствии заголовка +# auto_error=False: сами контролируем ответ при отсутствии заголовка security = HTTPBearer(auto_error=False) + +@dataclass(frozen=True) +class CurrentUser: + id: uuid.UUID + username: str + display_name: str + created_at: datetime + + +def _unauthorized(detail: str) -> HTTPException: + return HTTPException( + status_code=401, + detail=detail, + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + async def get_current_user( credentials: HTTPAuthorizationCredentials = Security(security), - db: AsyncSession = Depends(get_db) -) -> User: - # 1. Проверяем наличие заголовка Authorization + db: AsyncSession = Depends(get_db), +) -> CurrentUser: if not credentials: - raise HTTPException( - status_code=status.HTTP_401_UNAUTHORIZED, - detail="Missing authentication credentials", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'} - ) - + raise _unauthorized("Missing authentication credentials") + token = credentials.credentials - - # 2. Ищем сессию по токену - result = await db.execute(select(Session).where(Session.token == token)) - session = result.scalar_one_or_none() - - if not session: - raise HTTPException( - status_code=status.HTTP_401_UNAUTHORIZED, - detail="Invalid or unknown token", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'} - ) - - # 3. Проверяем, не истёк ли токен - if session.expires_at < datetime.now(timezone.utc): - raise HTTPException( - status_code=status.HTTP_401_UNAUTHORIZED, - detail="Token expired", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'} - ) - - # 4. Получаем пользователя, привязанного к сессии - result = await db.execute(select(User).where(User.id == session.user_id)) - user = result.scalar_one_or_none() - - if not user: - raise HTTPException( - status_code=status.HTTP_401_UNAUTHORIZED, - detail="User not found", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'} - ) - - return user \ No newline at end of file + now = datetime.now(timezone.utc) + + # 1. Кэш (Valkey). Любая ошибка кэша = промах. + cached = await cache_get(token) + if cached: + if datetime.fromisoformat(cached["expires_at"]) > now: + return CurrentUser( + uuid.UUID(cached["id"]), + cached["username"], + cached["display_name"], + datetime.fromisoformat(cached["created_at"]), + ) + await cache_delete(token) + raise _unauthorized("Token expired") + + # 2. Источник истины - PostgreSQL + row = (await db.execute( + select(Session, User).join(User, User.id == Session.user_id).where(Session.token == token) + )).first() + if not row: + raise _unauthorized("Invalid or unknown token") + + session, user = row + if session.expires_at <= now: + raise _unauthorized("Token expired") + + cu = CurrentUser(user.id, user.username, user.display_name, user.created_at) + ttl = min(CACHE_TTL, int((session.expires_at - now).total_seconds())) + await cache_set(token, { + "id": str(cu.id), + "username": cu.username, + "display_name": cu.display_name, + "created_at": cu.created_at.isoformat(), + "expires_at": session.expires_at.isoformat(), + }, ttl) + return cu diff --git a/src/main.py b/src/main.py index 670691c0..fb4efe61 100644 --- a/src/main.py +++ b/src/main.py @@ -1,270 +1,315 @@ +import asyncio import uuid -from fastapi import FastAPI, Depends, HTTPException, status, Query, Request, Security -from fastapi.responses import JSONResponse -from fastapi.security import HTTPBasic, HTTPBasicCredentials -from fastapi.exceptions import RequestValidationError -from starlette.middleware.base import BaseHTTPMiddleware -from sqlalchemy.ext.asyncio import AsyncSession -from sqlalchemy import select, func, and_, delete -from datetime import datetime, timezone +import os +from collections import defaultdict from typing import Optional -from src.database import get_db +from fastapi import FastAPI, Depends, HTTPException, status, Query, Request, Security +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from fastapi.security import HTTPBasic, HTTPBasicCredentials, HTTPAuthorizationCredentials +from sqlalchemy import select, text, delete, tuple_ +from sqlalchemy.exc import IntegrityError, OperationalError, InterfaceError +from sqlalchemy.exc import TimeoutError as SATimeoutError +from sqlalchemy.ext.asyncio import AsyncSession +from starlette.concurrency import run_in_threadpool +from starlette.middleware.base import BaseHTTPMiddleware + +from src.auth import (hash_password, verify_password, generate_token, + get_token_expiry, DUMMY_HASH) +from src.cache import cache_delete +from src.database import get_db, engine +from src.dependencies import get_current_user, security from src.models import User, Session, Chat, ChatMember, Message -from src.schemas import UserCreate, UserResponse, SessionResponse, CreateChat, CreateMessage, format_dt -from src.auth import hash_password, verify_password, generate_token, get_token_expiry -from src.dependencies import get_current_user +from src.pagination import encode_cursor, decode_cursor +from src.schemas import (UserCreate, UserResponse, SessionResponse, + CreateChat, CreateMessage, format_dt) app = FastAPI(title="Messenger API", version="2.0.0") + + +def _error(request: Request, status_code: int, code: str, message: str, headers=None): + request_id = getattr(request.state, "request_id", str(uuid.uuid4())) + h = dict(headers or {}) + h["X-Request-Id"] = request_id + return JSONResponse( + status_code=status_code, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=h, + ) + + @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): - request_id = getattr(request.state, "request_id", str(uuid.uuid4())) - - # Собираем все ошибки валидации в одну понятную строку - error_details = [] + parts = [] for err in exc.errors(): field = ".".join(str(x) for x in err.get("loc", []) if x != "body") msg = err.get("msg", "Invalid value") - error_details.append(f"{field}: {msg}" if field else msg) - - message = ", ".join(error_details) if error_details else "Invalid request payload" - - return JSONResponse( - status_code=status.HTTP_400_BAD_REQUEST, # <-- Тест ожидает именно 400, а не 422 - content={ - "error": { - "code": "invalid_request", - "message": message, - "request_id": request_id - } - }, - headers={"X-Request-Id": request_id} - ) + parts.append(f"{field}: {msg}" if field else msg) + return _error(request, 400, "invalid_request", + ", ".join(parts) if parts else "Invalid request payload") + + # 1. Middleware для X-Request-Id +REQUEST_TIMEOUT = float(os.getenv("REQUEST_TIMEOUT_SECONDS", "8")) + + class RequestIDMiddleware(BaseHTTPMiddleware): async def dispatch(self, request: Request, call_next): request_id = str(uuid.uuid4()) request.state.request_id = request_id - response = await call_next(request) + try: + # Жёсткий дедлайн: зависшая БД/кэш не должны держать запрос дольше REQUEST_TIMEOUT + response = await asyncio.wait_for(call_next(request), timeout=REQUEST_TIMEOUT) + except asyncio.TimeoutError: + return _error(request, 503, "unavailable", "Service temporarily unavailable") response.headers["X-Request-Id"] = request_id return response + app.add_middleware(RequestIDMiddleware) + # 2. Глобальный обработчик ошибок под формат OpenAPI @app.exception_handler(HTTPException) async def custom_http_exception_handler(request: Request, exc: HTTPException): - request_id = getattr(request.state, "request_id", str(uuid.uuid4())) code_map = { 400: "invalid_request", 401: "unauthorized", 403: "unauthorized", 404: "not_found", 409: "conflict", 413: "payload_too_large", - 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable", 500: "internal_error" + 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable", + 500: "internal_error", } - code = code_map.get(exc.status_code, "internal_error") message = exc.detail if isinstance(exc.detail, str) else "An error occurred" - - headers = dict(exc.headers) if exc.headers else {} - headers["X-Request-Id"] = request_id - - return JSONResponse(status_code=exc.status_code, content={ - "error": {"code": code, "message": message, "request_id": request_id} - }, headers=headers) + return _error(request, exc.status_code, code_map.get(exc.status_code, "internal_error"), + message, headers=exc.headers) + + +# 3. Недоступность БД/таймауты -> 503 (а не зависание или 500) +async def unavailable_handler(request: Request, exc: Exception): + return _error(request, 503, "unavailable", "Service temporarily unavailable") + + +for _exc in (OperationalError, InterfaceError, SATimeoutError, TimeoutError, OSError): + app.add_exception_handler(_exc, unavailable_handler) + # --- Healthcheck --- @app.get("/health/live") async def health_live(): return {"status": "ok"} + @app.get("/health/ready") -async def health_ready(db: AsyncSession = Depends(get_db)): - try: - await db.execute(select(func.now())) - return {"status": "ok"} - except Exception: +async def health_ready(): + async def probe(): + async with engine.connect() as conn: + await conn.execute(text("SELECT 1 FROM users LIMIT 1")) + + task = asyncio.create_task(probe()) + # забираем исключение фоновой задачи, чтобы не было "exception was never retrieved" + task.add_done_callback(lambda t: t.cancelled() or t.exception()) + + done, _ = await asyncio.wait({task}, timeout=2) + if not done: + task.cancel() # очистка соединения идёт в фоне и не задерживает ответ raise HTTPException(status_code=503, detail="Database not ready") + if task.exception() is not None: + raise HTTPException(status_code=503, detail="Database not ready") + return {"status": "ok"} + # --- Регистрация --- @app.post("/api/v1/users", status_code=status.HTTP_201_CREATED, response_model=UserResponse) async def create_user(user_data: UserCreate, db: AsyncSession = Depends(get_db)): - result = await db.execute(select(User).where(User.username == user_data.username)) - if result.scalar_one_or_none(): - raise HTTPException(status_code=409, detail="Username already exists") - - new_user = User(username=user_data.username, display_name=user_data.display_name, password_hash=hash_password(user_data.password)) + pw_hash = await run_in_threadpool(hash_password, user_data.password) # не блокируем event loop + new_user = User(username=user_data.username, + display_name=user_data.display_name, + password_hash=pw_hash) db.add(new_user) - await db.commit() - await db.refresh(new_user) - - return UserResponse(id=str(new_user.id), username=new_user.username, display_name=new_user.display_name, created_at=new_user.created_at) + try: + await db.commit() + except IntegrityError: # гонка одинакового username решается UNIQUE-ограничением + await db.rollback() + raise HTTPException(status_code=409, detail="Username already exists") + return UserResponse(id=str(new_user.id), username=new_user.username, + display_name=new_user.display_name, created_at=new_user.created_at) + # --- Аутентификация --- security_basic = HTTPBasic() -@app.post("/api/v1/auth/sessions", status_code=status.HTTP_201_CREATED, response_model=SessionResponse) -async def create_session(credentials: HTTPBasicCredentials = Security(security_basic), db: AsyncSession = Depends(get_db)): - result = await db.execute(select(User).where(User.username == credentials.username)) - user = result.scalar_one_or_none() - - if not user or not verify_password(credentials.password, user.password_hash): + +@app.post("/api/v1/auth/sessions", status_code=status.HTTP_201_CREATED, + response_model=SessionResponse) +async def create_session(credentials: HTTPBasicCredentials = Security(security_basic), + db: AsyncSession = Depends(get_db)): + user = (await db.execute( + select(User).where(User.username == credentials.username))).scalar_one_or_none() + + ok = await run_in_threadpool(verify_password, credentials.password, + user.password_hash if user else DUMMY_HASH) + if not user or not ok: raise HTTPException( - status_code=401, + status_code=401, detail="Invalid username or password", - headers={"WWW-Authenticate": "Basic"} # <--- ВОТ ЭТА СТРОЧКА РЕШАЕТ ВСЁ + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, ) - + token = generate_token() - expires_at = get_token_expiry(hours=24) - - new_session = Session(user_id=user.id, token=token, expires_at=expires_at) - db.add(new_session) + expires_at = get_token_expiry() # SESSION_TTL_SECONDS + + db.add(Session(user_id=user.id, token=token, expires_at=expires_at)) await db.commit() - + return SessionResponse( token=token, token_type="Bearer", expires_at=expires_at, - user=UserResponse(id=str(user.id), username=user.username, display_name=user.display_name, created_at=user.created_at) + user=UserResponse(id=str(user.id), username=user.username, + display_name=user.display_name, created_at=user.created_at), ) -# --- Logout --- + +# --- Logout: отзывается только предъявленная сессия --- @app.delete("/api/v1/auth/sessions/current", status_code=status.HTTP_204_NO_CONTENT) -async def delete_session(current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): - await db.execute(delete(Session).where(Session.user_id == current_user.id)) - await db.commit() +async def delete_session(credentials: HTTPAuthorizationCredentials = Security(security), + current_user=Depends(get_current_user), + db: AsyncSession = Depends(get_db)): + token = credentials.credentials + await db.execute(delete(Session).where(Session.token == token, + Session.user_id == current_user.id)) + await db.commit() # сначала фиксируем отзыв в PostgreSQL ... + await cache_delete(token) # ... затем инвалидируем кэш + # --- Текущий пользователь --- @app.get("/api/v1/users/me", response_model=UserResponse) -async def get_me(current_user: User = Depends(get_current_user)): - return UserResponse(id=str(current_user.id), username=current_user.username, display_name=current_user.display_name, created_at=current_user.created_at) +async def get_me(current_user=Depends(get_current_user)): + return UserResponse(id=str(current_user.id), username=current_user.username, + display_name=current_user.display_name, + created_at=current_user.created_at) + # --- Создание чата --- @app.post("/api/v1/chats", status_code=status.HTTP_201_CREATED) -async def create_chat( - chat_data: CreateChat, - current_user: User = Depends(get_current_user), - db: AsyncSession = Depends(get_db) -): - if str(current_user.id) not in chat_data.member_ids: +async def create_chat(chat_data: CreateChat, current_user=Depends(get_current_user), + db: AsyncSession = Depends(get_db)): + ids = chat_data.member_ids # уникальность и формат UUID проверены схемой + if current_user.id not in ids: raise HTTPException(status_code=400, detail="Creator must be in member_ids") - - for member_id in chat_data.member_ids: - if not (await db.execute(select(User).where(User.id == member_id))).scalar_one_or_none(): - raise HTTPException(status_code=404, detail=f"User {member_id} not found") - + + found = (await db.execute(select(User.id).where(User.id.in_(ids)))).scalars().all() + if len(found) != len(ids): + raise HTTPException(status_code=400, detail="Unknown member") # по контракту 400 + new_chat = Chat(title=chat_data.title) db.add(new_chat) await db.flush() - - for member_id in chat_data.member_ids: - db.add(ChatMember(chat_id=new_chat.id, user_id=member_id)) - await db.commit() - - member_result = await db.execute(select(ChatMember.user_id).where(ChatMember.chat_id == new_chat.id)) + db.add_all([ChatMember(chat_id=new_chat.id, user_id=m) for m in ids]) + await db.commit() # чат и участники - одна транзакция + + return {"id": str(new_chat.id), "title": new_chat.title, + "member_ids": [str(m) for m in ids], + "created_at": format_dt(new_chat.created_at)} + + +# --- Список чатов: keyset по (created_at, id) по возрастанию --- +@app.get("/api/v1/chats") +async def list_chats(limit: int = Query(50, ge=1, le=100), + cursor: Optional[str] = Query(None), + current_user=Depends(get_current_user), + db: AsyncSession = Depends(get_db)): + scope = f"chats:{current_user.id}" + query = (select(Chat) + .join(ChatMember, Chat.id == ChatMember.chat_id) + .where(ChatMember.user_id == current_user.id) + .order_by(Chat.created_at.asc(), Chat.id.asc()) + .limit(limit + 1)) + if cursor: + c_ts, c_id = decode_cursor(cursor, scope) + query = query.where(tuple_(Chat.created_at, Chat.id) > tuple_(c_ts, c_id)) + + chats = (await db.execute(query)).scalars().all() + has_next = len(chats) > limit + chats = chats[:limit] + + members = defaultdict(list) + if chats: + rows = await db.execute(select(ChatMember.chat_id, ChatMember.user_id) + .where(ChatMember.chat_id.in_([c.id for c in chats]))) + for cid, uid in rows.all(): + members[cid].append(str(uid)) + return { - "id": str(new_chat.id), - "title": new_chat.title, - "member_ids": [str(row[0]) for row in member_result.all()], - "created_at": format_dt(new_chat.created_at) + "items": [{"id": str(c.id), "title": c.title, "member_ids": members[c.id], + "created_at": format_dt(c.created_at)} for c in chats], + "next_cursor": (encode_cursor(chats[-1].created_at, chats[-1].id, scope) + if has_next else None), } -# --- Список чатов (ИСПРАВЛЕНО: правильная курсорная пагинация) --- -@app.get("/api/v1/chats") -async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = Query(None), current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): - # Запрашиваем limit + 1, чтобы узнать, есть ли следующая страница - query = select(Chat).join(ChatMember, Chat.id == ChatMember.chat_id).where(ChatMember.user_id == current_user.id).order_by(Chat.created_at.desc()).limit(limit + 1) - - if cursor: - cursor_dt = datetime.fromisoformat(cursor.replace('Z', '+00:00')) - query = query.where(Chat.created_at < cursor_dt) - - chats = (await db.execute(query)).scalars().all() - - has_next = len(chats) > limit - if has_next: - chats = chats[:-1] # Отбрасываем лишний элемент - - items = [] - for chat in chats: - members = [str(row[0]) for row in (await db.execute(select(ChatMember.user_id).where(ChatMember.chat_id == chat.id))).all()] - items.append({ - "id": str(chat.id), - "title": chat.title, - "member_ids": members, - "created_at": format_dt(chat.created_at) - }) - - # Если есть следующая страница, курсором будет последний элемент в items - next_cursor = items[-1]["created_at"] if has_next else None - - return {"items": items, "next_cursor": next_cursor} # --- Получение чата --- @app.get("/api/v1/chats/{chat_id}") -async def get_chat(chat_id: uuid.UUID, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): +async def get_chat(chat_id: uuid.UUID, current_user=Depends(get_current_user), + db: AsyncSession = Depends(get_db)): chat = (await db.execute(select(Chat).where(Chat.id == chat_id))).scalar_one_or_none() - if not chat: raise HTTPException(status_code=404, detail="Chat not found") - - if not (await db.execute(select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id))).scalar_one_or_none(): + if not chat: + raise HTTPException(status_code=404, detail="Chat not found") + + if not (await db.execute(select(ChatMember).where( + ChatMember.chat_id == chat_id, + ChatMember.user_id == current_user.id))).scalar_one_or_none(): raise HTTPException(status_code=404, detail="Chat not accessible") - - members = [str(row[0]) for row in (await db.execute(select(ChatMember.user_id).where(ChatMember.chat_id == chat_id))).all()] - return { - "id": str(chat.id), - "title": chat.title, - "member_ids": members, - "created_at": format_dt(chat.created_at) - } + + members = [str(r[0]) for r in (await db.execute( + select(ChatMember.user_id).where(ChatMember.chat_id == chat_id))).all()] + return {"id": str(chat.id), "title": chat.title, "member_ids": members, + "created_at": format_dt(chat.created_at)} + # --- Отправка сообщения --- @app.post("/api/v1/chats/{chat_id}/messages", status_code=status.HTTP_201_CREATED) -async def send_message( - chat_id: uuid.UUID, - msg_data: CreateMessage, - current_user: User = Depends(get_current_user), - db: AsyncSession = Depends(get_db) -): - if not (await db.execute(select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id))).scalar_one_or_none(): +async def send_message(chat_id: uuid.UUID, msg_data: CreateMessage, + current_user=Depends(get_current_user), + db: AsyncSession = Depends(get_db)): + if not (await db.execute(select(ChatMember).where( + ChatMember.chat_id == chat_id, + ChatMember.user_id == current_user.id))).scalar_one_or_none(): raise HTTPException(status_code=404, detail="Chat not accessible") - + msg = Message(chat_id=chat_id, sender_id=current_user.id, text=msg_data.text) db.add(msg) await db.commit() await db.refresh(msg) - - return { - "id": str(msg.id), - "chat_id": str(msg.chat_id), - "sender_id": str(msg.sender_id), - "text": msg.text, - "created_at": format_dt(msg.created_at) - } -# --- Список сообщений (ИСПРАВЛЕНО: правильная курсорная пагинация) --- + return {"id": str(msg.id), "chat_id": str(msg.chat_id), "sender_id": str(msg.sender_id), + "text": msg.text, "created_at": format_dt(msg.created_at)} + + +# --- История сообщений: keyset по (created_at, id) по возрастанию --- @app.get("/api/v1/chats/{chat_id}/messages") -async def list_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100), cursor: Optional[str] = Query(None), current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)): - if not (await db.execute(select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id))).scalar_one_or_none(): +async def list_messages(chat_id: uuid.UUID, limit: int = Query(50, ge=1, le=100), + cursor: Optional[str] = Query(None), + current_user=Depends(get_current_user), + db: AsyncSession = Depends(get_db)): + if not (await db.execute(select(ChatMember).where( + ChatMember.chat_id == chat_id, + ChatMember.user_id == current_user.id))).scalar_one_or_none(): raise HTTPException(status_code=404, detail="Chat not accessible") - - # Запрашиваем limit + 1, чтобы узнать, есть ли следующая страница - query = select(Message).where(Message.chat_id == chat_id).order_by(Message.created_at.asc(), Message.id.asc()).limit(limit + 1) - + + scope = f"chat:{chat_id}" # курсор привязан к чату + query = (select(Message).where(Message.chat_id == chat_id) + .order_by(Message.created_at.asc(), Message.id.asc()) + .limit(limit + 1)) if cursor: - cursor_dt = datetime.fromisoformat(cursor.replace('Z', '+00:00')) - query = query.where(Message.created_at > cursor_dt) - - messages = (await db.execute(query)).scalars().all() - - has_next = len(messages) > limit - if has_next: - messages = messages[:-1] # Отбрасываем лишний элемент - - items = [{ - "id": str(m.id), - "chat_id": str(m.chat_id), - "sender_id": str(m.sender_id), - "text": m.text, - "created_at": format_dt(m.created_at) - } for m in messages] - - # Если есть следующая страница, курсором будет последний элемент в items - next_cursor = items[-1]["created_at"] if has_next else None - - return {"items": items, "next_cursor": next_cursor} \ No newline at end of file + c_ts, c_id = decode_cursor(cursor, scope) + query = query.where(tuple_(Message.created_at, Message.id) > tuple_(c_ts, c_id)) + + rows = (await db.execute(query)).scalars().all() + has_next = len(rows) > limit + rows = rows[:limit] + + return { + "items": [{"id": str(m.id), "chat_id": str(m.chat_id), "sender_id": str(m.sender_id), + "text": m.text, "created_at": format_dt(m.created_at)} for m in rows], + "next_cursor": (encode_cursor(rows[-1].created_at, rows[-1].id, scope) + if has_next else None), + } diff --git a/src/models.py b/src/models.py index 67e59ab8..7d42c6e2 100644 --- a/src/models.py +++ b/src/models.py @@ -1,66 +1,76 @@ import uuid from datetime import datetime, timezone -from sqlalchemy import Column, String, DateTime, ForeignKey, Text, UniqueConstraint + +from sqlalchemy import Column, String, DateTime, ForeignKey, Text, Index from sqlalchemy.dialects.postgresql import UUID from sqlalchemy.orm import relationship + from src.database import Base + def get_now_utc(): return datetime.now(timezone.utc) + class User(Base): __tablename__ = "users" - + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) username = Column(String(32), unique=True, nullable=False, index=True) display_name = Column(String(100), nullable=False) - password_hash = Column(String(255), nullable=False) # Новое поле для хеша пароля + password_hash = Column(String(255), nullable=False) created_at = Column(DateTime(timezone=True), default=get_now_utc) - - # Связи + sessions = relationship("Session", back_populates="user", cascade="all, delete-orphan") chats = relationship("ChatMember", back_populates="user", cascade="all, delete-orphan") messages = relationship("Message", back_populates="sender", cascade="all, delete-orphan") + class Session(Base): __tablename__ = "sessions" - + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False) - token = Column(String(255), unique=True, nullable=False, index=True) # Opaque Bearer токен + token = Column(String(255), unique=True, nullable=False, index=True) # opaque Bearer expires_at = Column(DateTime(timezone=True), nullable=False) created_at = Column(DateTime(timezone=True), default=get_now_utc) - + user = relationship("User", back_populates="sessions") + class Chat(Base): __tablename__ = "chats" - + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) title = Column(String(100), nullable=False) created_at = Column(DateTime(timezone=True), default=get_now_utc) - + members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan") messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan") + class ChatMember(Base): __tablename__ = "chat_members" - + chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True) user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True) joined_at = Column(DateTime(timezone=True), default=get_now_utc) - + chat = relationship("Chat", back_populates="members") user = relationship("User", back_populates="chats") + class Message(Base): __tablename__ = "messages" - + id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4) - chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True) + chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False) sender_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False) text = Column(Text, nullable=False) - created_at = Column(DateTime(timezone=True), default=get_now_utc, index=True) # Индекс для пагинации - + created_at = Column(DateTime(timezone=True), default=get_now_utc) + chat = relationship("Chat", back_populates="messages") - sender = relationship("User", back_populates="messages") \ No newline at end of file + sender = relationship("User", back_populates="messages") + + # Индекс под keyset-историю: равенство по chat_id, затем порядок (created_at, id) + __table_args__ = (Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),) diff --git a/src/pagination.py b/src/pagination.py new file mode 100644 index 00000000..cecc8088 --- /dev/null +++ b/src/pagination.py @@ -0,0 +1,26 @@ +import base64 +import json +import uuid +from datetime import datetime, timezone + +from fastapi import HTTPException + + +def encode_cursor(created_at: datetime, row_id: uuid.UUID, scope: str) -> str: + """Непрозрачный keyset-курсор: полный ключ сортировки (created_at, id) + область (чат/пользователь).""" + raw = json.dumps({"t": created_at.isoformat(), "i": str(row_id), "s": scope}, + separators=(",", ":")) + return base64.urlsafe_b64encode(raw.encode()).decode().rstrip("=") + + +def decode_cursor(cursor: str, scope: str): + try: + data = json.loads(base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4))) + if data["s"] != scope: + raise ValueError("cursor belongs to another resource") + ts = datetime.fromisoformat(data["t"]) + if ts.tzinfo is None: + ts = ts.replace(tzinfo=timezone.utc) + return ts, uuid.UUID(data["i"]) + except Exception: + raise HTTPException(status_code=400, detail="Invalid cursor") diff --git a/src/schemas.py b/src/schemas.py index 4e206f57..fa0379f2 100644 --- a/src/schemas.py +++ b/src/schemas.py @@ -1,15 +1,28 @@ -from pydantic import BaseModel, Field, ConfigDict, field_serializer from datetime import datetime +from uuid import UUID + +from pydantic import BaseModel, Field, ConfigDict, field_serializer, field_validator + def format_dt(dt: datetime) -> str: """Форматирует datetime в ISO 8601 с суффиксом Z вместо +00:00""" return dt.isoformat().replace('+00:00', 'Z') + +def _not_blank(v: str) -> str: + if not v.strip(): + raise ValueError("must not be blank") + return v + + class UserCreate(BaseModel): 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) + _chk_display = field_validator("display_name")(_not_blank) + + class UserResponse(BaseModel): id: str username: str @@ -21,6 +34,7 @@ class UserResponse(BaseModel): def serialize_dt(self, dt: datetime) -> str: return format_dt(dt) + class SessionResponse(BaseModel): token: str token_type: str = "Bearer" @@ -32,11 +46,25 @@ class SessionResponse(BaseModel): def serialize_expires(self, dt: datetime) -> str: return format_dt(dt) + class CreateChat(BaseModel): title: str = Field(..., min_length=1, max_length=100) - member_ids: list[str] = Field(..., min_length=1) + # TODO: сверить с contracts/openapi.json (maxItems для member_ids) + member_ids: list[UUID] = Field(..., min_length=1) model_config = ConfigDict(extra="forbid") + _chk_title = field_validator("title")(_not_blank) + + @field_validator("member_ids") + @classmethod + def members_unique(cls, v): + if len(set(v)) != len(v): + raise ValueError("member_ids must be unique") + return v + + class CreateMessage(BaseModel): text: str = Field(..., min_length=1, max_length=4000) - model_config = ConfigDict(extra="forbid") \ No newline at end of file + model_config = ConfigDict(extra="forbid") + + _chk_text = field_validator("text")(_not_blank) diff --git a/src/storage.py b/src/storage.py deleted file mode 100644 index 0dfb17b6..00000000 --- a/src/storage.py +++ /dev/null @@ -1,93 +0,0 @@ -import uuid -import asyncio -from datetime import datetime, timezone -from dataclasses import dataclass -from typing import Dict, Set, List - -def get_now_iso() -> str: - return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z") - -@dataclass -class User: - id: str - username: str - display_name: str - created_at: str - -@dataclass -class Chat: - id: str - title: str - member_ids: Set[str] - created_at: str - -@dataclass -class Message: - id: str - chat_id: str - sender_id: str - text: str - created_at: str - -class Storage: - def __init__(self): - self.users_by_id: Dict[str, User] = {} - self.usernames: Set[str] = set() - - self.chats_by_id: Dict[str, Chat] = {} - self.chat_members: Dict[str, Set[str]] = {} - - self.messages_by_chat: Dict[str, List[Message]] = {} - - # ЗАМОК для защиты от гонок при одновременной записи - self.lock = asyncio.Lock() - - async def create_user(self, username: str, display_name: str) -> User: - async with self.lock: - if username in self.usernames: - raise ValueError("Username already exists") # Эту ошибку мы перехватим в main.py - - user_id = str(uuid.uuid4()) - user = User( - id=user_id, - username=username, - display_name=display_name, - created_at=get_now_iso() - ) - self.users_by_id[user_id] = user - self.usernames.add(username) - return user - - async def create_chat(self, title: str, member_ids: List[str]) -> Chat: - async with self.lock: - chat_id = str(uuid.uuid4()) - members_set = set(member_ids) - - chat = Chat( - id=chat_id, - title=title, - member_ids=members_set, - created_at=get_now_iso() - ) - - self.chats_by_id[chat_id] = chat - self.chat_members[chat_id] = members_set - - return chat - - async def create_message(self, chat_id: str, sender_id: str, text: str) -> Message: - async with self.lock: - message_id = str(uuid.uuid4()) - message = Message( - id=message_id, - chat_id=chat_id, - sender_id=sender_id, - text=text, - created_at=get_now_iso() - ) - - if chat_id not in self.messages_by_chat: - self.messages_by_chat[chat_id] = [] - - self.messages_by_chat[chat_id].append(message) - return message \ No newline at end of file diff --git a/tests_own/conftest.py b/tests_own/conftest.py new file mode 100644 index 00000000..3487fe21 --- /dev/null +++ b/tests_own/conftest.py @@ -0,0 +1,3 @@ +def pytest_configure(config): + config.addinivalue_line("markers", "ttl: нужен SESSION_TTL_SECONDS=2") + config.addinivalue_line("markers", "chaos: останавливает Valkey/PostgreSQL") diff --git a/tests_own/test_lab2_own.py b/tests_own/test_lab2_own.py new file mode 100644 index 00000000..3ba6ee4b --- /dev/null +++ b/tests_own/test_lab2_own.py @@ -0,0 +1,218 @@ +import os +import subprocess +import time +import uuid +from concurrent.futures import ThreadPoolExecutor + +import httpx +import pytest + +BASE = os.getenv("BASE_URL", "http://localhost:8080") +API = BASE + "/api/v1" +PW = "correct horse battery" + + +def dc(*a): + return subprocess.run(["docker", "compose", *a], check=True, capture_output=True, text=True) + + +def psql(sql): + return dc("exec", "-T", "db", "psql", "-U", "postgres", "-d", "messenger_db", + "-v", "ON_ERROR_STOP=1", "-c", sql) + + +def client(): + return httpx.Client(timeout=10) + + +def register(c, username=None, password=PW): + username = username or "u" + uuid.uuid4().hex[:12] + r = c.post(f"{API}/users", json={"username": username, "display_name": "T", "password": password}) + assert r.status_code == 201, r.text + return r.json() + + +def login(c, username, password=PW): + return c.post(f"{API}/auth/sessions", auth=(username, password)) + + +def auth(tok): + return {"Authorization": f"Bearer {tok}"} + + +def user_with_token(c): + u = register(c) + return u, login(c, u["username"]).json()["token"] + + +def make_chat(c, tok, member_ids): + r = c.post(f"{API}/chats", json={"title": "t", "member_ids": member_ids}, headers=auth(tok)) + assert r.status_code == 201, r.text + return r.json() + + +def wait_ready(timeout=30): + end = time.time() + timeout + while time.time() < end: + try: + if httpx.get(BASE + "/health/ready", timeout=3).status_code == 200: + return + except httpx.HTTPError: + pass + time.sleep(1) + raise AssertionError("API not ready") + + +# ---------- аутентификация ---------- +def test_wrong_password_401(): + with client() as c: + u = register(c) + r = login(c, u["username"], "wrong password!!") + assert r.status_code == 401 + assert r.headers["www-authenticate"].startswith("Basic") + + +def test_long_passwords_not_truncated(): + with client() as c: + pw = "a" * 72 + "X" * 12 + u = register(c, password=pw) + assert login(c, u["username"], "a" * 72 + "Y" * 12).status_code == 401 + assert login(c, u["username"], pw).status_code == 201 + + +def test_logout_revokes_only_current_session(): + with client() as c: + u = register(c) + t1 = login(c, u["username"]).json()["token"] + t2 = login(c, u["username"]).json()["token"] + assert c.delete(f"{API}/auth/sessions/current", headers=auth(t1)).status_code == 204 + assert c.get(f"{API}/users/me", headers=auth(t1)).status_code == 401 + assert c.get(f"{API}/users/me", headers=auth(t2)).status_code == 200 + assert c.delete(f"{API}/auth/sessions/current", headers=auth(t1)).status_code == 401 + + +def test_logout_invalidates_cache_immediately(): + with client() as c: + _, tok = user_with_token(c) + assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200 # прогрели кэш + c.delete(f"{API}/auth/sessions/current", headers=auth(tok)) + assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 401 + + +@pytest.mark.ttl +def test_session_expires(): + with client() as c: + _, tok = user_with_token(c) + assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200 + time.sleep(3.5) + assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 401 + + +# ---------- гонки и откат ---------- +def test_register_race_one_winner(): + name = "race" + uuid.uuid4().hex[:10] + + def go(_): + with client() as c: + return c.post(f"{API}/users", json={"username": name, "display_name": "T", + "password": PW}).status_code + + with ThreadPoolExecutor(10) as ex: + codes = list(ex.map(go, range(10))) + assert codes.count(201) == 1 and codes.count(409) == 9, codes + + +def test_chat_validation_and_rollback(): + with client() as c: + u, tok = user_with_token(c) + before = c.get(f"{API}/chats", headers=auth(tok)).json()["items"] + for ids in ([u["id"], u["id"]], # дубликат + [u["id"], str(uuid.uuid4())], # неизвестный участник + [str(uuid.uuid4())]): # нет вызывающего + r = c.post(f"{API}/chats", json={"title": "t", "member_ids": ids}, headers=auth(tok)) + assert r.status_code == 400, (ids, r.text) + assert c.get(f"{API}/chats", headers=auth(tok)).json()["items"] == before + + +# ---------- пагинация ---------- +def test_cursor_garbage_and_foreign_cursor_400(): + with client() as c: + u, tok = user_with_token(c) + c1, c2 = make_chat(c, tok, [u["id"]]), make_chat(c, tok, [u["id"]]) + for i in range(2): + c.post(f"{API}/chats/{c1['id']}/messages", json={"text": f"m{i}"}, headers=auth(tok)) + assert c.get(f"{API}/chats/{c1['id']}/messages?cursor=garbage", headers=auth(tok)).status_code == 400 + assert c.get(f"{API}/chats?cursor=garbage", headers=auth(tok)).status_code == 400 + nxt = c.get(f"{API}/chats/{c1['id']}/messages?limit=1", headers=auth(tok)).json()["next_cursor"] + assert nxt + assert c.get(f"{API}/chats/{c2['id']}/messages?cursor={nxt}", headers=auth(tok)).status_code == 400 + + +def test_pagination_with_equal_timestamps(): + with client() as c: + u, tok = user_with_token(c) + chat = make_chat(c, tok, [u["id"]]) + vals = ",".join(f"(gen_random_uuid(),'{chat['id']}','{u['id']}','m{i}','2026-01-01T00:00:00Z')" + for i in range(3)) + psql(f"INSERT INTO messages(id,chat_id,sender_id,text,created_at) VALUES {vals}") + seen, cursor = [], None + for _ in range(5): + url = f"{API}/chats/{chat['id']}/messages?limit=1" + (f"&cursor={cursor}" if cursor else "") + page = c.get(url, headers=auth(tok)).json() + seen += [m["id"] for m in page["items"]] + cursor = page["next_cursor"] + if not cursor: + break + assert len(seen) == 3 and len(set(seen)) == 3 + + +def test_pagination_full_walk_in_order(): + with client() as c: + u, tok = user_with_token(c) + chat = make_chat(c, tok, [u["id"]]) + sent = [c.post(f"{API}/chats/{chat['id']}/messages", json={"text": f"m{i}"}, + headers=auth(tok)).json()["id"] for i in range(5)] + got, cursor = [], None + while True: + url = f"{API}/chats/{chat['id']}/messages?limit=2" + (f"&cursor={cursor}" if cursor else "") + page = c.get(url, headers=auth(tok)).json() + got += [m["id"] for m in page["items"]] + cursor = page["next_cursor"] + if not cursor: + break + assert got == sent + + +# ---------- отказы зависимостей ---------- +@pytest.mark.chaos +def test_valkey_down_falls_back_to_db(): + with client() as c: + _, tok = user_with_token(c) + dc("stop", "valkey") + try: + assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200 # обход кэша + assert c.get(f"{API}/users/me").status_code == 401 # аноним не доверенный + assert c.get(f"{API}/users/me", headers={"Authorization": "Bearer nope"}).status_code == 401 + finally: + dc("start", "valkey") + time.sleep(2) + assert c.get(f"{API}/users/me", headers=auth(tok)).status_code == 200 + + +@pytest.mark.chaos +def test_db_paused_returns_503_and_recovers(): + with client() as c: + _, tok = user_with_token(c) + dc("pause", "db") + try: + t0 = time.time() + r = httpx.get(BASE + "/health/ready", timeout=8) + assert r.status_code == 503 + assert time.time() - t0 < 5 + assert c.get(f"{API}/users/me").status_code == 401 + r = httpx.get(f"{API}/chats", headers=auth(tok), timeout=20) + assert r.status_code == 503 and r.json()["error"]["code"] == "unavailable" + finally: + dc("unpause", "db") + wait_ready() + assert c.get(f"{API}/chats", headers=auth(tok)).status_code == 200 -- 2.54.0