ЛР 2 - Соколова Полина, БВТ2304 - на оценку 4 #74
+11
-10
@@ -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
|
||||
+26
@@ -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"]
|
||||
@@ -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
|
||||
@@ -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.
|
||||
+108
@@ -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()
|
||||
+129
@@ -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()
|
||||
@@ -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")
|
||||
@@ -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")
|
||||
@@ -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
|
||||
@@ -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,
|
||||
)
|
||||
+112
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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,
|
||||
}
|
||||
)
|
||||
@@ -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),
|
||||
)
|
||||
@@ -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)
|
||||
@@ -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"}
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
+273
@@ -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()
|
||||
@@ -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
|
||||
@@ -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:
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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'
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,2 @@
|
||||
python3 tests/smoke.py --base-url "http://localhost:18081"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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;
|
||||
Executable
+15
@@ -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
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user