diff --git a/.env.example b/.env.example index 714c8076..b06dc94d 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,12 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 -APP_ENV=lab +# Шаблон для локального учебного стенда. +# Скопируйте в .env и задайте отдельный пароль PostgreSQL. +# Не добавляйте настоящий .env и действующие пароли в Git. + +POSTGRES_PASSWORD=CHANGE_ME_LOCAL_ONLY + +# Срок жизни новых сессий в секундах. +# Для обычного smoke и persistence используйте не менее 300. SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url + +# TTL кэша публичных данных пользователя в Redis, в секундах. +USER_CACHE_TTL_SECONDS=60 \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..2f0bbebc --- /dev/null +++ b/Dockerfile @@ -0,0 +1,26 @@ +FROM python:3.12.10-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 + +WORKDIR /app + +COPY requirements.txt ./ +RUN pip install --no-cache-dir -r requirements.txt + +RUN addgroup --system appgroup \ + && adduser --system --ingroup appgroup --no-create-home appuser \ + && chown appuser:appgroup /app + +COPY --chown=appuser:appgroup app ./app +COPY --chown=appuser:appgroup migrations ./migrations + +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()" || exit 1 + +CMD ["python", "-m", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--no-access-log"] \ No newline at end of file diff --git a/Makefile b/Makefile index 9ecb223e..72d6d2df 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ PYTHON ?= python3 -BASE_URL ?= http://localhost:8080 +BASE_URL ?= http://localhost:18081 CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) @@ -24,3 +24,11 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +.PHONY: test-extra test-faults test-lab2 + +test-extra: ; BASE_URL="$(BASE_URL)" $(PYTHON) tests/lab2_checks.py + +test-faults: ; BASE_URL="$(BASE_URL)" $(PYTHON) tests/lab2_faults.py + +test-lab2: ; $(MAKE) test-extra && $(MAKE) test-faults \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index e42f2b05..3308000c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,657 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Соколова Полина, БВТ2304. +- Целевая оценка: 4. +- Трек уровня 5: не выполняется. +- Первый коммит реализации: 083dc49. +- Коммит рефакторинга / PR: добавить после публикации. + +Проверки выполнены на локальном стенде. Результаты сохранены +в каталоге `evidence/`. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +### Требования и версии + +Стенд разрабатывался и проверялся в Debian 12 под WSL 2. + +Использованные версии: + +- Docker Engine: `20.10.24+dfsg1`. +- Docker Compose: `v2.27.0`. +- Базовый образ приложения: `python:3.12.10-slim-bookworm`. +- PostgreSQL: `postgres:16.4-bookworm`. +- Redis: `redis:7.2.5-bookworm`. +- FastAPI: `0.115.12`. +- Uvicorn: `0.34.2`. +- Psycopg: `3.2.6`. +- psycopg-pool: `3.2.6`. +- redis-py: `5.2.1`. +- argon2-cffi: `23.1.0`. + +Прямые зависимости Python закреплены в `requirements.txt`. +Для запуска публичных и собственных тестов на стороне хоста +используется Python 3.9+. + +Внешний адрес API: `http://localhost:18081`. +Внутри контейнера приложение слушает `0.0.0.0:8080`. + +Порт `18081` выбран из-за занятых портов `8080` и `8081` +в локальном окружении. + +### Подготовка и запуск + +Команды выполняются из корня клонированного репозитория. + +При первоначальной настройке: + +```sh +cp .env.example .env +``` + +В новом локальном `.env` необходимо заменить +`POSTGRES_PASSWORD=CHANGE_ME_LOCAL_ONLY` отдельным учебным паролем. + +Файл `.env` не добавляется в Git. +Для уже настроенного стенда его не следует перезаписывать шаблоном. + +После настройки: + +```sh +docker compose --env-file .env config --quiet +docker compose --env-file .env build api +docker compose --env-file .env up -d --wait api redis +docker compose ps -a + +curl -i http://localhost:18081/health/live +curl -i http://localhost:18081/health/ready +``` + +Compose запускает PostgreSQL, одноразовый сервис `migrate` и API. +API зависит от готовности PostgreSQL и успешного завершения миграций. +Redis запускается явно в приведённой команде. + +Ожидаемое состояние: + +- `api` — healthy; +- `postgres` — healthy; +- `redis` — healthy; +- `migrate` — завершён с кодом `0`. + +### Миграции + +SQL-файлы находятся в `migrations/`. +Программа `app/migrate.py` хранит применённые версии и контрольные +суммы в таблице `schema_migrations`. + +Повторный запуск: + +```sh +docker compose --env-file .env run --rm migrate +``` + +Для уже применённого файла выводится: + +```text +Already applied: 001_initial.sql +Migrations committed successfully +``` + +Повторная миграция не создаёт дубликаты таблиц и данных. +Изменение применённого SQL-файла обнаруживается по контрольной сумме. + +Изменения схемы следует добавлять новой миграцией, +не редактируя уже применённые файлы. + +### Проверки + +```sh +make check + +make test BASE_URL=http://localhost:18081 + +make test-persistence \ + BASE_URL=http://localhost:18081 \ + ACTION_SCRIPT=scripts/restart.sh + +make test-lab2 BASE_URL=http://localhost:18081 +``` + +`make test-lab2` последовательно запускает: + +- `make test-extra` — шесть собственных проверок; +- `make test-faults` — отказы зависимостей и короткий TTL. + +Сценарий `test-faults` управляет локальным Compose-стендом. +Его нельзя запускать параллельно с другими проверками +или направлять на произвольный удалённый сервер. + +Для smoke и persistence используется обычный TTL `3600` секунд. +В тесте expiry API временно запускается с TTL `2` секунды, +после чего восстанавливается первоначальная настройка. + +Проверка индекса: + +```sh +docker compose exec -T postgres \ + psql -X -U messenger -d messenger -v ON_ERROR_STOP=1 \ + < scripts/explain_history.sql +``` + +Перед этим должен пройти smoke или собственные тесты: +SQL-сценарий использует одного существующего пользователя. + +Каждый запуск SQL-сценария создаёт новый чат и 10 000 сообщений. +Данные тестов автоматически не удаляются. + +### Остановка и удаление данных + +Остановка без удаления данных: + +```sh +docker compose --env-file .env stop +``` + +Удаление контейнеров и сети с сохранением именованных volumes: + +```sh +docker compose --env-file .env down +``` + +Только для намеренного полного сброса учебных данных: + +```sh +docker compose --env-file .env down --volumes +``` + +Последняя команда удаляет volumes PostgreSQL и Redis. +Она не применяется в persistence-проверках. + +Инструкция запуска подготовлена для нового окружения. +Отдельный эксперимент запуска из чистого clone с новыми volumes +на момент заполнения отчёта не выполнен. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +### Компоненты + +```text +Клиент + | + | HTTP, localhost:18081 + v +FastAPI + |-- PostgreSQL: источник истины + |-- Redis: кэш публичных данных пользователя +``` + +В PostgreSQL находятся: + +- `users` — пользователи и хеши паролей; +- `chats` — чаты; +- `chat_members` — участники; +- `messages` — сообщения; +- `sessions` — хеши токенов и сроки действия сессий; +- `schema_migrations` — история применения миграций. + +Обязательные данные не хранятся только в локальной памяти API. +Для PostgreSQL и Redis настроены отдельные именованные volumes. + +Порты хранилищ не публикуются на хосте. +API опубликован только на `127.0.0.1`. + +### Организация кода + +После реализации выполнен рефакторинг: маршруты и вспомогательные +функции вынесены из `main.py` в отдельные модули по назначению. + +```text +app/ + __init__.py + main.py — создание приложения, lifespan, middleware + и обработчики исключений + config.py — настройки срока действия сессий + errors.py — API-ошибки и формирование ответов с ошибками + responses.py — преобразование UUID и времени в JSON + validation.py — проверка входных данных + pagination.py — курсоры и формирование страниц + dependencies.py — текущий пользователь и доступ к чату + auth.py — Argon2id, Basic/Bearer и токены + cache.py — кэш пользователей в Redis + db.py — пул соединений PostgreSQL + store.py — SQL-запросы и транзакции + migrate.py — применение миграций + routers/ + __init__.py + health.py — live и ready + users.py — регистрация и текущий пользователь + sessions.py — вход и logout + chats.py — операции с чатами + messages.py — отправка и история сообщений +``` + +Каждая группа маршрутов использует `APIRouter`. +Маршруты подключаются в `main.py` через `app.include_router(...)`. + +В результате: + +- `main.py` сокращён с 655 до 112 строк; +- объявления всех 11 маршрутов сохранены; +- SQL-запросы и схема БД не изменены; +- функции перенесены без намеренного изменения поведения API; +- обработчики сгруппированы по предметной области; +- вспомогательные функции отделены от маршрутов. + +После рефакторинга выполнены проверка импорта, публичный smoke +и собственные тесты. Импорт приложения подтвердил регистрацию +11 маршрутов. + +### Изменения относительно лабораторной 1 + +Сохранены операции пользователей, чатов, сообщений и история. + +Изменено: + +- in-memory хранилище заменено PostgreSQL; +- при регистрации требуется `password`; +- вход выполняется через Basic; +- бизнес-запросы используют Bearer вместо `X-User-Id`; +- добавлены expiry и logout; +- добавлены Redis, миграции и проверки отказов; +- пагинация выполняется SQL-запросом без загрузки всей истории; +- код API разделён на маршруты и вспомогательные модули. + +### Аутентификация и сессии + +Пароли хешируются библиотекой `argon2-cffi` с Argon2id. + +`PasswordHasher` использует параметры: + +- `time_cost=3`; +- `memory_cost=65536 KiB`; +- `parallelism=4`; +- `hash_len=32`; +- `salt_len=16`. + +Вычисление и проверка хеша выполняются через `run_in_threadpool`, +а не непосредственно в цикле асинхронных HTTP-обработчиков. + +Basic credentials декодируются как UTF-8. +Разделение `username:password` выполняется по первому двоеточию, +поэтому двоеточия внутри пароля сохраняются. + +Для неизвестного username выполняется проверка фиктивного хеша. +Неверный пароль и неизвестный пользователь получают одинаковый +ответ `401` и сообщение об ошибке. Это не является гарантией +абсолютно одинакового времени ответа. + +Токен сессии генерируется `secrets.token_urlsafe(32)`: +используется 32 случайных байта, то есть 256 бит случайности. + +Клиент получает исходный токен, в PostgreSQL сохраняется +SHA-256 токена. + +SHA-256 применяется к случайным токенам и файлам миграций, +но не заменяет password KDF. + +Срок действия проверяется по времени PostgreSQL. +Истёкшая строка `sessions` не даёт доступ, даже если физически +ещё не удалена. Logout удаляет текущую сессию. + +`X-User-Id` не используется для аутентификации +и не меняет владельца действующей Bearer-сессии. + +Сессии сохраняются в PostgreSQL и пережили проверенный рестарт. + +### Аутентификация и доступ к ресурсам + +На защищённых endpoint сначала проверяется сессия, +затем доступ к конкретному чату. + +Неизвестный и чужой чат возвращают одинаковый `404`. +Участник чата может читать его историю и отправлять сообщения. + +Отправитель сообщения определяется по действующей сессии, +а не по полю, переданному клиентом. + +### Роль Redis + +Redis содержит только публичные поля пользователя: + +- `id`; +- `username`; +- `display_name`; +- `created_at`. + +Политика: + +- источник истины — PostgreSQL; +- TTL кэша по умолчанию — 60 секунд; +- пароли, хеши паролей и токены не кэшируются; +- действительность сессии проверяется в PostgreSQL до чтения кэша; +- при отказе Redis профиль читается из PostgreSQL; +- при отказе PostgreSQL кэш не заменяет проверку сессии; +- изменение и удаление профиля отсутствуют в обязательном API, + поэтому в текущем контракте используется истечение по TTL. + +Для Redis включён AOF с `appendfsync everysec`. +Сохранность сессий не зависит от Redis: они находятся в PostgreSQL. + +### Транзакции и ограничения + +В БД определены первичные и внешние ключи, +уникальность username и ограничения длины полей. + +Составной внешний ключ `messages(chat_id, sender_id)` +ссылается на `chat_members(chat_id, user_id)`. + +Создание чата и добавление всех участников выполняются +в одной транзакции. Ошибка участника откатывает всю операцию. + +В rollback-тесте проверяется не только HTTP 400, +но и отсутствие изменений количества чатов и участников. +После ошибки отдельно проверяется успешное создание валидного чата. + +При регистрации конкурентная уникальность обеспечивается +ограничением `users_username_unique`. +Конфликт username возвращается как HTTP 409. + +Ответ об успешной записи формируется после выхода +из транзакционного блока с успешным COMMIT. + +### Соединения и таймауты + +Используется `AsyncConnectionPool`: + +- `min_size=1`; +- `max_size=5` на процесс API; +- ожидание соединения — 3 секунды; +- `max_waiting=20`; +- `connect_timeout=3` секунды; +- `statement_timeout=3000 ms`; +- `lock_timeout=2000 ms`; +- `idle_in_transaction_session_timeout=10000 ms`. + +Значения SQL передаются параметрами, а не конкатенацией +пользовательского ввода. + +Динамически выбираемые фрагменты запросов пагинации +состоят из фиксированных строк приложения; +значения курсора и лимита передаются отдельно. + +Redis: + +- `socket_connect_timeout=0.2` секунды; +- `socket_timeout=0.2` секунды; +- `max_connections=10`. + +Эти настройки не являются единой жёсткой границей времени +любого HTTP-запроса. В сценарии отказов отдельно проверяется +локальный бюджет запроса менее 10 секунд. + +### Пагинация и конкурентные вставки + +История сортируется по `(created_at, id)`. +Курсор содержит эту пару и область запроса. +Курсор другого чата отклоняется. + +Для списка чатов также используется keyset-пагинация. +Область курсора привязана к текущему пользователю +и отличается от области курсоров сообщений. + +Запрашивается `limit + 1` строка для определения `next_cursor`. +Для неизменной истории продолжение использует строгое сравнение `>`, +поэтому последняя строка предыдущей страницы не повторяется. + +Между HTTP-запросами общий snapshot не поддерживается. +При конкурентных вставках новая запись с ключом больше текущего +курсора может попасть в последующие страницы. +Запись с ключом не больше уже пройденного курсора может быть +пропущена текущим обходом. + +Время создания пользователей, чатов и сообщений назначается +сервером БД через `clock_timestamp()`. + +Часы не являются уникальным идентификатором или гарантией +порядка COMMIT; для разрешения одинакового времени используется `id`. + +История сообщений не кэшируется в Redis. +Чтение истории выполняется из PostgreSQL. + +### Health и ошибки + +`/health/live` проверяет жизнь процесса и не обращается к БД. + +`/health/ready` проверяет доступность PostgreSQL. +Redis не является критичной зависимостью readiness: +при его отказе предусмотрен обход кэша. + +Ответы API содержат непустой `X-Request-Id`. +Ошибки используют единый JSON-формат, в котором `request_id` +совпадает с заголовком ответа. + +При неверной аутентификации возвращается соответствующий +`WWW-Authenticate` для Basic или Bearer. + +Ошибки зависимости не раскрывают SQL, credentials +или внутренний traceback в HTTP-ответе. + +### Конфигурация + +`.env.example` соответствует реализации: + +| Переменная | Назначение | +| --- | --- | +| `POSTGRES_PASSWORD` | Пароль PostgreSQL; передаётся приложению как `PGPASSWORD` | +| `SESSION_TTL_SECONDS` | Срок действия новых сессий, по умолчанию 3600 | +| `USER_CACHE_TTL_SECONDS` | TTL кэша пользователя, по умолчанию 60 | + +Адреса и имена сервисов заданы в `compose.yaml`. +Реальные credentials и `.env` не включаются в репозиторий. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий | Команда / сценарий | Наблюдаемый результат | Доказательство | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Структура и синтаксис | `make check` | PASS; приложение этой проверкой не тестируется | Вывод команды | +| Публичный API после рефакторинга | `make test BASE_URL=http://localhost:18081` | PASS: lab2 public API scenario | `evidence/smoke-final.txt` | +| Разделение API на модули | Импорт приложения и просмотр структуры | `main.py` — 112 строк; зарегистрировано 11 маршрутов | `app/main.py`, `app/routers/`, вспомогательные модули; вывод импорта | +| Миграции | Повторный запуск `migrate` | Already applied; в `schema_migrations` одна версия `001_initial.sql` | Вывод миграции и SELECT; `app/migrate.py` | +| Сохранность данных и сессии | `make test-persistence` с `scripts/restart.sh` | PASS: confirmed data and existing session preserved | Вывод persistence-теста; `evidence/persistence-before.txt` и `evidence/persistence-after.txt` | +| Реальный рестарт API и хранилищ | Сравнение `StartedAt` | Время запуска изменилось у API, PostgreSQL и Redis | `evidence/persistence-before.txt`; `evidence/persistence-after.txt` | +| Гонка username | Четыре конкурентные регистрации | Один 201 и три 409; вход созданного пользователя успешен | `evidence/lab2-final.txt` | +| Атомарность чата | Создание с неизвестным участником | 400; количество чатов и участников не изменилось; следующая валидная операция успешна | `evidence/lab2-final.txt` | +| Logout | Отзыв и повторное использование токена | 204 без тела; последующее чтение и повторный logout дают 401 | `evidence/lab2-final.txt` | +| Неверный пароль | Вход с неправильным паролем и неизвестным username | Одинаковый 401 и сообщение | `evidence/lab2-final.txt` | +| Unicode и двоеточия | Регистрация и вход с таким паролем | Успешный вход | `evidence/lab2-final.txt` | +| `X-User-Id` | Запрос без Bearer и попытка смены пользователя | Без токена 401; с токеном владелец не меняется | `evidence/lab2-final.txt` | +| Короткий expiry | `SESSION_TTL_SECONDS=2` | Сначала 200, затем 401 | `evidence/lab2-final.txt` | +| Отказ Redis | Остановка Redis | Действующий токен работает через PostgreSQL; анонимный доступ запрещён | `evidence/lab2-final.txt` | +| Отказ PostgreSQL | Остановка БД при заполненном кэше | Защищённый запрос 503; live 200; ready 503; без токена 401 | `evidence/lab2-final.txt` | +| Возврат PostgreSQL | Запуск БД после отказа | Прежняя сессия снова работает | `evidence/lab2-final.txt` | +| Индекс истории | EXPLAIN на 10 000 сообщениях | Index Scan для первой страницы и страницы после курсора | `evidence/explain-history.txt` | +| Pool и безопасные SQL-запросы | Проверка реализации | Ограниченный пул, таймауты, параметры SQL | `app/db.py`; `app/store.py` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Последовательность проверок -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +До рефакторинга выполнены: + +- применение и повторное применение миграций; +- публичный smoke; +- полный persistence-сценарий; +- собственные проверки; +- эксперимент с индексом на 10 000 сообщениях. + +После разделения `main.py` повторно выполнены: + +- импорт приложения; +- `make check`; +- публичный smoke; +- шесть собственных проверок; +- отказы Redis и PostgreSQL; +- проверка восстановления прежней сессии после возврата PostgreSQL; +- проверка expiry с коротким TTL. + +Полный persistence-сценарий с одновременным охватом API +и всех хранилищ после рефакторинга отдельно не повторялся. +SQL-запросы, миграции и restart-hook при рефакторинге не менялись. + +### Persistence + +Тест завершился: + +```text +PASS: persistence preserved confirmed data and existing session. +``` + +Зафиксированные времена запуска до и после: + +| Сервис | До, UTC | После, UTC | +| --- | --- | --- | +| API | 14:33:23 | 14:38:37 | +| PostgreSQL | 11:25:08 | 14:38:30 | +| Redis | 11:25:08 | 14:38:30 | + +Дата эксперимента: 2026-10-16. +Полные временные метки находятся в `evidence/`. + +Скрипт перезапускает API и оба используемых хранилища, +не удаляя volumes и не подменяя тестовые данные. + +После перезапуска тест прочитал подтверждённые данные +с прежним токеном без повторного входа. + +### Отказы и expiry: финальный запуск после рефакторинга + +| Воздействие | Наблюдение | +| --- | --- | +| Остановка Redis | Fallback успешен; защищённый запрос 0.135 s | +| Остановка PostgreSQL | Защищённый запрос получил 503 за 3.005 s | +| Возврат PostgreSQL | Прежняя сессия восстановила доступ | +| TTL=2 | Отказ по expiry наблюдался через 2.075 s после начала наблюдения | +| Завершение теста | Зависимости восстановлены; API запущен с TTL=3600; финальный ready-запрос успешен | + +Это одиночный локальный сценарий, не статистическое измерение +задержек и не production SLA. + +Полное время восстановления от момента запуска зависимости +отдельно не измерялось. + +Шесть собственных проверок в финальном запуске: + +```text +Ran 6 tests in 1.376s + +OK +``` + +Сценарий отказов завершился: + +```text +RESTORED: services running; SESSION_TTL_SECONDS=3600 +PASS: dependency outages and short session expiry +``` + +Результаты последнего запуска находятся в `evidence/lab2-final.txt`. +Файлы `evidence/lab2-checks.txt` и `evidence/lab2-faults.txt` +содержат результаты более ранних запусков. + +### Индекс истории + +Набор: 10 000 сообщений в одном чате, +1 000 различных `created_at`, по десять сообщений +на временную метку. + +Для синтетического набора использована фиксированная базовая дата. +Это подготовка данных эксперимента напрямую через SQL, +а не отправка сообщений через HTTP API. + +Индекс: + +```sql +CREATE INDEX messages_chat_created_id_idx +ON messages (chat_id, created_at, id); +``` + +Перед измерением выполнено: + +```sql +ANALYZE messages; +``` + +Проверены первая страница и страница после курсора +около середины истории. + +| Запрос | План | Фактически выдано строк | Shared hit | Execution Time | +| --- | --- | --- | --- | --- | +| Первая страница | Index Scan | 51 | 3 | 0.025 ms | +| Страница после курсора около середины | Index Scan | 51 | 9 | 0.052 ms | + +У второй страницы условие по `(created_at, id)` +входит в `Index Cond`. Отдельного узла `Sort` нет. + +`LIMIT 51` соответствует реализации: для страницы из 50 сообщений +запрашивается одна дополнительная строка. + +`OFFSET` используется только для подготовки контрольного +курсора в эксперименте, но не в запросах страниц приложения. + +На проверенных запросах PostgreSQL использует индекс, +а не полный последовательный scan истории для каждой страницы. + +Показанные времена относятся к SQL-запросам на данном наборе, +а не к HTTP API. В плане указаны shared hits; +холодный кэш отдельно не исследовался. + +После рефакторинга этот эксперимент повторно не выполнялся: +`app/store.py`, SQL-запросы и индекс не менялись. + +Нагрузочное исследование RPS, p50/p95/p99 и потребления CPU/RAM +не проводилось. Лимиты CPU/RAM сервисов в Compose не заданы. +Исследовательские треки уровня 5 не заявляются. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- По одному экземпляру API, PostgreSQL и Redis. + Высокая доступность не реализована. +- При отказе PostgreSQL обязательный путь недоступен; + API возвращает контролируемую ошибку. +- Redis является необязательным для корректности кэшем. +- Проверен штатный рестарт с сохранением volumes, + не потеря диска, авария питания или повреждение данных. +- Полный persistence-сценарий выполнен до рефакторинга. + После него повторены smoke и собственные проверки, + включая отказ и возврат PostgreSQL. +- HTTP применяется только для локального изолированного стенда + с синтетическими данными. +- Постраничный обход не является snapshot всей истории. +- Устаревшие строки `sessions` автоматически не очищаются, + но не проходят проверку expiry. +- При добавлении изменения или удаления профиля потребуется + дополнить политику инвалидации кэша. +- Rate limiting, вложения и фоновые workers не реализованы: + они не входят в обязательную реализацию этой лабораторной. +- Теги образов и прямые зависимости закреплены; + digest образов и полный lock транзитивных зависимостей не добавлены. +- Проверки не являются полным security/fuzz/load suite. +- Запуск из чистого clone с новыми volumes не заявляется + как выполненный эксперимент. +- Возможные следующие улучшения: отдельная проверка чистого запуска, + периодическая очистка истёкших сессий и расширение негативных тестов. + Эти улучшения не заявляются как реализованные. + +## Использованные материалы, библиотеки + +- Задание `README.md` и `contracts/README.md`. +- `contracts/openapi.json` и публичные `tests/`. +- Документация Docker Compose. +- Документация PostgreSQL: ограничения, транзакции, + индексы и EXPLAIN. +- Документация Psycopg 3 и psycopg-pool. +- Документация redis-py. +- Документация argon2-cffi. +- Документация FastAPI: приложение из нескольких файлов, + APIRouter и lifespan. +- FastAPI, Uvicorn и стандартная библиотека Python. \ No newline at end of file diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/auth.py b/app/auth.py new file mode 100644 index 00000000..3db7b8a2 --- /dev/null +++ b/app/auth.py @@ -0,0 +1,108 @@ +from __future__ import annotations + +import base64 +import binascii +import hashlib +import re +import secrets + +from argon2 import PasswordHasher, Type +from argon2.exceptions import VerificationError +from starlette.concurrency import run_in_threadpool + + +USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}", re.ASCII) + +password_hasher = PasswordHasher( + time_cost=3, + memory_cost=65536, + parallelism=4, + hash_len=32, + salt_len=16, + type=Type.ID, +) + +DUMMY_PASSWORD_HASH = password_hasher.hash( + secrets.token_urlsafe(32) +) + + +async def hash_password(password: str) -> str: + return await run_in_threadpool( + password_hasher.hash, + password, + ) + + +async def verify_password( + password_hash: str, + password: str, +) -> bool: + try: + return await run_in_threadpool( + password_hasher.verify, + password_hash, + password, + ) + except VerificationError: + return False + + +def parse_basic_credentials( + authorization: str | None, +) -> tuple[str, str] | None: + if authorization is None or len(authorization) > 2048: + return None + + parts = authorization.split() + + if len(parts) != 2 or parts[0].lower() != "basic": + return None + + try: + decoded = base64.b64decode( + parts[1], + validate=True, + ).decode("utf-8") + except (binascii.Error, UnicodeError, ValueError): + return None + + username, separator, password = decoded.partition(":") + + if not separator: + return None + + if USERNAME_RE.fullmatch(username) is None: + return None + + if not 12 <= len(password) <= 128: + return None + + return username, password + + +def parse_bearer_token( + authorization: str | None, +) -> str | None: + if authorization is None or len(authorization) > 2048: + return None + + parts = authorization.split() + + if len(parts) != 2 or parts[0].lower() != "bearer": + return None + + token = parts[1] + + if re.fullmatch(r"[A-Za-z0-9_-]{43}", token) is None: + return None + + return token + + +def generate_token() -> str: + return secrets.token_urlsafe(32) + + +def hash_token(token: str) -> str: + return hashlib.sha256(token.encode("ascii")).hexdigest() \ No newline at end of file diff --git a/app/cache.py b/app/cache.py new file mode 100644 index 00000000..acd7d21a --- /dev/null +++ b/app/cache.py @@ -0,0 +1,129 @@ +from __future__ import annotations + +import json +import logging +import os +from datetime import datetime, timezone +from uuid import UUID + +from redis.asyncio import Redis +from redis.exceptions import RedisError + +from app.store import store + + +logger = logging.getLogger("messenger.cache") + +CACHE_TTL_SECONDS = int( + os.getenv("USER_CACHE_TTL_SECONDS", "60") +) + +if not 1 <= CACHE_TTL_SECONDS <= 3600: + raise ValueError( + "USER_CACHE_TTL_SECONDS must be between 1 and 3600" + ) + + +redis_client = Redis( + host=os.getenv("REDIS_HOST", "redis"), + port=int(os.getenv("REDIS_PORT", "6379")), + decode_responses=True, + socket_connect_timeout=0.2, + socket_timeout=0.2, + retry_on_timeout=False, + max_connections=10, +) + + +def serialize_user(user: dict) -> str: + created_at = user["created_at"] + + return json.dumps( + { + "id": str(user["id"]), + "username": user["username"], + "display_name": user["display_name"], + "created_at": created_at.astimezone( + timezone.utc + ).isoformat().replace("+00:00", "Z"), + }, + ensure_ascii=False, + separators=(",", ":"), + ) + + +def deserialize_user( + raw: str, + expected_id: UUID, +) -> dict: + data = json.loads(raw) + + if not isinstance(data, dict): + raise ValueError("Invalid cached user") + + expected_fields = { + "id", + "username", + "display_name", + "created_at", + } + + if set(data) != expected_fields: + raise ValueError("Invalid cached user fields") + + if not all(isinstance(value, str) for value in data.values()): + raise ValueError("Invalid cached user types") + + user_id = UUID(data["id"]) + + if user_id != expected_id: + raise ValueError("Cached user ID mismatch") + + created_at = datetime.fromisoformat( + data["created_at"].replace("Z", "+00:00") + ) + + if created_at.tzinfo is None: + raise ValueError("Cached timestamp has no timezone") + + return { + "id": user_id, + "username": data["username"], + "display_name": data["display_name"], + "created_at": created_at, + } + + +async def get_cached_user(user_id: UUID) -> dict | None: + key = f"user:v1:{user_id}" + + try: + raw = await redis_client.get(key) + + if raw is not None: + return deserialize_user(raw, user_id) + + except RedisError: + logger.warning("User cache read unavailable") + except (ValueError, TypeError, OverflowError): + logger.warning("Invalid user cache entry ignored") + + user = await store.get_user(user_id) + + if user is None: + return None + + try: + await redis_client.set( + key, + serialize_user(user), + ex=CACHE_TTL_SECONDS, + ) + except RedisError: + logger.warning("User cache write unavailable") + + return user + + +async def close_cache() -> None: + await redis_client.aclose() \ No newline at end of file diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..477e8bbc --- /dev/null +++ b/app/config.py @@ -0,0 +1,12 @@ +from __future__ import annotations + +import os + + +SESSION_TTL_SECONDS = int( + os.getenv("SESSION_TTL_SECONDS", "3600") +) + + +if SESSION_TTL_SECONDS < 1: + raise ValueError("SESSION_TTL_SECONDS must be positive") diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..0cdd85ad --- /dev/null +++ b/app/db.py @@ -0,0 +1,44 @@ +from __future__ import annotations + +import os + +from psycopg.rows import dict_row +from psycopg_pool import AsyncConnectionPool + + +pool = AsyncConnectionPool( + conninfo="", + kwargs={ + "host": os.getenv("PGHOST", "postgres"), + "port": int(os.getenv("PGPORT", "5432")), + "dbname": os.getenv("PGDATABASE", "messenger"), + "user": os.getenv("PGUSER", "messenger"), + "password": os.environ.get("PGPASSWORD", ""), + "connect_timeout": 3, + "options": ( + "-c statement_timeout=3000 " + "-c lock_timeout=2000 " + "-c idle_in_transaction_session_timeout=10000" + ), + "row_factory": dict_row, + }, + min_size=1, + max_size=5, + timeout=3, + max_waiting=20, + open=False, + check=AsyncConnectionPool.check_connection, +) + + +async def open_db() -> None: + await pool.open(wait=True, timeout=10) + + +async def close_db() -> None: + await pool.close() + + +async def check_db() -> None: + async with pool.connection() as conn: + await conn.execute("SELECT 1") \ No newline at end of file diff --git a/app/dependencies.py b/app/dependencies.py new file mode 100644 index 00000000..59efb145 --- /dev/null +++ b/app/dependencies.py @@ -0,0 +1,48 @@ +from __future__ import annotations + +from uuid import UUID + +from fastapi import Request + +from app.auth import hash_token, parse_bearer_token +from app.cache import get_cached_user +from app.errors import not_found, unauthorized +from app.store import store +from app.validation import parse_uuid + + +async def current_user(request: Request) -> tuple[dict, str]: + token = parse_bearer_token( + request.headers.get("authorization") + ) + + if token is None: + raise unauthorized() + + token_digest = hash_token(token) + + user_id = await store.get_session_user_id(token_digest) + + if user_id is None: + raise unauthorized() + + user = await get_cached_user(user_id) + + if user is None: + raise unauthorized() + + return user, token_digest + + +async def accessible_chat( + raw_chat_id: str, + user_id: UUID, +) -> tuple[UUID, dict]: + chat_id = parse_uuid(raw_chat_id) + + chat = await store.get_accessible_chat(chat_id, user_id) + + if chat is None: + raise not_found() + + return chat_id, chat diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..adc2fb83 --- /dev/null +++ b/app/errors.py @@ -0,0 +1,71 @@ +from __future__ import annotations + +from uuid import uuid4 + +from fastapi import Request +from fastapi.responses import JSONResponse + + +class ApiError(Exception): + def __init__( + self, + status: int, + code: str, + message: str, + challenge: str | None = None, + ): + super().__init__(message) + self.status = status + self.code = code + self.message = message + self.challenge = challenge + + +def invalid(message: str = "Некорректный запрос") -> ApiError: + return ApiError(400, "invalid_request", message) + + +def unauthorized(scheme: str = "Bearer") -> ApiError: + if scheme == "Basic": + challenge = 'Basic realm="messenger", charset="UTF-8"' + else: + challenge = 'Bearer realm="messenger"' + + return ApiError( + 401, + "unauthorized", + "Недействительная аутентификация", + challenge, + ) + + +def not_found() -> ApiError: + return ApiError(404, "not_found", "Объект не найден") + + +def error_response( + request: Request, + error: ApiError, +) -> JSONResponse: + request_id = getattr( + request.state, + "request_id", + str(uuid4()), + ) + + headers = {"X-Request-Id": request_id} + + if error.challenge is not None: + headers["WWW-Authenticate"] = error.challenge + + return JSONResponse( + status_code=error.status, + content={ + "error": { + "code": error.code, + "message": error.message, + "request_id": request_id, + } + }, + headers=headers, + ) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..8a611f3e --- /dev/null +++ b/app/main.py @@ -0,0 +1,112 @@ +from __future__ import annotations + +import logging +from contextlib import asynccontextmanager +from uuid import uuid4 + +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from psycopg import InterfaceError, OperationalError +from psycopg.errors import LockNotAvailable, QueryCanceled +from psycopg_pool import PoolTimeout, TooManyRequests +from starlette.exceptions import HTTPException + +from app.cache import close_cache +from app.db import close_db, open_db +from app.errors import ApiError, error_response, invalid, not_found +from app.routers import chats, health, messages, sessions, users + + +logger = logging.getLogger("messenger.api") + + +@asynccontextmanager +async def lifespan(app: FastAPI): + try: + await open_db() + yield + finally: + await close_cache() + await close_db() + + +app = FastAPI( + title="PostgreSQL messenger — Lab 2", + docs_url=None, + redoc_url=None, + openapi_url=None, + lifespan=lifespan, +) + + +@app.middleware("http") +async def request_middleware(request: Request, call_next): + request.state.request_id = str(uuid4()) + + try: + response = await call_next(request) + + except ApiError as exc: + response = error_response(request, exc) + + except ( + OperationalError, + InterfaceError, + PoolTimeout, + TooManyRequests, + QueryCanceled, + LockNotAvailable, + ) as exc: + logger.warning( + "Database unavailable request_id=%s error_type=%s", + request.state.request_id, + type(exc).__name__, + ) + response = error_response( + request, + ApiError( + 503, + "unavailable", + "Сервис временно недоступен", + ), + ) + + except Exception as exc: + logger.error( + "Unhandled error request_id=%s error_type=%s", + request.state.request_id, + type(exc).__name__, + ) + response = error_response( + request, + ApiError( + 500, + "internal_error", + "Внутренняя ошибка сервера", + ), + ) + + response.headers["X-Request-Id"] = request.state.request_id + return response + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request: Request, exc): + return error_response(request, invalid()) + + +@app.exception_handler(HTTPException) +async def http_error_handler(request: Request, exc: HTTPException): + if exc.status_code == 404: + error = not_found() + else: + error = invalid("Недопустимый HTTP-запрос") + + return error_response(request, error) + + +app.include_router(health.router) +app.include_router(users.router) +app.include_router(sessions.router) +app.include_router(chats.router) +app.include_router(messages.router) diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..4d1cb2f7 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,84 @@ +from __future__ import annotations + +import hashlib +import os +from pathlib import Path + +import psycopg + + +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" +MIGRATION_LOCK_ID = 202602001 + + +def apply_migrations() -> None: + files = sorted(MIGRATIONS_DIR.glob("[0-9]*_*.sql")) + + if not files: + raise RuntimeError("Migration files not found") + + with psycopg.connect( + host=os.getenv("PGHOST", "postgres"), + port=int(os.getenv("PGPORT", "5432")), + dbname=os.getenv("PGDATABASE", "messenger"), + user=os.getenv("PGUSER", "messenger"), + password=os.environ["PGPASSWORD"], + connect_timeout=5, + options="-c statement_timeout=30000 -c lock_timeout=10000", + ) as conn: + conn.execute( + "SELECT pg_advisory_xact_lock(%s)", + (MIGRATION_LOCK_ID,), + ) + + conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + checksum TEXT NOT NULL, + applied_at TIMESTAMPTZ NOT NULL + DEFAULT clock_timestamp() + ) + """ + ) + + for path in files: + version = path.name + content = path.read_bytes() + checksum = hashlib.sha256(content).hexdigest() + + row = conn.execute( + """ + SELECT checksum + FROM schema_migrations + WHERE version = %s + """, + (version,), + ).fetchone() + + if row is not None: + if row[0] != checksum: + raise RuntimeError( + f"Applied migration was modified: {version}" + ) + + print(f"Already applied: {version}", flush=True) + continue + + conn.execute(content.decode("utf-8"), prepare=False) + + conn.execute( + """ + INSERT INTO schema_migrations (version, checksum) + VALUES (%s, %s) + """, + (version, checksum), + ) + + print(f"Executed: {version} (pending commit)", flush=True) + + print("Migrations committed successfully", flush=True) + + +if __name__ == "__main__": + apply_migrations() \ No newline at end of file diff --git a/app/pagination.py b/app/pagination.py new file mode 100644 index 00000000..839f7069 --- /dev/null +++ b/app/pagination.py @@ -0,0 +1,128 @@ +from __future__ import annotations + +import base64 +import binascii +import json +import re +from datetime import datetime +from uuid import UUID + +from fastapi import Request +from fastapi.responses import JSONResponse + +from app.errors import invalid +from app.responses import json_response, utc_text + + +def encode_cursor(scope: str, item: dict) -> str: + raw = json.dumps( + { + "scope": scope, + "created_at": utc_text(item["created_at"]), + "id": str(item["id"]), + }, + separators=(",", ":"), + ).encode("utf-8") + + return ( + base64.urlsafe_b64encode(raw) + .decode("ascii") + .rstrip("=") + ) + + +def decode_cursor( + cursor: str, + scope: str, +) -> tuple[datetime, UUID]: + if not cursor or len(cursor) > 2048: + raise invalid("Некорректный cursor") + + try: + padded = cursor + "=" * (-len(cursor) % 4) + + raw = base64.b64decode( + padded, + altchars=b"-_", + validate=True, + ) + + data = json.loads(raw.decode("utf-8")) + + if ( + not isinstance(data, dict) + or set(data) != {"scope", "created_at", "id"} + or data["scope"] != scope + ): + raise ValueError + + timestamp = data["created_at"] + + if ( + not isinstance(timestamp, str) + or not timestamp.endswith("Z") + or not isinstance(data["id"], str) + ): + raise ValueError + + created_at = datetime.fromisoformat( + timestamp[:-1] + "+00:00" + ) + + item_id = UUID(data["id"]) + + return created_at, item_id + + except ( + ValueError, + TypeError, + UnicodeError, + binascii.Error, + OverflowError, + ): + raise invalid("Некорректный cursor") from None + + +def pagination( + request: Request, + scope: str, +) -> tuple[int, tuple[datetime, UUID] | None]: + raw_limit = request.query_params.get("limit", "50") + + if ( + len(raw_limit) > 10 + or re.fullmatch(r"[0-9]+", raw_limit) is None + ): + raise invalid("Некорректный limit") + + limit = int(raw_limit) + + if not 1 <= limit <= 100: + raise invalid("Некорректный limit") + + raw_cursor = request.query_params.get("cursor") + after = None + + if raw_cursor is not None: + after = decode_cursor(raw_cursor, scope) + + return limit, after + + +def page_response( + rows: list[dict], + limit: int, + scope: str, +) -> JSONResponse: + items = rows[:limit] + next_cursor = None + + if len(rows) > limit: + next_cursor = encode_cursor(scope, items[-1]) + + return json_response( + { + "items": items, + "next_cursor": next_cursor, + } + ) diff --git a/app/responses.py b/app/responses.py new file mode 100644 index 00000000..4fed1a18 --- /dev/null +++ b/app/responses.py @@ -0,0 +1,40 @@ +from __future__ import annotations + +from datetime import datetime, timezone +from uuid import UUID + +from fastapi.responses import JSONResponse + + +def utc_text(value: datetime) -> str: + return ( + value.astimezone(timezone.utc) + .isoformat(timespec="microseconds") + .replace("+00:00", "Z") + ) + + +def to_json(value): + if isinstance(value, UUID): + return str(value) + + if isinstance(value, datetime): + return utc_text(value) + + if isinstance(value, dict): + return { + key: to_json(item) + for key, item in value.items() + } + + if isinstance(value, (list, tuple)): + return [to_json(item) for item in value] + + return value + + +def json_response(value, status: int = 200) -> JSONResponse: + return JSONResponse( + status_code=status, + content=to_json(value), + ) diff --git a/app/routers/__init__.py b/app/routers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/routers/chats.py b/app/routers/chats.py new file mode 100644 index 00000000..36a27f25 --- /dev/null +++ b/app/routers/chats.py @@ -0,0 +1,74 @@ +from __future__ import annotations + +from fastapi import APIRouter, Request + +from app.dependencies import accessible_chat, current_user +from app.errors import invalid +from app.pagination import page_response, pagination +from app.responses import json_response +from app.store import InvalidMembersError, store +from app.validation import parse_uuid, read_payload, valid_text + +router = APIRouter() + + +@router.post("/api/v1/chats") +async def create_chat(request: Request): + user, _ = await current_user(request) + + payload = await read_payload( + request, + {"title", "member_ids"}, + ) + + if not valid_text(payload["title"], 100): + raise invalid("Некорректный title") + + raw_members = payload["member_ids"] + + if ( + not isinstance(raw_members, list) + or not 1 <= len(raw_members) <= 100 + ): + raise invalid("Некорректный member_ids") + + member_ids = [parse_uuid(item) for item in raw_members] + + if len(set(member_ids)) != len(member_ids): + raise invalid("В member_ids есть дубликаты") + + if user["id"] not in member_ids: + raise invalid("Создатель должен входить в member_ids") + + try: + chat = await store.create_chat( + payload["title"], + member_ids, + ) + except InvalidMembersError: + raise invalid( + "В member_ids есть неизвестный пользователь" + ) from None + + return json_response(chat, 201) + + +@router.get("/api/v1/chats") +async def list_chats(request: Request): + user, _ = await current_user(request) + + scope = f"chats:{user['id']}" + limit, after = pagination(request, scope) + + rows = await store.list_chats(user["id"], limit, after) + + return page_response(rows, limit, scope) + + +@router.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, request: Request): + user, _ = await current_user(request) + + _, chat = await accessible_chat(chat_id, user["id"]) + + return json_response(chat) diff --git a/app/routers/health.py b/app/routers/health.py new file mode 100644 index 00000000..53ad5d90 --- /dev/null +++ b/app/routers/health.py @@ -0,0 +1,18 @@ +from __future__ import annotations + +from fastapi import APIRouter + +from app.db import check_db + +router = APIRouter() + + +@router.get("/health/live") +async def health_live(): + return {"status": "ok"} + + +@router.get("/health/ready") +async def health_ready(): + await check_db() + return {"status": "ok"} diff --git a/app/routers/messages.py b/app/routers/messages.py new file mode 100644 index 00000000..41cc694b --- /dev/null +++ b/app/routers/messages.py @@ -0,0 +1,56 @@ +from __future__ import annotations + +from fastapi import APIRouter, Request + +from app.dependencies import accessible_chat, current_user +from app.errors import invalid +from app.pagination import page_response, pagination +from app.responses import json_response +from app.store import store +from app.validation import read_payload, valid_text + +router = APIRouter() + + +@router.post("/api/v1/chats/{chat_id}/messages") +async def create_message(chat_id: str, request: Request): + user, _ = await current_user(request) + + chat_uuid, _ = await accessible_chat( + chat_id, + user["id"], + ) + + payload = await read_payload(request, {"text"}) + + if not valid_text(payload["text"], 4000): + raise invalid("Некорректный текст сообщения") + + message = await store.create_message( + chat_uuid, + user["id"], + payload["text"], + ) + + return json_response(message, 201) + + +@router.get("/api/v1/chats/{chat_id}/messages") +async def list_messages(chat_id: str, request: Request): + user, _ = await current_user(request) + + chat_uuid, _ = await accessible_chat( + chat_id, + user["id"], + ) + + scope = f"messages:{chat_uuid}" + limit, after = pagination(request, scope) + + rows = await store.list_messages( + chat_uuid, + limit, + after, + ) + + return page_response(rows, limit, scope) diff --git a/app/routers/sessions.py b/app/routers/sessions.py new file mode 100644 index 00000000..0dfaf2fb --- /dev/null +++ b/app/routers/sessions.py @@ -0,0 +1,82 @@ +from __future__ import annotations + +from fastapi import APIRouter, Request +from fastapi.responses import Response + +from app.auth import ( + DUMMY_PASSWORD_HASH, + generate_token, + hash_token, + parse_basic_credentials, + verify_password, +) +from app.config import SESSION_TTL_SECONDS +from app.dependencies import current_user +from app.errors import invalid, unauthorized +from app.responses import json_response +from app.store import store + +router = APIRouter() + + +@router.post("/api/v1/auth/sessions") +async def create_session(request: Request): + credentials = parse_basic_credentials( + request.headers.get("authorization") + ) + + if credentials is None: + raise unauthorized("Basic") + + username, password = credentials + + user = await store.get_user_for_login(username) + + stored_hash = ( + DUMMY_PASSWORD_HASH + if user is None + else user["password_hash"] + ) + + password_ok = await verify_password(stored_hash, password) + + if user is None or not password_ok: + raise unauthorized("Basic") + + if await request.body(): + raise invalid("Тело запроса при входе не допускается") + + token = generate_token() + + session = await store.create_session( + user["id"], + hash_token(token), + SESSION_TTL_SECONDS, + ) + + public_user = { + field: user[field] + for field in ("id", "username", "display_name", "created_at") + } + + return json_response( + { + "token": token, + "token_type": "Bearer", + "expires_at": session["expires_at"], + "user": public_user, + }, + 201, + ) + + +@router.delete("/api/v1/auth/sessions/current") +async def revoke_session(request: Request): + _, token_digest = await current_user(request) + + revoked = await store.revoke_session(token_digest) + + if not revoked: + raise unauthorized() + + return Response(status_code=204) diff --git a/app/routers/users.py b/app/routers/users.py new file mode 100644 index 00000000..9adb1e2c --- /dev/null +++ b/app/routers/users.py @@ -0,0 +1,59 @@ +from __future__ import annotations + +from fastapi import APIRouter, Request + +from app.auth import USERNAME_RE, hash_password +from app.dependencies import current_user +from app.errors import ApiError, invalid +from app.responses import json_response +from app.store import store +from app.validation import read_payload, valid_text + +router = APIRouter() + + +@router.post("/api/v1/users") +async def create_user(request: Request): + payload = await read_payload( + request, + {"username", "display_name", "password"}, + ) + + username = payload["username"] + display_name = payload["display_name"] + password = payload["password"] + + if ( + not isinstance(username, str) + or USERNAME_RE.fullmatch(username) is None + ): + raise invalid("Некорректный username") + + if not valid_text(display_name, 100): + raise invalid("Некорректное display_name") + + if not valid_text(password, 128) or len(password) < 12: + raise invalid("Пароль должен содержать от 12 до 128 символов") + + password_digest = await hash_password(password) + + user = await store.create_user( + username, + display_name, + password_digest, + ) + + if user is None: + raise ApiError( + 409, + "conflict", + "Username уже занят", + ) + + return json_response(user, 201) + + +@router.get("/api/v1/users/me") +async def get_current_user(request: Request): + user, _ = await current_user(request) + return json_response(user) diff --git a/app/store.py b/app/store.py new file mode 100644 index 00000000..e7a0c203 --- /dev/null +++ b/app/store.py @@ -0,0 +1,273 @@ +from __future__ import annotations + +from datetime import datetime +from uuid import UUID, uuid4 + +from psycopg.errors import ForeignKeyViolation, UniqueViolation + +from app.db import pool + + +class InvalidMembersError(Exception): + pass + + +class PostgresStore: + async def create_user( + self, + username: str, + display_name: str, + password_hash: str, + ) -> dict | None: + try: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + INSERT INTO users ( + id, username, display_name, password_hash + ) + VALUES (%s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (uuid4(), username, display_name, password_hash), + ) + user = await cursor.fetchone() + + return user + except UniqueViolation as exc: + if exc.diag.constraint_name == "users_username_unique": + return None + raise + + async def get_user(self, user_id: UUID) -> dict | None: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + SELECT id, username, display_name, created_at + FROM users + WHERE id = %s + """, + (user_id,), + ) + return await cursor.fetchone() + + async def get_user_for_login(self, username: str) -> dict | None: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + SELECT id, username, display_name, + password_hash, created_at + FROM users + WHERE username = %s + """, + (username,), + ) + return await cursor.fetchone() + + async def create_chat( + self, + title: str, + member_ids: list[UUID], + ) -> dict: + chat_id = uuid4() + + try: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + INSERT INTO chats (id, title) + VALUES (%s, %s) + RETURNING id, title, created_at + """, + (chat_id, title), + ) + chat = await cursor.fetchone() + + async with conn.cursor() as cursor: + await cursor.executemany( + """ + INSERT INTO chat_members (chat_id, user_id) + VALUES (%s, %s) + """, + [(chat_id, user_id) for user_id in member_ids], + ) + + chat["member_ids"] = member_ids + + return chat + except ForeignKeyViolation as exc: + raise InvalidMembersError from exc + + async def get_accessible_chat( + self, + chat_id: UUID, + user_id: UUID, + ) -> dict | None: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + SELECT c.id, c.title, c.created_at, + ARRAY( + SELECT cm.user_id + FROM chat_members AS cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + ) AS member_ids + FROM chats AS c + WHERE c.id = %s + AND EXISTS ( + SELECT 1 + FROM chat_members AS access + WHERE access.chat_id = c.id + AND access.user_id = %s + ) + """, + (chat_id, user_id), + ) + return await cursor.fetchone() + + async def list_chats( + self, + user_id: UUID, + limit: int, + after: tuple[datetime, UUID] | None = None, + ) -> list[dict]: + params: list[object] = [user_id] + after_sql = "" + + if after is not None: + after_sql = "AND (c.created_at, c.id) > (%s, %s)" + params.extend(after) + + params.append(limit + 1) + + async with pool.connection() as conn: + cursor = await conn.execute( + f""" + SELECT c.id, c.title, c.created_at, + ARRAY( + SELECT cm.user_id + FROM chat_members AS cm + WHERE cm.chat_id = c.id + ORDER BY cm.user_id + ) AS member_ids + FROM chats AS c + JOIN chat_members AS access + ON access.chat_id = c.id + WHERE access.user_id = %s + {after_sql} + ORDER BY c.created_at, c.id + LIMIT %s + """, + params, + ) + return await cursor.fetchall() + + async def create_message( + self, + chat_id: UUID, + sender_id: UUID, + text: str, + ) -> dict: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text) + VALUES (%s, %s, %s, %s) + RETURNING id, chat_id, sender_id, text, created_at + """, + (uuid4(), chat_id, sender_id, text), + ) + message = await cursor.fetchone() + + return message + + async def list_messages( + self, + chat_id: UUID, + limit: int, + after: tuple[datetime, UUID] | None = None, + ) -> list[dict]: + params: list[object] = [chat_id] + after_sql = "" + + if after is not None: + after_sql = "AND (created_at, id) > (%s, %s)" + params.extend(after) + + params.append(limit + 1) + + async with pool.connection() as conn: + cursor = await conn.execute( + f""" + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + {after_sql} + ORDER BY created_at, id + LIMIT %s + """, + params, + ) + return await cursor.fetchall() + + async def create_session( + self, + user_id: UUID, + token_hash: str, + ttl_seconds: int, + ) -> dict: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + INSERT INTO sessions ( + token_hash, user_id, created_at, expires_at + ) + VALUES ( + %s, %s, statement_timestamp(), + statement_timestamp() + + (%s * INTERVAL '1 second') + ) + RETURNING expires_at + """, + (token_hash, user_id, ttl_seconds), + ) + session = await cursor.fetchone() + + return session + + async def get_session_user_id( + self, + token_hash: str, + ) -> UUID | None: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + SELECT user_id + FROM sessions + WHERE token_hash = %s + AND expires_at > statement_timestamp() + """, + (token_hash,), + ) + row = await cursor.fetchone() + + return None if row is None else row["user_id"] + + async def revoke_session(self, token_hash: str) -> bool: + async with pool.connection() as conn: + cursor = await conn.execute( + """ + DELETE FROM sessions + WHERE token_hash = %s + AND expires_at > statement_timestamp() + RETURNING token_hash + """, + (token_hash,), + ) + row = await cursor.fetchone() + + return row is not None + + +store = PostgresStore() \ No newline at end of file diff --git a/app/validation.py b/app/validation.py new file mode 100644 index 00000000..0399af1b --- /dev/null +++ b/app/validation.py @@ -0,0 +1,57 @@ +from __future__ import annotations + +from uuid import UUID + +from fastapi import Request + +from app.errors import ApiError, invalid + + +def parse_uuid(value: object) -> UUID: + if not isinstance(value, str): + raise invalid("Некорректный UUID") + + try: + return UUID(value) + except ValueError: + raise invalid("Некорректный UUID") from None + + +def valid_text(value: object, maximum: int) -> bool: + return ( + isinstance(value, str) + and 1 <= len(value) <= maximum + and bool(value.strip()) + ) + + +async def read_payload( + request: Request, + expected_fields: set[str], +) -> dict: + content_type = ( + request.headers.get("content-type", "") + .split(";", 1)[0] + .strip() + .lower() + ) + + if content_type != "application/json": + raise ApiError( + 415, + "unsupported_media_type", + "Требуется Content-Type: application/json", + ) + + try: + payload = await request.json() + except (ValueError, UnicodeError): + raise invalid("Некорректный JSON") from None + + if ( + not isinstance(payload, dict) + or set(payload) != expected_fields + ): + raise invalid("Некорректные поля запроса") + + return payload diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..b5f8136f --- /dev/null +++ b/compose.yaml @@ -0,0 +1,84 @@ +name: mtusi2026lab2 + +services: + postgres: + image: postgres:16.4-bookworm + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: + - CMD-SHELL + - pg_isready -U "$$POSTGRES_USER" -d "$$POSTGRES_DB" + interval: 5s + timeout: 3s + retries: 10 + start_period: 20s + restart: unless-stopped + + redis: + image: redis:7.2.5-bookworm + command: + - redis-server + - --appendonly + - "yes" + - --appendfsync + - everysec + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 5s + restart: unless-stopped + + migrate: + build: + context: . + image: mtusi-messenger:lab2 + command: ["python", "-m", "app.migrate"] + environment: + PGHOST: postgres + PGPORT: "5432" + PGDATABASE: messenger + PGUSER: messenger + PGPASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + depends_on: + postgres: + condition: service_healthy + healthcheck: + disable: true + restart: "no" + + api: + build: + context: . + image: mtusi-messenger:lab2 + environment: + PGHOST: postgres + PGPORT: "5432" + PGDATABASE: messenger + PGUSER: messenger + PGPASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + REDIS_HOST: redis + REDIS_PORT: "6379" + USER_CACHE_TTL_SECONDS: "${USER_CACHE_TTL_SECONDS:-60}" + SESSION_TTL_SECONDS: "${SESSION_TTL_SECONDS:-3600}" + ports: + - "127.0.0.1:18081:8080" + depends_on: + postgres: + condition: service_healthy + migrate: + condition: service_completed_successfully + restart: unless-stopped + stop_grace_period: 10s + +volumes: + postgres_data: + redis_data: \ No newline at end of file diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 00000000..ca5dfa6c --- /dev/null +++ b/evidence/explain-history.txt @@ -0,0 +1,50 @@ +Pager usage is off. +=== PostgreSQL version === + version +--------------------------------------------------------------------------------------------------------------------- + PostgreSQL 16.4 (Debian 16.4-1.pgdg120+2) on x86_64-pc-linux-gnu, compiled by gcc (Debian 12.2.0-14) 12.2.0, 64-bit +(1 row) + +BEGIN +INSERT 0 1 +INSERT 0 1 +INSERT 0 10000 +COMMIT +ANALYZE +=== Fixture size === + chat_id | message_count | distinct_timestamps +--------------------------------------+---------------+--------------------- + 0d8d1cf4-bdfa-47a5-a665-3975e1113d78 | 10000 | 1000 +(1 row) + +=== History index definition === + indexdef +---------------------------------------------------------------------------------------------------- + CREATE INDEX messages_chat_created_id_idx ON public.messages USING btree (chat_id, created_at, id) +(1 row) + +=== First page: LIMIT 51 === + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.29..4.28 rows=51 width=78) (actual time=0.007..0.015 rows=51 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..783.65 rows=10000 width=78) (actual time=0.006..0.011 rows=51 loops=1) + Index Cond: (chat_id = '0d8d1cf4-bdfa-47a5-a665-3975e1113d78'::uuid) + Buffers: shared hit=3 + Planning: + Buffers: shared hit=9 + Planning Time: 0.067 ms + Execution Time: 0.025 ms +(9 rows) + +=== Middle page: keyset cursor, LIMIT 51 === + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.29..5.66 rows=51 width=78) (actual time=0.005..0.017 rows=51 loops=1) + Buffers: shared hit=9 + -> Index Scan using messages_chat_created_id_idx on messages (cost=0.29..527.86 rows=5010 width=78) (actual time=0.005..0.013 rows=51 loops=1) + Index Cond: ((chat_id = '0d8d1cf4-bdfa-47a5-a665-3975e1113d78'::uuid) AND (ROW(created_at, id) > ROW('2000-01-01 00:00:00.499+00'::timestamp with time zone, 'f53aa6fb-ea52-4332-a211-d239fbf6c885'::uuid))) + Buffers: shared hit=9 + Planning Time: 0.052 ms + Execution Time: 0.052 ms +(7 rows) diff --git a/evidence/lab2-checks.txt b/evidence/lab2-checks.txt new file mode 100644 index 00000000..9a69c169 --- /dev/null +++ b/evidence/lab2-checks.txt @@ -0,0 +1,11 @@ +test_chat_creation_rollback (__main__.Lab2Checks.test_chat_creation_rollback) ... ok +test_concurrent_username_registration (__main__.Lab2Checks.test_concurrent_username_registration) ... ok +test_logout (__main__.Lab2Checks.test_logout) ... ok +test_unicode_password_with_colons (__main__.Lab2Checks.test_unicode_password_with_colons) ... ok +test_wrong_password (__main__.Lab2Checks.test_wrong_password) ... ok +test_x_user_id_does_not_authenticate_or_change_user (__main__.Lab2Checks.test_x_user_id_does_not_authenticate_or_change_user) ... ok + +---------------------------------------------------------------------- +Ran 6 tests in 1.523s + +OK diff --git a/evidence/lab2-faults.txt b/evidence/lab2-faults.txt new file mode 100644 index 00000000..818f66b8 --- /dev/null +++ b/evidence/lab2-faults.txt @@ -0,0 +1,6 @@ +PASS: Redis outage fallback; authenticated request took 0.296s +PASS: PostgreSQL outage fails closed; authenticated request took 3.005s +PASS: existing session recovered after PostgreSQL restart +PASS: short session expired; observed after 2.065s +RESTORED: services running; SESSION_TTL_SECONDS=3600 +PASS: dependency outages and short session expiry diff --git a/evidence/lab2-final.txt b/evidence/lab2-final.txt new file mode 100644 index 00000000..a06a620a --- /dev/null +++ b/evidence/lab2-final.txt @@ -0,0 +1,24 @@ +make test-extra && make test-faults +make[1]: Entering directory '/home/polina/projects/mtusi2026lab2' +BASE_URL="http://localhost:18081" python3 tests/lab2_checks.py +test_chat_creation_rollback (__main__.Lab2Checks.test_chat_creation_rollback) ... ok +test_concurrent_username_registration (__main__.Lab2Checks.test_concurrent_username_registration) ... ok +test_logout (__main__.Lab2Checks.test_logout) ... ok +test_unicode_password_with_colons (__main__.Lab2Checks.test_unicode_password_with_colons) ... ok +test_wrong_password (__main__.Lab2Checks.test_wrong_password) ... ok +test_x_user_id_does_not_authenticate_or_change_user (__main__.Lab2Checks.test_x_user_id_does_not_authenticate_or_change_user) ... ok + +---------------------------------------------------------------------- +Ran 6 tests in 1.376s + +OK +make[1]: Leaving directory '/home/polina/projects/mtusi2026lab2' +make[1]: Entering directory '/home/polina/projects/mtusi2026lab2' +BASE_URL="http://localhost:18081" python3 tests/lab2_faults.py +PASS: Redis outage fallback; authenticated request took 0.135s +PASS: PostgreSQL outage fails closed; authenticated request took 3.005s +PASS: existing session recovered after PostgreSQL restart +PASS: short session expired; observed after 2.075s +RESTORED: services running; SESSION_TTL_SECONDS=3600 +PASS: dependency outages and short session expiry +make[1]: Leaving directory '/home/polina/projects/mtusi2026lab2' diff --git a/evidence/persistence-after.txt b/evidence/persistence-after.txt new file mode 100644 index 00000000..ec491388 --- /dev/null +++ b/evidence/persistence-after.txt @@ -0,0 +1,3 @@ +/mtusi2026lab2-api-1 started=2026-10-16T14:38:37.177198952Z status=running +/mtusi2026lab2-postgres-1 started=2026-10-16T14:38:30.216555143Z status=running +/mtusi2026lab2-redis-1 started=2026-10-16T14:38:30.148534088Z status=running diff --git a/evidence/persistence-before.txt b/evidence/persistence-before.txt new file mode 100644 index 00000000..107cb53b --- /dev/null +++ b/evidence/persistence-before.txt @@ -0,0 +1,3 @@ +/mtusi2026lab2-api-1 started=2026-10-16T14:33:23.126243575Z status=running +/mtusi2026lab2-postgres-1 started=2026-10-16T11:25:08.609760528Z status=running +/mtusi2026lab2-redis-1 started=2026-10-16T11:25:08.607145864Z status=running diff --git a/evidence/smoke-final.txt b/evidence/smoke-final.txt new file mode 100644 index 00000000..1ff1bb4f --- /dev/null +++ b/evidence/smoke-final.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:18081" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..586c0725 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,71 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format + CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_length + CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + + CONSTRAINT chats_title_length + CHECK (char_length(title) BETWEEN 1 AND 100) +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id), + user_id UUID NOT NULL REFERENCES users(id), + + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_chat_idx + ON chat_members (user_id, chat_id); + +CREATE INDEX chats_created_id_idx + ON chats (created_at, id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL, + sender_id UUID NOT NULL, + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + + CONSTRAINT messages_sender_membership_fk + FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members (chat_id, user_id), + + CONSTRAINT messages_text_length + CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +CREATE INDEX messages_chat_created_id_idx + ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id), + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + expires_at TIMESTAMPTZ NOT NULL, + + CONSTRAINT sessions_token_hash_format + CHECK (token_hash ~ '^[0-9a-f]{64}$'), + CONSTRAINT sessions_expiry_order + CHECK (expires_at > created_at) +); + +CREATE INDEX sessions_expires_at_idx + ON sessions (expires_at); + +CREATE INDEX sessions_user_id_idx + ON sessions (user_id); \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..bd85b1f4 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastapi==0.115.12 +uvicorn[standard]==0.34.2 +psycopg[binary]==3.2.6 +psycopg-pool==3.2.6 +redis==5.2.1 +argon2-cffi==23.1.0 \ No newline at end of file diff --git a/scripts/explain_history.sql b/scripts/explain_history.sql new file mode 100644 index 00000000..2f2401b7 --- /dev/null +++ b/scripts/explain_history.sql @@ -0,0 +1,94 @@ +\set ON_ERROR_STOP on +\pset pager off + +\echo '=== PostgreSQL version ===' +SELECT version(); + +SELECT id AS user_id +FROM users +ORDER BY created_at, id +LIMIT 1 +\gset fixture_ + +SELECT gen_random_uuid() AS chat_id +\gset fixture_ + +BEGIN; + +INSERT INTO chats (id, title) +VALUES ( + :'fixture_chat_id'::uuid, + 'EXPLAIN fixture: 10000 messages' +); + +INSERT INTO chat_members (chat_id, user_id) +VALUES ( + :'fixture_chat_id'::uuid, + :'fixture_user_id'::uuid +); + +INSERT INTO messages ( + id, + chat_id, + sender_id, + text, + created_at +) +SELECT + gen_random_uuid(), + :'fixture_chat_id'::uuid, + :'fixture_user_id'::uuid, + 'Synthetic message ' || n::text, + TIMESTAMPTZ '2000-01-01 00:00:00+00' + + ((n - 1) / 10) * INTERVAL '1 millisecond' +FROM generate_series(1, 10000) AS series(n); + +COMMIT; + +ANALYZE messages; + +\echo '=== Fixture size ===' +SELECT + chat_id, + count(*) AS message_count, + count(DISTINCT created_at) AS distinct_timestamps +FROM messages +WHERE chat_id = :'fixture_chat_id'::uuid +GROUP BY chat_id; + +\echo '=== History index definition ===' +SELECT indexdef +FROM pg_indexes +WHERE schemaname = 'public' + AND tablename = 'messages' + AND indexname = 'messages_chat_created_id_idx'; + +\echo '=== First page: LIMIT 51 ===' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = :'fixture_chat_id'::uuid +ORDER BY created_at, id +LIMIT 51; + +SELECT + created_at AS created_at, + id AS id +FROM messages +WHERE chat_id = :'fixture_chat_id'::uuid +ORDER BY created_at, id +OFFSET 4999 +LIMIT 1 +\gset cursor_ + +\echo '=== Middle page: keyset cursor, LIMIT 51 ===' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = :'fixture_chat_id'::uuid + AND (created_at, id) > ( + :'cursor_created_at'::timestamptz, + :'cursor_id'::uuid + ) +ORDER BY created_at, id +LIMIT 51; \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..4ae94754 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,15 @@ +#!/bin/sh +set -eu + +PROJECT_DIR="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)" +cd "$PROJECT_DIR" + +docker compose --env-file .env stop --timeout 10 api + +docker compose --env-file .env restart --timeout 10 postgres redis + +docker compose --env-file .env up \ + -d \ + --wait \ + --wait-timeout 60 \ + api redis \ No newline at end of file diff --git a/tests/lab2_checks.py b/tests/lab2_checks.py new file mode 100644 index 00000000..92ee9d32 --- /dev/null +++ b/tests/lab2_checks.py @@ -0,0 +1,328 @@ +from __future__ import annotations + +import base64 +import json +import os +import subprocess +import unittest +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path +from threading import Barrier +from urllib.error import HTTPError +from urllib.request import Request, urlopen +from uuid import uuid4 + + +BASE_URL = os.getenv( + "BASE_URL", + "http://localhost:18081", +).rstrip("/") + +PROJECT_DIR = Path(__file__).resolve().parent.parent + +PASSWORD = "Synthetic-test-password-123" + + +class Lab2Checks(unittest.TestCase): + def request( + self, + method, + path, + payload=None, + token=None, + headers=None, + ): + request_headers = dict(headers or {}) + data = None + + if payload is not None: + data = json.dumps( + payload, + ensure_ascii=False, + ).encode("utf-8") + request_headers["Content-Type"] = "application/json" + + if token is not None: + request_headers["Authorization"] = f"Bearer {token}" + + request = Request( + BASE_URL + path, + data=data, + headers=request_headers, + method=method, + ) + + try: + response = urlopen(request, timeout=20) + except HTTPError as exc: + response = exc + + with response: + status = response.code + response_headers = response.headers + raw = response.read() + + request_id = response_headers.get("X-Request-Id") + self.assertTrue(request_id, "Missing X-Request-Id") + + body = json.loads(raw.decode("utf-8")) if raw else None + + if status >= 400: + self.assertIsInstance(body, dict) + self.assertEqual(set(body), {"error"}) + self.assertEqual( + set(body["error"]), + {"code", "message", "request_id"}, + ) + self.assertEqual( + body["error"]["request_id"], + request_id, + ) + + return status, body, response_headers + + def create_user(self, password=PASSWORD): + username = "u_" + uuid4().hex[:20] + + status, user, _ = self.request( + "POST", + "/api/v1/users", + { + "username": username, + "display_name": "Тестовый пользователь", + "password": password, + }, + ) + + self.assertEqual(status, 201) + self.assertEqual( + set(user), + {"id", "username", "display_name", "created_at"}, + ) + + return username, user + + def login(self, username, password=PASSWORD): + credentials = base64.b64encode( + f"{username}:{password}".encode("utf-8") + ).decode("ascii") + + return self.request( + "POST", + "/api/v1/auth/sessions", + headers={"Authorization": f"Basic {credentials}"}, + ) + + def create_logged_in_user(self): + username, user = self.create_user() + + status, session, _ = self.login(username) + + self.assertEqual(status, 201) + + return user, session["token"] + + def database_counts(self): + result = subprocess.run( + [ + "docker", + "compose", + "--env-file", + ".env", + "exec", + "-T", + "postgres", + "psql", + "-U", + "messenger", + "-d", + "messenger", + "-At", + "-v", + "ON_ERROR_STOP=1", + "-c", + ( + "SELECT " + "(SELECT count(*) FROM chats), " + "(SELECT count(*) FROM chat_members);" + ), + ], + cwd=PROJECT_DIR, + check=True, + capture_output=True, + text=True, + timeout=15, + ) + + return tuple( + int(value) + for value in result.stdout.strip().split("|") + ) + + def test_wrong_password(self): + username, _ = self.create_user() + + status, body, headers = self.login( + username, + "Definitely-wrong-password-123", + ) + + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + self.assertEqual( + headers.get("WWW-Authenticate"), + 'Basic realm="messenger", charset="UTF-8"', + ) + + unknown_username = "missing_" + uuid4().hex[:16] + + other_status, other_body, _ = self.login( + unknown_username, + "Definitely-wrong-password-123", + ) + + self.assertEqual(other_status, 401) + self.assertEqual( + body["error"]["message"], + other_body["error"]["message"], + ) + + def test_logout(self): + _, token = self.create_logged_in_user() + + status, _, _ = self.request( + "GET", + "/api/v1/users/me", + token=token, + ) + self.assertEqual(status, 200) + + status, body, _ = self.request( + "DELETE", + "/api/v1/auth/sessions/current", + token=token, + ) + self.assertEqual(status, 204) + self.assertIsNone(body) + + status, _, headers = self.request( + "GET", + "/api/v1/users/me", + token=token, + ) + self.assertEqual(status, 401) + self.assertEqual( + headers.get("WWW-Authenticate"), + 'Bearer realm="messenger"', + ) + + status, _, _ = self.request( + "DELETE", + "/api/v1/auth/sessions/current", + token=token, + ) + self.assertEqual(status, 401) + + def test_x_user_id_does_not_authenticate_or_change_user(self): + first_user, token = self.create_logged_in_user() + _, second_user = self.create_user() + + status, _, _ = self.request( + "GET", + "/api/v1/users/me", + headers={"X-User-Id": second_user["id"]}, + ) + self.assertEqual(status, 401) + + status, body, _ = self.request( + "GET", + "/api/v1/users/me", + token=token, + headers={"X-User-Id": second_user["id"]}, + ) + self.assertEqual(status, 200) + self.assertEqual(body["id"], first_user["id"]) + + def test_unicode_password_with_colons(self): + password = "Учебный:пароль:длинный-123" + username, _ = self.create_user(password=password) + + status, _, _ = self.login(username, password=password) + self.assertEqual(status, 201) + + def test_concurrent_username_registration(self): + workers = 4 + barrier = Barrier(workers) + username = "race_" + uuid4().hex[:20] + + payload = { + "username": username, + "display_name": "Конкурентная регистрация", + "password": PASSWORD, + } + + def register(_): + barrier.wait(timeout=10) + + status, _, _ = self.request( + "POST", + "/api/v1/users", + payload, + ) + return status + + with ThreadPoolExecutor(max_workers=workers) as executor: + statuses = list(executor.map(register, range(workers))) + + self.assertEqual( + sorted(statuses), + [201, 409, 409, 409], + ) + + status, _, _ = self.login(username) + self.assertEqual(status, 201) + + def test_chat_creation_rollback(self): + user, token = self.create_logged_in_user() + + before = self.database_counts() + + status, body, _ = self.request( + "POST", + "/api/v1/chats", + { + "title": "Этот чат должен откатиться", + "member_ids": [ + user["id"], + str(uuid4()), + ], + }, + token=token, + ) + + self.assertEqual(status, 400) + self.assertEqual(body["error"]["code"], "invalid_request") + + after = self.database_counts() + + self.assertEqual( + before, + after, + "Failed chat creation left database rows", + ) + + status, _, _ = self.request( + "POST", + "/api/v1/chats", + { + "title": "Создание после rollback", + "member_ids": [user["id"]], + }, + token=token, + ) + + self.assertEqual(status, 201) + + +if __name__ == "__main__": + unittest.main(verbosity=2) \ No newline at end of file diff --git a/tests/lab2_faults.py b/tests/lab2_faults.py new file mode 100644 index 00000000..f658f36a --- /dev/null +++ b/tests/lab2_faults.py @@ -0,0 +1,325 @@ +from __future__ import annotations + +import os +import subprocess +import time + +import lab2_checks as checks + + +PROJECT_DIR = checks.PROJECT_DIR +client = checks.Lab2Checks() + +COMPOSE = [ + "docker", + "compose", + "--env-file", + ".env", +] + + +def compose(*args, ttl=None): + env = os.environ.copy() + + if ttl is not None: + env["SESSION_TTL_SECONDS"] = str(ttl) + + result = subprocess.run( + COMPOSE + list(args), + cwd=PROJECT_DIR, + env=env, + capture_output=True, + text=True, + timeout=90, + ) + + if result.returncode != 0: + raise RuntimeError( + "Compose command failed: " + + " ".join(args) + + ". Check docker compose ps -a and service logs." + ) + + return result.stdout.strip() + + +def start_storage(service): + compose( + "up", + "-d", + "--no-deps", + "--wait", + "--wait-timeout", + "45", + service, + ) + + +def recreate_api(ttl): + compose( + "up", + "-d", + "--no-deps", + "--force-recreate", + "--wait", + "--wait-timeout", + "45", + "api", + ttl=ttl, + ) + + +def expect_status( + method, + path, + expected, + token=None, + headers=None, +): + started = time.monotonic() + + status, body, response_headers = client.request( + method, + path, + token=token, + headers=headers, + ) + + elapsed = time.monotonic() - started + + client.assertEqual( + status, + expected, + f"Unexpected status for {method} {path}", + ) + + client.assertLess( + elapsed, + 10, + f"Request exceeded local test budget: {path}", + ) + + return body, response_headers, elapsed + + +def wait_for_working_token(token, timeout=20): + deadline = time.monotonic() + timeout + + while time.monotonic() < deadline: + try: + status, _, _ = client.request( + "GET", + "/api/v1/users/me", + token=token, + ) + except OSError: + time.sleep(0.5) + continue + + if status == 200: + return + + time.sleep(0.5) + + raise AssertionError( + "Existing session did not recover after database restart" + ) + + +def main(): + original_ttl = int( + compose( + "exec", + "-T", + "api", + "python", + "-c", + ( + "import os; " + "print(os.getenv('SESSION_TTL_SECONDS', '3600'))" + ), + ) + ) + + client.assertGreaterEqual( + original_ttl, + 300, + "Start this scenario with normal SESSION_TTL_SECONDS >= 300", + ) + + user, token = client.create_logged_in_user() + + try: + # Warm the user cache before dependency failures. + expect_status( + "GET", + "/api/v1/users/me", + 200, + token=token, + ) + expect_status( + "GET", + "/api/v1/users/me", + 200, + token=token, + ) + + compose("stop", "--timeout", "10", "redis") + + _, _, elapsed = expect_status( + "GET", + "/api/v1/users/me", + 200, + token=token, + ) + + expect_status( + "GET", + "/api/v1/users/me", + 401, + headers={"X-User-Id": str(user["id"])}, + ) + + expect_status("GET", "/health/live", 200) + expect_status("GET", "/health/ready", 200) + + print( + f"PASS: Redis outage fallback; " + f"authenticated request took {elapsed:.3f}s", + flush=True, + ) + + start_storage("redis") + + # Refill the cache, then prove it cannot replace session checks. + expect_status( + "GET", + "/api/v1/users/me", + 200, + token=token, + ) + + compose("stop", "--timeout", "10", "postgres") + + body, _, elapsed = expect_status( + "GET", + "/api/v1/users/me", + 503, + token=token, + ) + client.assertEqual( + body["error"]["code"], + "unavailable", + ) + + expect_status("GET", "/health/live", 200) + expect_status("GET", "/health/ready", 503) + + expect_status( + "GET", + "/api/v1/users/me", + 401, + headers={"X-User-Id": str(user["id"])}, + ) + + print( + f"PASS: PostgreSQL outage fails closed; " + f"authenticated request took {elapsed:.3f}s", + flush=True, + ) + + start_storage("postgres") + wait_for_working_token(token) + + print( + "PASS: existing session recovered after PostgreSQL restart", + flush=True, + ) + + recreate_api(ttl=2) + + _, short_token = client.create_logged_in_user() + + expect_status( + "GET", + "/api/v1/users/me", + 200, + token=short_token, + ) + + started = time.monotonic() + deadline = started + 10 + + while True: + status, body, headers = client.request( + "GET", + "/api/v1/users/me", + token=short_token, + ) + + if status == 401: + client.assertEqual( + body["error"]["code"], + "unauthorized", + ) + client.assertEqual( + headers.get("WWW-Authenticate"), + 'Bearer realm="messenger"', + ) + break + + client.assertEqual(status, 200) + + if time.monotonic() >= deadline: + raise AssertionError( + "Session did not expire with TTL=2" + ) + + time.sleep(0.25) + + print( + f"PASS: short session expired; " + f"observed after {time.monotonic() - started:.3f}s", + flush=True, + ) + + finally: + restoration_errors = [] + + for service in ("postgres", "redis"): + try: + start_storage(service) + except Exception as exc: + restoration_errors.append( + f"{service}: {type(exc).__name__}" + ) + + try: + recreate_api(ttl=original_ttl) + except Exception as exc: + restoration_errors.append( + f"api: {type(exc).__name__}" + ) + + if restoration_errors: + raise RuntimeError( + "Automatic restoration failed: " + + ", ".join(restoration_errors) + ) + + print( + f"RESTORED: services running; " + f"SESSION_TTL_SECONDS={original_ttl}", + flush=True, + ) + + expect_status("GET", "/health/ready", 200) + + print( + "PASS: dependency outages and short session expiry", + flush=True, + ) + + +if __name__ == "__main__": + main() \ No newline at end of file