ЛР 2 - БПИ2301 - Антонова - на 4 #90
+36
@@ -0,0 +1,36 @@
|
||||
FROM python:3.12.8-slim-bookworm AS base
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_DISABLE_PIP_VERSION_CHECK=1 \
|
||||
PIP_ROOT_USER_ACTION=ignore \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080 \
|
||||
APP_ENV=lab
|
||||
|
||||
RUN groupadd --system --gid 10001 app \
|
||||
&& useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app
|
||||
|
||||
WORKDIR /srv
|
||||
|
||||
COPY requirements.txt ./
|
||||
RUN pip install -r requirements.txt
|
||||
|
||||
COPY app ./app
|
||||
|
||||
FROM base AS test
|
||||
COPY requirements-test.txt ./
|
||||
RUN pip install -r requirements-test.txt
|
||||
COPY pytest.ini ./
|
||||
COPY student-tests ./student-tests
|
||||
USER app
|
||||
CMD ["python", "-m", "pytest", "-v", "--no-header"]
|
||||
|
||||
FROM base AS runtime
|
||||
USER app
|
||||
EXPOSE 8080
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
|
||||
CMD ["python", "-m", "app.healthcheck"]
|
||||
STOPSIGNAL SIGTERM
|
||||
CMD ["python", "-m", "app"]
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
# EVIDENCE — как собраны доказательства
|
||||
|
||||
Все файлы `evidence/` пересобираются одной командой из корня проекта (нужны Docker и `python3` на хосте, venv не нужен):
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env up -d --build
|
||||
scripts/collect_evidence.sh # все пункты
|
||||
scripts/collect_evidence.sh 14 15 # отдельные пункты
|
||||
```
|
||||
|
||||
Каждый файл, кроме 13 и 14, пишет `scripts/run_and_save.py`: дата, commit, команда, вывод, код возврата и время. Файлы 13 и 14 — листинги сценариев, которые сами выполняют команды и проверки. Их последняя строка — `ИТОГ: PASS` или `ИТОГ: FAIL`. Данные синтетические; тома не удаляются.
|
||||
|
||||
| № | Что доказывает | Команда (из `scripts/collect_evidence.sh`) | Файл |
|
||||
| --- | --- | --- | --- |
|
||||
| 01 | Структура контракта | `make check` | `01_check_contract.txt` |
|
||||
| 02 | Публичный smoke | `make test` | `02_smoke.txt` |
|
||||
| 03 | Контейнеры и том **до** рестарта | `docker compose ps`, `docker volume inspect mtusi-messenger_pgdata` | `03_ps_before.txt`, `03_volume_before.txt` |
|
||||
| 04 | Данные и прежний токен после рестарта API, Redis и PostgreSQL | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `04_persistence.txt` |
|
||||
| 05 | Контейнеры и том **после** (Up сброшен, том тот же) | как 03 | `05_ps_after.txt`, `05_volume_after.txt` |
|
||||
| 06 | PK, FK, UNIQUE, CHECK, индексы | `psql -c '\d users' … '\d sessions'` в контейнере `db` | `06_schema.txt` |
|
||||
| 07 | Миграции с нуля и повторно | `docker compose logs api` первого старта на пустом томе; `python -m app.migrate`; `SELECT * FROM schema_migrations` | `07_migrations_first.txt`, `07_migrations.txt`, `07_migrations_table.txt` |
|
||||
| 08 | Пароль — scrypt, токен — только SHA-256 | `SELECT left(password_hash,7) …`, `SELECT length(token_hash) …` | `08_hashes.txt` |
|
||||
| 09 | Basic/Bearer, expiry, logout, `X-User-Id` | pytest в контейнере `tests`: `test_auth.py test_session_expiry.py` | `09_auth_tests.txt` |
|
||||
| 10 | Атомарность, rollback, пул, гонка username, отказ БД | pytest: `test_database.py test_db_failure.py test_transactions.py test_duplicate_username.py` | `10_database_tests.txt` |
|
||||
| 11 | Все собственные тесты (`153 passed`) | `docker compose --profile test run --rm tests` (= `make test-student`) | `11_all_tests.txt` |
|
||||
| 12 | Секреты не в Git | `git check-ignore -v .env`; `git ls-files --cached --others --exclude-standard`; `grep -n -i 'password\|secret' compose.yaml` | `12_git_secrets.txt`, `12_git_files.txt`, `12_compose_no_secrets.txt` |
|
||||
| 13 | Данные переживают `down` → `up -d` | `python3 scripts/storage_demo.py` | `13_storage.txt` |
|
||||
| 14 | Роль Redis, инвалидация, рестарт/остановка Redis, остановка PostgreSQL | `python3 scripts/dependency_demo.py` | `14_dependencies.txt` |
|
||||
| 15 | EXPLAIN (ANALYZE, BUFFERS) истории на 60 000 сообщений; автотест плана на 10 000 | `docker compose exec -T api python -m app.explain`; pytest `test_explain.py` | `15_explain.txt`, `15_explain_tests.txt` |
|
||||
| 16 | Expiry на живом стенде (TTL 3 с), logout, неверный пароль | `docker compose --profile expiry up -d api-ttl`; `python3 scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3` | `16_expiry_live.txt` |
|
||||
|
||||
Пункт 07 «с нуля» снимается только на пустом томе: `docker compose --env-file .env down -v` (**удаляет учебные данные**), затем `up -d --build` и `python3 scripts/run_and_save.py evidence/07_migrations_first.txt -- docker compose --env-file .env logs api`.
|
||||
|
||||
## Что смотреть в файлах
|
||||
|
||||
- **03/05**: у `api`, `db`, `redis` в 05 время `Up` — секунды; дата создания тома в 03 и 05 одна и та же.
|
||||
- **14**: «Чтений индекса sessions_pkey в PostgreSQL за 50 запросов: 0» и `keyspace_hits=49`; значение ключа после logout — `revoked`; при остановленном Redis все операции 2xx, а аноним получает 401; при остановленной БД — 503 и `/health/live` 200; в логе API — `cache_unavailable` и `cache: FLUSHDB after a lost revocation`.
|
||||
- **15**: у запроса приложения `Index Scan using messages_chat_created_idx`, `rows=51`, `shared hit=6` на первой и глубокой странице; у OFFSET и варианта без индекса — `Seq Scan` и `Sort`.
|
||||
|
||||
## Проверка перед сдачей
|
||||
|
||||
- В `evidence/` нет паролей и токенов: `grep -l "$(sed -n 's/^POSTGRES_PASSWORD=//p' .env)" evidence/*` ничего не находит. Ключи Redis в 14 маскируются как `session:<sha256 токена>`.
|
||||
- `11_all_tests.txt` заканчивается строкой `153 passed`, а `13_storage.txt` и `14_dependencies.txt` — строкой `ИТОГ: PASS`.
|
||||
- `evidence/` указан в `.dockerignore` и в образ не попадает.
|
||||
@@ -0,0 +1,65 @@
|
||||
# GUIDE — запуск и тесты
|
||||
|
||||
Нужно: Docker с Compose v2 и Git. Для публичных проверок (`tests/`, `scripts/*.py`) — `python3` 3.9+ на хосте: они используют только стандартную библиотеку. Виртуальное окружение не нужно: API и собственные pytest-тесты собираются и работают в контейнерах. Команды выполняются из корня проекта. Для Windows (cmd) замените `cp` на `copy`, а `scripts/restart.sh` на `scripts\restart.bat`.
|
||||
|
||||
## 1. Поднять стенд
|
||||
|
||||
```sh
|
||||
cp env.lab2.template .env # затем смените POSTGRES_PASSWORD (латиница и цифры)
|
||||
docker compose --env-file .env up -d --build
|
||||
docker compose --env-file .env ps # db, redis, api — healthy
|
||||
curl http://localhost:8080/health/ready # {"status":"ok"}
|
||||
```
|
||||
|
||||
- Миграции применяются сами при старте API.
|
||||
- API: `http://localhost:8080`. PostgreSQL для отладки: `127.0.0.1:5433`. Redis наружу не опубликован: `docker compose --env-file .env exec redis redis-cli`.
|
||||
- Если `api` перезапускается, смотрите `docker compose --env-file .env logs api`.
|
||||
|
||||
Остановить с сохранением данных: `docker compose --env-file .env stop`. Удалить вместе с данными: `docker compose --env-file .env down -v`.
|
||||
|
||||
## 2. Проверки
|
||||
|
||||
| Команда | Что проверяет |
|
||||
| --- | --- |
|
||||
| `make check` | Структура репозитория и контракта (офлайн) |
|
||||
| `make test` | Публичный сквозной smoke по живому API |
|
||||
| `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Рестарт API, Redis и PostgreSQL: данные и **прежний токен** живы |
|
||||
| `make test-student` | Все собственные тесты (153) в контейнере `tests` |
|
||||
| `make explain` | EXPLAIN (ANALYZE, BUFFERS) истории на 60 000 синтетических сообщений |
|
||||
| `python3 scripts/dependency_demo.py` | Роль Redis; остановка Redis и PostgreSQL (листинг в `evidence/14_dependencies.txt`) |
|
||||
| `python3 scripts/storage_demo.py` | `down` → `up -d`, те же данные старыми токенами |
|
||||
| `docker compose --env-file .env --profile expiry up -d api-ttl` и `python3 scripts/check_expiry.py` | Expiry на живом экземпляре с `SESSION_TTL_SECONDS=3` (порт 8081) |
|
||||
| `scripts/collect_evidence.sh` | Всё сразу, с сохранением в `evidence/` (см. `EVIDENCE.md`) |
|
||||
|
||||
Собственные тесты работают с **отдельной** БД `messenger_test` на том же PostgreSQL и с Redis DB 15, поэтому рабочие данные `messenger` не затрагиваются. Один файл или один тест:
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env --profile test run --rm tests python -m pytest -v student-tests/test_cache.py
|
||||
docker compose --env-file .env --profile test run --rm tests python -m pytest -v -k redis_down
|
||||
```
|
||||
|
||||
После изменения тестов или кода пересоберите образ: `make test-student` делает `--build` сам.
|
||||
|
||||
### Что проверяет каждый файл `student-tests/`
|
||||
|
||||
| Файл | За что отвечает |
|
||||
| --- | --- |
|
||||
| `test_auth.py` | Регистрация с паролем; Basic только на входе; Bearer на остальном; одинаковый 401 + `WWW-Authenticate` для неверного пароля и несуществующего логина; logout и повтор = 401; `X-User-Id` не даёт доступ |
|
||||
| `test_session_expiry.py` | TTL 1 с и TTL 2 с из `SESSION_TTL_SECONDS` → 401; очистка истёкших сессий при входе |
|
||||
| `test_cache.py` | Redis: попадания и TTL ключа, в кэше нет токенов и паролей, logout → `revoked`, `SET NX` против гонки, FLUSHDB без потерь, кэш не продлевает сессию, граница устаревания, Redis недоступен → обход и 401 для анонимов, FLUSHDB «грязного» кэша после восстановления |
|
||||
| `test_db_failure.py` | БД недоступна → 503, live 200, ready 503, аноним не пропускается (с кэшем и без) |
|
||||
| `test_transactions.py` | Сбой посреди создания чата → ROLLBACK; пул ограничен настройками; занятый пул → быстрый 503 |
|
||||
| `test_explain.py` | План запроса истории на 10 000 сообщениях: Index Scan, нет Seq Scan и Sort |
|
||||
| `test_database.py` | Что реально лежит в БД: `scrypt$…`, хеш токена, PK/FK/UNIQUE/CHECK, повторные миграции, атомарность чата |
|
||||
| `test_duplicate_username.py` | 409 и гонка 10 одновременных регистраций → ровно один 201 |
|
||||
| `test_invalid_json.py`, `test_empty_message.py`, `test_foreign_chat.py`, `test_pagination.py`, `test_concurrency.py`, `test_contract_basics.py` | Валидация, ACL (404 для чужого), keyset-курсор, параллельная запись, общий формат ошибок, отсутствие секретов в логах |
|
||||
|
||||
## 3. Запуск без Docker (только для отладки)
|
||||
|
||||
Нужны свои PostgreSQL и Redis (необязательно) и установленные `requirements.txt`.
|
||||
|
||||
```sh
|
||||
DATABASE_URL=postgresql+asyncpg://messenger:ПАРОЛЬ@127.0.0.1:5433/messenger CACHE_URL= python -m app
|
||||
```
|
||||
|
||||
Адрес БД обязан начинаться с `postgresql+asyncpg://`. Пустой `CACHE_URL` выключает кэш.
|
||||
@@ -4,7 +4,7 @@ CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
.PHONY: help check validate test load test-persistence
|
||||
.PHONY: help check validate test load test-persistence up test-student explain evidence
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@@ -24,3 +24,17 @@ 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)
|
||||
|
||||
COMPOSE = docker compose --env-file .env
|
||||
|
||||
up:
|
||||
$(COMPOSE) up -d --build
|
||||
|
||||
test-student:
|
||||
$(COMPOSE) --profile test run --rm --build tests
|
||||
|
||||
explain:
|
||||
$(COMPOSE) exec -T api python -m app.explain
|
||||
|
||||
evidence:
|
||||
scripts/collect_evidence.sh
|
||||
|
||||
@@ -0,0 +1,83 @@
|
||||
# OPERATIONS — эксплуатация кратко
|
||||
|
||||
Формат: **что — как — для чего**.
|
||||
|
||||
## Стенд
|
||||
|
||||
| Что | Как | Для чего |
|
||||
| --- | --- | --- |
|
||||
| Три сервиса: `db` (PostgreSQL 16.6), `redis` (Redis 7.4.1, кэш сессий), `api` | `docker compose --env-file .env up -d --build` | Один запуск воспроизводит весь стенд |
|
||||
| Профили: `test` (контейнер с pytest), `expiry` (`api-ttl` с TTL 3 с на 8081) | `--profile test run --rm tests`, `--profile expiry up -d api-ttl` | Тесты и проверка expiry без venv на хосте |
|
||||
| Версии закреплены (`python:3.12.8`, `postgres:16.6`, `redis:7.4.1`, пакеты с транзитивными) | `Dockerfile`, `compose.yaml`, `requirements*.txt` | Сборка через год даёт то же самое, а не «latest» |
|
||||
| API стартует после healthy `db`; Redis не обязателен | `depends_on` + повторные попытки подключения к БД в коде | Холодный старт не падает; без Redis API работает |
|
||||
| API работает не от root | `USER app` в `Dockerfile` | Взлом приложения не даёт прав root в контейнере |
|
||||
|
||||
## Запуск, остановка, рестарт
|
||||
|
||||
| Действие | Команда | Что происходит с данными |
|
||||
| --- | --- | --- |
|
||||
| Запуск | `docker compose --env-file .env up -d --build` | Том `pgdata` создаётся при первом запуске |
|
||||
| Остановка | `docker compose --env-file .env stop` | Данные остаются; кэш Redis пропадает (это нормально) |
|
||||
| Рестарт API, Redis и БД | `scripts/restart.sh` (Windows: `scripts\restart.bat`), stop+start | Данные и сессии остаются; хук для `make test-persistence` |
|
||||
| Пересборка API | `docker compose --env-file .env up -d --build api` | Данные остаются |
|
||||
| **Удаление данных** | `docker compose --env-file .env down -v` | Том `pgdata` удалён, всё пропадает |
|
||||
|
||||
## Миграции
|
||||
|
||||
- Файлы `app/migrations/NNNN_*.sql` применяются по порядку при старте API; применённые записываются в `schema_migrations`.
|
||||
- Повторный запуск ничего не делает. `pg_advisory_lock` гарантирует, что миграции выполняет один экземпляр.
|
||||
- Вручную: `docker compose --env-file .env exec api python -m app.migrate`.
|
||||
- Изменение схемы — **новый** файл `0002_*.sql`, старые файлы не редактируются.
|
||||
|
||||
## Redis (кэш сессий)
|
||||
|
||||
| Что | Как | Для чего |
|
||||
| --- | --- | --- |
|
||||
| Ключ | `session:<SHA-256 токена>` → JSON пользователя | Проверка Bearer без запроса к PostgreSQL |
|
||||
| TTL | `min(CACHE_TTL_SECONDS=60, остаток сессии по часам БД)` | Кэш не продлевает сессию |
|
||||
| Logout | DELETE в PostgreSQL, затем `revoked` в Redis; заполнение — `SET NX` | Отозванный токен не возвращается из кэша |
|
||||
| Persistence | выключена (`--save ""`, `--appendonly no`) | Источник истины — PostgreSQL, кэш одноразовый |
|
||||
| Память | `maxmemory 64mb`, `noeviction` | Отметки отзыва не вытесняются |
|
||||
| Посмотреть | `docker compose --env-file .env exec redis redis-cli --scan --pattern 'session:*'`, `INFO stats` | Диагностика попаданий и промахов |
|
||||
| Сбросить | `docker compose --env-file .env exec redis redis-cli FLUSHDB` | Безопасно: следующий запрос заполнит кэш из БД |
|
||||
|
||||
## Секреты
|
||||
|
||||
| Что | Где | Для чего |
|
||||
| --- | --- | --- |
|
||||
| Пароль БД | локальный `.env` (в `.gitignore`), в образ не зашит | Секрет не попадает в Git и в образ |
|
||||
| Шаблон | `env.lab2.template` (без реального пароля) | Оператор знает, какие значения задать |
|
||||
| Пароли пользователей | в БД только scrypt с солью | Утечка БД не раскрывает пароли |
|
||||
| Токены сессий | у клиента — токен; в БД и Redis — SHA-256 | Утечка БД или Redis не даёт войти |
|
||||
| Логи | без тел запросов, паролей, токенов, текста сообщений | Логи можно показывать и хранить |
|
||||
| Известные ограничения | пароль БД виден в `docker inspect api`; Redis без пароля (только внутренняя сеть) | Учебный стенд; код умеет `DATABASE_URL_FILE` и `CACHE_URL_FILE` |
|
||||
|
||||
## Здоровье
|
||||
|
||||
| Адрес | Значение | Для чего |
|
||||
| --- | --- | --- |
|
||||
| `/health/live` | Процесс жив, зависимости не проверяются | Оркестратор не убивает API из-за временного сбоя БД |
|
||||
| `/health/ready` | Миграции применены и PostgreSQL отвечает на `SELECT 1`: 200 или 503. Redis не учитывается | Трафик не идёт туда, где обязательный путь не работает |
|
||||
| `HEALTHCHECK` образа | вызывает `/health/ready` | `docker compose ps` показывает `healthy` |
|
||||
| `pg_isready`, `redis-cli ping` | healthcheck `db` и `redis` | От `db` зависит старт API |
|
||||
|
||||
## Поведение при сбоях
|
||||
|
||||
| Сбой | Ответ | Для чего |
|
||||
| --- | --- | --- |
|
||||
| Redis недоступен | Проверка токена идёт в PostgreSQL; таймаут 300 мс, затем кэш пропускается 5 с; ready 200 | Кэш не превращается в точку отказа |
|
||||
| Logout во время сбоя Redis | 204; кэш помечен «грязным» → FLUSHDB при восстановлении | Отозванный токен не оживает из старой записи |
|
||||
| БД недоступна | `503 unavailable` без деталей; live 200, ready 503 | Клиент понимает «временно», SQL и адреса не утекают |
|
||||
| Не удалось проверить токен | `503`, запрос не пропускается | Сбой не превращает запрос в анонимно-доверенный |
|
||||
| Нет свободного соединения в пуле | `503` через `DB_POOL_TIMEOUT` | Запросы не копятся при перегрузке |
|
||||
| Неожиданная ошибка | `500 internal_error`, детали только в логе | Клиенту ничего лишнего, оператору — `request_id` |
|
||||
| Рестарт БД | Данные живы (том), пул пересоздаёт соединения (`pool_pre_ping`) | Восстановление без рестарта API |
|
||||
| SIGTERM (`docker stop`) | Корректное завершение: закрываются пул БД и Redis | Транзакции не обрываются |
|
||||
|
||||
## Логи
|
||||
|
||||
`docker compose --env-file .env logs -f api`. Строка запроса: `request request_id=… method=… path=… status=… duration_ms=…`. Сбои кэша: `cache_unavailable type=…` и `cache: FLUSHDB after a lost revocation`. По `request_id` (он же в `X-Request-Id` и в теле ошибки) запрос клиента находится в логе. Уровень логов задаёт `LOG_LEVEL`.
|
||||
|
||||
## Конфигурация (`.env` → compose)
|
||||
|
||||
`POSTGRES_USER/PASSWORD/DB` — учётка БД; `SESSION_TTL_SECONDS` — срок сессии (для persistence-теста ≥ 300); `SESSION_STORE=postgres`; `DB_POOL_SIZE`, `DB_MAX_OVERFLOW`, `DB_POOL_TIMEOUT` — пул; `CACHE_URL` (пусто — кэш выключен), `CACHE_TTL_SECONDS`, `CACHE_TIMEOUT_MS`, `CACHE_RETRY_SECONDS` — кэш; `LOG_LEVEL`, `APP_ENV`. Всё задаётся окружением, поэтому один образ работает на любом стенде без пересборки.
|
||||
@@ -1,37 +1,77 @@
|
||||
# Отчёт — лабораторная 2
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Антонова Ирина Андреевна БПИ2301
|
||||
- Целевая оценка: 4
|
||||
- Commit/PR: 840907cf2bdaafa91543a3fbf964b18e34d9c851
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI, SQLAlchemy (async) + asyncpg, Pydantic, uvicorn, redis-py, pytest, httpx; при написании кода использовался ИИ-ассистент (Claude).
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Нужны Docker с Compose v2 и Python 3.9+ (только для публичных скриптов `tests/`). Образы: `python:3.12.8-slim-bookworm`, `postgres:16.6-bookworm`, `redis:7.4.1-bookworm`; зависимости закреплены в `requirements.txt`.
|
||||
|
||||
```sh
|
||||
cp env.lab2.template .env # задать свой POSTGRES_PASSWORD
|
||||
docker compose --env-file .env up -d --build # миграции применяются при старте API
|
||||
curl http://localhost:8080/health/ready # ждать {"status":"ok"}
|
||||
python tests/smoke.py --base-url "http://localhost:8080" # публичный smoke
|
||||
$env:ACTION_SCRIPT="scripts/restart.sh"
|
||||
python tests/resilience.py --mode persistence --action-script "$env:ACTION_SCRIPT" --base-url "http://localhost:8080"
|
||||
docker compose --env-file .env --profile test run --rm --build tests # собственные тесты в контейнере
|
||||
```
|
||||
|
||||
- Остановка с сохранением данных: `docker compose --env-file .env stop`.
|
||||
- Удаление учебных данных: `docker compose --env-file .env down -v`.
|
||||
- `.env` не попадает в Git; в `compose.yaml` пароли только подставляются из `.env`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
Клиент → API (FastAPI) → PostgreSQL (том pgdata) — источник истины
|
||||
↘ Redis — кэш проверки сессий
|
||||
```
|
||||
|
||||
| Что появилось | Как сделано |
|
||||
| --- | --- |
|
||||
| Хранение данных | Пользователи, чаты, участники, сообщения и сессии в PostgreSQL; версионируемые миграции `app/migrations/` |
|
||||
| Регистрация с паролем | Пароль 12–128 символов, хранится хеш scrypt с солью |
|
||||
| Вход | `POST /auth/sessions` только по Basic, выдаёт случайный токен (256 бит) |
|
||||
| Доступ | Все остальные эндпоинты только по Bearer; `X-User-Id` игнорируется |
|
||||
| Срок жизни и выход | `SESSION_TTL_SECONDS`, срок считает БД; `DELETE /auth/sessions/current` отзывает токен |
|
||||
| Кэш сессий | Redis хранит проверенные сессии с TTL не больше остатка сессии; при logout ставится отметка отзыва |
|
||||
| Отказ Redis | Запросы проверяются через PostgreSQL, API продолжает работать |
|
||||
| Отказ БД | `503` без деталей, `/health/live` 200, `/health/ready` 503 |
|
||||
| Атомарность | Чат и участники создаются в одной транзакции |
|
||||
| Пагинация истории | Keyset-курсор по `(created_at, id)` и индекс `messages(chat_id, created_at, id)` |
|
||||
| Пул и таймауты | Пул 5+5 соединений, ожидание 5 с; таймаут Redis 300 мс |
|
||||
|
||||
Транзакция — одна HTTP-операция; ответ 201 уходит после COMMIT. Уникальность username и целостность ссылок обеспечивают ограничения БД (UNIQUE, FK, CHECK).
|
||||
|
||||
Переменные `.env.example`: `SESSION_TTL_SECONDS` — срок сессии; `SESSION_STORE=postgres` — где хранятся сессии; `DATABASE_URL_FILE` / `CACHE_URL_FILE` (или `DATABASE_URL` / `CACHE_URL`) — адреса PostgreSQL и Redis; `APP_HOST`, `APP_PORT`, `APP_ENV` — параметры сервера.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Публичный smoke | `make test` | `PASS` | `evidence/02_smoke.txt` |
|
||||
| Данные и сессии переживают рестарт API, БД и Redis | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` + `docker compose ps` до/после | `PASS`; контейнеры перезапущены, том тот же | `evidence/03_*`, `04_persistence.txt`, `05_*` |
|
||||
| Данные переживают пересоздание контейнеров | `python scripts/storage_demo.py` | `ИТОГ: PASS` | `evidence/13_storage.txt` |
|
||||
| Таблицы, ключи, индексы | `psql \d` | PK, FK, UNIQUE(username), CHECK, индексы | `evidence/06_schema.txt` |
|
||||
| Миграции с нуля и повторно | лог первого старта, `python -m app.migrate` | `0001_init.sql`, затем «ничего нового» | `evidence/07_*` |
|
||||
| Пароль — KDF, токен — хеш | `SELECT` из `users` и `sessions` | `scrypt$…`, хеш токена 64 символа | `evidence/08_hashes.txt` |
|
||||
| Basic/Bearer, срок сессии, logout, неверный пароль | pytest `test_auth.py`, `test_session_expiry.py` | `38 passed` | `evidence/09_auth_tests.txt` |
|
||||
| Атомарность, rollback, гонка username, пул | pytest `test_database.py`, `test_transactions.py`, `test_duplicate_username.py`, `test_db_failure.py` | `19 passed` | `evidence/10_database_tests.txt` |
|
||||
| Все собственные тесты | `make test-student` | `153 passed` | `evidence/11_all_tests.txt` |
|
||||
| Секреты не в Git | `git check-ignore -v .env` | `.env` игнорируется | `evidence/12_*` |
|
||||
| Redis используется для сессий | `python scripts/dependency_demo.py` | 50 запросов: 0 обращений к PostgreSQL за сессией, 49 попаданий в кэш | `evidence/14_dependencies.txt` |
|
||||
| Отказ Redis и БД | там же | без Redis всё работает; без БД — 503, аноним — 401 | `evidence/14_dependencies.txt` |
|
||||
| Индекс истории, EXPLAIN на ≥10 000 сообщений | `make explain` | Index Scan, 51 строка на любой странице; без индекса — Seq Scan | `evidence/15_explain.txt` |
|
||||
| Expiry при коротком TTL | `api-ttl` с TTL 3 с + `scripts/check_expiry.py` | через TTL токен даёт 401 | `evidence/16_expiry_live.txt` |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
Все файлы пересобираются командой `scripts/collect_evidence.sh`.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Один экземпляр API, PostgreSQL и Redis без репликации и бэкапов.
|
||||
- Redis без пароля, доступен только внутри сети compose; HTTP без TLS.
|
||||
- Если logout пришёлся на сбой Redis, кэш очищается только в этом экземпляре API.
|
||||
- scrypt вместо Argon2id.
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
"""Мессенджер: HTTP API на FastAPI с PostgreSQL и кэшем сессий в Redis."""
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Точка входа: python -m app запускает HTTP-сервер."""
|
||||
|
||||
import signal
|
||||
import sys
|
||||
|
||||
import uvicorn
|
||||
|
||||
from .config import Settings
|
||||
from .logging_setup import get_logger
|
||||
from .main import create_app
|
||||
|
||||
|
||||
def _exit_quietly(signum, frame):
|
||||
"""Завершить процесс с кодом 0 по SIGTERM."""
|
||||
raise SystemExit(0)
|
||||
|
||||
|
||||
def main() -> int:
|
||||
"""Прочитать настройки и запустить uvicorn; вернуть код выхода."""
|
||||
try:
|
||||
settings = Settings.from_env()
|
||||
except ValueError as error:
|
||||
print("Ошибка настроек:", error, file=sys.stderr)
|
||||
return 2
|
||||
signal.signal(signal.SIGTERM, _exit_quietly)
|
||||
app = create_app(settings)
|
||||
get_logger().info("listen host=%s port=%d", settings.host, settings.port)
|
||||
config = uvicorn.Config(
|
||||
app,
|
||||
host=settings.host,
|
||||
port=settings.port,
|
||||
log_level=settings.log_level.lower(),
|
||||
access_log=False,
|
||||
timeout_graceful_shutdown=5,
|
||||
)
|
||||
server = uvicorn.Server(config)
|
||||
if sys.platform == "win32":
|
||||
signal.signal(
|
||||
signal.SIGBREAK, lambda signum, frame: setattr(server, "should_exit", True)
|
||||
)
|
||||
server.run()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
+102
@@ -0,0 +1,102 @@
|
||||
"""Аутентификация: разбор Authorization (Basic и Bearer) и определение пользователя."""
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
import re
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from typing import AsyncIterator, Tuple
|
||||
|
||||
from fastapi import Depends, Request
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from . import crud
|
||||
from .errors import ApiError
|
||||
from .models import User
|
||||
from .security import hash_token
|
||||
|
||||
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
|
||||
BEARER_CHALLENGE = 'Bearer realm="messenger"'
|
||||
TOKEN_RE = re.compile(r"[A-Za-z0-9_-]{20,200}")
|
||||
|
||||
|
||||
def unauthorized(challenge: str) -> ApiError:
|
||||
"""Ошибка 401 с заголовком WWW-Authenticate и одинаковым текстом."""
|
||||
return ApiError(
|
||||
401, "unauthorized", "Нет действительной аутентификации", {"WWW-Authenticate": challenge}
|
||||
)
|
||||
|
||||
|
||||
async def get_session(request: Request) -> AsyncIterator[AsyncSession]:
|
||||
"""Зависимость FastAPI: сессия БД на время запроса."""
|
||||
async with request.app.state.sessionmaker() as session:
|
||||
yield session
|
||||
|
||||
|
||||
def parse_basic(request: Request) -> Tuple[str, str]:
|
||||
"""Вернуть (username, password) из Basic; при любой ошибке формата 401."""
|
||||
header = request.headers.get("authorization", "")
|
||||
scheme, _, encoded = header.partition(" ")
|
||||
if scheme.lower() != "basic" or not encoded.strip():
|
||||
raise unauthorized(BASIC_CHALLENGE)
|
||||
try:
|
||||
raw = base64.b64decode(encoded.strip(), validate=True)
|
||||
username_bytes, separator, password_bytes = raw.partition(b":")
|
||||
if not separator:
|
||||
raise ValueError("нет двоеточия")
|
||||
return username_bytes.decode("ascii"), password_bytes.decode("utf-8")
|
||||
except (binascii.Error, ValueError):
|
||||
raise unauthorized(BASIC_CHALLENGE)
|
||||
|
||||
|
||||
def parse_bearer(request: Request) -> str:
|
||||
"""Вернуть токен из Bearer; при неверной схеме или формате 401."""
|
||||
header = request.headers.get("authorization", "")
|
||||
scheme, _, token = header.partition(" ")
|
||||
token = token.strip()
|
||||
if scheme.lower() != "bearer" or not TOKEN_RE.fullmatch(token):
|
||||
raise unauthorized(BEARER_CHALLENGE)
|
||||
return token
|
||||
|
||||
|
||||
def cached_user(data: dict) -> User:
|
||||
"""Собрать User из данных кэша (без привязки к сессии БД)."""
|
||||
return User(
|
||||
id=uuid.UUID(data["id"]),
|
||||
username=data["username"],
|
||||
display_name=data["display_name"],
|
||||
password_hash="",
|
||||
created_at=datetime.fromisoformat(data["created_at"]),
|
||||
)
|
||||
|
||||
|
||||
async def current_user(
|
||||
request: Request, session: AsyncSession = Depends(get_session)
|
||||
) -> User:
|
||||
"""Зависимость FastAPI: пользователь по Bearer-токену.
|
||||
|
||||
Сначала кэш, при промахе или недоступном Redis -- PostgreSQL.
|
||||
Ошибка БД превращается в 503, неизвестный токен -- в 401.
|
||||
"""
|
||||
token_hash = hash_token(parse_bearer(request))
|
||||
cache = request.app.state.cache
|
||||
data = await cache.get(token_hash)
|
||||
if data is not None:
|
||||
if data.get("revoked"):
|
||||
raise unauthorized(BEARER_CHALLENGE)
|
||||
return cached_user(data)
|
||||
found = await crud.get_user_by_token(session, token_hash)
|
||||
if found is None:
|
||||
raise unauthorized(BEARER_CHALLENGE)
|
||||
user, remaining_seconds = found
|
||||
await cache.put(
|
||||
token_hash,
|
||||
{
|
||||
"id": str(user.id),
|
||||
"username": user.username,
|
||||
"display_name": user.display_name,
|
||||
"created_at": user.created_at.isoformat(),
|
||||
},
|
||||
remaining_seconds,
|
||||
)
|
||||
return user
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
"""Read-through кэш сессий в Redis; источник истины -- таблица sessions.
|
||||
|
||||
Ключ session:<sha256 токена>, TTL не больше остатка сессии. Заполнение
|
||||
через SET NX, logout записывает отметку отзыва. При недоступном Redis
|
||||
запросы идут в PostgreSQL; потерянная отметка отзыва ведёт к FLUSHDB
|
||||
перед следующим использованием кэша.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import time
|
||||
from typing import Awaitable, Callable, Dict, Optional, TypeVar
|
||||
|
||||
from redis.asyncio import Redis
|
||||
from redis.exceptions import RedisError
|
||||
|
||||
from .logging_setup import get_logger
|
||||
|
||||
KEY_PREFIX = "session:"
|
||||
REVOKED = "revoked"
|
||||
CACHE_ERRORS = (RedisError, OSError, asyncio.TimeoutError)
|
||||
|
||||
T = TypeVar("T")
|
||||
|
||||
|
||||
class SessionCache:
|
||||
"""Кэш сессий поверх Redis; ошибки Redis не выходят наружу."""
|
||||
|
||||
enabled = True
|
||||
|
||||
def __init__(self, url: str, ttl_cap: int, timeout_ms: int, retry_seconds: int):
|
||||
"""Создать клиент Redis с таймаутами; соединение открывается лениво."""
|
||||
timeout = timeout_ms / 1000
|
||||
self.client = Redis.from_url(
|
||||
url,
|
||||
socket_timeout=timeout,
|
||||
socket_connect_timeout=timeout,
|
||||
retry_on_timeout=False,
|
||||
decode_responses=True,
|
||||
)
|
||||
self.ttl_cap = ttl_cap
|
||||
self.timeout = timeout
|
||||
self.retry_seconds = retry_seconds
|
||||
self.down_until = 0.0
|
||||
self.dirty = False
|
||||
self.stats: Dict[str, int] = {
|
||||
"hits": 0, "misses": 0, "revoked_hits": 0, "errors": 0, "bypassed": 0
|
||||
}
|
||||
|
||||
async def _call(self, operation: Callable[[], Awaitable[T]]) -> T:
|
||||
"""Выполнить операцию с таймаутом, паузой после сбоя и очисткой грязного кэша."""
|
||||
if time.monotonic() < self.down_until:
|
||||
self.stats["bypassed"] += 1
|
||||
raise ConnectionError("cache is paused after a failure")
|
||||
try:
|
||||
if self.dirty:
|
||||
await asyncio.wait_for(self.client.flushdb(), self.timeout * 2)
|
||||
self.dirty = False
|
||||
get_logger().warning("cache: FLUSHDB after a lost revocation")
|
||||
return await asyncio.wait_for(operation(), self.timeout * 2)
|
||||
except CACHE_ERRORS as error:
|
||||
self.stats["errors"] += 1
|
||||
self.down_until = time.monotonic() + self.retry_seconds
|
||||
get_logger().warning("cache_unavailable type=%s", type(error).__name__)
|
||||
raise
|
||||
|
||||
async def get(self, token_hash: str) -> Optional[dict]:
|
||||
"""Данные пользователя, {"revoked": True} или None при промахе и сбое."""
|
||||
try:
|
||||
raw = await self._call(lambda: self.client.get(KEY_PREFIX + token_hash))
|
||||
except CACHE_ERRORS:
|
||||
return None
|
||||
if raw is None:
|
||||
self.stats["misses"] += 1
|
||||
return None
|
||||
if raw == REVOKED:
|
||||
self.stats["revoked_hits"] += 1
|
||||
return {"revoked": True}
|
||||
self.stats["hits"] += 1
|
||||
return json.loads(raw)
|
||||
|
||||
async def put(self, token_hash: str, user: dict, remaining_seconds: float) -> None:
|
||||
"""Сохранить сессию с TTL не больше её остатка, не затирая существующий ключ."""
|
||||
ttl_ms = int(min(self.ttl_cap, remaining_seconds) * 1000)
|
||||
if ttl_ms <= 0:
|
||||
return
|
||||
payload = json.dumps(user, separators=(",", ":"))
|
||||
try:
|
||||
await self._call(
|
||||
lambda: self.client.set(KEY_PREFIX + token_hash, payload, px=ttl_ms, nx=True)
|
||||
)
|
||||
except CACHE_ERRORS:
|
||||
pass
|
||||
|
||||
async def revoke(self, token_hash: str) -> None:
|
||||
"""Записать отметку отзыва; при сбое пометить кэш для очистки."""
|
||||
try:
|
||||
await self._call(
|
||||
lambda: self.client.set(
|
||||
KEY_PREFIX + token_hash, REVOKED, px=self.ttl_cap * 1000
|
||||
)
|
||||
)
|
||||
except CACHE_ERRORS:
|
||||
self.dirty = True
|
||||
|
||||
async def close(self) -> None:
|
||||
"""Закрыть соединения с Redis."""
|
||||
try:
|
||||
await self.client.aclose()
|
||||
except CACHE_ERRORS:
|
||||
pass
|
||||
|
||||
|
||||
class NoCache:
|
||||
"""Заглушка при выключенном кэше: всегда промах."""
|
||||
|
||||
enabled = False
|
||||
stats: Dict[str, int] = {}
|
||||
|
||||
async def get(self, token_hash: str) -> Optional[dict]:
|
||||
"""Всегда промах."""
|
||||
return None
|
||||
|
||||
async def put(self, token_hash: str, user: dict, remaining_seconds: float) -> None:
|
||||
"""Ничего не делает."""
|
||||
return None
|
||||
|
||||
async def revoke(self, token_hash: str) -> None:
|
||||
"""Ничего не делает."""
|
||||
return None
|
||||
|
||||
async def close(self) -> None:
|
||||
"""Ничего не делает."""
|
||||
return None
|
||||
|
||||
|
||||
def create_cache(settings) -> "SessionCache | NoCache":
|
||||
"""SessionCache, если задан CACHE_URL, иначе NoCache."""
|
||||
if not settings.cache_url:
|
||||
return NoCache()
|
||||
return SessionCache(
|
||||
settings.cache_url,
|
||||
settings.cache_ttl_seconds,
|
||||
settings.cache_timeout_ms,
|
||||
settings.cache_retry_seconds,
|
||||
)
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
"""Настройки приложения из переменных окружения."""
|
||||
|
||||
import os
|
||||
from dataclasses import dataclass
|
||||
from typing import Mapping, Optional
|
||||
|
||||
LOG_LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Settings:
|
||||
"""Неизменяемый набор настроек."""
|
||||
|
||||
host: str
|
||||
port: int
|
||||
env: str
|
||||
log_level: str
|
||||
database_url: str
|
||||
session_ttl_seconds: int
|
||||
session_store: str
|
||||
db_pool_size: int
|
||||
db_max_overflow: int
|
||||
db_pool_timeout: int
|
||||
db_startup_wait_seconds: int
|
||||
cache_url: str
|
||||
cache_ttl_seconds: int
|
||||
cache_timeout_ms: int
|
||||
cache_retry_seconds: int
|
||||
|
||||
@classmethod
|
||||
def from_env(cls, environ: Optional[Mapping[str, str]] = None) -> "Settings":
|
||||
"""Собрать и проверить настройки; при ошибке ValueError с описанием."""
|
||||
source = os.environ if environ is None else environ
|
||||
|
||||
def get(name: str, default: str) -> str:
|
||||
value = source.get(name)
|
||||
if value is None or value.strip() == "":
|
||||
return default
|
||||
return value.strip()
|
||||
|
||||
def get_int(name: str, default: int, low: int, high: int) -> int:
|
||||
text = get(name, str(default))
|
||||
if not text.isdigit() or not (low <= int(text) <= high):
|
||||
raise ValueError(
|
||||
"%s должен быть числом от %d до %d" % (name, low, high)
|
||||
)
|
||||
return int(text)
|
||||
|
||||
log_level = get("LOG_LEVEL", "INFO").upper()
|
||||
if log_level not in LOG_LEVELS:
|
||||
raise ValueError(
|
||||
"LOG_LEVEL должен быть одним из %s" % ", ".join(LOG_LEVELS)
|
||||
)
|
||||
|
||||
session_store = get("SESSION_STORE", "postgres")
|
||||
if session_store != "postgres":
|
||||
raise ValueError(
|
||||
"SESSION_STORE: источник истины сессий -- только postgres "
|
||||
"(Redis -- кэш, задаётся CACHE_URL)"
|
||||
)
|
||||
|
||||
database_url = _read_database_url(source)
|
||||
if not database_url.startswith("postgresql+asyncpg://"):
|
||||
raise ValueError("DATABASE_URL должен начинаться с postgresql+asyncpg://")
|
||||
|
||||
return cls(
|
||||
host=get("APP_HOST", "127.0.0.1"),
|
||||
port=get_int("APP_PORT", 8080, 1, 65535),
|
||||
env=get("APP_ENV", "lab"),
|
||||
log_level=log_level,
|
||||
database_url=database_url,
|
||||
session_ttl_seconds=get_int("SESSION_TTL_SECONDS", 3600, 1, 30 * 24 * 3600),
|
||||
session_store=session_store,
|
||||
db_pool_size=get_int("DB_POOL_SIZE", 5, 1, 50),
|
||||
db_max_overflow=get_int("DB_MAX_OVERFLOW", 5, 0, 50),
|
||||
db_pool_timeout=get_int("DB_POOL_TIMEOUT", 5, 1, 60),
|
||||
db_startup_wait_seconds=get_int("DB_STARTUP_WAIT_SECONDS", 30, 0, 300),
|
||||
cache_url=_read_cache_url(source),
|
||||
cache_ttl_seconds=get_int("CACHE_TTL_SECONDS", 60, 1, 3600),
|
||||
cache_timeout_ms=get_int("CACHE_TIMEOUT_MS", 300, 10, 5000),
|
||||
cache_retry_seconds=get_int("CACHE_RETRY_SECONDS", 5, 0, 300),
|
||||
)
|
||||
|
||||
|
||||
def _read_database_url(source: Mapping[str, str]) -> str:
|
||||
"""Адрес БД из DATABASE_URL_FILE или DATABASE_URL."""
|
||||
path = source.get("DATABASE_URL_FILE", "").strip()
|
||||
if path:
|
||||
with open(path, encoding="utf-8") as handle:
|
||||
return handle.read().strip()
|
||||
value = source.get("DATABASE_URL", "").strip()
|
||||
if not value:
|
||||
raise ValueError("Не задан DATABASE_URL (или DATABASE_URL_FILE)")
|
||||
return value
|
||||
|
||||
|
||||
def _read_cache_url(source: Mapping[str, str]) -> str:
|
||||
"""Адрес Redis из CACHE_URL_FILE или CACHE_URL; пустая строка -- кэш выключен."""
|
||||
path = source.get("CACHE_URL_FILE", "").strip()
|
||||
if path:
|
||||
with open(path, encoding="utf-8") as handle:
|
||||
value = handle.read().strip()
|
||||
else:
|
||||
value = source.get("CACHE_URL", "").strip()
|
||||
if value and not value.startswith(("redis://", "rediss://")):
|
||||
raise ValueError("CACHE_URL должен начинаться с redis:// или rediss://")
|
||||
return value
|
||||
+208
@@ -0,0 +1,208 @@
|
||||
"""Запросы к PostgreSQL через SQLAlchemy с параметрами.
|
||||
|
||||
Изменяющие функции -- одна транзакция: commit в конце, rollback при ошибке.
|
||||
"""
|
||||
|
||||
import uuid
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Dict, List, Optional, Tuple
|
||||
|
||||
from sqlalchemy import Select, delete, func, insert, select, tuple_
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from .models import Chat, ChatMember, Message, SessionRow, User
|
||||
|
||||
UNIQUE_VIOLATION = "23505"
|
||||
FOREIGN_KEY_VIOLATION = "23503"
|
||||
|
||||
Position = Tuple[datetime, uuid.UUID]
|
||||
|
||||
|
||||
class UsernameTaken(Exception):
|
||||
"""Username уже занят."""
|
||||
|
||||
|
||||
class UnknownMember(Exception):
|
||||
"""Среди участников чата есть несуществующий пользователь."""
|
||||
|
||||
|
||||
def sqlstate(error: IntegrityError) -> Optional[str]:
|
||||
"""Код SQLSTATE из исключения SQLAlchemy."""
|
||||
original = error.orig
|
||||
code = getattr(original, "sqlstate", None)
|
||||
if code is None:
|
||||
code = getattr(getattr(original, "__cause__", None), "sqlstate", None)
|
||||
return code
|
||||
|
||||
|
||||
async def create_user(
|
||||
session: AsyncSession, username: str, display_name: str, password_hash: str
|
||||
) -> User:
|
||||
"""Создать пользователя; дубликат username -> UsernameTaken."""
|
||||
statement = (
|
||||
insert(User)
|
||||
.values(
|
||||
id=uuid.uuid4(),
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
password_hash=password_hash,
|
||||
)
|
||||
.returning(User)
|
||||
)
|
||||
try:
|
||||
user = (await session.execute(statement)).scalar_one()
|
||||
await session.commit()
|
||||
except IntegrityError as error:
|
||||
await session.rollback()
|
||||
if sqlstate(error) == UNIQUE_VIOLATION:
|
||||
raise UsernameTaken(username)
|
||||
raise
|
||||
return user
|
||||
|
||||
|
||||
async def get_user_by_username(session: AsyncSession, username: str) -> Optional[User]:
|
||||
"""Пользователь по username или None."""
|
||||
return (
|
||||
await session.execute(select(User).where(User.username == username))
|
||||
).scalar_one_or_none()
|
||||
|
||||
|
||||
async def create_session(
|
||||
session: AsyncSession, user_id: uuid.UUID, token_hash: str, ttl_seconds: int
|
||||
) -> datetime:
|
||||
"""Удалить истёкшие сессии пользователя, создать новую, вернуть expires_at."""
|
||||
await session.execute(
|
||||
delete(SessionRow).where(
|
||||
SessionRow.user_id == user_id, SessionRow.expires_at < func.now()
|
||||
)
|
||||
)
|
||||
statement = (
|
||||
insert(SessionRow)
|
||||
.values(
|
||||
token_hash=token_hash,
|
||||
user_id=user_id,
|
||||
expires_at=func.now() + timedelta(seconds=ttl_seconds),
|
||||
)
|
||||
.returning(SessionRow.expires_at)
|
||||
)
|
||||
expires_at = (await session.execute(statement)).scalar_one()
|
||||
await session.commit()
|
||||
return expires_at
|
||||
|
||||
|
||||
async def get_user_by_token(
|
||||
session: AsyncSession, token_hash: str
|
||||
) -> Optional[Tuple[User, float]]:
|
||||
"""(User, секунд до истечения) для действующей сессии или None."""
|
||||
statement = (
|
||||
select(User, func.extract("epoch", SessionRow.expires_at - func.now()))
|
||||
.join(SessionRow, SessionRow.user_id == User.id)
|
||||
.where(SessionRow.token_hash == token_hash, SessionRow.expires_at > func.now())
|
||||
)
|
||||
row = (await session.execute(statement)).one_or_none()
|
||||
if row is None:
|
||||
return None
|
||||
return row[0], float(row[1])
|
||||
|
||||
|
||||
async def delete_session(session: AsyncSession, token_hash: str) -> None:
|
||||
"""Удалить сессию по хешу токена."""
|
||||
await session.execute(delete(SessionRow).where(SessionRow.token_hash == token_hash))
|
||||
await session.commit()
|
||||
|
||||
|
||||
async def create_chat(
|
||||
session: AsyncSession, title: str, member_ids: List[uuid.UUID]
|
||||
) -> Tuple[Chat, List[uuid.UUID]]:
|
||||
"""Атомарно создать чат и участников; неизвестный участник -> UnknownMember."""
|
||||
chat_statement = insert(Chat).values(id=uuid.uuid4(), title=title).returning(Chat)
|
||||
try:
|
||||
chat = (await session.execute(chat_statement)).scalar_one()
|
||||
await session.execute(
|
||||
insert(ChatMember),
|
||||
[{"chat_id": chat.id, "user_id": user_id} for user_id in member_ids],
|
||||
)
|
||||
await session.commit()
|
||||
except IntegrityError as error:
|
||||
await session.rollback()
|
||||
if sqlstate(error) == FOREIGN_KEY_VIOLATION:
|
||||
raise UnknownMember()
|
||||
raise
|
||||
return chat, member_ids
|
||||
|
||||
|
||||
async def get_chat_for_member(
|
||||
session: AsyncSession, chat_id: uuid.UUID, user_id: uuid.UUID
|
||||
) -> Optional[Chat]:
|
||||
"""Чат, если пользователь в нём состоит, иначе None."""
|
||||
statement = (
|
||||
select(Chat)
|
||||
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
||||
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
|
||||
)
|
||||
return (await session.execute(statement)).scalar_one_or_none()
|
||||
|
||||
|
||||
async def get_member_ids(
|
||||
session: AsyncSession, chat_ids: List[uuid.UUID]
|
||||
) -> Dict[uuid.UUID, List[uuid.UUID]]:
|
||||
"""Участники нескольких чатов одним запросом: {chat_id: [user_id]}."""
|
||||
result: Dict[uuid.UUID, List[uuid.UUID]] = {chat_id: [] for chat_id in chat_ids}
|
||||
if chat_ids:
|
||||
statement = (
|
||||
select(ChatMember.chat_id, ChatMember.user_id)
|
||||
.where(ChatMember.chat_id.in_(chat_ids))
|
||||
.order_by(ChatMember.chat_id, ChatMember.user_id)
|
||||
)
|
||||
for chat_id, user_id in (await session.execute(statement)).all():
|
||||
result[chat_id].append(user_id)
|
||||
return result
|
||||
|
||||
|
||||
async def list_chats(
|
||||
session: AsyncSession, user_id: uuid.UUID, after: Optional[Position], limit: int
|
||||
) -> Tuple[List[Chat], bool]:
|
||||
"""Страница чатов пользователя по (created_at, id) и признак следующей страницы."""
|
||||
statement = (
|
||||
select(Chat)
|
||||
.join(ChatMember, ChatMember.chat_id == Chat.id)
|
||||
.where(ChatMember.user_id == user_id)
|
||||
)
|
||||
if after is not None:
|
||||
statement = statement.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after))
|
||||
statement = statement.order_by(Chat.created_at, Chat.id).limit(limit + 1)
|
||||
rows = list((await session.execute(statement)).scalars())
|
||||
return rows[:limit], len(rows) > limit
|
||||
|
||||
|
||||
async def create_message(
|
||||
session: AsyncSession, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str
|
||||
) -> Message:
|
||||
"""Сохранить сообщение; время назначает БД."""
|
||||
statement = (
|
||||
insert(Message)
|
||||
.values(id=uuid.uuid4(), chat_id=chat_id, sender_id=sender_id, text=text)
|
||||
.returning(Message)
|
||||
)
|
||||
message = (await session.execute(statement)).scalar_one()
|
||||
await session.commit()
|
||||
return message
|
||||
|
||||
|
||||
def history_query(chat_id: uuid.UUID, after: Optional[Position], limit: int) -> Select:
|
||||
"""SELECT страницы истории по курсору (created_at, id); идёт по индексу чата."""
|
||||
statement = select(Message).where(Message.chat_id == chat_id)
|
||||
if after is not None:
|
||||
statement = statement.where(
|
||||
tuple_(Message.created_at, Message.id) > tuple_(*after)
|
||||
)
|
||||
return statement.order_by(Message.created_at, Message.id).limit(limit + 1)
|
||||
|
||||
|
||||
async def list_messages(
|
||||
session: AsyncSession, chat_id: uuid.UUID, after: Optional[Position], limit: int
|
||||
) -> Tuple[List[Message], bool]:
|
||||
"""Страница истории чата и признак следующей страницы."""
|
||||
rows = list((await session.execute(history_query(chat_id, after, limit))).scalars())
|
||||
return rows[:limit], len(rows) > limit
|
||||
@@ -0,0 +1,45 @@
|
||||
"""Непрозрачный keyset-курсор пагинации.
|
||||
|
||||
Хранит позицию (микросекунды, id) и область действия, поэтому курсор
|
||||
другого ресурса отвергается.
|
||||
"""
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
import json
|
||||
import re
|
||||
from typing import Tuple
|
||||
|
||||
Key = Tuple[int, str]
|
||||
|
||||
UUID_RE = re.compile(
|
||||
r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"
|
||||
)
|
||||
MAX_CURSOR_LENGTH = 512
|
||||
|
||||
|
||||
def encode_cursor(scope: str, key: Key) -> str:
|
||||
"""Закодировать позицию и область в URL-безопасную строку."""
|
||||
payload = json.dumps({"s": scope, "t": key[0], "i": key[1]}, separators=(",", ":"))
|
||||
return base64.urlsafe_b64encode(payload.encode("ascii")).decode("ascii").rstrip("=")
|
||||
|
||||
|
||||
def decode_cursor(text: str, scope: str) -> Key:
|
||||
"""Раскодировать курсор; ValueError, если он испорчен или чужой."""
|
||||
if len(text) > MAX_CURSOR_LENGTH or not re.fullmatch(r"[A-Za-z0-9_-]+", text):
|
||||
raise ValueError("bad cursor")
|
||||
try:
|
||||
padded = text + "=" * (-len(text) % 4)
|
||||
data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")))
|
||||
except (binascii.Error, ValueError, UnicodeError):
|
||||
raise ValueError("bad cursor")
|
||||
if not isinstance(data, dict) or set(data) != {"s", "t", "i"}:
|
||||
raise ValueError("bad cursor")
|
||||
stamp, ident = data["t"], data["i"]
|
||||
if data["s"] != scope:
|
||||
raise ValueError("cursor belongs to another resource")
|
||||
if not isinstance(stamp, int) or isinstance(stamp, bool) or stamp < 0:
|
||||
raise ValueError("bad cursor")
|
||||
if not isinstance(ident, str) or not UUID_RE.fullmatch(ident):
|
||||
raise ValueError("bad cursor")
|
||||
return stamp, ident
|
||||
@@ -0,0 +1,27 @@
|
||||
"""Подключение к PostgreSQL: движок с пулом и фабрика сессий."""
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from .config import Settings
|
||||
|
||||
|
||||
def create_engine(settings: Settings) -> AsyncEngine:
|
||||
"""Async-движок с ограниченным пулом и таймаутами."""
|
||||
return create_async_engine(
|
||||
settings.database_url,
|
||||
pool_size=settings.db_pool_size,
|
||||
max_overflow=settings.db_max_overflow,
|
||||
pool_timeout=settings.db_pool_timeout,
|
||||
pool_pre_ping=True,
|
||||
connect_args={
|
||||
"timeout": 5,
|
||||
"command_timeout": 10,
|
||||
"server_settings": {"application_name": "messenger-api"},
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
def create_sessionmaker(engine: AsyncEngine) -> "async_sessionmaker[AsyncSession]":
|
||||
"""Фабрика сессий без истечения объектов после commit."""
|
||||
return async_sessionmaker(engine, expire_on_commit=False)
|
||||
@@ -0,0 +1,37 @@
|
||||
"""Единый формат ошибок API."""
|
||||
|
||||
from typing import Dict, Optional
|
||||
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
class ApiError(Exception):
|
||||
"""Исключение, которое превращается в ответ с кодом и сообщением."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
status: int,
|
||||
code: str,
|
||||
message: str,
|
||||
headers: Optional[Dict[str, str]] = None,
|
||||
):
|
||||
super().__init__(message)
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
self.headers = headers
|
||||
|
||||
|
||||
def error_response(
|
||||
request_id: str,
|
||||
status: int,
|
||||
code: str,
|
||||
message: str,
|
||||
headers: Optional[Dict[str, str]] = None,
|
||||
) -> JSONResponse:
|
||||
"""JSON-ответ вида {"error": {code, message, request_id}}."""
|
||||
return JSONResponse(
|
||||
status_code=status,
|
||||
content={"error": {"code": code, "message": message, "request_id": request_id}},
|
||||
headers=headers,
|
||||
)
|
||||
+139
@@ -0,0 +1,139 @@
|
||||
"""Анализ плана запроса истории: EXPLAIN (ANALYZE, BUFFERS) на синтетических данных.
|
||||
|
||||
Запуск: python -m app.explain [--messages N]. Создаёт данные один раз,
|
||||
затем сравнивает запрос приложения с OFFSET и с вариантом без индекса.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import sys
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncEngine
|
||||
|
||||
from .config import Settings
|
||||
from .crud import history_query
|
||||
from .db import create_engine
|
||||
|
||||
SEED_NAMESPACE = uuid.UUID("6f1c1a52-6a39-4c1e-9d0e-5ab0e0c0e2a1")
|
||||
BIG_CHAT = uuid.uuid5(SEED_NAMESPACE, "chat-big")
|
||||
OTHER_CHATS = [uuid.uuid5(SEED_NAMESPACE, "chat-%d" % n) for n in range(49)]
|
||||
SENDERS = [uuid.uuid5(SEED_NAMESPACE, "user-a"), uuid.uuid5(SEED_NAMESPACE, "user-b")]
|
||||
PAGE = 50
|
||||
DEEP_OFFSET = 15000
|
||||
|
||||
|
||||
async def seed(pg, total: int) -> None:
|
||||
"""Создать синтетических пользователей, чаты и сообщения, если их ещё нет."""
|
||||
if await pg.fetchval("SELECT 1 FROM chats WHERE id = $1", BIG_CHAT):
|
||||
return
|
||||
async with pg.transaction():
|
||||
await pg.executemany(
|
||||
"INSERT INTO users (id, username, display_name, password_hash)"
|
||||
" VALUES ($1, $2, $3, 'disabled')",
|
||||
[(SENDERS[0], "explain_seed_a", "Seed A"), (SENDERS[1], "explain_seed_b", "Seed B")],
|
||||
)
|
||||
chats = [BIG_CHAT] + OTHER_CHATS
|
||||
await pg.executemany(
|
||||
"INSERT INTO chats (id, title, created_at)"
|
||||
" VALUES ($1, $2, now() - interval '30 days')",
|
||||
[(chat, "explain seed %d" % n) for n, chat in enumerate(chats)],
|
||||
)
|
||||
await pg.executemany(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
|
||||
[(chat, sender) for chat in chats for sender in SENDERS],
|
||||
)
|
||||
await pg.execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(),
|
||||
CASE WHEN g % 3 = 0 THEN $1::uuid ELSE ($2::uuid[])[1 + g % 49] END,
|
||||
($3::uuid[])[1 + g % 2],
|
||||
'synthetic message #' || g,
|
||||
now() - interval '30 days' + g * interval '10 milliseconds'
|
||||
FROM generate_series(1, $4::int) AS g
|
||||
""",
|
||||
BIG_CHAT, OTHER_CHATS, SENDERS, total,
|
||||
)
|
||||
await pg.execute("ANALYZE messages")
|
||||
await pg.execute("ANALYZE chats")
|
||||
await pg.execute("ANALYZE chat_members")
|
||||
|
||||
|
||||
def compiled(engine: AsyncEngine, after: Optional[Tuple[datetime, uuid.UUID]]) -> Tuple[str, List]:
|
||||
"""Текст SQL запроса истории и значения его параметров."""
|
||||
query = history_query(BIG_CHAT, after, PAGE).compile(dialect=engine.dialect)
|
||||
return query.string, [query.params[name] for name in query.positiontup]
|
||||
|
||||
|
||||
async def explain(pg, title: str, sql: str, params: List) -> None:
|
||||
"""Напечатать запрос, параметры и план выполнения."""
|
||||
print("\n" + "=" * 78)
|
||||
print(title)
|
||||
print("=" * 78)
|
||||
print(sql)
|
||||
print("-- параметры:", ", ".join(str(p) for p in params))
|
||||
for row in await pg.fetch("EXPLAIN (ANALYZE, BUFFERS) " + sql, *params):
|
||||
print(row[0])
|
||||
|
||||
|
||||
async def main_async(total: int) -> int:
|
||||
"""Заполнить данные и вывести планы запросов."""
|
||||
engine = create_engine(Settings.from_env())
|
||||
try:
|
||||
async with engine.connect() as conn:
|
||||
pg = (await conn.get_raw_connection()).driver_connection
|
||||
await seed(pg, total)
|
||||
print("PostgreSQL:", await pg.fetchval("SHOW server_version"))
|
||||
print("Сообщений всего:", await pg.fetchval("SELECT count(*) FROM messages"))
|
||||
print("Сообщений в большом чате:",
|
||||
await pg.fetchval("SELECT count(*) FROM messages WHERE chat_id = $1", BIG_CHAT))
|
||||
print("Размер таблицы messages:",
|
||||
await pg.fetchval("SELECT pg_size_pretty(pg_relation_size('messages'))"))
|
||||
print("Размер индекса messages_chat_created_idx:",
|
||||
await pg.fetchval("SELECT pg_size_pretty(pg_relation_size('messages_chat_created_idx'))"))
|
||||
cursor = await pg.fetchrow(
|
||||
"SELECT created_at, id FROM messages WHERE chat_id = $1"
|
||||
" ORDER BY created_at, id OFFSET $2 LIMIT 1",
|
||||
BIG_CHAT, DEEP_OFFSET - 1,
|
||||
)
|
||||
after = (cursor["created_at"], cursor["id"])
|
||||
|
||||
sql, params = compiled(engine, None)
|
||||
await explain(pg, "1. Первая страница (без cursor), запрос приложения", sql, params)
|
||||
sql, params = compiled(engine, after)
|
||||
await explain(pg, "2. Глубокая страница: cursor после %d-го сообщения (keyset)"
|
||||
% DEEP_OFFSET, sql, params)
|
||||
await explain(
|
||||
pg, "3. Для сравнения: та же страница через OFFSET (так приложение НЕ делает)",
|
||||
"SELECT * FROM messages WHERE chat_id = $1 ORDER BY created_at, id"
|
||||
" OFFSET %d LIMIT %d" % (DEEP_OFFSET, PAGE + 1),
|
||||
[BIG_CHAT],
|
||||
)
|
||||
tx = pg.transaction()
|
||||
await tx.start()
|
||||
try:
|
||||
await pg.execute("DROP INDEX messages_chat_created_idx")
|
||||
await explain(pg, "4. Для сравнения: запрос приложения БЕЗ индекса"
|
||||
" (DROP INDEX в транзакции, затем ROLLBACK)", sql, params)
|
||||
finally:
|
||||
await tx.rollback()
|
||||
print("\nИндекс messages_chat_created_idx на месте:",
|
||||
bool(await pg.fetchval("SELECT to_regclass('messages_chat_created_idx')")))
|
||||
finally:
|
||||
await engine.dispose()
|
||||
return 0
|
||||
|
||||
|
||||
def main() -> int:
|
||||
"""Разобрать аргументы командной строки и запустить анализ."""
|
||||
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
parser.add_argument("--messages", type=int, default=60000,
|
||||
help="сколько синтетических сообщений создать при первом запуске")
|
||||
return asyncio.run(main_async(parser.parse_args().messages))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,20 @@
|
||||
"""Проверка готовности для HEALTHCHECK контейнера."""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import urllib.request
|
||||
|
||||
|
||||
def main() -> int:
|
||||
"""0, если /health/ready отвечает 200, иначе 1."""
|
||||
port = os.environ.get("APP_PORT", "8080").strip() or "8080"
|
||||
try:
|
||||
url = "http://127.0.0.1:%s/health/ready" % port
|
||||
with urllib.request.urlopen(url, timeout=2) as reply:
|
||||
return 0 if reply.status == 200 else 1
|
||||
except Exception:
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,102 @@
|
||||
"""Помощники HTTP: чтение JSON, проверка тела, разбор UUID, limit и cursor."""
|
||||
|
||||
import json
|
||||
import re
|
||||
from typing import Optional, Type, TypeVar
|
||||
|
||||
from fastapi import Request
|
||||
from pydantic import BaseModel, ValidationError
|
||||
|
||||
from .cursor import Key, UUID_RE, decode_cursor
|
||||
from .errors import ApiError
|
||||
|
||||
MAX_BODY_BYTES = 256 * 1024
|
||||
DEFAULT_LIMIT = 50
|
||||
MAX_LIMIT = 100
|
||||
|
||||
T = TypeVar("T", bound=BaseModel)
|
||||
|
||||
|
||||
def bad_request(message: str) -> ApiError:
|
||||
"""Ошибка 400 invalid_request."""
|
||||
return ApiError(400, "invalid_request", message)
|
||||
|
||||
|
||||
def _reject_constant(name: str):
|
||||
"""Запретить NaN и Infinity в JSON."""
|
||||
raise ValueError("недопустимое значение " + name)
|
||||
|
||||
|
||||
async def read_json_object(request: Request) -> dict:
|
||||
"""Прочитать тело запроса как JSON-объект."""
|
||||
content_type = request.headers.get("content-type", "")
|
||||
media_type, _, params = content_type.partition(";")
|
||||
if media_type.strip().lower() != "application/json":
|
||||
raise ApiError(
|
||||
415, "unsupported_media_type", "Нужен Content-Type: application/json"
|
||||
)
|
||||
charset = re.search(r"charset\s*=\s*\"?([^\";\s]+)", params, re.IGNORECASE)
|
||||
if charset and charset.group(1).lower() not in ("utf-8", "utf8"):
|
||||
raise ApiError(
|
||||
415, "unsupported_media_type", "Поддерживается только кодировка UTF-8"
|
||||
)
|
||||
|
||||
declared = request.headers.get("content-length", "")
|
||||
if declared.isdigit() and int(declared) > MAX_BODY_BYTES:
|
||||
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
|
||||
|
||||
chunks = []
|
||||
size = 0
|
||||
async for chunk in request.stream():
|
||||
size += len(chunk)
|
||||
if size > MAX_BODY_BYTES:
|
||||
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
|
||||
chunks.append(chunk)
|
||||
|
||||
try:
|
||||
data = json.loads(
|
||||
b"".join(chunks).decode("utf-8"), parse_constant=_reject_constant
|
||||
)
|
||||
except (UnicodeDecodeError, ValueError, RecursionError):
|
||||
raise bad_request("Тело запроса не является корректным JSON")
|
||||
if not isinstance(data, dict):
|
||||
raise bad_request("Тело запроса должно быть JSON-объектом")
|
||||
return data
|
||||
|
||||
|
||||
def validate_body(model: Type[T], data: dict) -> T:
|
||||
"""Проверить словарь моделью Pydantic; ошибки -> 400."""
|
||||
try:
|
||||
return model.model_validate(data)
|
||||
except ValidationError as exc:
|
||||
problems = []
|
||||
for err in exc.errors()[:3]:
|
||||
field = ".".join(str(part) for part in err["loc"]) or "body"
|
||||
problems.append("%s: %s" % (field, err["msg"].replace("Value error, ", "")))
|
||||
raise bad_request("Неверные данные: " + "; ".join(problems))
|
||||
|
||||
|
||||
def parse_uuid(value: str, what: str) -> str:
|
||||
"""Проверить строку как UUID и вернуть её в нижнем регистре."""
|
||||
if not UUID_RE.fullmatch(value):
|
||||
raise bad_request("%s должен быть UUID" % what)
|
||||
return value.lower()
|
||||
|
||||
|
||||
def parse_limit(raw: Optional[str]) -> int:
|
||||
"""Размер страницы: по умолчанию 50, допустимо 1-100."""
|
||||
if raw is None:
|
||||
return DEFAULT_LIMIT
|
||||
if not re.fullmatch(r"[0-9]{1,6}", raw) or not 1 <= int(raw) <= MAX_LIMIT:
|
||||
raise bad_request("limit должен быть целым числом от 1 до %d" % MAX_LIMIT)
|
||||
return int(raw)
|
||||
|
||||
|
||||
def parse_cursor(raw: Optional[str], scope: str) -> Optional[Key]:
|
||||
"""Позиция из курсора или None; неверный курсор -> 400."""
|
||||
if raw is None or raw == "":
|
||||
return None
|
||||
try:
|
||||
return decode_cursor(raw, scope)
|
||||
except ValueError:
|
||||
raise bad_request("Некорректный cursor")
|
||||
@@ -0,0 +1,25 @@
|
||||
"""Настройка логирования в stdout."""
|
||||
|
||||
import logging
|
||||
import sys
|
||||
|
||||
LOGGER_NAME = "messenger"
|
||||
|
||||
|
||||
def get_logger() -> logging.Logger:
|
||||
"""Логгер приложения."""
|
||||
return logging.getLogger(LOGGER_NAME)
|
||||
|
||||
|
||||
def setup_logging(level: str = "INFO") -> logging.Logger:
|
||||
"""Задать уровень и формат: одна строка на событие."""
|
||||
logger = get_logger()
|
||||
logger.setLevel(level)
|
||||
if not logger.handlers:
|
||||
handler = logging.StreamHandler(sys.stdout)
|
||||
handler.setFormatter(
|
||||
logging.Formatter("%(asctime)s %(levelname)s %(message)s", "%Y-%m-%dT%H:%M:%S%z")
|
||||
)
|
||||
logger.addHandler(handler)
|
||||
logger.propagate = False
|
||||
return logger
|
||||
+136
@@ -0,0 +1,136 @@
|
||||
"""Сборка приложения FastAPI: зависимости, миграции, обработчики ошибок."""
|
||||
|
||||
import asyncio
|
||||
import time
|
||||
from contextlib import asynccontextmanager
|
||||
from typing import Optional
|
||||
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from sqlalchemy.exc import InterfaceError, OperationalError
|
||||
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from .cache import create_cache
|
||||
from .config import Settings
|
||||
from .db import create_engine, create_sessionmaker
|
||||
from .errors import ApiError, error_response
|
||||
from .logging_setup import get_logger, setup_logging
|
||||
from .middleware import RequestContextMiddleware
|
||||
from .migrate import run_migrations
|
||||
from .routes import api, router
|
||||
|
||||
DB_UNAVAILABLE = (
|
||||
OperationalError,
|
||||
InterfaceError,
|
||||
PoolTimeoutError,
|
||||
OSError,
|
||||
asyncio.TimeoutError,
|
||||
)
|
||||
|
||||
|
||||
async def migrate_with_retry(engine, wait_seconds: int) -> None:
|
||||
"""Применить миграции, повторяя попытки, пока БД не станет доступна."""
|
||||
deadline = time.monotonic() + wait_seconds
|
||||
while True:
|
||||
try:
|
||||
applied = await run_migrations(engine)
|
||||
get_logger().info(
|
||||
"migrations: %s", ", ".join(applied) if applied else "nothing to apply"
|
||||
)
|
||||
return
|
||||
except Exception as exc:
|
||||
if time.monotonic() >= deadline:
|
||||
raise
|
||||
get_logger().warning(
|
||||
"migrations: БД ещё не готова (%s), повтор", type(exc).__name__
|
||||
)
|
||||
await asyncio.sleep(1)
|
||||
|
||||
|
||||
def create_app(settings: Optional[Settings] = None) -> FastAPI:
|
||||
"""Создать приложение FastAPI с заданными настройками."""
|
||||
settings = settings or Settings.from_env()
|
||||
setup_logging(settings.log_level)
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
"""Старт: кэш, движок, миграции. Остановка: закрыть соединения."""
|
||||
get_logger().info(
|
||||
"config env=%s pool=%d+%d ttl=%ds store=%s cache=%s",
|
||||
settings.env,
|
||||
settings.db_pool_size,
|
||||
settings.db_max_overflow,
|
||||
settings.session_ttl_seconds,
|
||||
settings.session_store,
|
||||
"redis" if settings.cache_url else "off",
|
||||
)
|
||||
app.state.cache = create_cache(settings)
|
||||
engine = create_engine(settings)
|
||||
app.state.engine = engine
|
||||
app.state.sessionmaker = create_sessionmaker(engine)
|
||||
await migrate_with_retry(engine, settings.db_startup_wait_seconds)
|
||||
app.state.ready = True
|
||||
get_logger().info("startup: приложение готово")
|
||||
yield
|
||||
app.state.ready = False
|
||||
await app.state.cache.close()
|
||||
await engine.dispose()
|
||||
get_logger().info("shutdown: получен сигнал остановки, соединения с БД закрыты")
|
||||
|
||||
app = FastAPI(title="Messenger API", version="1.2.0", lifespan=lifespan)
|
||||
app.state.settings = settings
|
||||
app.state.ready = False
|
||||
app.router.redirect_slashes = False
|
||||
app.add_middleware(RequestContextMiddleware)
|
||||
|
||||
@app.exception_handler(ApiError)
|
||||
async def handle_api_error(request: Request, exc: ApiError):
|
||||
"""ApiError -> ответ в общем формате."""
|
||||
return error_response(
|
||||
request.state.request_id, exc.status, exc.code, exc.message, exc.headers
|
||||
)
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def handle_http_error(request: Request, exc: StarletteHTTPException):
|
||||
"""404 и 405 -> ответ в общем формате."""
|
||||
if exc.status_code == 404:
|
||||
return error_response(
|
||||
request.state.request_id, 404, "not_found", "Объект не найден"
|
||||
)
|
||||
headers = dict(exc.headers) if exc.headers else None
|
||||
return error_response(
|
||||
request.state.request_id,
|
||||
exc.status_code,
|
||||
"invalid_request",
|
||||
"Запрос не поддерживается",
|
||||
headers,
|
||||
)
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def handle_validation_error(request: Request, exc: RequestValidationError):
|
||||
"""Ошибки разбора параметров -> 400."""
|
||||
return error_response(
|
||||
request.state.request_id,
|
||||
400,
|
||||
"invalid_request",
|
||||
"Неверные параметры запроса",
|
||||
)
|
||||
|
||||
async def handle_db_unavailable(request: Request, exc: Exception):
|
||||
"""Недоступная БД или пул -> 503 без деталей."""
|
||||
get_logger().error(
|
||||
"db_unavailable request_id=%s type=%s",
|
||||
request.state.request_id,
|
||||
type(exc).__name__,
|
||||
)
|
||||
return error_response(
|
||||
request.state.request_id, 503, "unavailable", "Сервис временно недоступен"
|
||||
)
|
||||
|
||||
for error_type in DB_UNAVAILABLE:
|
||||
app.add_exception_handler(error_type, handle_db_unavailable)
|
||||
|
||||
app.include_router(router)
|
||||
app.include_router(api)
|
||||
return app
|
||||
@@ -0,0 +1,68 @@
|
||||
"""ASGI-middleware: X-Request-Id, ответ 500 при сбое и строка лога на запрос."""
|
||||
|
||||
import time
|
||||
import traceback
|
||||
import uuid
|
||||
|
||||
from starlette.datastructures import MutableHeaders
|
||||
from starlette.types import ASGIApp, Message, Receive, Scope, Send
|
||||
|
||||
from .errors import error_response
|
||||
from .logging_setup import get_logger
|
||||
|
||||
|
||||
class RequestContextMiddleware:
|
||||
"""Request id, обработка необработанных исключений, журнал запросов."""
|
||||
|
||||
def __init__(self, app: ASGIApp) -> None:
|
||||
"""Сохранить следующее приложение в цепочке."""
|
||||
self.app = app
|
||||
|
||||
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
|
||||
"""Обработать один HTTP-запрос."""
|
||||
if scope["type"] != "http":
|
||||
await self.app(scope, receive, send)
|
||||
return
|
||||
|
||||
request_id = uuid.uuid4().hex
|
||||
scope.setdefault("state", {})["request_id"] = request_id
|
||||
started = time.perf_counter()
|
||||
state = {"status": 500, "response_started": False}
|
||||
|
||||
async def send_with_request_id(message: Message) -> None:
|
||||
if message["type"] == "http.response.start":
|
||||
state["status"] = message["status"]
|
||||
state["response_started"] = True
|
||||
MutableHeaders(scope=message)["X-Request-Id"] = request_id
|
||||
await send(message)
|
||||
|
||||
try:
|
||||
await self.app(scope, receive, send_with_request_id)
|
||||
except Exception as exc:
|
||||
|
||||
frames = traceback.extract_tb(exc.__traceback__)
|
||||
where = " <- ".join(
|
||||
"%s:%s" % (f.filename.split("/")[-1], f.lineno)
|
||||
for f in reversed(frames[-3:])
|
||||
)
|
||||
get_logger().error(
|
||||
"unhandled_error request_id=%s type=%s where=%s",
|
||||
request_id,
|
||||
type(exc).__name__,
|
||||
where,
|
||||
)
|
||||
if state["response_started"]:
|
||||
raise
|
||||
response = error_response(
|
||||
request_id, 500, "internal_error", "Внутренняя ошибка сервера"
|
||||
)
|
||||
await response(scope, receive, send_with_request_id)
|
||||
finally:
|
||||
get_logger().info(
|
||||
"request request_id=%s method=%s path=%s status=%s duration_ms=%.1f",
|
||||
request_id,
|
||||
scope.get("method"),
|
||||
scope.get("path"),
|
||||
state["status"],
|
||||
(time.perf_counter() - started) * 1000,
|
||||
)
|
||||
@@ -0,0 +1,64 @@
|
||||
"""Применение SQL-миграций из app/migrations/.
|
||||
|
||||
Применённые файлы хранятся в schema_migrations; каждый файл выполняется
|
||||
в своей транзакции под advisory lock. Запуск: python -m app.migrate
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import List
|
||||
|
||||
from sqlalchemy.ext.asyncio import AsyncEngine
|
||||
|
||||
from .config import Settings
|
||||
from .db import create_engine
|
||||
|
||||
MIGRATIONS_DIR = Path(__file__).parent / "migrations"
|
||||
LOCK_ID = 727001
|
||||
|
||||
|
||||
async def run_migrations(engine: AsyncEngine) -> List[str]:
|
||||
"""Применить новые миграции и вернуть их имена."""
|
||||
applied_now: List[str] = []
|
||||
async with engine.connect() as conn:
|
||||
raw = await conn.get_raw_connection()
|
||||
pg = raw.driver_connection
|
||||
await pg.execute("SELECT pg_advisory_lock(%d)" % LOCK_ID)
|
||||
try:
|
||||
await pg.execute(
|
||||
"CREATE TABLE IF NOT EXISTS schema_migrations ("
|
||||
" version text PRIMARY KEY,"
|
||||
" applied_at timestamptz NOT NULL DEFAULT now())"
|
||||
)
|
||||
done = {
|
||||
row["version"]
|
||||
for row in await pg.fetch("SELECT version FROM schema_migrations")
|
||||
}
|
||||
for path in sorted(MIGRATIONS_DIR.glob("*.sql")):
|
||||
if path.name in done:
|
||||
continue
|
||||
async with pg.transaction():
|
||||
await pg.execute(path.read_text(encoding="utf-8"))
|
||||
await pg.execute(
|
||||
"INSERT INTO schema_migrations (version) VALUES ($1)", path.name
|
||||
)
|
||||
applied_now.append(path.name)
|
||||
finally:
|
||||
await pg.execute("SELECT pg_advisory_unlock(%d)" % LOCK_ID)
|
||||
return applied_now
|
||||
|
||||
|
||||
async def _main() -> int:
|
||||
"""Применить миграции из командной строки и напечатать результат."""
|
||||
engine = create_engine(Settings.from_env())
|
||||
try:
|
||||
applied = await run_migrations(engine)
|
||||
finally:
|
||||
await engine.dispose()
|
||||
print("Применено: %s" % (", ".join(applied) if applied else "ничего нового"))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(asyncio.run(_main()))
|
||||
@@ -0,0 +1,41 @@
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL UNIQUE
|
||||
CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
display_name text NOT NULL
|
||||
CHECK (char_length(display_name) BETWEEN 1 AND 100),
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX chats_created_idx ON chats (created_at, id);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX messages_chat_created_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash text PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
expires_at timestamptz NOT NULL
|
||||
);
|
||||
CREATE INDEX sessions_user_idx ON sessions (user_id);
|
||||
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,70 @@
|
||||
"""ORM-модели таблиц; схема и ограничения задаются миграциями."""
|
||||
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import DateTime, func
|
||||
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
|
||||
|
||||
NOW = func.clock_timestamp()
|
||||
|
||||
|
||||
class Base(DeclarativeBase):
|
||||
"""Базовый класс моделей."""
|
||||
|
||||
|
||||
class User(Base):
|
||||
"""Пользователь; пароль хранится только как хеш."""
|
||||
|
||||
__tablename__ = "users"
|
||||
id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
|
||||
username: Mapped[str]
|
||||
display_name: Mapped[str]
|
||||
password_hash: Mapped[str]
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=NOW
|
||||
)
|
||||
|
||||
|
||||
class Chat(Base):
|
||||
"""Чат."""
|
||||
|
||||
__tablename__ = "chats"
|
||||
id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
|
||||
title: Mapped[str]
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=NOW
|
||||
)
|
||||
|
||||
|
||||
class ChatMember(Base):
|
||||
"""Участие пользователя в чате."""
|
||||
|
||||
__tablename__ = "chat_members"
|
||||
chat_id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
|
||||
user_id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
|
||||
|
||||
|
||||
class Message(Base):
|
||||
"""Сообщение чата."""
|
||||
|
||||
__tablename__ = "messages"
|
||||
id: Mapped[uuid.UUID] = mapped_column(primary_key=True)
|
||||
chat_id: Mapped[uuid.UUID]
|
||||
sender_id: Mapped[uuid.UUID]
|
||||
text: Mapped[str]
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=NOW
|
||||
)
|
||||
|
||||
|
||||
class SessionRow(Base):
|
||||
"""Сессия входа; хранится SHA-256 токена."""
|
||||
|
||||
__tablename__ = "sessions"
|
||||
token_hash: Mapped[str] = mapped_column(primary_key=True)
|
||||
user_id: Mapped[uuid.UUID]
|
||||
created_at: Mapped[datetime] = mapped_column(
|
||||
DateTime(timezone=True), server_default=NOW
|
||||
)
|
||||
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
|
||||
+290
@@ -0,0 +1,290 @@
|
||||
"""HTTP-эндпоинты API.
|
||||
|
||||
Порядок проверок: аутентификация (401), доступ к чату (404), тело запроса (400).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import uuid
|
||||
from typing import List
|
||||
|
||||
from fastapi import APIRouter, Depends, Request, Response
|
||||
from sqlalchemy import text
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from . import crud
|
||||
from .auth import (
|
||||
BASIC_CHALLENGE,
|
||||
current_user,
|
||||
get_session,
|
||||
parse_basic,
|
||||
parse_bearer,
|
||||
unauthorized,
|
||||
)
|
||||
from .cursor import encode_cursor
|
||||
from .errors import ApiError
|
||||
from .http_utils import (
|
||||
parse_cursor,
|
||||
parse_limit,
|
||||
parse_uuid,
|
||||
read_json_object,
|
||||
validate_body,
|
||||
)
|
||||
from .models import Chat, Message, User
|
||||
from .schemas import (
|
||||
ChatOut,
|
||||
ChatPage,
|
||||
CreateChatIn,
|
||||
CreateMessageIn,
|
||||
CreateUserIn,
|
||||
MessageOut,
|
||||
MessagePage,
|
||||
SessionOut,
|
||||
UserOut,
|
||||
)
|
||||
from .security import (
|
||||
DUMMY_HASH,
|
||||
hash_password_async,
|
||||
hash_token,
|
||||
new_token,
|
||||
verify_password_async,
|
||||
)
|
||||
from .timeutil import format_ts, from_micros, to_micros
|
||||
|
||||
router = APIRouter()
|
||||
api = APIRouter(prefix="/api/v1")
|
||||
|
||||
|
||||
def body_doc(model: type) -> dict:
|
||||
"""Описание тела запроса для OpenAPI-документации."""
|
||||
return {
|
||||
"requestBody": {
|
||||
"required": True,
|
||||
"content": {"application/json": {"schema": model.model_json_schema()}},
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
def user_out(user: User) -> dict:
|
||||
"""User -> словарь ответа."""
|
||||
return {
|
||||
"id": str(user.id),
|
||||
"username": user.username,
|
||||
"display_name": user.display_name,
|
||||
"created_at": format_ts(user.created_at),
|
||||
}
|
||||
|
||||
|
||||
def chat_out(chat: Chat, member_ids: List[uuid.UUID]) -> dict:
|
||||
"""Chat и участники -> словарь ответа."""
|
||||
return {
|
||||
"id": str(chat.id),
|
||||
"title": chat.title,
|
||||
"member_ids": [str(member_id) for member_id in member_ids],
|
||||
"created_at": format_ts(chat.created_at),
|
||||
}
|
||||
|
||||
|
||||
def message_out(message: Message) -> dict:
|
||||
"""Message -> словарь ответа."""
|
||||
return {
|
||||
"id": str(message.id),
|
||||
"chat_id": str(message.chat_id),
|
||||
"sender_id": str(message.sender_id),
|
||||
"text": message.text,
|
||||
"created_at": format_ts(message.created_at),
|
||||
}
|
||||
|
||||
|
||||
def position(key):
|
||||
"""Позицию из курсора перевести в (datetime, UUID)."""
|
||||
if key is None:
|
||||
return None
|
||||
return from_micros(key[0]), uuid.UUID(key[1])
|
||||
|
||||
|
||||
def cursor_for(scope: str, row) -> str:
|
||||
"""Курсор, указывающий на строку row."""
|
||||
return encode_cursor(scope, (to_micros(row.created_at), str(row.id)))
|
||||
|
||||
|
||||
async def open_chat(session: AsyncSession, user: User, chat_id_text: str) -> Chat:
|
||||
"""Чат, доступный пользователю; неверный id -> 400, чужой или несуществующий -> 404."""
|
||||
chat_id = uuid.UUID(parse_uuid(chat_id_text, "chat_id"))
|
||||
chat = await crud.get_chat_for_member(session, chat_id, user.id)
|
||||
if chat is None:
|
||||
raise ApiError(404, "not_found", "Объект не найден")
|
||||
return chat
|
||||
|
||||
|
||||
@router.get("/health/live")
|
||||
async def live() -> dict:
|
||||
"""Процесс жив."""
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@router.get("/health/ready")
|
||||
async def ready(request: Request):
|
||||
"""Готовность: миграции применены и БД отвечает."""
|
||||
if not getattr(request.app.state, "ready", False):
|
||||
raise ApiError(503, "unavailable", "Сервис не готов")
|
||||
try:
|
||||
async with request.app.state.sessionmaker() as session:
|
||||
await asyncio.wait_for(session.execute(text("SELECT 1")), timeout=2)
|
||||
except Exception:
|
||||
raise ApiError(503, "unavailable", "База данных недоступна")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@api.post(
|
||||
"/users",
|
||||
status_code=201,
|
||||
response_model=UserOut,
|
||||
openapi_extra=body_doc(CreateUserIn),
|
||||
)
|
||||
async def register_user(request: Request, session: AsyncSession = Depends(get_session)):
|
||||
"""Регистрация пользователя."""
|
||||
body = validate_body(CreateUserIn, await read_json_object(request))
|
||||
password_hash = await hash_password_async(body.password)
|
||||
try:
|
||||
user = await crud.create_user(
|
||||
session, body.username, body.display_name, password_hash
|
||||
)
|
||||
except crud.UsernameTaken:
|
||||
raise ApiError(409, "conflict", "Такое имя пользователя уже занято")
|
||||
return user_out(user)
|
||||
|
||||
|
||||
@api.post("/auth/sessions", status_code=201, response_model=SessionOut)
|
||||
async def login(request: Request, session: AsyncSession = Depends(get_session)):
|
||||
"""Вход по Basic: создать сессию и вернуть Bearer-токен."""
|
||||
username, password = parse_basic(request)
|
||||
user = await crud.get_user_by_username(session, username)
|
||||
password_ok = await verify_password_async(
|
||||
password, user.password_hash if user else DUMMY_HASH
|
||||
)
|
||||
if user is None or not password_ok:
|
||||
raise unauthorized(BASIC_CHALLENGE)
|
||||
token = new_token()
|
||||
expires_at = await crud.create_session(
|
||||
session,
|
||||
user.id,
|
||||
hash_token(token),
|
||||
request.app.state.settings.session_ttl_seconds,
|
||||
)
|
||||
return {
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": format_ts(expires_at),
|
||||
"user": user_out(user),
|
||||
}
|
||||
|
||||
|
||||
@api.delete("/auth/sessions/current", status_code=204)
|
||||
async def logout(
|
||||
request: Request,
|
||||
user: User = Depends(current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
"""Отозвать текущую сессию."""
|
||||
token_hash = hash_token(parse_bearer(request))
|
||||
await crud.delete_session(session, token_hash)
|
||||
await request.app.state.cache.revoke(token_hash)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@api.get("/users/me", response_model=UserOut)
|
||||
async def read_me(user: User = Depends(current_user)):
|
||||
"""Текущий пользователь."""
|
||||
return user_out(user)
|
||||
|
||||
|
||||
@api.post(
|
||||
"/chats",
|
||||
status_code=201,
|
||||
response_model=ChatOut,
|
||||
openapi_extra=body_doc(CreateChatIn),
|
||||
)
|
||||
async def create_chat(
|
||||
request: Request,
|
||||
user: User = Depends(current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
"""Создать чат с участниками."""
|
||||
body = validate_body(CreateChatIn, await read_json_object(request))
|
||||
member_ids = [uuid.UUID(item) for item in body.member_ids]
|
||||
if user.id not in member_ids:
|
||||
raise ApiError(400, "invalid_request", "member_ids должен включать вас самих")
|
||||
try:
|
||||
chat, members = await crud.create_chat(session, body.title, member_ids)
|
||||
except crud.UnknownMember:
|
||||
raise ApiError(
|
||||
400, "invalid_request", "member_ids содержит несуществующего пользователя"
|
||||
)
|
||||
return chat_out(chat, sorted(members))
|
||||
|
||||
|
||||
@api.get("/chats", response_model=ChatPage)
|
||||
async def list_chats(
|
||||
request: Request,
|
||||
user: User = Depends(current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
"""Страница чатов текущего пользователя."""
|
||||
limit = parse_limit(request.query_params.get("limit"))
|
||||
scope = "chats:" + str(user.id)
|
||||
after = position(parse_cursor(request.query_params.get("cursor"), scope))
|
||||
chats, has_more = await crud.list_chats(session, user.id, after, limit)
|
||||
members = await crud.get_member_ids(session, [chat.id for chat in chats])
|
||||
next_cursor = cursor_for(scope, chats[-1]) if has_more and chats else None
|
||||
return {
|
||||
"items": [chat_out(c, members[c.id]) for c in chats],
|
||||
"next_cursor": next_cursor,
|
||||
}
|
||||
|
||||
|
||||
@api.get("/chats/{chat_id}", response_model=ChatOut)
|
||||
async def read_chat(
|
||||
chat_id: str,
|
||||
user: User = Depends(current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
"""Один чат по id."""
|
||||
chat = await open_chat(session, user, chat_id)
|
||||
members = await crud.get_member_ids(session, [chat.id])
|
||||
return chat_out(chat, members[chat.id])
|
||||
|
||||
|
||||
@api.post(
|
||||
"/chats/{chat_id}/messages",
|
||||
status_code=201,
|
||||
response_model=MessageOut,
|
||||
openapi_extra=body_doc(CreateMessageIn),
|
||||
)
|
||||
async def create_message(
|
||||
chat_id: str,
|
||||
request: Request,
|
||||
user: User = Depends(current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
"""Отправить сообщение в чат."""
|
||||
chat = await open_chat(session, user, chat_id)
|
||||
body = validate_body(CreateMessageIn, await read_json_object(request))
|
||||
message = await crud.create_message(session, chat.id, user.id, body.text)
|
||||
return message_out(message)
|
||||
|
||||
|
||||
@api.get("/chats/{chat_id}/messages", response_model=MessagePage)
|
||||
async def list_messages(
|
||||
chat_id: str,
|
||||
request: Request,
|
||||
user: User = Depends(current_user),
|
||||
session: AsyncSession = Depends(get_session),
|
||||
):
|
||||
"""Страница истории чата."""
|
||||
chat = await open_chat(session, user, chat_id)
|
||||
limit = parse_limit(request.query_params.get("limit"))
|
||||
scope = "messages:" + str(chat.id)
|
||||
after = position(parse_cursor(request.query_params.get("cursor"), scope))
|
||||
messages, has_more = await crud.list_messages(session, chat.id, after, limit)
|
||||
next_cursor = cursor_for(scope, messages[-1]) if has_more and messages else None
|
||||
return {"items": [message_out(m) for m in messages], "next_cursor": next_cursor}
|
||||
+153
@@ -0,0 +1,153 @@
|
||||
"""Pydantic-модели тел запросов и ответов."""
|
||||
|
||||
import re
|
||||
from typing import List, Optional
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, field_validator
|
||||
|
||||
from .cursor import UUID_RE
|
||||
|
||||
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
|
||||
|
||||
|
||||
def _check_text(value: str, name: str, max_len: int, allow_blank: bool = False) -> str:
|
||||
"""Проверить строку: тип, длина в символах, не только пробелы, без NUL."""
|
||||
try:
|
||||
value.encode("utf-8")
|
||||
except UnicodeEncodeError:
|
||||
raise ValueError("%s содержит недопустимые символы" % name)
|
||||
if "\x00" in value:
|
||||
raise ValueError("%s не может содержать символ NUL" % name)
|
||||
if not allow_blank and value.strip() == "":
|
||||
raise ValueError("%s не может быть пустым или состоять из пробелов" % name)
|
||||
if len(value) > max_len:
|
||||
raise ValueError("%s длиннее %d символов" % (name, max_len))
|
||||
return value
|
||||
|
||||
|
||||
class _Strict(BaseModel):
|
||||
"""База моделей запроса: лишние поля и приведение типов запрещены."""
|
||||
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
|
||||
class CreateUserIn(_Strict):
|
||||
"""Тело регистрации."""
|
||||
|
||||
username: str
|
||||
display_name: str
|
||||
password: str
|
||||
|
||||
@field_validator("username")
|
||||
@classmethod
|
||||
def _username(cls, value: str) -> str:
|
||||
"""username: [a-z0-9_]{3,32}."""
|
||||
if not USERNAME_RE.fullmatch(value):
|
||||
raise ValueError("username: только a-z, 0-9 и _, длина 3-32")
|
||||
return value
|
||||
|
||||
@field_validator("display_name")
|
||||
@classmethod
|
||||
def _display_name(cls, value: str) -> str:
|
||||
"""display_name: 1-100 символов."""
|
||||
return _check_text(value, "display_name", 100)
|
||||
|
||||
@field_validator("password")
|
||||
@classmethod
|
||||
def _password(cls, value: str) -> str:
|
||||
"""password: 12-128 символов, без обрезки пробелов."""
|
||||
_check_text(value, "password", 128, allow_blank=True)
|
||||
if len(value) < 12:
|
||||
raise ValueError("password короче 12 символов")
|
||||
return value
|
||||
|
||||
|
||||
class CreateChatIn(_Strict):
|
||||
"""Тело создания чата."""
|
||||
|
||||
title: str
|
||||
member_ids: List[str]
|
||||
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def _title(cls, value: str) -> str:
|
||||
"""title: 1-100 символов."""
|
||||
return _check_text(value, "title", 100)
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def _members(cls, value: List[str]) -> List[str]:
|
||||
"""member_ids: 1-100 уникальных UUID."""
|
||||
if not 1 <= len(value) <= 100:
|
||||
raise ValueError("member_ids: от 1 до 100 участников")
|
||||
normalized = []
|
||||
for item in value:
|
||||
if not UUID_RE.fullmatch(item):
|
||||
raise ValueError("member_ids: каждый элемент должен быть UUID")
|
||||
normalized.append(item.lower())
|
||||
if len(set(normalized)) != len(normalized):
|
||||
raise ValueError("member_ids: дубликаты не допускаются")
|
||||
return normalized
|
||||
|
||||
|
||||
class CreateMessageIn(_Strict):
|
||||
"""Тело сообщения; отправитель определяется по токену."""
|
||||
|
||||
text: str
|
||||
|
||||
@field_validator("text")
|
||||
@classmethod
|
||||
def _text(cls, value: str) -> str:
|
||||
"""text: 1-4000 символов."""
|
||||
return _check_text(value, "text", 4000)
|
||||
|
||||
|
||||
class UserOut(BaseModel):
|
||||
"""Пользователь в ответе."""
|
||||
|
||||
id: str
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: str
|
||||
|
||||
|
||||
class SessionOut(BaseModel):
|
||||
"""Ответ на вход."""
|
||||
|
||||
token: str
|
||||
token_type: str
|
||||
expires_at: str
|
||||
user: UserOut
|
||||
|
||||
|
||||
class ChatOut(BaseModel):
|
||||
"""Чат в ответе."""
|
||||
|
||||
id: str
|
||||
title: str
|
||||
member_ids: List[str]
|
||||
created_at: str
|
||||
|
||||
|
||||
class MessageOut(BaseModel):
|
||||
"""Сообщение в ответе."""
|
||||
|
||||
id: str
|
||||
chat_id: str
|
||||
sender_id: str
|
||||
text: str
|
||||
created_at: str
|
||||
|
||||
|
||||
class ChatPage(BaseModel):
|
||||
"""Страница списка чатов."""
|
||||
|
||||
items: List[ChatOut]
|
||||
next_cursor: Optional[str]
|
||||
|
||||
|
||||
class MessagePage(BaseModel):
|
||||
"""Страница истории сообщений."""
|
||||
|
||||
items: List[MessageOut]
|
||||
next_cursor: Optional[str]
|
||||
@@ -0,0 +1,74 @@
|
||||
"""Хеширование паролей (scrypt) и токены сессий."""
|
||||
|
||||
import asyncio
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import os
|
||||
import secrets
|
||||
|
||||
SCRYPT_N = 2**14
|
||||
SCRYPT_R = 8
|
||||
SCRYPT_P = 1
|
||||
SCRYPT_LEN = 32
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
"""Хеш пароля scrypt со случайной солью в формате scrypt$N$r$p$соль$хеш."""
|
||||
salt = os.urandom(16)
|
||||
digest = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=salt,
|
||||
n=SCRYPT_N,
|
||||
r=SCRYPT_R,
|
||||
p=SCRYPT_P,
|
||||
dklen=SCRYPT_LEN,
|
||||
)
|
||||
return "scrypt$%d$%d$%d$%s$%s" % (
|
||||
SCRYPT_N,
|
||||
SCRYPT_R,
|
||||
SCRYPT_P,
|
||||
base64.b64encode(salt).decode(),
|
||||
base64.b64encode(digest).decode(),
|
||||
)
|
||||
|
||||
|
||||
def verify_password(password: str, stored: str) -> bool:
|
||||
"""Проверить пароль по сохранённому хешу за постоянное время."""
|
||||
try:
|
||||
_, n, r, p, salt_b64, hash_b64 = stored.split("$")
|
||||
expected = base64.b64decode(hash_b64)
|
||||
actual = hashlib.scrypt(
|
||||
password.encode("utf-8"),
|
||||
salt=base64.b64decode(salt_b64),
|
||||
n=int(n),
|
||||
r=int(r),
|
||||
p=int(p),
|
||||
dklen=len(expected),
|
||||
)
|
||||
except (ValueError, TypeError):
|
||||
return False
|
||||
return hmac.compare_digest(actual, expected)
|
||||
|
||||
|
||||
DUMMY_HASH = hash_password("dummy-password-for-timing-only")
|
||||
|
||||
|
||||
async def hash_password_async(password: str) -> str:
|
||||
"""hash_password в отдельном потоке."""
|
||||
return await asyncio.to_thread(hash_password, password)
|
||||
|
||||
|
||||
async def verify_password_async(password: str, stored: str) -> bool:
|
||||
"""verify_password в отдельном потоке."""
|
||||
return await asyncio.to_thread(verify_password, password, stored)
|
||||
|
||||
|
||||
def new_token() -> str:
|
||||
"""Случайный токен сессии (256 бит)."""
|
||||
return secrets.token_urlsafe(32)
|
||||
|
||||
|
||||
def hash_token(token: str) -> str:
|
||||
"""SHA-256 токена в hex."""
|
||||
return hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
@@ -0,0 +1,20 @@
|
||||
"""Преобразования времени: RFC 3339 UTC и микросекунды."""
|
||||
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
|
||||
|
||||
|
||||
def format_ts(moment: datetime) -> str:
|
||||
"""datetime -> строка RFC 3339 в UTC с суффиксом Z."""
|
||||
return moment.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
||||
|
||||
|
||||
def to_micros(moment: datetime) -> int:
|
||||
"""datetime -> микросекунды от эпохи."""
|
||||
return (moment - EPOCH) // timedelta(microseconds=1)
|
||||
|
||||
|
||||
def from_micros(micros: int) -> datetime:
|
||||
"""Микросекунды от эпохи -> datetime в UTC."""
|
||||
return EPOCH + timedelta(microseconds=micros)
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
name: mtusi-messenger
|
||||
|
||||
x-api-env: &api-env
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: "8080"
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
LOG_LEVEL: ${LOG_LEVEL:-INFO}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
SESSION_STORE: ${SESSION_STORE:-postgres}
|
||||
DB_POOL_SIZE: ${DB_POOL_SIZE:-5}
|
||||
DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:-5}
|
||||
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-5}
|
||||
DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}:${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}@db:5432/${POSTGRES_DB:?задайте POSTGRES_DB в файле .env}
|
||||
CACHE_URL: ${CACHE_URL-redis://redis:6379/0}
|
||||
CACHE_TTL_SECONDS: ${CACHE_TTL_SECONDS:-60}
|
||||
CACHE_TIMEOUT_MS: ${CACHE_TIMEOUT_MS:-300}
|
||||
CACHE_RETRY_SECONDS: ${CACHE_RETRY_SECONDS:-5}
|
||||
|
||||
services:
|
||||
db:
|
||||
image: postgres:16.6-bookworm
|
||||
container_name: messenger-db
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
|
||||
POSTGRES_DB: ${POSTGRES_DB:?задайте POSTGRES_DB в файле .env}
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
ports:
|
||||
- "127.0.0.1:5433:5432"
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.4.1-bookworm
|
||||
container_name: messenger-redis
|
||||
command:
|
||||
- redis-server
|
||||
- --save
|
||||
- ""
|
||||
- --appendonly
|
||||
- "no"
|
||||
- --maxmemory
|
||||
- 64mb
|
||||
- --maxmemory-policy
|
||||
- noeviction
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
restart: unless-stopped
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
container_name: messenger-api
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_started
|
||||
required: false
|
||||
environment: *api-env
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
restart: unless-stopped
|
||||
|
||||
api-ttl:
|
||||
profiles: ["expiry"]
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
container_name: messenger-api-ttl
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
<<: *api-env
|
||||
SESSION_TTL_SECONDS: "3"
|
||||
ports:
|
||||
- "127.0.0.1:8081:8080"
|
||||
|
||||
tests:
|
||||
profiles: ["test"]
|
||||
build:
|
||||
context: .
|
||||
target: test
|
||||
image: mtusi-messenger:lab2-test
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
TEST_DB_HOST: db
|
||||
TEST_DB_PORT: "5432"
|
||||
TEST_DB_USER: ${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}
|
||||
TEST_DB_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
|
||||
TEST_CACHE_URL: redis://redis:6379/15
|
||||
command: ["python", "-m", "pytest", "-v", "--no-header", "-p", "no:cacheprovider"]
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,17 @@
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=ChangeMe123
|
||||
POSTGRES_DB=messenger
|
||||
|
||||
APP_ENV=lab
|
||||
LOG_LEVEL=INFO
|
||||
SESSION_TTL_SECONDS=3600
|
||||
SESSION_STORE=postgres
|
||||
|
||||
DB_POOL_SIZE=5
|
||||
DB_MAX_OVERFLOW=5
|
||||
DB_POOL_TIMEOUT=5
|
||||
|
||||
CACHE_URL=redis://redis:6379/0
|
||||
CACHE_TTL_SECONDS=60
|
||||
CACHE_TIMEOUT_MS=300
|
||||
CACHE_RETRY_SECONDS=5
|
||||
@@ -0,0 +1,8 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:04
|
||||
# Commit: 65003b6
|
||||
# Команда: python3 scripts/check_contract.py
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.06 с
|
||||
@@ -0,0 +1,9 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:05
|
||||
# Commit: 65003b6
|
||||
# Команда: make test
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
python3 tests/smoke.py --base-url "http://localhost:8080"
|
||||
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.58 с
|
||||
@@ -0,0 +1,11 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:05
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env ps
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
messenger-api mtusi-messenger:lab2 "python -m app" api 24 seconds ago Up 18 seconds (healthy) 127.0.0.1:8080->8080/tcp
|
||||
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 24 seconds ago Up 23 seconds (healthy) 127.0.0.1:5433->5432/tcp
|
||||
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 24 seconds ago Up 23 seconds (healthy) 6379/tcp
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.07 с
|
||||
@@ -0,0 +1,8 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:05
|
||||
# Commit: 65003b6
|
||||
# Команда: docker volume inspect mtusi-messenger_pgdata --format {{.Name}} created={{.CreatedAt}}
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
mtusi-messenger_pgdata created=2026-10-23T13:16:41+03:00
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.01 с
|
||||
@@ -0,0 +1,10 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:14
|
||||
# Commit: 65003b6
|
||||
# Команда: make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 9.13 с
|
||||
@@ -0,0 +1,11 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:14
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env ps
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
messenger-api mtusi-messenger:lab2 "python -m app" api 33 seconds ago Up 1 second (health: starting) 127.0.0.1:8080->8080/tcp
|
||||
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 33 seconds ago Up 7 seconds (healthy) 127.0.0.1:5433->5432/tcp
|
||||
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 33 seconds ago Up 7 seconds (healthy) 6379/tcp
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.07 с
|
||||
@@ -0,0 +1,8 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:14
|
||||
# Commit: 65003b6
|
||||
# Команда: docker volume inspect mtusi-messenger_pgdata --format {{.Name}} created={{.CreatedAt}}
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
mtusi-messenger_pgdata created=2026-10-23T13:16:41+03:00
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.01 с
|
||||
@@ -0,0 +1,83 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:15
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env exec -T db psql -U messenger -d messenger -c \d users -c \d chats -c \d chat_members -c \d messages -c \d sessions
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
Table "public.users"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
---------------+--------------------------+-----------+----------+-------------------
|
||||
id | uuid | | not null |
|
||||
username | text | | not null |
|
||||
display_name | text | | not null |
|
||||
password_hash | text | | not null |
|
||||
created_at | timestamp with time zone | | not null | clock_timestamp()
|
||||
Indexes:
|
||||
"users_pkey" PRIMARY KEY, btree (id)
|
||||
"users_username_key" UNIQUE CONSTRAINT, btree (username)
|
||||
Check constraints:
|
||||
"users_display_name_check" CHECK (char_length(display_name) >= 1 AND char_length(display_name) <= 100)
|
||||
"users_username_check" CHECK (username ~ '^[a-z0-9_]{3,32}$'::text)
|
||||
Referenced by:
|
||||
TABLE "chat_members" CONSTRAINT "chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
|
||||
TABLE "messages" CONSTRAINT "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
|
||||
TABLE "sessions" CONSTRAINT "sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
|
||||
Table "public.chats"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
------------+--------------------------+-----------+----------+-------------------
|
||||
id | uuid | | not null |
|
||||
title | text | | not null |
|
||||
created_at | timestamp with time zone | | not null | clock_timestamp()
|
||||
Indexes:
|
||||
"chats_pkey" PRIMARY KEY, btree (id)
|
||||
"chats_created_idx" btree (created_at, id)
|
||||
Check constraints:
|
||||
"chats_title_check" CHECK (char_length(title) >= 1 AND char_length(title) <= 100)
|
||||
Referenced by:
|
||||
TABLE "chat_members" CONSTRAINT "chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
TABLE "messages" CONSTRAINT "messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
|
||||
Table "public.chat_members"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
---------+------+-----------+----------+---------
|
||||
chat_id | uuid | | not null |
|
||||
user_id | uuid | | not null |
|
||||
Indexes:
|
||||
"chat_members_pkey" PRIMARY KEY, btree (chat_id, user_id)
|
||||
"chat_members_user_idx" btree (user_id, chat_id)
|
||||
Foreign-key constraints:
|
||||
"chat_members_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
"chat_members_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id)
|
||||
|
||||
Table "public.messages"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
------------+--------------------------+-----------+----------+-------------------
|
||||
id | uuid | | not null |
|
||||
chat_id | uuid | | not null |
|
||||
sender_id | uuid | | not null |
|
||||
text | text | | not null |
|
||||
created_at | timestamp with time zone | | not null | clock_timestamp()
|
||||
Indexes:
|
||||
"messages_pkey" PRIMARY KEY, btree (id)
|
||||
"messages_chat_created_idx" btree (chat_id, created_at, id)
|
||||
Check constraints:
|
||||
"messages_text_check" CHECK (char_length(text) >= 1 AND char_length(text) <= 4000)
|
||||
Foreign-key constraints:
|
||||
"messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE
|
||||
"messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id)
|
||||
|
||||
Table "public.sessions"
|
||||
Column | Type | Collation | Nullable | Default
|
||||
------------+--------------------------+-----------+----------+-------------------
|
||||
token_hash | text | | not null |
|
||||
user_id | uuid | | not null |
|
||||
created_at | timestamp with time zone | | not null | clock_timestamp()
|
||||
expires_at | timestamp with time zone | | not null |
|
||||
Indexes:
|
||||
"sessions_pkey" PRIMARY KEY, btree (token_hash)
|
||||
"sessions_expires_idx" btree (expires_at)
|
||||
"sessions_user_idx" btree (user_id)
|
||||
Foreign-key constraints:
|
||||
"sessions_user_id_fkey" FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.16 с
|
||||
@@ -0,0 +1,8 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:16
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env exec -T api python -m app.migrate
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
Применено: ничего нового
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.98 с
|
||||
@@ -0,0 +1,16 @@
|
||||
# Дата (UTC): 2026-10-23 10:16:49
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env logs api
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
messenger-api | 2026-10-23T10:16:48+0000 INFO listen host=0.0.0.0 port=8080
|
||||
messenger-api | INFO: Started server process [1]
|
||||
messenger-api | INFO: Waiting for application startup.
|
||||
messenger-api | 2026-10-23T10:16:48+0000 INFO config env=lab pool=5+5 ttl=3600s store=postgres cache=redis
|
||||
messenger-api | 2026-10-23T10:16:48+0000 INFO migrations: 0001_init.sql
|
||||
messenger-api | 2026-10-23T10:16:48+0000 INFO startup: приложение готово
|
||||
messenger-api | INFO: Application startup complete.
|
||||
messenger-api | INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)
|
||||
messenger-api | 2026-10-23T10:16:49+0000 INFO request request_id=4933db77a1c84e3197e740dc2e11d0f1 method=GET path=/health/ready status=200 duration_ms=14.7
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.07 с
|
||||
@@ -0,0 +1,11 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:16
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env exec -T db psql -U messenger -d messenger -c SELECT * FROM schema_migrations
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
version | applied_at
|
||||
---------------+-------------------------------
|
||||
0001_init.sql | 2026-10-23 10:16:48.774351+00
|
||||
(1 row)
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.13 с
|
||||
@@ -0,0 +1,20 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:16
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env exec -T db psql -U messenger -d messenger -c SELECT username, left(password_hash, 7) AS password_prefix, length(password_hash) AS len FROM users WHERE password_hash LIKE 'scrypt$%' LIMIT 3 -c SELECT length(token_hash) AS token_hash_len, expires_at FROM sessions LIMIT 3
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
username | password_prefix | len
|
||||
----------------------+-----------------+-----
|
||||
u_alice_cbe058671fcd | scrypt$ | 86
|
||||
u_bob_b1685b095bab | scrypt$ | 86
|
||||
u_eve_1f0c444128f3 | scrypt$ | 86
|
||||
(3 rows)
|
||||
|
||||
token_hash_len | expires_at
|
||||
----------------+-------------------------------
|
||||
64 | 2026-10-23 11:17:05.128109+00
|
||||
64 | 2026-10-23 11:17:05.223716+00
|
||||
64 | 2026-10-23 11:17:05.789433+00
|
||||
(3 rows)
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.13 с
|
||||
@@ -0,0 +1,64 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:28
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider student-tests/test_auth.py student-tests/test_session_expiry.py
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
============================= test session starts ==============================
|
||||
collecting ... collected 38 items
|
||||
|
||||
student-tests/test_auth.py::test_register_returns_user_without_secrets PASSED [ 2%]
|
||||
student-tests/test_auth.py::test_register_password_rules[None] PASSED [ 5%]
|
||||
student-tests/test_auth.py::test_register_password_rules[] PASSED [ 7%]
|
||||
student-tests/test_auth.py::test_register_password_rules[short] PASSED [ 10%]
|
||||
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaa] PASSED [ 13%]
|
||||
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] PASSED [ 15%]
|
||||
student-tests/test_auth.py::test_register_password_rules[123456789012] PASSED [ 18%]
|
||||
student-tests/test_auth.py::test_register_password_rules[\u043f\u0430\u0440\u043e\u043b\u044c] PASSED [ 21%]
|
||||
student-tests/test_auth.py::test_register_password_border_lengths PASSED [ 23%]
|
||||
student-tests/test_auth.py::test_login_success_shape PASSED [ 26%]
|
||||
student-tests/test_auth.py::test_each_login_gives_new_token PASSED [ 28%]
|
||||
student-tests/test_auth.py::test_wrong_password_and_unknown_user_look_the_same PASSED [ 31%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic] PASSED [ 34%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic !!!not-base64!!!] PASSED [ 36%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic bm9jb2xvbg==] PASSED [ 39%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic 0LjQvNGPOnBhc3N3b3JkLTEyMzQ1Ng==] PASSED [ 42%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic dXNlcjr//i1iYWQtdXRmOA==] PASSED [ 44%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Bearer abc] PASSED [ 47%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[] PASSED [ 50%]
|
||||
student-tests/test_auth.py::test_login_without_header_is_401 PASSED [ 52%]
|
||||
student-tests/test_auth.py::test_password_with_colon_and_unicode_works PASSED [ 55%]
|
||||
student-tests/test_auth.py::test_bearer_token_gives_access PASSED [ 57%]
|
||||
student-tests/test_auth.py::test_business_endpoint_rejects_basic PASSED [ 60%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[] PASSED [ 63%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer] PASSED [ 65%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer short] PASSED [ 68%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] PASSED [ 71%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Token abc] PASSED [ 73%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[bearer] PASSED [ 76%]
|
||||
student-tests/test_auth.py::test_x_user_id_alone_gives_no_access PASSED [ 78%]
|
||||
student-tests/test_auth.py::test_x_user_id_does_not_change_owner_of_session PASSED [ 81%]
|
||||
student-tests/test_auth.py::test_logout_revokes_token_and_repeat_is_401 PASSED [ 84%]
|
||||
student-tests/test_auth.py::test_logout_without_token_is_401 PASSED [ 86%]
|
||||
student-tests/test_auth.py::test_logout_revokes_only_current_session PASSED [ 89%]
|
||||
student-tests/test_auth.py::test_session_lives_longer_than_300_seconds PASSED [ 92%]
|
||||
student-tests/test_session_expiry.py::test_session_expires_after_ttl PASSED [ 94%]
|
||||
student-tests/test_session_expiry.py::test_expired_sessions_are_cleaned_on_next_login PASSED [ 97%]
|
||||
student-tests/test_session_expiry.py::test_short_ttl_from_environment_variable PASSED [100%]
|
||||
|
||||
=============================== warnings summary ===============================
|
||||
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
|
||||
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
|
||||
from starlette.testclient import TestClient as TestClient # noqa
|
||||
|
||||
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
|
||||
======================== 38 passed, 1 warning in 8.97s =========================
|
||||
Container messenger-db Running
|
||||
Container messenger-redis Running
|
||||
Container messenger-db Waiting
|
||||
Container messenger-redis Waiting
|
||||
Container messenger-redis Healthy
|
||||
Container messenger-db Healthy
|
||||
Container mtusi-messenger-tests-run-5a33a2ea2bbb Creating
|
||||
Container mtusi-messenger-tests-run-5a33a2ea2bbb Created
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 12.15 с
|
||||
@@ -0,0 +1,45 @@
|
||||
# Дата (UTC): 2026-10-23 10:17:35
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider student-tests/test_database.py student-tests/test_db_failure.py student-tests/test_transactions.py student-tests/test_duplicate_username.py
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
============================= test session starts ==============================
|
||||
collecting ... collected 19 items
|
||||
|
||||
student-tests/test_database.py::test_password_is_stored_as_scrypt_hash_not_plaintext PASSED [ 5%]
|
||||
student-tests/test_database.py::test_same_password_gives_different_hashes PASSED [ 10%]
|
||||
student-tests/test_database.py::test_session_table_keeps_token_hash_not_token PASSED [ 15%]
|
||||
student-tests/test_database.py::test_message_is_really_in_the_database PASSED [ 21%]
|
||||
student-tests/test_database.py::test_migrations_can_run_again_without_duplicating_anything PASSED [ 26%]
|
||||
student-tests/test_database.py::test_expected_tables_and_indexes_exist PASSED [ 31%]
|
||||
student-tests/test_database.py::test_primary_and_foreign_keys_are_declared PASSED [ 36%]
|
||||
student-tests/test_database.py::test_database_itself_rejects_bad_rows PASSED [ 42%]
|
||||
student-tests/test_database.py::test_chat_creation_is_atomic PASSED [ 47%]
|
||||
student-tests/test_database.py::test_successful_chat_has_all_members_in_database PASSED [ 52%]
|
||||
student-tests/test_db_failure.py::test_database_down_gives_503_and_never_trusts_anyone PASSED [ 57%]
|
||||
student-tests/test_db_failure.py::test_database_down_with_cache_up_still_needs_database_for_data PASSED [ 63%]
|
||||
student-tests/test_transactions.py::test_failure_after_chat_insert_rolls_back_whole_operation PASSED [ 68%]
|
||||
student-tests/test_transactions.py::test_pool_is_bounded_by_settings PASSED [ 73%]
|
||||
student-tests/test_transactions.py::test_exhausted_pool_gives_fast_503 PASSED [ 78%]
|
||||
student-tests/test_duplicate_username.py::test_second_registration_with_same_username_is_409 PASSED [ 84%]
|
||||
student-tests/test_duplicate_username.py::test_duplicate_does_not_replace_original_user PASSED [ 89%]
|
||||
student-tests/test_duplicate_username.py::test_username_is_case_sensitive_lowercase_only PASSED [ 94%]
|
||||
student-tests/test_duplicate_username.py::test_parallel_registration_of_same_username_creates_exactly_one PASSED [100%]
|
||||
|
||||
=============================== warnings summary ===============================
|
||||
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
|
||||
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
|
||||
from starlette.testclient import TestClient as TestClient # noqa
|
||||
|
||||
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
|
||||
======================== 19 passed, 1 warning in 3.91s =========================
|
||||
Container messenger-redis Running
|
||||
Container messenger-db Running
|
||||
Container messenger-db Waiting
|
||||
Container messenger-redis Waiting
|
||||
Container messenger-db Healthy
|
||||
Container messenger-redis Healthy
|
||||
Container mtusi-messenger-tests-run-28da14e927b9 Creating
|
||||
Container mtusi-messenger-tests-run-28da14e927b9 Created
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 7.04 с
|
||||
@@ -0,0 +1,179 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:12
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env --profile test run --rm tests
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
============================= test session starts ==============================
|
||||
collecting ... collected 153 items
|
||||
|
||||
student-tests/test_auth.py::test_register_returns_user_without_secrets PASSED [ 0%]
|
||||
student-tests/test_auth.py::test_register_password_rules[None] PASSED [ 1%]
|
||||
student-tests/test_auth.py::test_register_password_rules[] PASSED [ 1%]
|
||||
student-tests/test_auth.py::test_register_password_rules[short] PASSED [ 2%]
|
||||
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaa] PASSED [ 3%]
|
||||
student-tests/test_auth.py::test_register_password_rules[aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] PASSED [ 3%]
|
||||
student-tests/test_auth.py::test_register_password_rules[123456789012] PASSED [ 4%]
|
||||
student-tests/test_auth.py::test_register_password_rules[\u043f\u0430\u0440\u043e\u043b\u044c] PASSED [ 5%]
|
||||
student-tests/test_auth.py::test_register_password_border_lengths PASSED [ 5%]
|
||||
student-tests/test_auth.py::test_login_success_shape PASSED [ 6%]
|
||||
student-tests/test_auth.py::test_each_login_gives_new_token PASSED [ 7%]
|
||||
student-tests/test_auth.py::test_wrong_password_and_unknown_user_look_the_same PASSED [ 7%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic] PASSED [ 8%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic !!!not-base64!!!] PASSED [ 9%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic bm9jb2xvbg==] PASSED [ 9%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic 0LjQvNGPOnBhc3N3b3JkLTEyMzQ1Ng==] PASSED [ 10%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Basic dXNlcjr//i1iYWQtdXRmOA==] PASSED [ 11%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[Bearer abc] PASSED [ 11%]
|
||||
student-tests/test_auth.py::test_malformed_basic_is_401[] PASSED [ 12%]
|
||||
student-tests/test_auth.py::test_login_without_header_is_401 PASSED [ 13%]
|
||||
student-tests/test_auth.py::test_password_with_colon_and_unicode_works PASSED [ 13%]
|
||||
student-tests/test_auth.py::test_bearer_token_gives_access PASSED [ 14%]
|
||||
student-tests/test_auth.py::test_business_endpoint_rejects_basic PASSED [ 15%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[] PASSED [ 15%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer] PASSED [ 16%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer short] PASSED [ 16%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Bearer xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx] PASSED [ 17%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[Token abc] PASSED [ 18%]
|
||||
student-tests/test_auth.py::test_bad_or_unknown_bearer_is_401[bearer] PASSED [ 18%]
|
||||
student-tests/test_auth.py::test_x_user_id_alone_gives_no_access PASSED [ 19%]
|
||||
student-tests/test_auth.py::test_x_user_id_does_not_change_owner_of_session PASSED [ 20%]
|
||||
student-tests/test_auth.py::test_logout_revokes_token_and_repeat_is_401 PASSED [ 20%]
|
||||
student-tests/test_auth.py::test_logout_without_token_is_401 PASSED [ 21%]
|
||||
student-tests/test_auth.py::test_logout_revokes_only_current_session PASSED [ 22%]
|
||||
student-tests/test_auth.py::test_session_lives_longer_than_300_seconds PASSED [ 22%]
|
||||
student-tests/test_cache.py::test_token_check_is_served_from_cache_with_bounded_ttl PASSED [ 23%]
|
||||
student-tests/test_cache.py::test_cache_never_stores_raw_tokens_or_passwords PASSED [ 24%]
|
||||
student-tests/test_cache.py::test_logout_revokes_cached_session PASSED [ 24%]
|
||||
student-tests/test_cache.py::test_late_cache_fill_cannot_resurrect_revoked_session PASSED [ 25%]
|
||||
student-tests/test_cache.py::test_flushed_cache_loses_nothing PASSED [ 26%]
|
||||
student-tests/test_cache.py::test_cache_does_not_extend_short_session PASSED [ 26%]
|
||||
student-tests/test_cache.py::test_staleness_after_out_of_band_delete_is_bounded_by_cache_ttl PASSED [ 27%]
|
||||
student-tests/test_cache.py::test_redis_down_requests_bypass_cache_and_stay_fast PASSED [ 28%]
|
||||
student-tests/test_cache.py::test_redis_down_never_trusts_anonymous_or_unknown_tokens PASSED [ 28%]
|
||||
student-tests/test_cache.py::test_revocation_lost_while_redis_down_is_flushed_on_recovery PASSED [ 29%]
|
||||
student-tests/test_cache.py::test_without_cache_url_cache_is_off PASSED [ 30%]
|
||||
student-tests/test_concurrency.py::test_100_messages_from_10_clients_in_parallel PASSED [ 30%]
|
||||
student-tests/test_concurrency.py::test_parallel_chat_creation_and_reading PASSED [ 31%]
|
||||
student-tests/test_contract_basics.py::test_health_endpoints PASSED [ 32%]
|
||||
student-tests/test_contract_basics.py::test_every_response_has_unique_request_id PASSED [ 32%]
|
||||
student-tests/test_contract_basics.py::test_unknown_path_is_404_in_common_format PASSED [ 33%]
|
||||
student-tests/test_contract_basics.py::test_trailing_slash_is_not_redirected PASSED [ 33%]
|
||||
student-tests/test_contract_basics.py::test_wrong_method_is_405_in_common_format PASSED [ 34%]
|
||||
student-tests/test_contract_basics.py::test_two_users_one_chat_two_messages PASSED [ 35%]
|
||||
student-tests/test_contract_basics.py::test_chat_response_shape PASSED [ 35%]
|
||||
student-tests/test_contract_basics.py::test_unexpected_exception_gives_500_without_details PASSED [ 36%]
|
||||
student-tests/test_contract_basics.py::test_logs_have_requests_but_no_secrets PASSED [ 37%]
|
||||
student-tests/test_database.py::test_password_is_stored_as_scrypt_hash_not_plaintext PASSED [ 37%]
|
||||
student-tests/test_database.py::test_same_password_gives_different_hashes PASSED [ 38%]
|
||||
student-tests/test_database.py::test_session_table_keeps_token_hash_not_token PASSED [ 39%]
|
||||
student-tests/test_database.py::test_message_is_really_in_the_database PASSED [ 39%]
|
||||
student-tests/test_database.py::test_migrations_can_run_again_without_duplicating_anything PASSED [ 40%]
|
||||
student-tests/test_database.py::test_expected_tables_and_indexes_exist PASSED [ 41%]
|
||||
student-tests/test_database.py::test_primary_and_foreign_keys_are_declared PASSED [ 41%]
|
||||
student-tests/test_database.py::test_database_itself_rejects_bad_rows PASSED [ 42%]
|
||||
student-tests/test_database.py::test_chat_creation_is_atomic PASSED [ 43%]
|
||||
student-tests/test_database.py::test_successful_chat_has_all_members_in_database PASSED [ 43%]
|
||||
student-tests/test_db_failure.py::test_database_down_gives_503_and_never_trusts_anyone PASSED [ 44%]
|
||||
student-tests/test_db_failure.py::test_database_down_with_cache_up_still_needs_database_for_data PASSED [ 45%]
|
||||
student-tests/test_duplicate_username.py::test_second_registration_with_same_username_is_409 PASSED [ 45%]
|
||||
student-tests/test_duplicate_username.py::test_duplicate_does_not_replace_original_user PASSED [ 46%]
|
||||
student-tests/test_duplicate_username.py::test_username_is_case_sensitive_lowercase_only PASSED [ 47%]
|
||||
student-tests/test_duplicate_username.py::test_parallel_registration_of_same_username_creates_exactly_one PASSED [ 47%]
|
||||
student-tests/test_empty_message.py::test_blank_text_is_rejected[] PASSED [ 48%]
|
||||
student-tests/test_empty_message.py::test_blank_text_is_rejected[ ] PASSED [ 49%]
|
||||
student-tests/test_empty_message.py::test_blank_text_is_rejected[ ] PASSED [ 49%]
|
||||
student-tests/test_empty_message.py::test_blank_text_is_rejected[\n] PASSED [ 50%]
|
||||
student-tests/test_empty_message.py::test_blank_text_is_rejected[\t \n] PASSED [ 50%]
|
||||
student-tests/test_empty_message.py::test_blank_text_is_rejected[\xa0] PASSED [ 51%]
|
||||
student-tests/test_empty_message.py::test_blank_text_is_rejected[\u2003] PASSED [ 52%]
|
||||
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body0] PASSED [ 52%]
|
||||
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body1] PASSED [ 53%]
|
||||
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body2] PASSED [ 54%]
|
||||
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body3] PASSED [ 54%]
|
||||
student-tests/test_empty_message.py::test_missing_or_wrong_type_text_is_rejected[body4] PASSED [ 55%]
|
||||
student-tests/test_empty_message.py::test_text_length_is_counted_in_characters PASSED [ 56%]
|
||||
student-tests/test_empty_message.py::test_nul_character_is_400_not_500 PASSED [ 56%]
|
||||
student-tests/test_empty_message.py::test_unicode_survives_the_database PASSED [ 57%]
|
||||
student-tests/test_empty_message.py::test_message_has_correct_fields PASSED [ 58%]
|
||||
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[0] PASSED [ 58%]
|
||||
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[9000] PASSED [ 59%]
|
||||
student-tests/test_foreign_chat.py::test_outsider_cannot_read_chat PASSED [ 60%]
|
||||
student-tests/test_foreign_chat.py::test_outsider_cannot_read_history PASSED [ 60%]
|
||||
student-tests/test_foreign_chat.py::test_outsider_cannot_write PASSED [ 61%]
|
||||
student-tests/test_foreign_chat.py::test_outsider_gets_404_even_with_bad_body PASSED [ 62%]
|
||||
student-tests/test_foreign_chat.py::test_unknown_chat_looks_the_same_as_foreign PASSED [ 62%]
|
||||
student-tests/test_foreign_chat.py::test_chat_list_shows_only_own_chats PASSED [ 63%]
|
||||
student-tests/test_foreign_chat.py::test_bad_chat_id_is_400 PASSED [ 64%]
|
||||
student-tests/test_foreign_chat.py::test_no_token_is_401_everywhere PASSED [ 64%]
|
||||
student-tests/test_foreign_chat.py::test_401_comes_before_404 PASSED [ 65%]
|
||||
student-tests/test_foreign_chat.py::test_member_can_read_and_write PASSED [ 66%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[{] PASSED [ 66%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[not json at all] PASSED [ 67%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[] PASSED [ 67%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[{"username": "abc",}] PASSED [ 68%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[\xff\xfe\x00] PASSED [ 69%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[{"username": NaN}] PASSED [ 69%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[["username"]] PASSED [ 70%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json["text"] PASSED [ 71%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_broken_json[null] PASSED [ 71%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes0] PASSED [ 72%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes1] PASSED [ 73%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes2] PASSED [ 73%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes3] PASSED [ 74%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes4] PASSED [ 75%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes5] PASSED [ 75%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes6] PASSED [ 76%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes7] PASSED [ 77%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes8] PASSED [ 77%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes9] PASSED [ 78%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes10] PASSED [ 79%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes11] PASSED [ 79%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes12] PASSED [ 80%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes13] PASSED [ 81%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes14] PASSED [ 81%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes15] PASSED [ 82%]
|
||||
student-tests/test_invalid_json.py::test_registration_rejects_bad_fields[changes16] PASSED [ 83%]
|
||||
student-tests/test_invalid_json.py::test_border_values_are_accepted PASSED [ 83%]
|
||||
student-tests/test_invalid_json.py::test_lone_surrogate_is_400_not_500 PASSED [ 84%]
|
||||
student-tests/test_invalid_json.py::test_wrong_or_missing_content_type_is_415 PASSED [ 84%]
|
||||
student-tests/test_invalid_json.py::test_huge_body_is_413 PASSED [ 85%]
|
||||
student-tests/test_invalid_json.py::test_broken_json_in_message_and_chat PASSED [ 86%]
|
||||
student-tests/test_invalid_json.py::test_sender_id_in_message_is_rejected PASSED [ 86%]
|
||||
student-tests/test_invalid_json.py::test_chat_body_validation PASSED [ 87%]
|
||||
student-tests/test_pagination.py::test_walk_25_messages_by_7 PASSED [ 88%]
|
||||
student-tests/test_pagination.py::test_exact_multiple_has_no_empty_extra_page PASSED [ 88%]
|
||||
student-tests/test_pagination.py::test_limit_one_walks_everything PASSED [ 89%]
|
||||
student-tests/test_pagination.py::test_default_limit_is_50_and_max_is_100 PASSED [ 90%]
|
||||
student-tests/test_pagination.py::test_empty_history PASSED [ 90%]
|
||||
student-tests/test_pagination.py::test_limit_can_change_between_pages PASSED [ 91%]
|
||||
student-tests/test_pagination.py::test_messages_sent_during_walk_appear_at_the_end PASSED [ 92%]
|
||||
student-tests/test_pagination.py::test_created_at_is_increasing_and_utc PASSED [ 92%]
|
||||
student-tests/test_pagination.py::test_bad_limit_values PASSED [ 93%]
|
||||
student-tests/test_pagination.py::test_garbage_cursor_is_400 PASSED [ 94%]
|
||||
student-tests/test_pagination.py::test_cursor_from_another_chat_is_400 PASSED [ 94%]
|
||||
student-tests/test_pagination.py::test_chat_list_pagination PASSED [ 95%]
|
||||
student-tests/test_pagination.py::test_chat_list_cursor_cannot_be_used_for_messages PASSED [ 96%]
|
||||
student-tests/test_session_expiry.py::test_session_expires_after_ttl PASSED [ 96%]
|
||||
student-tests/test_session_expiry.py::test_expired_sessions_are_cleaned_on_next_login PASSED [ 97%]
|
||||
student-tests/test_session_expiry.py::test_short_ttl_from_environment_variable PASSED [ 98%]
|
||||
student-tests/test_transactions.py::test_failure_after_chat_insert_rolls_back_whole_operation PASSED [ 98%]
|
||||
student-tests/test_transactions.py::test_pool_is_bounded_by_settings PASSED [ 99%]
|
||||
student-tests/test_transactions.py::test_exhausted_pool_gives_fast_503 PASSED [100%]
|
||||
|
||||
=============================== warnings summary ===============================
|
||||
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
|
||||
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
|
||||
from starlette.testclient import TestClient as TestClient # noqa
|
||||
|
||||
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
|
||||
======================= 153 passed, 1 warning in 33.55s ========================
|
||||
Container messenger-db Running
|
||||
Container messenger-redis Running
|
||||
Container messenger-redis Waiting
|
||||
Container messenger-db Waiting
|
||||
Container messenger-redis Healthy
|
||||
Container messenger-db Healthy
|
||||
Container mtusi-messenger-tests-run-27b6c4db6282 Creating
|
||||
Container mtusi-messenger-tests-run-27b6c4db6282 Created
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 36.72 с
|
||||
@@ -0,0 +1,10 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:12
|
||||
# Commit: 65003b6
|
||||
# Команда: grep -n -i password\|secret compose.yaml
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
13: DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:?задайте POSTGRES_USER в файле .env}:${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}@db:5432/${POSTGRES_DB:?задайте POSTGRES_DB в файле .env}
|
||||
25: POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
|
||||
102: TEST_DB_PASSWORD: ${POSTGRES_PASSWORD:?задайте POSTGRES_PASSWORD в файле .env}
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.00 с
|
||||
@@ -0,0 +1,113 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:12
|
||||
# Commit: 65003b6
|
||||
# Команда: git ls-files --cached --others --exclude-standard
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
Dockerfile
|
||||
EVIDENCE.md
|
||||
GUIDE.md
|
||||
OPERATIONS.md
|
||||
app/__init__.py
|
||||
app/__main__.py
|
||||
app/auth.py
|
||||
app/cache.py
|
||||
app/config.py
|
||||
app/crud.py
|
||||
app/cursor.py
|
||||
app/db.py
|
||||
app/errors.py
|
||||
app/explain.py
|
||||
app/healthcheck.py
|
||||
app/http_utils.py
|
||||
app/logging_setup.py
|
||||
app/main.py
|
||||
app/middleware.py
|
||||
app/migrate.py
|
||||
app/migrations/0001_init.sql
|
||||
app/models.py
|
||||
app/routes.py
|
||||
app/schemas.py
|
||||
app/security.py
|
||||
app/timeutil.py
|
||||
compose.yaml
|
||||
env.lab2.template
|
||||
evidence/01_check_contract.txt
|
||||
evidence/02_smoke.txt
|
||||
evidence/03_ps_before.txt
|
||||
evidence/03_volume_before.txt
|
||||
evidence/04_persistence.txt
|
||||
evidence/05_ps_after.txt
|
||||
evidence/05_volume_after.txt
|
||||
evidence/06_schema.txt
|
||||
evidence/07_migrations.txt
|
||||
evidence/07_migrations_first.txt
|
||||
evidence/07_migrations_table.txt
|
||||
evidence/08_hashes.txt
|
||||
evidence/09_auth_tests.txt
|
||||
evidence/10_database_tests.txt
|
||||
evidence/11_all_tests.txt
|
||||
evidence/12_compose_no_secrets.txt
|
||||
evidence/12_git_files.txt
|
||||
evidence/12_git_secrets.txt
|
||||
evidence/13_storage.txt
|
||||
evidence/14_dependencies.txt
|
||||
evidence/15_explain.txt
|
||||
evidence/15_explain_tests.txt
|
||||
evidence/16_expiry_live.txt
|
||||
pytest.ini
|
||||
requirements-test.txt
|
||||
requirements.txt
|
||||
scripts/check_expiry.py
|
||||
scripts/collect_evidence.sh
|
||||
scripts/dependency_demo.py
|
||||
scripts/restart.bat
|
||||
scripts/restart.sh
|
||||
scripts/run_and_save.py
|
||||
scripts/storage_demo.py
|
||||
student-tests/conftest.py
|
||||
student-tests/test_auth.py
|
||||
student-tests/test_cache.py
|
||||
student-tests/test_concurrency.py
|
||||
student-tests/test_contract_basics.py
|
||||
student-tests/test_database.py
|
||||
student-tests/test_db_failure.py
|
||||
student-tests/test_duplicate_username.py
|
||||
student-tests/test_empty_message.py
|
||||
student-tests/test_explain.py
|
||||
student-tests/test_foreign_chat.py
|
||||
student-tests/test_invalid_json.py
|
||||
student-tests/test_pagination.py
|
||||
student-tests/test_session_expiry.py
|
||||
student-tests/test_transactions.py
|
||||
.dockerignore
|
||||
.env.example
|
||||
.github/pull_request_template.md
|
||||
.github/workflows/contracts.yml
|
||||
.gitignore
|
||||
CONTRIBUTING.md
|
||||
COURSE.md
|
||||
Dockerfile.example
|
||||
MAINTAINERS.md
|
||||
Makefile
|
||||
README.md
|
||||
REPORT.md
|
||||
compose.example.yaml
|
||||
contracts/README.md
|
||||
contracts/examples.json
|
||||
contracts/infrastructure.json
|
||||
contracts/openapi.json
|
||||
evidence/README.md
|
||||
examples/requests.http
|
||||
infra/README.md
|
||||
lab.json
|
||||
requirements-dev.txt
|
||||
scripts/check_contract.py
|
||||
scripts/restart.example.sh
|
||||
scripts/validate_openapi.py
|
||||
tests/README.md
|
||||
tests/client.py
|
||||
tests/load.py
|
||||
tests/resilience.py
|
||||
tests/smoke.py
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.00 с
|
||||
@@ -0,0 +1,8 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:12
|
||||
# Commit: 65003b6
|
||||
# Команда: git check-ignore -v .env
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
.gitignore:2:.env .env
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 0.00 с
|
||||
@@ -0,0 +1,194 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:23
|
||||
# Commit: 65003b6
|
||||
# Команда: python scripts/storage_demo.py --mode down
|
||||
|
||||
|
||||
==============================================================================
|
||||
1. Как устроено приложение
|
||||
==============================================================================
|
||||
Приложение -- мессенджер: HTTP API (FastAPI), PostgreSQL и Redis (кэш сессий).
|
||||
* Сам API состояния не хранит: пользователи, чаты, участники, сообщения и сессии
|
||||
лежат в PostgreSQL (таблицы users, chats, chat_members, messages, sessions).
|
||||
* Файлы PostgreSQL лежат не в контейнере, а в именованном томе Docker (pgdata).
|
||||
Контейнеры api и db временные, том постоянный.
|
||||
* Пароль хранится как scrypt-хеш, у сессии в БД лежит только SHA-256 токена,
|
||||
срок сессии считает сама БД -- перезапуск его не продлевает и не сбрасывает.
|
||||
* Redis только кэширует проверку токена (без persistence): после перезапуска
|
||||
кэш пуст, и сессии читаются из PostgreSQL.
|
||||
Ожидание: пока том не удалён (команда down -v здесь НЕ используется), после
|
||||
удаления и повторного создания контейнеров (docker compose down, затем up -d)
|
||||
те же пользователи, чат, сообщение и тот же токен продолжают работать.
|
||||
План: (1) создать данные через API, (2) показать их в БД, (3) выключить,
|
||||
(4) включить, (5) проверить, что данные и токены прежние.
|
||||
|
||||
|
||||
==============================================================================
|
||||
2. Состояние до начала
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env ps
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
messenger-api mtusi-messenger:lab2 "python -m app" api About a minute ago Up 59 seconds (healthy) 127.0.0.1:8080->8080/tcp
|
||||
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db About a minute ago Up About a minute (healthy) 127.0.0.1:5433->5432/tcp
|
||||
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis About a minute ago Up About a minute (healthy) 6379/tcp
|
||||
$ docker volume ls --filter name=pgdata --format {{.Name}}
|
||||
mtusi-messenger_pgdata
|
||||
$ docker volume inspect mtusi-messenger_pgdata --format "{{.Name}} создан: {{.CreatedAt}}"
|
||||
mtusi-messenger_pgdata создан: 2026-10-23T13:16:41+03:00
|
||||
|
||||
==============================================================================
|
||||
3. Запись данных через API (создаём пользователей, чат, сообщение)
|
||||
==============================================================================
|
||||
$ POST /api/v1/users # регистрация Алисы
|
||||
тело запроса: {"username": "demo_a_7681083c", "display_name": "Алиса", "password": "***"}
|
||||
ответ: 201 {"id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "username": "demo_a_7681083c", "display_name": "Алиса", "created_at": "2026-10-23T10:18:12.849116Z"}
|
||||
$ POST /api/v1/users # регистрация Боба
|
||||
тело запроса: {"username": "demo_b_7681083c", "display_name": "Боб", "password": "***"}
|
||||
ответ: 201 {"id": "2c34c828-f3c2-46ae-8055-bfaa49de3789", "username": "demo_b_7681083c", "display_name": "Боб", "created_at": "2026-10-23T10:18:12.903720Z"}
|
||||
$ POST /api/v1/auth/sessions # вход Алисы (Basic)
|
||||
ответ: 201 {"token": "<скрыт, 43 симв.>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:12.910850Z", "user": {"id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "username": "demo_a_7681083c", "display_name": "Алиса", "created_at": "2026-10-23T10:18:12.849116Z"}}
|
||||
$ POST /api/v1/auth/sessions # вход Боба (Basic)
|
||||
ответ: 201 {"token": "<скрыт, 43 симв.>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:12.961660Z", "user": {"id": "2c34c828-f3c2-46ae-8055-bfaa49de3789", "username": "demo_b_7681083c", "display_name": "Боб", "created_at": "2026-10-23T10:18:12.903720Z"}}
|
||||
$ POST /api/v1/chats # чат Алисы и Боба (Bearer)
|
||||
тело запроса: {"title": "Проверка сохранности 7681083c", "member_ids": ["a0fce947-1cb5-4780-ba66-daddb74fadea", "2c34c828-f3c2-46ae-8055-bfaa49de3789"]}
|
||||
ответ: 201 {"id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "title": "Проверка сохранности 7681083c", "member_ids": ["2c34c828-f3c2-46ae-8055-bfaa49de3789", "a0fce947-1cb5-4780-ba66-daddb74fadea"], "created_at": "2026-10-23T10:18:13.013118Z"}
|
||||
$ POST /api/v1/chats/051a293a-c75d-45f5-b4ab-7e24ef0833f4/messages # сообщение Алисы
|
||||
тело запроса: {"text": "Это сообщение должно пережить перезапуск 7681083c"}
|
||||
ответ: 201 {"id": "8d7c0e89-8043-413d-b3f0-d6bca0062b3e", "chat_id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "sender_id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "text": "Это сообщение должно пережить перезапуск 7681083c", "created_at": "2026-10-23T10:18:13.025076Z"}
|
||||
|
||||
==============================================================================
|
||||
4. Что лежит в PostgreSQL ДО выключения (SELECT внутри контейнера db)
|
||||
==============================================================================
|
||||
-- пользователи (пароль -- только префикс хеша)
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at FROM users WHERE username IN ('demo_a_7681083c', 'demo_b_7681083c') ORDER BY username"
|
||||
username | display_name | password_prefix | created_at
|
||||
-----------------+--------------+-----------------+-------------------------------
|
||||
demo_a_7681083c | Алиса | scrypt$ | 2026-10-23 10:18:12.849116+00
|
||||
demo_b_7681083c | Боб | scrypt$ | 2026-10-23 10:18:12.90372+00
|
||||
(2 rows)
|
||||
-- чат и число участников
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT c.title, count(m.user_id) AS members FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4' GROUP BY c.title"
|
||||
title | members
|
||||
-------------------------------+---------
|
||||
Проверка сохранности 7681083c | 2
|
||||
(1 row)
|
||||
-- сообщение
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4'"
|
||||
id | sender_id | text | created_at
|
||||
--------------------------------------+--------------------------------------+---------------------------------------------------+-------------------------------
|
||||
8d7c0e89-8043-413d-b3f0-d6bca0062b3e | a0fce947-1cb5-4780-ba66-daddb74fadea | Это сообщение должно пережить перезапуск 7681083c | 2026-10-23 10:18:13.025076+00
|
||||
(1 row)
|
||||
-- действующие сессии (токены не показываем)
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id WHERE u.username IN ('demo_a_7681083c', 'demo_b_7681083c') AND s.expires_at > now()"
|
||||
live_sessions
|
||||
---------------
|
||||
2
|
||||
(1 row)
|
||||
|
||||
==============================================================================
|
||||
5. Выключаем приложение (контейнеры УДАЛЯЮТСЯ, том остаётся)
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env down
|
||||
Container messenger-api Stopping
|
||||
Container messenger-api Stopped
|
||||
Container messenger-api Removing
|
||||
Container messenger-api Removed
|
||||
Container messenger-db Stopping
|
||||
Container messenger-redis Stopping
|
||||
Container messenger-redis Stopped
|
||||
Container messenger-redis Removing
|
||||
Container messenger-redis Removed
|
||||
Container messenger-db Stopped
|
||||
Container messenger-db Removing
|
||||
Container messenger-db Removed
|
||||
Network mtusi-messenger_default Removing
|
||||
Network mtusi-messenger_default Removed
|
||||
$ docker compose --env-file .env ps -a
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
API на http://localhost:8080 не отвечает -- приложение выключено (так и должно быть).
|
||||
-- том с данными на месте:
|
||||
$ docker volume ls --filter name=pgdata
|
||||
DRIVER VOLUME NAME
|
||||
local mtusi-messenger_pgdata
|
||||
|
||||
==============================================================================
|
||||
6. Включаем снова
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env up -d
|
||||
Network mtusi-messenger_default Creating
|
||||
Network mtusi-messenger_default Creating
|
||||
Network mtusi-messenger_default Created
|
||||
Network mtusi-messenger_default Created
|
||||
Container messenger-db Creating
|
||||
Container messenger-redis Creating
|
||||
Container messenger-redis Created
|
||||
Container messenger-db Created
|
||||
Container messenger-api Creating
|
||||
Container messenger-api Created
|
||||
Container messenger-db Starting
|
||||
Container messenger-redis Starting
|
||||
Container messenger-db Started
|
||||
Container messenger-redis Started
|
||||
Container messenger-db Waiting
|
||||
Container messenger-db Healthy
|
||||
Container messenger-api Starting
|
||||
Container messenger-api Started
|
||||
API снова готов (/health/ready = 200) через 2 с.
|
||||
$ docker compose --env-file .env ps
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
messenger-api mtusi-messenger:lab2 "python -m app" api 7 seconds ago Up 2 seconds (health: starting) 127.0.0.1:8080->8080/tcp
|
||||
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 7 seconds ago Up 7 seconds (healthy) 127.0.0.1:5433->5432/tcp
|
||||
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 7 seconds ago Up 7 seconds (healthy) 6379/tcp
|
||||
|
||||
==============================================================================
|
||||
7. Проверка ПОСЛЕ перезапуска: те же данные и те же токены
|
||||
==============================================================================
|
||||
$ GET /api/v1/users/me # старый токен Алисы, повторный вход НЕ делали
|
||||
ответ: 200 {"id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "username": "demo_a_7681083c", "display_name": "Алиса", "created_at": "2026-10-23T10:18:12.849116Z"}
|
||||
OK: тот же пользователь (id, username, created_at совпали).
|
||||
$ GET /api/v1/chats/051a293a-c75d-45f5-b4ab-7e24ef0833f4/messages # старый токен Боба читает историю чата
|
||||
ответ: 200 {"items": [{"id": "8d7c0e89-8043-413d-b3f0-d6bca0062b3e", "chat_id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "sender_id": "a0fce947-1cb5-4780-ba66-daddb74fadea", "text": "Это сообщение должно пережить перезапуск 7681083c", "created_at": "2026-10-23T10:18:13.025076Z"}], "next_cursor": null}
|
||||
OK: то же сообщение (id, text, created_at совпали).
|
||||
$ GET /api/v1/chats?limit=100 # список чатов Алисы
|
||||
ответ: 200 {"items": [{"id": "051a293a-c75d-45f5-b4ab-7e24ef0833f4", "title": "Проверка сохранности 7681083c", "member_ids": ["2c34c828-f3c2-46ae-8055-bfaa49de3789", "a0fce947-1cb5-4780-ba66-daddb74fadea"], "created_at": "2026-10-23T10:18:13.013118Z"}], "next_cursor": null}
|
||||
OK: чат в списке.
|
||||
|
||||
Те же SELECT после перезапуска (сравниваем с выводом из пункта 4):
|
||||
-- пользователи (пароль -- только префикс хеша)
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at FROM users WHERE username IN ('demo_a_7681083c', 'demo_b_7681083c') ORDER BY username"
|
||||
username | display_name | password_prefix | created_at
|
||||
-----------------+--------------+-----------------+-------------------------------
|
||||
demo_a_7681083c | Алиса | scrypt$ | 2026-10-23 10:18:12.849116+00
|
||||
demo_b_7681083c | Боб | scrypt$ | 2026-10-23 10:18:12.90372+00
|
||||
(2 rows)
|
||||
OK: вывод идентичен выводу до перезапуска.
|
||||
-- чат и число участников
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT c.title, count(m.user_id) AS members FROM chats c JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4' GROUP BY c.title"
|
||||
title | members
|
||||
-------------------------------+---------
|
||||
Проверка сохранности 7681083c | 2
|
||||
(1 row)
|
||||
OK: вывод идентичен выводу до перезапуска.
|
||||
-- сообщение
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '051a293a-c75d-45f5-b4ab-7e24ef0833f4'"
|
||||
id | sender_id | text | created_at
|
||||
--------------------------------------+--------------------------------------+---------------------------------------------------+-------------------------------
|
||||
8d7c0e89-8043-413d-b3f0-d6bca0062b3e | a0fce947-1cb5-4780-ba66-daddb74fadea | Это сообщение должно пережить перезапуск 7681083c | 2026-10-23 10:18:13.025076+00
|
||||
(1 row)
|
||||
OK: вывод идентичен выводу до перезапуска.
|
||||
-- действующие сессии (токены не показываем)
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -c "SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id WHERE u.username IN ('demo_a_7681083c', 'demo_b_7681083c') AND s.expires_at > now()"
|
||||
live_sessions
|
||||
---------------
|
||||
2
|
||||
(1 row)
|
||||
OK: вывод идентичен выводу до перезапуска.
|
||||
|
||||
-- том тот же (дата создания не изменилась):
|
||||
$ docker volume inspect mtusi-messenger_pgdata --format "{{.Name}} создан: {{.CreatedAt}}"
|
||||
mtusi-messenger_pgdata создан: 2026-10-23T13:16:41+03:00
|
||||
OK: том не пересоздавался.
|
||||
|
||||
==============================================================================
|
||||
ИТОГ
|
||||
==============================================================================
|
||||
ИТОГ: PASS -- пользователи, чат, сообщение и действующие сессии сохранились после удаления и повторного создания контейнеров (docker compose down, затем up -d).
|
||||
@@ -0,0 +1,323 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:23
|
||||
# Commit: 65003b6
|
||||
# Команда: python3 scripts/dependency_demo.py
|
||||
|
||||
==============================================================================
|
||||
0. Контейнеры
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env ps
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
messenger-api mtusi-messenger:lab2 "python -m app" api 8 seconds ago Up 2 seconds (health: starting) 127.0.0.1:8080->8080/tcp
|
||||
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 8 seconds ago Up 8 seconds (healthy) 127.0.0.1:5433->5432/tcp
|
||||
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 8 seconds ago Up 8 seconds (healthy) 6379/tcp
|
||||
|
||||
==============================================================================
|
||||
1. Redis: версия и настройки (кэш, persistence выключена намеренно)
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env exec -T redis redis-server --version
|
||||
Redis server v=7.4.1 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=9ce9f16f947e6690
|
||||
$ docker compose --env-file .env exec -T redis redis-cli CONFIG GET save
|
||||
save
|
||||
$ docker compose --env-file .env exec -T redis redis-cli CONFIG GET appendonly
|
||||
appendonly
|
||||
no
|
||||
$ docker compose --env-file .env exec -T redis redis-cli CONFIG GET maxmemory-policy
|
||||
maxmemory-policy
|
||||
noeviction
|
||||
|
||||
==============================================================================
|
||||
2. Роль кэша: проверка Bearer-токена без запроса к PostgreSQL
|
||||
==============================================================================
|
||||
POST /api/v1/users -> 201 (57 мс) # регистрация
|
||||
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
|
||||
POST /api/v1/auth/sessions -> 201 (52 мс) # вход (Basic)
|
||||
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:24.063082Z", "user": {"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}}
|
||||
POST /api/v1/users -> 201 (47 мс) # регистрация
|
||||
{"id": "5430982a-788d-47f8-a794-b135476578df", "username": "bob_e2ebd6fa", "display_name": "bob", "created_at": "2026-10-23T10:18:24.154704Z"}
|
||||
POST /api/v1/auth/sessions -> 201 (48 мс) # вход (Basic)
|
||||
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:24.161175Z", "user": {"id": "5430982a-788d-47f8-a794-b135476578df", "username": "bob_e2ebd6fa", "display_name": "bob", "created_at": "2026-10-23T10:18:24.154704Z"}}
|
||||
$ docker compose --env-file .env exec -T redis redis-cli CONFIG RESETSTAT
|
||||
OK
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -At -c "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelname = 'sessions_pkey'"
|
||||
10
|
||||
50 x GET /api/v1/users/me -> 200; первый 4.1 мс, медиана остальных 1.7 мс
|
||||
$ docker compose --env-file .env exec -T db psql -U messenger -d messenger -At -c "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelname = 'sessions_pkey'"
|
||||
10
|
||||
Чтений индекса sessions_pkey в PostgreSQL за 50 запросов: 0
|
||||
$ docker compose --env-file .env exec -T redis redis-cli INFO stats
|
||||
# Stats
|
||||
total_connections_received:2
|
||||
total_commands_processed:53
|
||||
instantaneous_ops_per_sec:32
|
||||
total_net_input_bytes:4910
|
||||
total_net_output_bytes:7470
|
||||
total_net_repl_input_bytes:0
|
||||
total_net_repl_output_bytes:0
|
||||
instantaneous_input_kbps:2.96
|
||||
instantaneous_output_kbps:4.53
|
||||
instantaneous_input_repl_kbps:0.00
|
||||
instantaneous_output_repl_kbps:0.00
|
||||
rejected_connections:0
|
||||
sync_full:0
|
||||
sync_partial_ok:0
|
||||
sync_partial_err:0
|
||||
expired_subkeys:0
|
||||
expired_keys:0
|
||||
expired_stale_perc:0.00
|
||||
expired_time_cap_reached_count:0
|
||||
expire_cycle_cpu_milliseconds:0
|
||||
evicted_keys:0
|
||||
evicted_clients:0
|
||||
evicted_scripts:0
|
||||
total_eviction_exceeded_time:0
|
||||
current_eviction_exceeded_time:0
|
||||
keyspace_hits:49
|
||||
keyspace_misses:1
|
||||
pubsub_channels:0
|
||||
pubsub_patterns:0
|
||||
pubsubshard_channels:0
|
||||
latest_fork_usec:0
|
||||
total_forks:0
|
||||
migrate_cached_sockets:0
|
||||
slave_expires_tracked_keys:0
|
||||
active_defrag_hits:0
|
||||
active_defrag_misses:0
|
||||
active_defrag_key_hits:0
|
||||
active_defrag_key_misses:0
|
||||
total_active_defrag_time:0
|
||||
current_active_defrag_time:0
|
||||
tracking_total_keys:0
|
||||
tracking_total_items:0
|
||||
tracking_total_prefixes:0
|
||||
unexpected_error_replies:0
|
||||
total_error_replies:0
|
||||
dump_payload_sanitizations:0
|
||||
total_reads_processed:55
|
||||
total_writes_processed:53
|
||||
io_threaded_reads_processed:0
|
||||
io_threaded_writes_processed:0
|
||||
client_query_buffer_limit_disconnections:0
|
||||
client_output_buffer_limit_disconnections:0
|
||||
reply_buffer_shrinks:0
|
||||
reply_buffer_expands:0
|
||||
eventloop_cycles:81
|
||||
eventloop_duration_sum:14650
|
||||
eventloop_duration_cmd_sum:128
|
||||
instantaneous_eventloop_cycles_per_sec:42
|
||||
instantaneous_eventloop_duration_usec:452
|
||||
acl_access_denied_auth:0
|
||||
acl_access_denied_cmd:0
|
||||
acl_access_denied_key:0
|
||||
acl_access_denied_channel:0
|
||||
Redis: keyspace_hits=49 keyspace_misses=1
|
||||
$ docker compose --env-file .env exec -T redis redis-cli PTTL session:<sha256 токена>
|
||||
58542
|
||||
TTL ключа сессии: 58542 мс (<= CACHE_TTL_SECONDS=60 с и <= остатка сессии)
|
||||
$ docker compose --env-file .env exec -T redis redis-cli GET session:<sha256 токена>
|
||||
{"id":"2454e675-039f-49b3-92f0-e2e492e0cefc","username":"alice_a3a3d232","display_name":"alice","created_at":"2026-10-23T10:18:24.048024+00:00"}
|
||||
|
||||
==============================================================================
|
||||
3. Logout: DELETE в PostgreSQL, затем отметка отзыва в Redis
|
||||
==============================================================================
|
||||
POST /api/v1/users -> 201 (54 мс) # регистрация
|
||||
{"id": "b3b307ec-a474-451c-a347-51450f51fec8", "username": "carol_e6a6b17a", "display_name": "carol", "created_at": "2026-10-23T10:18:27.081509Z"}
|
||||
POST /api/v1/auth/sessions -> 201 (49 мс) # вход (Basic)
|
||||
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:27.095801Z", "user": {"id": "b3b307ec-a474-451c-a347-51450f51fec8", "username": "carol_e6a6b17a", "display_name": "carol", "created_at": "2026-10-23T10:18:27.081509Z"}}
|
||||
GET /api/v1/users/me -> 200 (4 мс) # кладёт сессию в кэш
|
||||
{"id": "b3b307ec-a474-451c-a347-51450f51fec8", "username": "carol_e6a6b17a", "display_name": "carol", "created_at": "2026-10-23T10:18:27.081509Z"}
|
||||
DELETE /api/v1/auth/sessions/current -> 204 (7 мс)
|
||||
(пусто)
|
||||
$ docker compose --env-file .env exec -T redis redis-cli GET session:<sha256 токена>
|
||||
revoked
|
||||
GET /api/v1/users/me -> 401 (2 мс) # отозванный токен
|
||||
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "5137ca7dc5464437bdaa45e85bb17e84"}}
|
||||
|
||||
==============================================================================
|
||||
4. Рестарт Redis: кэш пуст, сессии живы (источник истины -- PostgreSQL)
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env restart redis
|
||||
Container messenger-redis Restarting
|
||||
Container messenger-redis Started
|
||||
redis healthy через 5.4 с
|
||||
$ docker compose --env-file .env exec -T redis redis-cli DBSIZE
|
||||
0
|
||||
GET /api/v1/users/me -> 200 (5 мс) # тот же токен
|
||||
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
|
||||
$ docker compose --env-file .env exec -T redis redis-cli EXISTS session:<sha256 токена>
|
||||
1
|
||||
GET /api/v1/users/me -> 401 (4 мс) # отозванный токен после потери кэша всё равно 401 (решает PostgreSQL)
|
||||
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "aed4a94de8cf4ebfb495e3b35ae51bc3"}}
|
||||
|
||||
==============================================================================
|
||||
5. Redis ОСТАНОВЛЕН: API обходит кэш
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env stop redis
|
||||
Container messenger-redis Stopping
|
||||
Container messenger-redis Stopped
|
||||
GET /health/live -> 200 (1 мс)
|
||||
{"status": "ok"}
|
||||
GET /health/ready -> 200 (2 мс) # Redis не критичен для обязательного пути
|
||||
{"status": "ok"}
|
||||
GET /api/v1/users/me -> 200 (307 мс)
|
||||
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
|
||||
POST /api/v1/chats -> 201 (21 мс)
|
||||
{"id": "515465df-f215-49f0-9548-55d81bf82331", "title": "без Redis", "member_ids": ["2454e675-039f-49b3-92f0-e2e492e0cefc", "5430982a-788d-47f8-a794-b135476578df"], "created_at": "2026-10-23T10:18:33.810751Z"}
|
||||
POST /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 201 (10 мс)
|
||||
{"id": "ebd92a19-9f52-41c2-a883-6ecf0fa880b1", "chat_id": "515465df-f215-49f0-9548-55d81bf82331", "sender_id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "text": "сообщение при остановленном Redis", "created_at": "2026-10-23T10:18:33.830951Z"}
|
||||
GET /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 200 (5 мс)
|
||||
{"items": [{"id": "ebd92a19-9f52-41c2-a883-6ecf0fa880b1", "chat_id": "515465df-f215-49f0-9548-55d81bf82331", "sender_id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "text": "сообщение при остановленном Redis", "created_at": "2026-10-23T10:18:33.830951Z"}], "next_cursor": null}
|
||||
GET /api/v1/users/me -> 401 (2 мс) # без токена -- 401, не доверяем
|
||||
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "9726e3049265430abcbbf1370d866d0e"}}
|
||||
GET /api/v1/users/me -> 401 (4 мс) # чужой токен -- 401
|
||||
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "f187d7d2bd65451ba37797de881c940f"}}
|
||||
POST /api/v1/users -> 201 (51 мс) # регистрация
|
||||
{"id": "ff7f3a4f-e69f-465b-a2ae-3a38b9571bc8", "username": "dave_3786d2ec", "display_name": "dave", "created_at": "2026-10-23T10:18:33.890145Z"}
|
||||
POST /api/v1/auth/sessions -> 201 (49 мс) # вход (Basic)
|
||||
{"token": "<скрыт>", "token_type": "Bearer", "expires_at": "2026-10-23T11:18:33.898871Z", "user": {"id": "ff7f3a4f-e69f-465b-a2ae-3a38b9571bc8", "username": "dave_3786d2ec", "display_name": "dave", "created_at": "2026-10-23T10:18:33.890145Z"}}
|
||||
GET /api/v1/users/me -> 200 (3 мс)
|
||||
{"id": "ff7f3a4f-e69f-465b-a2ae-3a38b9571bc8", "username": "dave_3786d2ec", "display_name": "dave", "created_at": "2026-10-23T10:18:33.890145Z"}
|
||||
DELETE /api/v1/auth/sessions/current -> 204 (7 мс) # logout при недоступном Redis
|
||||
(пусто)
|
||||
GET /api/v1/users/me -> 401 (3 мс)
|
||||
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "afc3e9b8832241068e49c15a5f255647"}}
|
||||
Максимальная задержка запросов без Redis: 307 мс
|
||||
$ docker compose --env-file .env start redis
|
||||
Container messenger-redis Starting
|
||||
Container messenger-redis Started
|
||||
redis healthy через 5.4 с
|
||||
GET /api/v1/users/me -> 200 (21 мс) # кэш снова в работе
|
||||
{"id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "username": "alice_a3a3d232", "display_name": "alice", "created_at": "2026-10-23T10:18:24.048024Z"}
|
||||
GET /api/v1/users/me -> 401 (14 мс)
|
||||
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "9b50d84c22434a8ea61d0e642afb75d7"}}
|
||||
$ docker compose --env-file .env logs --since 2m api
|
||||
messenger-api | 2026-10-23T10:18:21+0000 INFO listen host=0.0.0.0 port=8080
|
||||
messenger-api | INFO: Started server process [1]
|
||||
messenger-api | INFO: Waiting for application startup.
|
||||
messenger-api | 2026-10-23T10:18:21+0000 INFO config env=lab pool=5+5 ttl=3600s store=postgres cache=redis
|
||||
messenger-api | 2026-10-23T10:18:21+0000 INFO migrations: nothing to apply
|
||||
messenger-api | 2026-10-23T10:18:21+0000 INFO startup: приложение готово
|
||||
messenger-api | INFO: Application startup complete.
|
||||
messenger-api | INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit)
|
||||
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=ab0d003663564a1b9dc29362448eba2a method=GET path=/health/ready status=200 duration_ms=7.1
|
||||
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=5ef96f93ebaa48f492ed2cc18ae57cef method=GET path=/api/v1/users/me status=200 duration_ms=15.0
|
||||
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=3c763fd0b51641a8b6e78e67b93713dc method=GET path=/api/v1/chats/051a293a-c75d-45f5-b4ab-7e24ef0833f4/messages status=200 duration_ms=8.5
|
||||
messenger-api | 2026-10-23T10:18:22+0000 INFO request request_id=028499cc5fea4ab6806c129125221538 method=GET path=/api/v1/chats status=200 duration_ms=5.5
|
||||
messenger-api | 2026-10-23T10:18:23+0000 INFO request request_id=fcded80bfe3747828ad334eb67bf452a method=GET path=/health/ready status=200 duration_ms=2.1
|
||||
messenger-api | 2026-10-23T10:18:23+0000 INFO request request_id=ce4a44fa17fa419385d393eab8eda558 method=GET path=/health/ready status=200 duration_ms=2.0
|
||||
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=a327a13994254a5e8695f8065c0052c7 method=POST path=/api/v1/users status=201 duration_ms=55.9
|
||||
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=1bac32dcbdc9426981c93b4b1fc2a6a7 method=POST path=/api/v1/auth/sessions status=201 duration_ms=50.6
|
||||
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=2ad87a6b1d714522b6ce473c3d03a88e method=POST path=/api/v1/users status=201 duration_ms=46.3
|
||||
messenger-api | 2026-10-23T10:18:24+0000 INFO request request_id=b6f69c04a1894b06966dce197177dc74 method=POST path=/api/v1/auth/sessions status=201 duration_ms=47.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=0939be01468d46149145707bb6a13e4e method=GET path=/api/v1/users/me status=200 duration_ms=3.4
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=68668e6e03c143d8aba1bc765e46594f method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=061a41bf184b4a28ae09a236a100b954 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3ac82f390f1e4c9ebf62030403c6d5f3 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=b5d7ef2a5af14a17a409261526158e73 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=60d4a26bdac3438fa1169f6e45eed859 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=0a795eda6f1b43cb83c37b5ca3633d2b method=GET path=/api/v1/users/me status=200 duration_ms=0.7
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=d33c6949fe41473c91ded47999a57451 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3da894a019194c80b4eb470af8067f9b method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3d45d5bb28e7433c91bd92fdabcf6529 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=4e6752620fa24ec1803dd970647f372a method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=bad3a45c841e4f619fb6f0d05847f2cb method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=0afb12feb0b34ef8a29835d7a33655be method=GET path=/api/v1/users/me status=200 duration_ms=1.0
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=f10d8b39b9b844c884e91d230ab6ee93 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=1d69e3356cac44dbb424492f1b666d5f method=GET path=/api/v1/users/me status=200 duration_ms=1.0
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=b52dcff84fe7411eb185807f66a477db method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=1f87f056fcda4b2d87e277424a596a81 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=7b7c2bbf8a8d49d9be2e163d12c2783a method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=e767c61290b240f190b673bbe0cb8320 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5a9a796e47a343d699a6d42e604c1a32 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5b8ef3ca395e4efbbd54c1e7fdd91781 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=f786c6bd84f84722886bf6dfd35d1a32 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=dabde023b7784d77b66993f95c3b0666 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=49c5501d17fd46eb916ce33a0ed8b504 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=6b46168eb0a44611a7ddbbe6138cf5a2 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3dde34ec48e146d7b5f0110f1d2fbdc1 method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=1f122734d4544a9b8b1dc6f12cad4f87 method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=ba06f9dbf16e4b538f68fc5ee1268f0f method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=75b39d4d183e46878ad7ce0e0946d4fe method=GET path=/api/v1/users/me status=200 duration_ms=0.8
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=344a490d3a37460fa08ea554600cf13d method=GET path=/api/v1/users/me status=200 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=d86193959efb469fa70484723c0479f7 method=GET path=/api/v1/users/me status=200 duration_ms=1.0
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5c7d4a99cf0d42e290c00843c5c5c277 method=GET path=/api/v1/users/me status=200 duration_ms=1.3
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=01eeb99a98c2496eae093957542f779c method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=33cccf79cdcb4b86a66b8db765943207 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=ccfc557d55cf4205b7010790f41f61e1 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=beb012eb4b4344c6ba47b1c229888c24 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=30a106dab9ad4ad9bde5a9c67dfa0fa8 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=2ef1c83fa84141f7ba9125ee2bd32b94 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=eb54e1442e49409dbe3952b1dc472a9d method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=add208ea268245af868c186f2a464580 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=124ca2404be5494696aae09353d139c3 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=5b3f9c939709426992d41d96c14d32ee method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=d1cbe63bd9a44638abe624657ba0c203 method=GET path=/api/v1/users/me status=200 duration_ms=1.5
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=945013d1534c4a94a924a12eec335baa method=GET path=/api/v1/users/me status=200 duration_ms=1.5
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=464c092f0f164f9db27d86e840466e2a method=GET path=/api/v1/users/me status=200 duration_ms=1.3
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=becf9277028c4408bbab35fbf3e6fad2 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=4481eecaef30407e85ecf86762337d39 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=e1d34ed15b144d3b9907b64025677d39 method=GET path=/api/v1/users/me status=200 duration_ms=1.2
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=3d43e46e55334ddf91274467d331b167 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=8817c423a2da48529a4519cbb19791e6 method=GET path=/api/v1/users/me status=200 duration_ms=1.1
|
||||
messenger-api | 2026-10-23T10:18:25+0000 INFO request request_id=705142a4330249bd99beaa84bdbc6127 method=GET path=/health/ready status=200 duration_ms=2.0
|
||||
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=f4934e6692bd473fad9c59a9927fa304 method=POST path=/api/v1/users status=201 duration_ms=53.4
|
||||
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=335a26c51d784946882f57f5668946e5 method=POST path=/api/v1/auth/sessions status=201 duration_ms=47.8
|
||||
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=ea1bddbde1d04083966b5b77278a1618 method=GET path=/api/v1/users/me status=200 duration_ms=3.1
|
||||
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=a47b63e1b3214a67974a4c506590b905 method=DELETE path=/api/v1/auth/sessions/current status=204 duration_ms=6.2
|
||||
messenger-api | 2026-10-23T10:18:27+0000 INFO request request_id=5137ca7dc5464437bdaa45e85bb17e84 method=GET path=/api/v1/users/me status=401 duration_ms=0.9
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=05218a878a3044d598f8a5c8ccc17ab6 method=GET path=/api/v1/users/me status=200 duration_ms=3.8
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=aed4a94de8cf4ebfb495e3b35ae51bc3 method=GET path=/api/v1/users/me status=401 duration_ms=2.7
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=dc35c7f0f7da44daa96e7f9995fe8ec7 method=GET path=/health/live status=200 duration_ms=0.5
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=742e776579014925b3426c3e5f28ed1a method=GET path=/health/ready status=200 duration_ms=1.5
|
||||
messenger-api | 2026-10-23T10:18:33+0000 WARNING cache_unavailable type=TimeoutError
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=34d82defd3454b18a6b5e3b17fc31fd8 method=GET path=/api/v1/users/me status=200 duration_ms=306.3
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=41c38a52d56042a8b5346d7fb623d2d3 method=POST path=/api/v1/chats status=201 duration_ms=19.7
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=44445527e20f47ae847911b139196fde method=POST path=/api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages status=201 duration_ms=8.9
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=97111a005b89485c8f2abac6c18275a1 method=GET path=/api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages status=200 duration_ms=4.4
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=9726e3049265430abcbbf1370d866d0e method=GET path=/api/v1/users/me status=401 duration_ms=0.6
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=f187d7d2bd65451ba37797de881c940f method=GET path=/api/v1/users/me status=401 duration_ms=2.6
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=bd141144a65a4644887fe5fb2b511a27 method=POST path=/api/v1/users status=201 duration_ms=50.0
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=e52d5593aa6b459ca4d49cfc2b185b01 method=POST path=/api/v1/auth/sessions status=201 duration_ms=47.7
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=d0dbee871d0a44e3a8a0eb106e955ce0 method=GET path=/api/v1/users/me status=200 duration_ms=2.7
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=f4ce6d2b27f74affbbc32a88b7712765 method=DELETE path=/api/v1/auth/sessions/current status=204 duration_ms=6.4
|
||||
messenger-api | 2026-10-23T10:18:33+0000 INFO request request_id=afc3e9b8832241068e49c15a5f255647 method=GET path=/api/v1/users/me status=401 duration_ms=2.3
|
||||
messenger-api | 2026-10-23T10:18:36+0000 INFO request request_id=d549e191c0974a69bd6f4bf634ee50bb method=GET path=/health/ready status=200 duration_ms=2.0
|
||||
messenger-api | 2026-10-23T10:18:45+0000 WARNING cache: FLUSHDB after a lost revocation
|
||||
messenger-api | 2026-10-23T10:18:45+0000 INFO request request_id=2620a2039cbf4f4e8cf5879087f13ec4 method=GET path=/api/v1/users/me status=200 duration_ms=18.6
|
||||
messenger-api | 2026-10-23T10:18:45+0000 INFO request request_id=9b50d84c22434a8ea61d0e642afb75d7 method=GET path=/api/v1/users/me status=401 duration_ms=9.8
|
||||
|
||||
==============================================================================
|
||||
6. PostgreSQL ОСТАНОВЛЕН: ограниченная ошибка, никого не пускаем без проверки
|
||||
==============================================================================
|
||||
$ docker compose --env-file .env stop db
|
||||
Container messenger-db Stopping
|
||||
Container messenger-db Stopped
|
||||
GET /health/live -> 200 (1 мс) # процесс жив
|
||||
{"status": "ok"}
|
||||
GET /health/ready -> 503 (912 мс) # обязательная зависимость недоступна
|
||||
{"error": {"code": "unavailable", "message": "База данных недоступна", "request_id": "127dd693633743c2ae7c483fec38293f"}}
|
||||
GET /api/v1/chats -> 503 (6 мс) # данные только в БД
|
||||
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "606963e195294eb1ac31c8195b368194"}}
|
||||
POST /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 503 (6 мс)
|
||||
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "27b4b397069446bca210fda788cc5f6d"}}
|
||||
POST /api/v1/users -> 503 (51 мс)
|
||||
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "72a0730aad794645b2f27e12da18c230"}}
|
||||
GET /api/v1/users/me -> 401 (1 мс) # аноним -- 401
|
||||
{"error": {"code": "unauthorized", "message": "Нет действительной аутентификации", "request_id": "2e09c4aa32f044aebadbb9a58101de2c"}}
|
||||
GET /api/v1/users/me -> 503 (5 мс) # неизвестный токен: проверить нельзя -> 503, не 200
|
||||
{"error": {"code": "unavailable", "message": "Сервис временно недоступен", "request_id": "e8f919b332014c4398f452d6e7787f5e"}}
|
||||
$ docker compose --env-file .env start db
|
||||
Container messenger-db Starting
|
||||
Container messenger-db Started
|
||||
API снова готов через 0.5 с после start db
|
||||
GET /api/v1/chats/515465df-f215-49f0-9548-55d81bf82331/messages -> 200 (16 мс) # тот же токен, те же данные
|
||||
{"items": [{"id": "ebd92a19-9f52-41c2-a883-6ecf0fa880b1", "chat_id": "515465df-f215-49f0-9548-55d81bf82331", "sender_id": "2454e675-039f-49b3-92f0-e2e492e0cefc", "text": "сообщение при остановленном Redis", "created_at": "2026-10-23T10:18:33.830951Z"}], "next_cursor": null}
|
||||
$ docker compose --env-file .env ps
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
messenger-api mtusi-messenger:lab2 "python -m app" api 32 seconds ago Up 26 seconds (healthy) 127.0.0.1:8080->8080/tcp
|
||||
messenger-db postgres:16.6-bookworm "docker-entrypoint.s…" db 32 seconds ago Up Less than a second (health: starting) 127.0.0.1:5433->5432/tcp
|
||||
messenger-redis redis:7.4.1-bookworm "docker-entrypoint.s…" redis 32 seconds ago Up 13 seconds (healthy) 6379/tcp
|
||||
|
||||
==============================================================================
|
||||
ИТОГ
|
||||
==============================================================================
|
||||
ИТОГ: PASS -- Redis кэширует проверку сессий; рестарт/остановка Redis не теряют сессий и не пропускают анонимов; остановка PostgreSQL даёт 503 без деталей и восстанавливается.
|
||||
@@ -0,0 +1,89 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:50
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env exec -T api python -m app.explain
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
PostgreSQL: 16.6 (Debian 16.6-1.pgdg120+1)
|
||||
Сообщений всего: 60005
|
||||
Сообщений в большом чате: 20000
|
||||
Размер таблицы messages: 6784 kB
|
||||
Размер индекса messages_chat_created_idx: 5992 kB
|
||||
|
||||
==============================================================================
|
||||
1. Первая страница (без cursor), запрос приложения
|
||||
==============================================================================
|
||||
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
|
||||
FROM messages
|
||||
WHERE messages.chat_id = $1::UUID ORDER BY messages.created_at, messages.id
|
||||
LIMIT $2::INTEGER
|
||||
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576, 51
|
||||
Limit (cost=0.41..12.38 rows=51 width=80) (actual time=0.008..0.022 rows=51 loops=1)
|
||||
Buffers: shared hit=6
|
||||
-> Index Scan using messages_chat_created_idx on messages (cost=0.41..4718.99 rows=20106 width=80) (actual time=0.007..0.018 rows=51 loops=1)
|
||||
Index Cond: (chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid)
|
||||
Buffers: shared hit=6
|
||||
Planning:
|
||||
Buffers: shared hit=6
|
||||
Planning Time: 0.073 ms
|
||||
Execution Time: 0.032 ms
|
||||
|
||||
==============================================================================
|
||||
2. Глубокая страница: cursor после 15000-го сообщения (keyset)
|
||||
==============================================================================
|
||||
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
|
||||
FROM messages
|
||||
WHERE messages.chat_id = $1::UUID AND (messages.created_at, messages.id) > ($2::TIMESTAMP WITH TIME ZONE, $3) ORDER BY messages.created_at, messages.id
|
||||
LIMIT $4::INTEGER
|
||||
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576, 2026-09-23 10:26:18.547526+00:00, c108c4dd-61dd-4321-8b6c-70b26623adf7, 51
|
||||
Limit (cost=0.41..38.34 rows=51 width=80) (actual time=0.009..0.022 rows=51 loops=1)
|
||||
Buffers: shared hit=6
|
||||
-> Index Scan using messages_chat_created_idx on messages (cost=0.41..3712.96 rows=4992 width=80) (actual time=0.008..0.019 rows=51 loops=1)
|
||||
Index Cond: ((chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid) AND (ROW(created_at, id) > ROW('2026-09-23 10:26:18.547526+00'::timestamp with time zone, 'c108c4dd-61dd-4321-8b6c-70b26623adf7'::uuid)))
|
||||
Buffers: shared hit=6
|
||||
Planning Time: 0.052 ms
|
||||
Execution Time: 0.049 ms
|
||||
|
||||
==============================================================================
|
||||
3. Для сравнения: та же страница через OFFSET (так приложение НЕ делает)
|
||||
==============================================================================
|
||||
SELECT * FROM messages WHERE chat_id = $1 ORDER BY created_at, id OFFSET 15000 LIMIT 51
|
||||
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576
|
||||
Limit (cost=3072.67..3072.80 rows=51 width=80) (actual time=7.919..7.925 rows=51 loops=1)
|
||||
Buffers: shared hit=848
|
||||
-> Sort (cost=3035.17..3085.44 rows=20106 width=80) (actual time=6.788..7.505 rows=15051 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: quicksort Memory: 3271kB
|
||||
Buffers: shared hit=848
|
||||
-> Seq Scan on messages (cost=0.00..1598.06 rows=20106 width=80) (actual time=0.006..5.029 rows=20000 loops=1)
|
||||
Filter: (chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid)
|
||||
Rows Removed by Filter: 40005
|
||||
Buffers: shared hit=848
|
||||
Planning Time: 0.035 ms
|
||||
Execution Time: 7.938 ms
|
||||
|
||||
==============================================================================
|
||||
4. Для сравнения: запрос приложения БЕЗ индекса (DROP INDEX в транзакции, затем ROLLBACK)
|
||||
==============================================================================
|
||||
SELECT messages.id, messages.chat_id, messages.sender_id, messages.text, messages.created_at
|
||||
FROM messages
|
||||
WHERE messages.chat_id = $1::UUID AND (messages.created_at, messages.id) > ($2::TIMESTAMP WITH TIME ZONE, $3) ORDER BY messages.created_at, messages.id
|
||||
LIMIT $4::INTEGER
|
||||
-- параметры: b21f9b12-3f7c-5896-bc0d-5c48f78f3576, 2026-09-23 10:26:18.547526+00:00, c108c4dd-61dd-4321-8b6c-70b26623adf7, 51
|
||||
Limit (cost=2064.63..2064.76 rows=51 width=80) (actual time=5.644..5.649 rows=51 loops=1)
|
||||
Buffers: shared hit=848
|
||||
-> Sort (cost=2064.63..2077.11 rows=4992 width=80) (actual time=5.643..5.645 rows=51 loops=1)
|
||||
Sort Key: created_at, id
|
||||
Sort Method: top-N heapsort Memory: 31kB
|
||||
Buffers: shared hit=848
|
||||
-> Seq Scan on messages (cost=0.00..1898.09 rows=4992 width=80) (actual time=3.769..5.197 rows=5000 loops=1)
|
||||
Filter: ((chat_id = 'b21f9b12-3f7c-5896-bc0d-5c48f78f3576'::uuid) AND (ROW(created_at, id) > ROW('2026-09-23 10:26:18.547526+00'::timestamp with time zone, 'c108c4dd-61dd-4321-8b6c-70b26623adf7'::uuid)))
|
||||
Rows Removed by Filter: 55005
|
||||
Buffers: shared hit=848
|
||||
Planning:
|
||||
Buffers: shared hit=4
|
||||
Planning Time: 0.067 ms
|
||||
Execution Time: 5.661 ms
|
||||
|
||||
Индекс messages_chat_created_idx на месте: True
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 2.44 с
|
||||
@@ -0,0 +1,28 @@
|
||||
# Дата (UTC): 2026-10-23 10:18:54
|
||||
# Commit: 65003b6
|
||||
# Команда: docker compose --env-file .env --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider student-tests/test_explain.py
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
============================= test session starts ==============================
|
||||
collecting ... collected 2 items
|
||||
|
||||
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[0] PASSED [ 50%]
|
||||
student-tests/test_explain.py::test_history_page_uses_index_without_full_scan[9000] PASSED [100%]
|
||||
|
||||
=============================== warnings summary ===============================
|
||||
../usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1
|
||||
/usr/local/lib/python3.12/site-packages/fastapi/testclient.py:1: StarletteDeprecationWarning: Using `httpx` with `starlette.testclient` is deprecated; install `httpx2` instead.
|
||||
from starlette.testclient import TestClient as TestClient # noqa
|
||||
|
||||
-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
|
||||
========================= 2 passed, 1 warning in 0.15s =========================
|
||||
Container messenger-redis Running
|
||||
Container messenger-db Running
|
||||
Container messenger-db Waiting
|
||||
Container messenger-redis Waiting
|
||||
Container messenger-redis Healthy
|
||||
Container messenger-db Healthy
|
||||
Container mtusi-messenger-tests-run-177db5fdb80c Creating
|
||||
Container mtusi-messenger-tests-run-177db5fdb80c Created
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 4.73 с
|
||||
@@ -0,0 +1,19 @@
|
||||
# Дата (UTC): 2026-10-23 10:19:02
|
||||
# Commit: 65003b6
|
||||
# Команда: python3 scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
|
||||
# ---------------------------------------- вывод ----------------------------------------
|
||||
OK регистрация -> 201
|
||||
OK вход -> 201, expires_at через 2.9 с (TTL=3)
|
||||
OK GET /users/me #1 до истечения -> 200
|
||||
OK GET /users/me #2 до истечения -> 200
|
||||
OK GET /users/me #3 до истечения -> 200
|
||||
OK GET /users/me после TTL+1 с -> 401, WWW-Authenticate: Bearer realm="messenger", code=unauthorized
|
||||
OK новый вход -> 201
|
||||
OK logout -> 204
|
||||
OK GET /users/me после logout -> 401
|
||||
OK повторный logout -> 401
|
||||
OK вход с неверным паролем -> 401, WWW-Authenticate: Basic realm="messenger", charset="UTF-8"
|
||||
PASS: expiry (TTL=3 с), logout и неверный пароль на запущенном API
|
||||
# ---------------------------------------------------------------------------------------
|
||||
# Код возврата: 0
|
||||
# Время выполнения: 4.34 с
|
||||
@@ -0,0 +1,4 @@
|
||||
[pytest]
|
||||
testpaths = student-tests
|
||||
pythonpath = .
|
||||
addopts = -ra
|
||||
@@ -0,0 +1,10 @@
|
||||
# Зависимости собственных тестов (student-tests/). Ставятся только в test-образ
|
||||
# (Dockerfile, target test) поверх requirements.txt.
|
||||
certifi==2026.10.19
|
||||
httpcore==1.0.9
|
||||
httpx==0.28.1
|
||||
iniconfig==2.3.1
|
||||
packaging==26.3
|
||||
pluggy==1.7.0
|
||||
Pygments==2.21.0
|
||||
pytest==9.1.1
|
||||
@@ -0,0 +1,20 @@
|
||||
# Зависимости API (runtime). Точные версии, включая транзитивные: сборка повторяема.
|
||||
# Получено `pip freeze` в python:3.12.8-slim-bookworm.
|
||||
annotated-doc==0.0.5
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
asyncpg==0.32.0
|
||||
click==8.5.0
|
||||
fastapi==0.159.1
|
||||
greenlet==3.5.6
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
opentelemetry-api==1.45.1
|
||||
pydantic==2.14.1
|
||||
pydantic_core==2.50.1
|
||||
redis==5.2.1
|
||||
SQLAlchemy==2.1.6
|
||||
starlette==1.9.0
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
uvicorn==0.54.0
|
||||
@@ -0,0 +1,90 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Проверка срока жизни сессии, выхода и неверного пароля на запущенном API.
|
||||
|
||||
python scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
|
||||
|
||||
API должен работать с SESSION_TTL_SECONDS, равным --ttl.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
|
||||
|
||||
def http(base, method, path, body=None, headers=None):
|
||||
"""HTTP-запрос: (статус, заголовки, тело)."""
|
||||
data = json.dumps(body).encode() if body is not None else None
|
||||
request = urllib.request.Request(base + path, data=data, method=method, headers=dict(headers or {}))
|
||||
if data is not None:
|
||||
request.add_header("Content-Type", "application/json")
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=10) as reply:
|
||||
return reply.status, reply.headers, reply.read()
|
||||
except urllib.error.HTTPError as error:
|
||||
return error.code, error.headers, error.read()
|
||||
|
||||
|
||||
def step(text, ok):
|
||||
"""Напечатать результат шага; при неудаче завершить с кодом 1."""
|
||||
print(("OK " if ok else "FAIL ") + text, flush=True)
|
||||
if not ok:
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
def main():
|
||||
"""Выполнить проверку."""
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--base-url", default="http://localhost:8081")
|
||||
parser.add_argument("--ttl", type=float, default=3)
|
||||
args = parser.parse_args()
|
||||
base = args.base_url.rstrip("/")
|
||||
|
||||
username, password = "ttl_" + uuid.uuid4().hex[:8], "Expiry-" + uuid.uuid4().hex
|
||||
basic = {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
|
||||
status, _, _ = http(base, "POST", "/api/v1/users",
|
||||
{"username": username, "display_name": "TTL", "password": password})
|
||||
step("регистрация -> %d" % status, status == 201)
|
||||
|
||||
status, _, raw = http(base, "POST", "/api/v1/auth/sessions", headers=basic)
|
||||
session = json.loads(raw)
|
||||
expires = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
|
||||
left = (expires - datetime.now(timezone.utc)).total_seconds()
|
||||
step("вход -> %d, expires_at через %.1f с (TTL=%g)" % (status, left, args.ttl),
|
||||
status == 201 and 0 < left <= args.ttl + 1)
|
||||
bearer = {"Authorization": "Bearer " + session["token"]}
|
||||
for n in range(3):
|
||||
status, _, _ = http(base, "GET", "/api/v1/users/me", headers=bearer)
|
||||
step("GET /users/me #%d до истечения -> %d" % (n + 1, status), status == 200)
|
||||
|
||||
time.sleep(args.ttl + 1)
|
||||
status, headers, raw = http(base, "GET", "/api/v1/users/me", headers=bearer)
|
||||
step("GET /users/me после TTL+1 с -> %d, WWW-Authenticate: %s, code=%s"
|
||||
% (status, headers.get("WWW-Authenticate"), json.loads(raw)["error"]["code"]),
|
||||
status == 401 and headers.get("WWW-Authenticate") == 'Bearer realm="messenger"')
|
||||
|
||||
status, _, raw = http(base, "POST", "/api/v1/auth/sessions", headers=basic)
|
||||
bearer = {"Authorization": "Bearer " + json.loads(raw)["token"]}
|
||||
step("новый вход -> %d" % status, status == 201)
|
||||
status, _, _ = http(base, "DELETE", "/api/v1/auth/sessions/current", headers=bearer)
|
||||
step("logout -> %d" % status, status == 204)
|
||||
status, _, _ = http(base, "GET", "/api/v1/users/me", headers=bearer)
|
||||
step("GET /users/me после logout -> %d" % status, status == 401)
|
||||
status, _, _ = http(base, "DELETE", "/api/v1/auth/sessions/current", headers=bearer)
|
||||
step("повторный logout -> %d" % status, status == 401)
|
||||
|
||||
wrong = {"Authorization": "Basic " + base64.b64encode((username + ":wrong-password-123").encode()).decode()}
|
||||
status, headers, _ = http(base, "POST", "/api/v1/auth/sessions", headers=wrong)
|
||||
step("вход с неверным паролем -> %d, WWW-Authenticate: %s" % (status, headers.get("WWW-Authenticate")),
|
||||
status == 401 and headers.get("WWW-Authenticate", "").startswith("Basic"))
|
||||
print("PASS: expiry (TTL=%g с), logout и неверный пароль на запущенном API" % args.ttl)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,63 @@
|
||||
#!/bin/sh
|
||||
set -u
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
R="python3 scripts/run_and_save.py"
|
||||
DC="docker compose --env-file .env"
|
||||
PGUSER=$(sed -n 's/^POSTGRES_USER=//p' .env)
|
||||
PGDB=$(sed -n 's/^POSTGRES_DB=//p' .env)
|
||||
PSQL="$DC exec -T db psql -U ${PGUSER:-messenger} -d ${PGDB:-messenger}"
|
||||
VOLUME=mtusi-messenger_pgdata
|
||||
VOLFMT='{{.Name}} created={{.CreatedAt}}'
|
||||
STEPS=${*:-"01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16"}
|
||||
|
||||
wait_ready() {
|
||||
for _ in $(seq 1 90); do
|
||||
curl -sf http://localhost:8080/health/ready >/dev/null && return 0
|
||||
sleep 1
|
||||
done
|
||||
echo "API не готов" >&2
|
||||
return 1
|
||||
}
|
||||
|
||||
for step in $STEPS; do
|
||||
echo "=== $step"
|
||||
case $step in
|
||||
01) $R evidence/01_check_contract.txt -- python3 scripts/check_contract.py ;;
|
||||
02) $R evidence/02_smoke.txt -- make test ;;
|
||||
03) $R evidence/03_ps_before.txt -- $DC ps
|
||||
$R evidence/03_volume_before.txt -- docker volume inspect $VOLUME --format "$VOLFMT" ;;
|
||||
04) $R evidence/04_persistence.txt -- make test-persistence ACTION_SCRIPT=scripts/restart.sh ;;
|
||||
05) $R evidence/05_ps_after.txt -- $DC ps
|
||||
$R evidence/05_volume_after.txt -- docker volume inspect $VOLUME --format "$VOLFMT" ;;
|
||||
06) $R evidence/06_schema.txt -- $PSQL -c '\d users' -c '\d chats' -c '\d chat_members' \
|
||||
-c '\d messages' -c '\d sessions' ;;
|
||||
07) $R evidence/07_migrations.txt -- $DC exec -T api python -m app.migrate
|
||||
$R evidence/07_migrations_table.txt -- $PSQL -c 'SELECT * FROM schema_migrations' ;;
|
||||
08) $R evidence/08_hashes.txt -- $PSQL \
|
||||
-c "SELECT username, left(password_hash, 7) AS password_prefix, length(password_hash) AS len FROM users WHERE password_hash LIKE 'scrypt\$%' LIMIT 3" \
|
||||
-c 'SELECT length(token_hash) AS token_hash_len, expires_at FROM sessions LIMIT 3' ;;
|
||||
09) $R evidence/09_auth_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
|
||||
student-tests/test_auth.py student-tests/test_session_expiry.py ;;
|
||||
10) $R evidence/10_database_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
|
||||
student-tests/test_database.py student-tests/test_db_failure.py student-tests/test_transactions.py \
|
||||
student-tests/test_duplicate_username.py ;;
|
||||
11) $R evidence/11_all_tests.txt -- $DC --profile test run --rm tests ;;
|
||||
12) $R evidence/12_git_secrets.txt -- git check-ignore -v .env
|
||||
$R evidence/12_git_files.txt -- git ls-files --cached --others --exclude-standard
|
||||
$R evidence/12_compose_no_secrets.txt -- grep -n -i 'password\|secret' compose.yaml ;;
|
||||
13) python3 scripts/storage_demo.py --output evidence/13_storage.txt
|
||||
wait_ready ;;
|
||||
14) python3 scripts/dependency_demo.py --output evidence/14_dependencies.txt
|
||||
wait_ready ;;
|
||||
15) $R evidence/15_explain.txt -- $DC exec -T api python -m app.explain
|
||||
$R evidence/15_explain_tests.txt -- $DC --profile test run --rm tests python -m pytest -v --no-header -p no:cacheprovider \
|
||||
student-tests/test_explain.py ;;
|
||||
16) $DC --profile expiry up -d api-ttl
|
||||
for _ in $(seq 1 60); do curl -sf http://localhost:8081/health/ready >/dev/null && break; sleep 1; done
|
||||
$R evidence/16_expiry_live.txt -- python3 scripts/check_expiry.py --base-url http://localhost:8081 --ttl 3
|
||||
$DC --profile expiry stop api-ttl
|
||||
$DC --profile expiry rm -f api-ttl ;;
|
||||
*) echo "неизвестный пункт $step" >&2 ;;
|
||||
esac
|
||||
done
|
||||
@@ -0,0 +1,324 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Сценарий проверки кэша сессий и отказов зависимостей.
|
||||
|
||||
python scripts/dependency_demo.py [--output файл]
|
||||
|
||||
Показывает настройки Redis и попадания в кэш, отзыв сессии, рестарт и
|
||||
остановку Redis, остановку PostgreSQL и восстановление. Тома не удаляются,
|
||||
ключи Redis маскируются. Код возврата 0 -- все проверки прошли.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
||||
|
||||
|
||||
class Fail(Exception):
|
||||
"""Проверка не прошла."""
|
||||
pass
|
||||
|
||||
|
||||
class Log:
|
||||
"""Вывод на экран с накоплением строк для файла."""
|
||||
def __init__(self):
|
||||
"""Пустой листинг."""
|
||||
self.lines = []
|
||||
|
||||
def say(self, text=""):
|
||||
"""Напечатать строку и добавить её в листинг."""
|
||||
self.lines.append(text)
|
||||
print(text, flush=True)
|
||||
|
||||
def title(self, text):
|
||||
"""Напечатать заголовок раздела."""
|
||||
self.say("")
|
||||
self.say("=" * 78)
|
||||
self.say(text)
|
||||
self.say("=" * 78)
|
||||
|
||||
|
||||
def check(condition, message):
|
||||
"""Бросить Fail, если условие ложно."""
|
||||
if not condition:
|
||||
raise Fail(message)
|
||||
|
||||
|
||||
def mask(text):
|
||||
"""Скрыть SHA-256 токенов в ключах Redis."""
|
||||
return re.sub(r"session:[0-9a-f]{64}", "session:<sha256 токена>", text)
|
||||
|
||||
|
||||
def run(log, args, must_succeed=True):
|
||||
"""Выполнить команду, записать её и вывод в листинг."""
|
||||
log.say("$ " + mask(" ".join(a if a and " " not in a else '"%s"' % a for a in args)))
|
||||
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
|
||||
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
|
||||
if output:
|
||||
log.say(mask(output))
|
||||
if must_succeed and done.returncode != 0:
|
||||
raise Fail("команда завершилась с кодом %d" % done.returncode)
|
||||
return output
|
||||
|
||||
|
||||
def env_value(name, default):
|
||||
"""Значение переменной из .env."""
|
||||
path = ROOT / ".env"
|
||||
if path.exists():
|
||||
for line in path.read_text(encoding="utf-8").splitlines():
|
||||
if line.strip().startswith(name + "="):
|
||||
return line.split("=", 1)[1].strip()
|
||||
return default
|
||||
|
||||
|
||||
def psql(log, query):
|
||||
"""Выполнить запрос в контейнере db."""
|
||||
user = env_value("POSTGRES_USER", "messenger")
|
||||
db = env_value("POSTGRES_DB", "messenger")
|
||||
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", db, "-At", "-c", query])
|
||||
|
||||
|
||||
def redis_cli(log, *args):
|
||||
"""Выполнить команду redis-cli в контейнере redis."""
|
||||
return run(log, COMPOSE + ["exec", "-T", "redis", "redis-cli"] + list(args))
|
||||
|
||||
|
||||
def http(base, method, path, body=None, headers=None, timeout=10):
|
||||
"""HTTP-запрос: (статус, JSON или None, время в мс)."""
|
||||
data = json.dumps(body).encode() if body is not None else None
|
||||
request = urllib.request.Request(base + path, data=data, method=method, headers=dict(headers or {}))
|
||||
if data is not None:
|
||||
request.add_header("Content-Type", "application/json")
|
||||
started = time.monotonic()
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=timeout) as reply:
|
||||
status, raw = reply.status, reply.read()
|
||||
except urllib.error.HTTPError as error:
|
||||
status, raw = error.code, error.read()
|
||||
elapsed = (time.monotonic() - started) * 1000
|
||||
return status, (json.loads(raw) if raw else None), elapsed
|
||||
|
||||
|
||||
def call(log, base, method, path, expected, body=None, headers=None, note=""):
|
||||
"""HTTP-запрос с проверкой статуса и записью в листинг."""
|
||||
status, payload, elapsed = http(base, method, path, body, headers)
|
||||
shown = json.dumps(payload, ensure_ascii=False) if payload is not None else "(пусто)"
|
||||
if isinstance(payload, dict) and "token" in payload:
|
||||
shown = json.dumps(dict(payload, token="<скрыт>"), ensure_ascii=False)
|
||||
log.say("%s %s -> %d (%.0f мс)%s" % (method, path, status, elapsed, (" # " + note) if note else ""))
|
||||
log.say(" " + shown[:300])
|
||||
check(status == expected, "%s %s: ожидали %d, получили %d" % (method, path, expected, status))
|
||||
return payload, elapsed
|
||||
|
||||
|
||||
def wait_ready(base, seconds=90):
|
||||
"""Дождаться /health/ready = 200."""
|
||||
started = time.monotonic()
|
||||
while time.monotonic() - started < seconds:
|
||||
try:
|
||||
if http(base, "GET", "/health/ready", timeout=3)[0] == 200:
|
||||
return time.monotonic() - started
|
||||
except (urllib.error.URLError, OSError):
|
||||
pass
|
||||
time.sleep(0.5)
|
||||
raise Fail("API не стал готов за %d с" % seconds)
|
||||
|
||||
|
||||
def wait_service_healthy(log, service, seconds=60):
|
||||
"""Дождаться статуса healthy у контейнера сервиса."""
|
||||
started = time.monotonic()
|
||||
while time.monotonic() - started < seconds:
|
||||
done = subprocess.run(
|
||||
["docker", "inspect", "-f", "{{.State.Health.Status}}", "messenger-" + service],
|
||||
capture_output=True, text=True,
|
||||
)
|
||||
if done.stdout.strip() == "healthy":
|
||||
log.say("%s healthy через %.1f с" % (service, time.monotonic() - started))
|
||||
return
|
||||
time.sleep(0.5)
|
||||
raise Fail(service + " не стал healthy")
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
"""Заголовок Basic."""
|
||||
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode()).decode()}
|
||||
|
||||
|
||||
def bearer(token):
|
||||
"""Заголовок Bearer."""
|
||||
return {"Authorization": "Bearer " + token}
|
||||
|
||||
|
||||
def new_user(log, base, name):
|
||||
"""Зарегистрировать пользователя и войти."""
|
||||
username = "%s_%s" % (name, uuid.uuid4().hex[:8])
|
||||
password = "Demo-" + uuid.uuid4().hex
|
||||
user, _ = call(log, base, "POST", "/api/v1/users", 201,
|
||||
{"username": username, "display_name": name, "password": password},
|
||||
note="регистрация")
|
||||
session, _ = call(log, base, "POST", "/api/v1/auth/sessions", 201,
|
||||
headers=basic(username, password), note="вход (Basic)")
|
||||
return user, session["token"]
|
||||
|
||||
|
||||
def key_of(token):
|
||||
"""Ключ Redis для токена."""
|
||||
return "session:" + hashlib.sha256(token.encode()).hexdigest()
|
||||
|
||||
|
||||
def sessions_pkey_scans(log):
|
||||
"""Число чтений индекса sessions_pkey."""
|
||||
out = psql(log, "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelname = 'sessions_pkey'")
|
||||
return int(out.strip().splitlines()[-1])
|
||||
|
||||
|
||||
def scenario(log, base):
|
||||
"""Выполнить сценарий проверки."""
|
||||
log.title("0. Контейнеры")
|
||||
check(http(base, "GET", "/health/ready")[0] == 200,
|
||||
"API не готов: docker compose --env-file .env up -d --build")
|
||||
run(log, COMPOSE + ["ps"])
|
||||
|
||||
log.title("1. Redis: версия и настройки (кэш, persistence выключена намеренно)")
|
||||
run(log, COMPOSE + ["exec", "-T", "redis", "redis-server", "--version"])
|
||||
redis_cli(log, "CONFIG", "GET", "save")
|
||||
redis_cli(log, "CONFIG", "GET", "appendonly")
|
||||
redis_cli(log, "CONFIG", "GET", "maxmemory-policy")
|
||||
|
||||
log.title("2. Роль кэша: проверка Bearer-токена без запроса к PostgreSQL")
|
||||
alice, alice_token = new_user(log, base, "alice")
|
||||
bob, bob_token = new_user(log, base, "bob")
|
||||
redis_cli(log, "CONFIG", "RESETSTAT")
|
||||
time.sleep(1)
|
||||
scans_before = sessions_pkey_scans(log)
|
||||
timings = []
|
||||
for _ in range(50):
|
||||
status, _, elapsed = http(base, "GET", "/api/v1/users/me", headers=bearer(alice_token))
|
||||
check(status == 200, "GET /users/me не 200")
|
||||
timings.append(elapsed)
|
||||
log.say("50 x GET /api/v1/users/me -> 200; первый %.1f мс, медиана остальных %.1f мс"
|
||||
% (timings[0], sorted(timings[1:])[len(timings) // 2]))
|
||||
time.sleep(1)
|
||||
scans_after = sessions_pkey_scans(log)
|
||||
log.say("Чтений индекса sessions_pkey в PostgreSQL за 50 запросов: %d" % (scans_after - scans_before))
|
||||
check(scans_after - scans_before <= 2, "проверка токена ходит в PostgreSQL мимо кэша")
|
||||
stats = redis_cli(log, "INFO", "stats")
|
||||
hits = int(re.search(r"keyspace_hits:(\d+)", stats).group(1))
|
||||
misses = int(re.search(r"keyspace_misses:(\d+)", stats).group(1))
|
||||
log.say("Redis: keyspace_hits=%d keyspace_misses=%d" % (hits, misses))
|
||||
check(hits >= 49 and misses >= 1, "ожидали 1 промах и 49 попаданий")
|
||||
ttl = int(redis_cli(log, "PTTL", key_of(alice_token)).splitlines()[-1])
|
||||
log.say("TTL ключа сессии: %d мс (<= CACHE_TTL_SECONDS=60 с и <= остатка сессии)" % ttl)
|
||||
check(0 < ttl <= 60000, "TTL ключа вне ожидаемого диапазона")
|
||||
redis_cli(log, "GET", key_of(alice_token))
|
||||
|
||||
log.title("3. Logout: DELETE в PostgreSQL, затем отметка отзыва в Redis")
|
||||
_, carol_token = new_user(log, base, "carol")
|
||||
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(carol_token), note="кладёт сессию в кэш")
|
||||
call(log, base, "DELETE", "/api/v1/auth/sessions/current", 204, headers=bearer(carol_token))
|
||||
check(redis_cli(log, "GET", key_of(carol_token)).splitlines()[-1] == "revoked", "нет отметки отзыва")
|
||||
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(carol_token), note="отозванный токен")
|
||||
|
||||
log.title("4. Рестарт Redis: кэш пуст, сессии живы (источник истины -- PostgreSQL)")
|
||||
run(log, COMPOSE + ["restart", "redis"])
|
||||
wait_service_healthy(log, "redis")
|
||||
redis_cli(log, "DBSIZE")
|
||||
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token), note="тот же токен")
|
||||
check(redis_cli(log, "EXISTS", key_of(alice_token)).splitlines()[-1] == "1", "ключ не создан заново")
|
||||
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(carol_token),
|
||||
note="отозванный токен после потери кэша всё равно 401 (решает PostgreSQL)")
|
||||
|
||||
log.title("5. Redis ОСТАНОВЛЕН: API обходит кэш")
|
||||
run(log, COMPOSE + ["stop", "redis"])
|
||||
call(log, base, "GET", "/health/live", 200)
|
||||
call(log, base, "GET", "/health/ready", 200, note="Redis не критичен для обязательного пути")
|
||||
_, t1 = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token))
|
||||
chat, t2 = call(log, base, "POST", "/api/v1/chats", 201,
|
||||
{"title": "без Redis", "member_ids": [alice["id"], bob["id"]]},
|
||||
headers=bearer(alice_token))
|
||||
path = "/api/v1/chats/%s/messages" % chat["id"]
|
||||
message, t3 = call(log, base, "POST", path, 201, {"text": "сообщение при остановленном Redis"},
|
||||
headers=bearer(alice_token))
|
||||
page, t4 = call(log, base, "GET", path, 200, headers=bearer(bob_token))
|
||||
check(page["items"] == [message], "история не совпала")
|
||||
call(log, base, "GET", "/api/v1/users/me", 401, note="без токена -- 401, не доверяем")
|
||||
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer("Z" * 43), note="чужой токен -- 401")
|
||||
_, dave_token = new_user(log, base, "dave")
|
||||
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(dave_token))
|
||||
call(log, base, "DELETE", "/api/v1/auth/sessions/current", 204, headers=bearer(dave_token),
|
||||
note="logout при недоступном Redis")
|
||||
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(dave_token))
|
||||
log.say("Максимальная задержка запросов без Redis: %.0f мс" % max(t1, t2, t3, t4))
|
||||
check(max(t1, t2, t3, t4) < 2000, "обход кэша слишком медленный")
|
||||
run(log, COMPOSE + ["start", "redis"])
|
||||
wait_service_healthy(log, "redis")
|
||||
time.sleep(5.5)
|
||||
call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token), note="кэш снова в работе")
|
||||
call(log, base, "GET", "/api/v1/users/me", 401, headers=bearer(dave_token))
|
||||
run(log, COMPOSE + ["logs", "--since", "2m", "api"], must_succeed=False)
|
||||
|
||||
log.title("6. PostgreSQL ОСТАНОВЛЕН: ограниченная ошибка, никого не пускаем без проверки")
|
||||
run(log, COMPOSE + ["stop", "db"])
|
||||
call(log, base, "GET", "/health/live", 200, note="процесс жив")
|
||||
call(log, base, "GET", "/health/ready", 503, note="обязательная зависимость недоступна")
|
||||
call(log, base, "GET", "/api/v1/chats", 503, headers=bearer(alice_token), note="данные только в БД")
|
||||
call(log, base, "POST", path, 503, {"text": "не будет записано"}, headers=bearer(alice_token))
|
||||
call(log, base, "POST", "/api/v1/users", 503,
|
||||
{"username": "nodb_" + uuid.uuid4().hex[:6], "display_name": "x", "password": "long-enough-pass"})
|
||||
call(log, base, "GET", "/api/v1/users/me", 401, note="аноним -- 401")
|
||||
call(log, base, "GET", "/api/v1/users/me", 503, headers=bearer("Y" * 43),
|
||||
note="неизвестный токен: проверить нельзя -> 503, не 200")
|
||||
run(log, COMPOSE + ["start", "db"])
|
||||
waited = wait_ready(base)
|
||||
log.say("API снова готов через %.1f с после start db" % waited)
|
||||
page, _ = call(log, base, "GET", path, 200, headers=bearer(bob_token), note="тот же токен, те же данные")
|
||||
check(page["items"] == [message], "сообщение пропало")
|
||||
run(log, COMPOSE + ["ps"])
|
||||
|
||||
log.title("ИТОГ")
|
||||
log.say("ИТОГ: PASS -- Redis кэширует проверку сессий; рестарт/остановка Redis не теряют сессий "
|
||||
"и не пропускают анонимов; остановка PostgreSQL даёт 503 без деталей и восстанавливается.")
|
||||
|
||||
|
||||
def main():
|
||||
"""Выполнить сценарий и сохранить листинг."""
|
||||
parser = argparse.ArgumentParser(description="Роль Redis и отказы зависимостей")
|
||||
parser.add_argument("--base-url", default="http://localhost:8080")
|
||||
parser.add_argument("--output", default="evidence/14_dependencies.txt")
|
||||
args = parser.parse_args()
|
||||
log = Log()
|
||||
commit = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
|
||||
capture_output=True, text=True).stdout.strip() or "нет"
|
||||
log.say("# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"))
|
||||
log.say("# Commit: " + commit)
|
||||
log.say("# Команда: python3 scripts/dependency_demo.py")
|
||||
code = 0
|
||||
try:
|
||||
scenario(log, args.base_url.rstrip("/"))
|
||||
except Fail as error:
|
||||
log.say("")
|
||||
log.say("ИТОГ: FAIL -- " + str(error))
|
||||
code = 1
|
||||
finally:
|
||||
for service in ("db", "redis"):
|
||||
subprocess.run(COMPOSE + ["start", service], cwd=str(ROOT), capture_output=True)
|
||||
output = ROOT / args.output
|
||||
output.parent.mkdir(parents=True, exist_ok=True)
|
||||
output.write_text("\n".join(log.lines) + "\n", encoding="utf-8")
|
||||
return code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,5 @@
|
||||
@echo off
|
||||
cd /d "%~dp0.."
|
||||
docker compose --env-file .env stop api redis db || exit /b 1
|
||||
docker compose --env-file .env start db redis api || exit /b 1
|
||||
exit /b 0
|
||||
@@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env stop api redis db
|
||||
docker compose --env-file .env start db redis api
|
||||
@@ -0,0 +1,64 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Выполнить команду и сохранить её вывод в файл вместе с датой, коммитом и кодом возврата.
|
||||
|
||||
python scripts/run_and_save.py evidence/01.txt -- python scripts/check_contract.py
|
||||
"""
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def git_commit(root: Path) -> str:
|
||||
"""Короткий hash текущего коммита или пояснение, почему его нет."""
|
||||
try:
|
||||
out = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(root), capture_output=True,
|
||||
text=True, timeout=5)
|
||||
return out.stdout.strip() if out.returncode == 0 and out.stdout.strip() else "нет (git не используется)"
|
||||
except Exception:
|
||||
return "нет (git не найден)"
|
||||
|
||||
|
||||
def main() -> int:
|
||||
"""Выполнить команду после --, записать отчёт и вернуть её код возврата."""
|
||||
argv = sys.argv[1:]
|
||||
if len(argv) < 3 or argv[1] != "--":
|
||||
print(__doc__)
|
||||
return 2
|
||||
target = Path(argv[0])
|
||||
command = argv[2:]
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
|
||||
env = dict(os.environ, PYTHONIOENCODING="utf-8", PYTHONUTF8="1")
|
||||
started = time.monotonic()
|
||||
try:
|
||||
done = subprocess.run(command, capture_output=True, env=env, cwd=str(root))
|
||||
output = (done.stdout + done.stderr).decode("utf-8", errors="replace")
|
||||
code = done.returncode
|
||||
except FileNotFoundError:
|
||||
output = "Команда не найдена: %s\n" % command[0]
|
||||
code = 127
|
||||
elapsed = time.monotonic() - started
|
||||
|
||||
text = "\n".join([
|
||||
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
|
||||
"# Commit: " + git_commit(root),
|
||||
"# Команда: " + " ".join(command),
|
||||
"# ---------------------------------------- вывод ----------------------------------------",
|
||||
output.rstrip(),
|
||||
"# ---------------------------------------------------------------------------------------",
|
||||
"# Код возврата: %d" % code,
|
||||
"# Время выполнения: %.2f с" % elapsed,
|
||||
"",
|
||||
])
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
target.write_text(text, encoding="utf-8")
|
||||
sys.stdout.buffer.write(text.encode("utf-8", errors="replace"))
|
||||
print("\n[сохранено в %s]" % target)
|
||||
return code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,379 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Сценарий проверки сохранности данных при пересоздании контейнеров.
|
||||
|
||||
python scripts/storage_demo.py [--mode down|stop] [--output файл]
|
||||
|
||||
Создаёт данные через API, показывает их в PostgreSQL, выключает и снова
|
||||
включает контейнеры (тома не удаляются) и проверяет те же данные прежними
|
||||
токенами. Пароли и токены в листинг не попадают. Код возврата 0 -- успех.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
||||
|
||||
INTRO = """\
|
||||
Приложение -- мессенджер: HTTP API (FastAPI), PostgreSQL и Redis (кэш сессий).
|
||||
* Сам API состояния не хранит: пользователи, чаты, участники, сообщения и сессии
|
||||
лежат в PostgreSQL (таблицы users, chats, chat_members, messages, sessions).
|
||||
* Файлы PostgreSQL лежат не в контейнере, а в именованном томе Docker (pgdata).
|
||||
Контейнеры api и db временные, том постоянный.
|
||||
* Пароль хранится как scrypt-хеш, у сессии в БД лежит только SHA-256 токена,
|
||||
срок сессии считает сама БД -- перезапуск его не продлевает и не сбрасывает.
|
||||
* Redis только кэширует проверку токена (без persistence): после перезапуска
|
||||
кэш пуст, и сессии читаются из PostgreSQL.
|
||||
Ожидание: пока том не удалён (команда down -v здесь НЕ используется), после
|
||||
%(what)s
|
||||
те же пользователи, чат, сообщение и тот же токен продолжают работать.
|
||||
План: (1) создать данные через API, (2) показать их в БД, (3) выключить,
|
||||
(4) включить, (5) проверить, что данные и токены прежние.
|
||||
"""
|
||||
|
||||
|
||||
class Fail(Exception):
|
||||
"""Проверка не прошла."""
|
||||
|
||||
|
||||
class Log:
|
||||
"""Вывод на экран с накоплением строк для файла."""
|
||||
|
||||
def __init__(self):
|
||||
"""Пустой листинг."""
|
||||
self.lines = []
|
||||
|
||||
def say(self, text=""):
|
||||
"""Напечатать строку и добавить её в листинг."""
|
||||
self.lines.append(text)
|
||||
print(text, flush=True)
|
||||
|
||||
def title(self, text):
|
||||
"""Напечатать заголовок раздела."""
|
||||
self.say("")
|
||||
self.say("=" * 78)
|
||||
self.say(text)
|
||||
self.say("=" * 78)
|
||||
|
||||
|
||||
def show(args):
|
||||
"""Команда одной строкой для листинга."""
|
||||
parts = []
|
||||
for arg in args:
|
||||
if arg == "" or " " in arg:
|
||||
quote = "'" if '"' in arg else '"'
|
||||
parts.append(quote + arg + quote)
|
||||
else:
|
||||
parts.append(arg)
|
||||
return " ".join(parts)
|
||||
|
||||
|
||||
def run(log, args, must_succeed=True):
|
||||
"""Выполнить команду, записать её и вывод в листинг."""
|
||||
log.say("$ " + show(args))
|
||||
try:
|
||||
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
|
||||
except FileNotFoundError:
|
||||
raise Fail("команда не найдена: %s (установлен ли Docker Desktop?)" % args[0])
|
||||
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
|
||||
if output:
|
||||
log.say(output)
|
||||
if must_succeed and done.returncode != 0:
|
||||
raise Fail("команда завершилась с кодом %d" % done.returncode)
|
||||
return output
|
||||
|
||||
|
||||
def read_env():
|
||||
"""Прочитать .env в словарь."""
|
||||
values = {}
|
||||
path = ROOT / ".env"
|
||||
if path.exists():
|
||||
for line in path.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if line and not line.startswith("#") and "=" in line:
|
||||
key, _, value = line.partition("=")
|
||||
values[key.strip()] = value.strip()
|
||||
return values
|
||||
|
||||
|
||||
def sql(log, query):
|
||||
"""Выполнить SELECT в контейнере db."""
|
||||
env = read_env()
|
||||
user = env.get("POSTGRES_USER", "messenger")
|
||||
database = env.get("POSTGRES_DB", "messenger")
|
||||
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", database, "-c", query])
|
||||
|
||||
|
||||
def http(base, method, path, body=None, headers=None, timeout=10):
|
||||
"""HTTP-запрос к API: (статус, JSON или None)."""
|
||||
data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
|
||||
request_headers = {"Accept": "application/json"}
|
||||
if body is not None:
|
||||
request_headers["Content-Type"] = "application/json"
|
||||
request_headers.update(headers or {})
|
||||
request = urllib.request.Request(base + path, data=data, method=method, headers=request_headers)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=timeout)
|
||||
status, payload = response.status, response.read()
|
||||
except urllib.error.HTTPError as error:
|
||||
status, payload = error.code, error.read()
|
||||
return status, (json.loads(payload) if payload else None)
|
||||
|
||||
|
||||
def masked(value):
|
||||
"""Копия ответа со скрытым токеном."""
|
||||
if isinstance(value, dict):
|
||||
return {
|
||||
key: ("<скрыт, %d симв.>" % len(item) if key == "token" and isinstance(item, str) else masked(item))
|
||||
for key, item in value.items()
|
||||
}
|
||||
if isinstance(value, list):
|
||||
return [masked(item) for item in value]
|
||||
return value
|
||||
|
||||
|
||||
def call(log, base, method, path, expected, body=None, headers=None, note=""):
|
||||
"""HTTP-запрос с проверкой статуса и записью в листинг."""
|
||||
status, payload = http(base, method, path, body, headers)
|
||||
shown = dict(body) if isinstance(body, dict) else body
|
||||
if isinstance(shown, dict) and "password" in shown:
|
||||
shown["password"] = "***"
|
||||
log.say("$ %s %s %s" % (method, path, (" # " + note) if note else ""))
|
||||
if shown is not None:
|
||||
log.say(" тело запроса: " + json.dumps(shown, ensure_ascii=False))
|
||||
log.say(" ответ: %d %s" % (status, json.dumps(masked(payload), ensure_ascii=False)))
|
||||
if status != expected:
|
||||
raise Fail("%s %s: ожидали %d, получили %d" % (method, path, expected, status))
|
||||
return payload
|
||||
|
||||
|
||||
def wait_ready(base, seconds):
|
||||
"""Дождаться /health/ready = 200 и вернуть время ожидания."""
|
||||
started = time.monotonic()
|
||||
while time.monotonic() - started < seconds:
|
||||
try:
|
||||
status, _ = http(base, "GET", "/health/ready", timeout=3)
|
||||
if status == 200:
|
||||
return time.monotonic() - started
|
||||
except (urllib.error.URLError, OSError, ValueError):
|
||||
pass
|
||||
time.sleep(1)
|
||||
raise Fail("API не стал готовым за %d с" % seconds)
|
||||
|
||||
|
||||
def is_down(base):
|
||||
"""True, если API не отвечает."""
|
||||
try:
|
||||
http(base, "GET", "/health/live", timeout=3)
|
||||
return False
|
||||
except (urllib.error.URLError, OSError, ValueError):
|
||||
return True
|
||||
|
||||
|
||||
def volume_name(log):
|
||||
"""Имя тома pgdata."""
|
||||
out = run(log, ["docker", "volume", "ls", "--filter", "name=pgdata", "--format", "{{.Name}}"])
|
||||
names = [line.strip() for line in out.splitlines() if line.strip()]
|
||||
if not names:
|
||||
raise Fail("том pgdata не найден: приложение не запускали? (docker compose --env-file .env up -d --build)")
|
||||
return names[0]
|
||||
|
||||
|
||||
def volume_info(log, name):
|
||||
"""Имя и дата создания тома."""
|
||||
return run(log, ["docker", "volume", "inspect", name, "--format", "{{.Name}} создан: {{.CreatedAt}}"])
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
"""Заголовок Basic."""
|
||||
raw = (username + ":" + password).encode("utf-8")
|
||||
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
|
||||
|
||||
|
||||
def bearer(token):
|
||||
"""Заголовок Bearer."""
|
||||
return {"Authorization": "Bearer " + token}
|
||||
|
||||
|
||||
def scenario(log, args):
|
||||
"""Выполнить сценарий проверки."""
|
||||
base = args.base_url.rstrip("/")
|
||||
down_mode = args.mode == "down"
|
||||
what = (
|
||||
"удаления и повторного создания контейнеров (docker compose down, затем up -d)"
|
||||
if down_mode
|
||||
else "остановки и повторного запуска контейнеров (docker compose stop, затем start)"
|
||||
)
|
||||
|
||||
log.title("1. Как устроено приложение")
|
||||
log.say(INTRO % {"what": what})
|
||||
|
||||
log.title("2. Состояние до начала")
|
||||
try:
|
||||
status, _ = http(base, "GET", "/health/ready")
|
||||
except (urllib.error.URLError, OSError, ValueError):
|
||||
status = 0
|
||||
if status != 200:
|
||||
raise Fail("API не отвечает на %s. Запустите приложение: docker compose --env-file .env up -d --build" % base)
|
||||
run(log, COMPOSE + ["ps"])
|
||||
volume = volume_name(log)
|
||||
volume_before = volume_info(log, volume)
|
||||
|
||||
log.title("3. Запись данных через API (создаём пользователей, чат, сообщение)")
|
||||
suffix = uuid.uuid4().hex[:8]
|
||||
alice_name, bob_name = "demo_a_" + suffix, "demo_b_" + suffix
|
||||
alice_pass, bob_pass = "Storage-" + uuid.uuid4().hex, "Storage-" + uuid.uuid4().hex
|
||||
alice = call(log, base, "POST", "/api/v1/users", 201,
|
||||
{"username": alice_name, "display_name": "Алиса", "password": alice_pass},
|
||||
note="регистрация Алисы")
|
||||
bob = call(log, base, "POST", "/api/v1/users", 201,
|
||||
{"username": bob_name, "display_name": "Боб", "password": bob_pass},
|
||||
note="регистрация Боба")
|
||||
alice_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
|
||||
headers=basic(alice_name, alice_pass), note="вход Алисы (Basic)")["token"]
|
||||
bob_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
|
||||
headers=basic(bob_name, bob_pass), note="вход Боба (Basic)")["token"]
|
||||
chat = call(log, base, "POST", "/api/v1/chats", 201,
|
||||
{"title": "Проверка сохранности " + suffix, "member_ids": [alice["id"], bob["id"]]},
|
||||
headers=bearer(alice_token), note="чат Алисы и Боба (Bearer)")
|
||||
message = call(log, base, "POST", "/api/v1/chats/%s/messages" % chat["id"], 201,
|
||||
{"text": "Это сообщение должно пережить перезапуск " + suffix},
|
||||
headers=bearer(alice_token), note="сообщение Алисы")
|
||||
|
||||
log.title("4. Что лежит в PostgreSQL ДО выключения (SELECT внутри контейнера db)")
|
||||
queries = {
|
||||
"пользователи (пароль -- только префикс хеша)":
|
||||
"SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at "
|
||||
"FROM users WHERE username IN ('%s', '%s') ORDER BY username" % (alice_name, bob_name),
|
||||
"чат и число участников":
|
||||
"SELECT c.title, count(m.user_id) AS members FROM chats c "
|
||||
"JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '%s' GROUP BY c.title" % chat["id"],
|
||||
"сообщение":
|
||||
"SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '%s'" % chat["id"],
|
||||
"действующие сессии (токены не показываем)":
|
||||
"SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id "
|
||||
"WHERE u.username IN ('%s', '%s') AND s.expires_at > now()" % (alice_name, bob_name),
|
||||
}
|
||||
before = {}
|
||||
for title, query in queries.items():
|
||||
log.say("-- " + title)
|
||||
before[title] = sql(log, query)
|
||||
|
||||
log.title("5. Выключаем приложение" + (" (контейнеры УДАЛЯЮТСЯ, том остаётся)" if down_mode else ""))
|
||||
if down_mode:
|
||||
run(log, COMPOSE + ["down"])
|
||||
run(log, COMPOSE + ["ps", "-a"], must_succeed=False)
|
||||
else:
|
||||
run(log, COMPOSE + ["stop", "api", "redis", "db"])
|
||||
run(log, COMPOSE + ["ps", "-a"])
|
||||
if not is_down(base):
|
||||
raise Fail("после выключения API всё ещё отвечает")
|
||||
log.say("API на %s не отвечает -- приложение выключено (так и должно быть)." % base)
|
||||
log.say("-- том с данными на месте:")
|
||||
run(log, ["docker", "volume", "ls", "--filter", "name=pgdata"])
|
||||
|
||||
log.title("6. Включаем снова")
|
||||
if down_mode:
|
||||
run(log, COMPOSE + ["up", "-d"])
|
||||
else:
|
||||
run(log, COMPOSE + ["start", "db", "redis", "api"])
|
||||
waited = wait_ready(base, args.wait)
|
||||
log.say("API снова готов (/health/ready = 200) через %.0f с." % waited)
|
||||
run(log, COMPOSE + ["ps"])
|
||||
|
||||
log.title("7. Проверка ПОСЛЕ перезапуска: те же данные и те же токены")
|
||||
me = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token),
|
||||
note="старый токен Алисы, повторный вход НЕ делали")
|
||||
if me != alice:
|
||||
raise Fail("пользователь после перезапуска отличается: %r != %r" % (me, alice))
|
||||
log.say(" OK: тот же пользователь (id, username, created_at совпали).")
|
||||
page = call(log, base, "GET", "/api/v1/chats/%s/messages" % chat["id"], 200,
|
||||
headers=bearer(bob_token), note="старый токен Боба читает историю чата")
|
||||
if page["items"] != [message]:
|
||||
raise Fail("история чата отличается от записанной до перезапуска")
|
||||
log.say(" OK: то же сообщение (id, text, created_at совпали).")
|
||||
listed = call(log, base, "GET", "/api/v1/chats?limit=100", 200, headers=bearer(alice_token),
|
||||
note="список чатов Алисы")
|
||||
if not any(item["id"] == chat["id"] for item in listed["items"]):
|
||||
raise Fail("чат пропал из списка")
|
||||
log.say(" OK: чат в списке.")
|
||||
|
||||
log.say("")
|
||||
log.say("Те же SELECT после перезапуска (сравниваем с выводом из пункта 4):")
|
||||
for title, query in queries.items():
|
||||
log.say("-- " + title)
|
||||
after = sql(log, query)
|
||||
if after != before[title]:
|
||||
raise Fail("результат SELECT изменился: " + title)
|
||||
log.say(" OK: вывод идентичен выводу до перезапуска.")
|
||||
|
||||
log.say("")
|
||||
log.say("-- том тот же (дата создания не изменилась):")
|
||||
volume_after = volume_info(log, volume)
|
||||
if volume_after != volume_before:
|
||||
raise Fail("том изменился: был «%s», стал «%s»" % (volume_before, volume_after))
|
||||
log.say(" OK: том не пересоздавался.")
|
||||
|
||||
log.title("ИТОГ")
|
||||
log.say("ИТОГ: PASS -- пользователи, чат, сообщение и действующие сессии сохранились после "
|
||||
+ what + ".")
|
||||
|
||||
|
||||
def commit_hash():
|
||||
"""Короткий hash текущего коммита."""
|
||||
try:
|
||||
done = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
|
||||
capture_output=True, text=True, timeout=5)
|
||||
return done.stdout.strip() if done.returncode == 0 and done.stdout.strip() else "нет"
|
||||
except Exception:
|
||||
return "нет"
|
||||
|
||||
|
||||
def main():
|
||||
"""Разобрать аргументы, выполнить сценарий и сохранить листинг."""
|
||||
parser = argparse.ArgumentParser(description="Доказательство сохранности данных после перезапуска")
|
||||
parser.add_argument("--base-url", default="http://localhost:8080")
|
||||
parser.add_argument("--output", default="evidence/13_storage.txt")
|
||||
parser.add_argument("--mode", choices=["down", "stop"], default="down",
|
||||
help="down: удалить и создать контейнеры (по умолчанию); stop: остановить и запустить")
|
||||
parser.add_argument("--wait", type=int, default=90, help="сколько секунд ждать готовности API")
|
||||
args = parser.parse_args()
|
||||
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8", errors="replace")
|
||||
|
||||
log = Log()
|
||||
code = 0
|
||||
try:
|
||||
scenario(log, args)
|
||||
except Fail as error:
|
||||
log.say("")
|
||||
log.say("ИТОГ: FAIL -- " + str(error))
|
||||
code = 1
|
||||
|
||||
header = [
|
||||
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
|
||||
"# Commit: " + commit_hash(),
|
||||
"# Команда: python scripts/storage_demo.py --mode " + args.mode,
|
||||
"",
|
||||
]
|
||||
target = Path(args.output)
|
||||
if not target.is_absolute():
|
||||
target = ROOT / target
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
target.write_text("\n".join(header + log.lines) + "\n", encoding="utf-8")
|
||||
print("\n[сохранено в %s]" % target)
|
||||
return code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
+381
@@ -0,0 +1,381 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Доказать, что данные переживают удаление/перезапуск контейнеров.
|
||||
|
||||
Запуск (из корня проекта, стенд уже поднят: docker compose --env-file .env up -d --build):
|
||||
|
||||
python scripts\\storage_demo.py
|
||||
|
||||
Что делает скрипт и записывает в evidence/storage.txt (листинг команд и их вывода):
|
||||
1. коротко описывает приложение;
|
||||
2. создаёт через API двух пользователей, входит, создаёт чат и отправляет сообщение;
|
||||
3. показывает, что именно лежит в PostgreSQL (SELECT внутри контейнера db);
|
||||
4. выключает приложение (по умолчанию `docker compose down` -- контейнеры удаляются,
|
||||
том pgdata остаётся; режим --mode stop делает `stop`, как scripts\\restart.bat);
|
||||
5. включает снова и ждёт готовности;
|
||||
6. тем же токеном читает те же данные и сравнивает SELECT до и после.
|
||||
|
||||
Флаг -v (удаление тома) скрипт НЕ использует никогда. Пароли и токены в файл не попадают.
|
||||
Код возврата: 0 -- данные сохранились, 1 -- нет (или стенд не запущен).
|
||||
Только стандартная библиотека Python 3.9+.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import platform
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
||||
|
||||
INTRO = """\
|
||||
Приложение -- учебный мессенджер: HTTP API (FastAPI) и база PostgreSQL.
|
||||
* Сам API состояния не хранит: пользователи, чаты, участники, сообщения и сессии
|
||||
лежат в PostgreSQL (таблицы users, chats, chat_members, messages, sessions).
|
||||
* Файлы PostgreSQL лежат не в контейнере, а в именованном томе Docker (pgdata).
|
||||
Контейнеры api и db временные, том постоянный.
|
||||
* Пароль хранится как scrypt-хеш, у сессии в БД лежит только SHA-256 токена,
|
||||
срок сессии считает сама БД -- перезапуск его не продлевает и не сбрасывает.
|
||||
Ожидание: пока том не удалён (команда down -v здесь НЕ используется), после
|
||||
%(what)s
|
||||
те же пользователи, чат, сообщение и тот же токен продолжают работать.
|
||||
План: (1) создать данные через API, (2) показать их в БД, (3) выключить,
|
||||
(4) включить, (5) проверить, что данные и токены прежние.
|
||||
"""
|
||||
|
||||
|
||||
class Fail(Exception):
|
||||
"""Проверка не прошла или стенд не запущен."""
|
||||
|
||||
|
||||
class Log:
|
||||
"""Печатает строки на экран и копит их для файла evidence/storage.txt."""
|
||||
|
||||
def __init__(self):
|
||||
self.lines = []
|
||||
|
||||
def say(self, text=""):
|
||||
self.lines.append(text)
|
||||
print(text, flush=True)
|
||||
|
||||
def title(self, text):
|
||||
self.say("")
|
||||
self.say("=" * 78)
|
||||
self.say(text)
|
||||
self.say("=" * 78)
|
||||
|
||||
|
||||
def show(args):
|
||||
"""Команда в виде строки для листинга (аргументы с пробелами в кавычках)."""
|
||||
parts = []
|
||||
for arg in args:
|
||||
if arg == "" or " " in arg:
|
||||
quote = "'" if '"' in arg else '"'
|
||||
parts.append(quote + arg + quote)
|
||||
else:
|
||||
parts.append(arg)
|
||||
return " ".join(parts)
|
||||
|
||||
|
||||
def run(log, args, must_succeed=True):
|
||||
"""Выполнить команду, записать её и вывод в листинг, вернуть вывод текстом."""
|
||||
log.say("$ " + show(args))
|
||||
try:
|
||||
done = subprocess.run(args, cwd=str(ROOT), capture_output=True)
|
||||
except FileNotFoundError:
|
||||
raise Fail("команда не найдена: %s (установлен ли Docker Desktop?)" % args[0])
|
||||
output = (done.stdout + done.stderr).decode("utf-8", errors="replace").strip()
|
||||
if output:
|
||||
log.say(output)
|
||||
if must_succeed and done.returncode != 0:
|
||||
raise Fail("команда завершилась с кодом %d" % done.returncode)
|
||||
return output
|
||||
|
||||
|
||||
def read_env():
|
||||
"""Прочитать .env (KEY=VALUE) в словарь. Пароль скрипту не нужен: psql внутри db заходит по сокету."""
|
||||
values = {}
|
||||
path = ROOT / ".env"
|
||||
if path.exists():
|
||||
for line in path.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if line and not line.startswith("#") and "=" in line:
|
||||
key, _, value = line.partition("=")
|
||||
values[key.strip()] = value.strip()
|
||||
return values
|
||||
|
||||
|
||||
def sql(log, query):
|
||||
"""SELECT внутри контейнера db. Команда в листинге копируется в консоль как есть."""
|
||||
env = read_env()
|
||||
user = env.get("POSTGRES_USER", "messenger")
|
||||
database = env.get("POSTGRES_DB", "messenger")
|
||||
return run(log, COMPOSE + ["exec", "-T", "db", "psql", "-U", user, "-d", database, "-c", query])
|
||||
|
||||
|
||||
def http(base, method, path, body=None, headers=None, timeout=10):
|
||||
"""HTTP-запрос к API. Возвращает (статус, JSON или None)."""
|
||||
data = json.dumps(body, ensure_ascii=False).encode("utf-8") if body is not None else None
|
||||
request_headers = {"Accept": "application/json"}
|
||||
if body is not None:
|
||||
request_headers["Content-Type"] = "application/json"
|
||||
request_headers.update(headers or {})
|
||||
request = urllib.request.Request(base + path, data=data, method=method, headers=request_headers)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=timeout)
|
||||
status, payload = response.status, response.read()
|
||||
except urllib.error.HTTPError as error:
|
||||
status, payload = error.code, error.read()
|
||||
return status, (json.loads(payload) if payload else None)
|
||||
|
||||
|
||||
def masked(value):
|
||||
"""Копия ответа без токена: токены в evidence не сохраняем."""
|
||||
if isinstance(value, dict):
|
||||
return {
|
||||
key: ("<скрыт, %d симв.>" % len(item) if key == "token" and isinstance(item, str) else masked(item))
|
||||
for key, item in value.items()
|
||||
}
|
||||
if isinstance(value, list):
|
||||
return [masked(item) for item in value]
|
||||
return value
|
||||
|
||||
|
||||
def call(log, base, method, path, expected, body=None, headers=None, note=""):
|
||||
"""HTTP-запрос с проверкой статуса и записью в листинг (без паролей и токенов)."""
|
||||
status, payload = http(base, method, path, body, headers)
|
||||
shown = dict(body) if isinstance(body, dict) else body
|
||||
if isinstance(shown, dict) and "password" in shown:
|
||||
shown["password"] = "***"
|
||||
log.say("$ %s %s %s" % (method, path, (" # " + note) if note else ""))
|
||||
if shown is not None:
|
||||
log.say(" тело запроса: " + json.dumps(shown, ensure_ascii=False))
|
||||
log.say(" ответ: %d %s" % (status, json.dumps(masked(payload), ensure_ascii=False)))
|
||||
if status != expected:
|
||||
raise Fail("%s %s: ожидали %d, получили %d" % (method, path, expected, status))
|
||||
return payload
|
||||
|
||||
|
||||
def wait_ready(base, seconds):
|
||||
"""Ждать, пока /health/ready ответит 200. Возвращает, сколько секунд ждали."""
|
||||
started = time.monotonic()
|
||||
while time.monotonic() - started < seconds:
|
||||
try:
|
||||
status, _ = http(base, "GET", "/health/ready", timeout=3)
|
||||
if status == 200:
|
||||
return time.monotonic() - started
|
||||
except (urllib.error.URLError, OSError, ValueError):
|
||||
pass
|
||||
time.sleep(1)
|
||||
raise Fail("API не стал готовым за %d с" % seconds)
|
||||
|
||||
|
||||
def is_down(base):
|
||||
"""True, если API сейчас не отвечает (контейнеры выключены)."""
|
||||
try:
|
||||
http(base, "GET", "/health/live", timeout=3)
|
||||
return False
|
||||
except (urllib.error.URLError, OSError, ValueError):
|
||||
return True
|
||||
|
||||
|
||||
def volume_name(log):
|
||||
"""Имя тома pgdata (оно зависит от имени проекта compose)."""
|
||||
out = run(log, ["docker", "volume", "ls", "--filter", "name=pgdata", "--format", "{{.Name}}"])
|
||||
names = [line.strip() for line in out.splitlines() if line.strip()]
|
||||
if not names:
|
||||
raise Fail("том pgdata не найден: стенд не запускали? (docker compose --env-file .env up -d --build)")
|
||||
return names[0]
|
||||
|
||||
|
||||
def volume_info(log, name):
|
||||
return run(log, ["docker", "volume", "inspect", name, "--format", "{{.Name}} создан: {{.CreatedAt}}"])
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
raw = (username + ":" + password).encode("utf-8")
|
||||
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
|
||||
|
||||
|
||||
def bearer(token):
|
||||
return {"Authorization": "Bearer " + token}
|
||||
|
||||
|
||||
def scenario(log, args):
|
||||
base = args.base_url.rstrip("/")
|
||||
down_mode = args.mode == "down"
|
||||
what = (
|
||||
"удаления и повторного создания контейнеров (docker compose down, затем up -d)"
|
||||
if down_mode
|
||||
else "остановки и повторного запуска контейнеров (docker compose stop, затем start)"
|
||||
)
|
||||
|
||||
log.title("1. Как устроено приложение")
|
||||
log.say(INTRO % {"what": what})
|
||||
|
||||
log.title("2. Состояние до начала")
|
||||
try:
|
||||
status, _ = http(base, "GET", "/health/ready")
|
||||
except (urllib.error.URLError, OSError, ValueError):
|
||||
status = 0
|
||||
if status != 200:
|
||||
raise Fail("API не отвечает на %s. Поднимите стенд: docker compose --env-file .env up -d --build" % base)
|
||||
run(log, COMPOSE + ["ps"])
|
||||
volume = volume_name(log)
|
||||
volume_before = volume_info(log, volume)
|
||||
|
||||
log.title("3. Запись данных через API (создаём пользователей, чат, сообщение)")
|
||||
suffix = uuid.uuid4().hex[:8]
|
||||
alice_name, bob_name = "evidence_a_" + suffix, "evidence_b_" + suffix
|
||||
alice_pass, bob_pass = "Storage-" + uuid.uuid4().hex, "Storage-" + uuid.uuid4().hex
|
||||
alice = call(log, base, "POST", "/api/v1/users", 201,
|
||||
{"username": alice_name, "display_name": "Алиса (evidence)", "password": alice_pass},
|
||||
note="регистрация Алисы")
|
||||
bob = call(log, base, "POST", "/api/v1/users", 201,
|
||||
{"username": bob_name, "display_name": "Боб (evidence)", "password": bob_pass},
|
||||
note="регистрация Боба")
|
||||
alice_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
|
||||
headers=basic(alice_name, alice_pass), note="вход Алисы (Basic)")["token"]
|
||||
bob_token = call(log, base, "POST", "/api/v1/auth/sessions", 201,
|
||||
headers=basic(bob_name, bob_pass), note="вход Боба (Basic)")["token"]
|
||||
chat = call(log, base, "POST", "/api/v1/chats", 201,
|
||||
{"title": "Проверка сохранности " + suffix, "member_ids": [alice["id"], bob["id"]]},
|
||||
headers=bearer(alice_token), note="чат Алисы и Боба (Bearer)")
|
||||
message = call(log, base, "POST", "/api/v1/chats/%s/messages" % chat["id"], 201,
|
||||
{"text": "Это сообщение должно пережить перезапуск " + suffix},
|
||||
headers=bearer(alice_token), note="сообщение Алисы")
|
||||
|
||||
log.title("4. Что лежит в PostgreSQL ДО выключения (SELECT внутри контейнера db)")
|
||||
queries = {
|
||||
"пользователи (пароль -- только префикс хеша)":
|
||||
"SELECT username, display_name, left(password_hash, 7) AS password_prefix, created_at "
|
||||
"FROM users WHERE username IN ('%s', '%s') ORDER BY username" % (alice_name, bob_name),
|
||||
"чат и число участников":
|
||||
"SELECT c.title, count(m.user_id) AS members FROM chats c "
|
||||
"JOIN chat_members m ON m.chat_id = c.id WHERE c.id = '%s' GROUP BY c.title" % chat["id"],
|
||||
"сообщение":
|
||||
"SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = '%s'" % chat["id"],
|
||||
"действующие сессии (токены не показываем)":
|
||||
"SELECT count(*) AS live_sessions FROM sessions s JOIN users u ON u.id = s.user_id "
|
||||
"WHERE u.username IN ('%s', '%s') AND s.expires_at > now()" % (alice_name, bob_name),
|
||||
}
|
||||
before = {}
|
||||
for title, query in queries.items():
|
||||
log.say("-- " + title)
|
||||
before[title] = sql(log, query)
|
||||
|
||||
log.title("5. Выключаем приложение" + (" (контейнеры УДАЛЯЮТСЯ, том остаётся)" if down_mode else ""))
|
||||
if down_mode:
|
||||
run(log, COMPOSE + ["down"])
|
||||
run(log, COMPOSE + ["ps", "-a"], must_succeed=False)
|
||||
else:
|
||||
run(log, COMPOSE + ["stop", "api", "db"])
|
||||
run(log, COMPOSE + ["ps", "-a"])
|
||||
if not is_down(base):
|
||||
raise Fail("после выключения API всё ещё отвечает")
|
||||
log.say("API на %s не отвечает -- приложение выключено (так и должно быть)." % base)
|
||||
log.say("-- том с данными на месте:")
|
||||
run(log, ["docker", "volume", "ls", "--filter", "name=pgdata"])
|
||||
|
||||
log.title("6. Включаем снова")
|
||||
if down_mode:
|
||||
run(log, COMPOSE + ["up", "-d"])
|
||||
else:
|
||||
run(log, COMPOSE + ["start", "db", "api"])
|
||||
waited = wait_ready(base, args.wait)
|
||||
log.say("API снова готов (/health/ready = 200) через %.0f с." % waited)
|
||||
run(log, COMPOSE + ["ps"])
|
||||
|
||||
log.title("7. Проверка ПОСЛЕ перезапуска: те же данные и те же токены")
|
||||
me = call(log, base, "GET", "/api/v1/users/me", 200, headers=bearer(alice_token),
|
||||
note="старый токен Алисы, повторный вход НЕ делали")
|
||||
if me != alice:
|
||||
raise Fail("пользователь после перезапуска отличается: %r != %r" % (me, alice))
|
||||
log.say(" OK: тот же пользователь (id, username, created_at совпали).")
|
||||
page = call(log, base, "GET", "/api/v1/chats/%s/messages" % chat["id"], 200,
|
||||
headers=bearer(bob_token), note="старый токен Боба читает историю чата")
|
||||
if page["items"] != [message]:
|
||||
raise Fail("история чата отличается от записанной до перезапуска")
|
||||
log.say(" OK: то же сообщение (id, text, created_at совпали).")
|
||||
listed = call(log, base, "GET", "/api/v1/chats?limit=100", 200, headers=bearer(alice_token),
|
||||
note="список чатов Алисы")
|
||||
if not any(item["id"] == chat["id"] for item in listed["items"]):
|
||||
raise Fail("чат пропал из списка")
|
||||
log.say(" OK: чат в списке.")
|
||||
|
||||
log.say("")
|
||||
log.say("Те же SELECT после перезапуска (сравниваем с выводом из пункта 4):")
|
||||
for title, query in queries.items():
|
||||
log.say("-- " + title)
|
||||
after = sql(log, query)
|
||||
if after != before[title]:
|
||||
raise Fail("результат SELECT изменился: " + title)
|
||||
log.say(" OK: вывод идентичен выводу до перезапуска.")
|
||||
|
||||
log.say("")
|
||||
log.say("-- том тот же (дата создания не изменилась):")
|
||||
volume_after = volume_info(log, volume)
|
||||
if volume_after != volume_before:
|
||||
raise Fail("том изменился: был «%s», стал «%s»" % (volume_before, volume_after))
|
||||
log.say(" OK: том не пересоздавался.")
|
||||
|
||||
log.title("ИТОГ")
|
||||
log.say("ИТОГ: PASS -- пользователи, чат, сообщение и действующие сессии сохранились после "
|
||||
+ what + ".")
|
||||
|
||||
|
||||
def commit_hash():
|
||||
try:
|
||||
done = subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=str(ROOT),
|
||||
capture_output=True, text=True, timeout=5)
|
||||
return done.stdout.strip() if done.returncode == 0 and done.stdout.strip() else "нет"
|
||||
except Exception:
|
||||
return "нет"
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Доказательство сохранности данных после перезапуска")
|
||||
parser.add_argument("--base-url", default="http://localhost:8080")
|
||||
parser.add_argument("--output", default="evidence/storage.txt")
|
||||
parser.add_argument("--mode", choices=["down", "stop"], default="down",
|
||||
help="down: удалить и создать контейнеры (по умолчанию); stop: остановить и запустить")
|
||||
parser.add_argument("--wait", type=int, default=90, help="сколько секунд ждать готовности API")
|
||||
args = parser.parse_args()
|
||||
|
||||
if hasattr(sys.stdout, "reconfigure"):
|
||||
sys.stdout.reconfigure(encoding="utf-8", errors="replace")
|
||||
|
||||
log = Log()
|
||||
code = 0
|
||||
try:
|
||||
scenario(log, args)
|
||||
except Fail as error:
|
||||
log.say("")
|
||||
log.say("ИТОГ: FAIL -- " + str(error))
|
||||
code = 1
|
||||
|
||||
header = [
|
||||
"# Дата (UTC): " + datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
|
||||
"# Система: %s, Python %s" % (platform.platform(), platform.python_version()),
|
||||
"# Commit: " + commit_hash(),
|
||||
"# Команда: python scripts/storage_demo.py --mode " + args.mode,
|
||||
"",
|
||||
]
|
||||
target = Path(args.output)
|
||||
if not target.is_absolute():
|
||||
target = ROOT / target
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
target.write_text("\n".join(header + log.lines) + "\n", encoding="utf-8")
|
||||
print("\n[сохранено в %s]" % target)
|
||||
return code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,257 @@
|
||||
"""Общие фикстуры тестов.
|
||||
|
||||
Тесты работают с настоящим PostgreSQL (отдельная БД messenger_test) и,
|
||||
если задан TEST_CACHE_URL, с Redis.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import base64
|
||||
import os
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
import asyncpg
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.config import Settings
|
||||
from app.main import create_app
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
TEST_DB_NAME = "messenger_test"
|
||||
|
||||
|
||||
def read_dotenv() -> dict:
|
||||
"""Прочитать .env из корня проекта в словарь."""
|
||||
values = {}
|
||||
path = ROOT / ".env"
|
||||
if path.exists():
|
||||
for line in path.read_text(encoding="utf-8").splitlines():
|
||||
line = line.strip()
|
||||
if line and not line.startswith("#") and "=" in line:
|
||||
key, _, value = line.partition("=")
|
||||
values[key.strip()] = value.strip()
|
||||
return values
|
||||
|
||||
|
||||
def database_parts() -> dict:
|
||||
"""Параметры подключения к тестовой БД из TEST_DB_* или .env."""
|
||||
env = read_dotenv()
|
||||
return {
|
||||
"user": os.environ.get("TEST_DB_USER", env.get("POSTGRES_USER", "messenger")),
|
||||
"password": os.environ.get(
|
||||
"TEST_DB_PASSWORD", env.get("POSTGRES_PASSWORD", "")
|
||||
),
|
||||
"host": os.environ.get("TEST_DB_HOST", "127.0.0.1"),
|
||||
"port": int(os.environ.get("TEST_DB_PORT", "5433")),
|
||||
}
|
||||
|
||||
|
||||
def sqlalchemy_url(database: str = TEST_DB_NAME) -> str:
|
||||
"""URL тестовой БД для SQLAlchemy."""
|
||||
p = database_parts()
|
||||
return "postgresql+asyncpg://%s:%s@%s:%d/%s" % (
|
||||
p["user"],
|
||||
p["password"],
|
||||
p["host"],
|
||||
p["port"],
|
||||
database,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture(scope="session", autouse=True)
|
||||
def test_database():
|
||||
"""Проверить доступность PostgreSQL и создать тестовую БД."""
|
||||
p = database_parts()
|
||||
|
||||
async def prepare():
|
||||
conn = await asyncpg.connect(
|
||||
user=p["user"],
|
||||
password=p["password"],
|
||||
host=p["host"],
|
||||
port=p["port"],
|
||||
database="postgres",
|
||||
timeout=5,
|
||||
)
|
||||
try:
|
||||
exists = await conn.fetchval(
|
||||
"SELECT 1 FROM pg_database WHERE datname = $1", TEST_DB_NAME
|
||||
)
|
||||
if not exists:
|
||||
await conn.execute(
|
||||
"CREATE DATABASE \"%s\" TEMPLATE template0 ENCODING 'UTF8'"
|
||||
% TEST_DB_NAME
|
||||
)
|
||||
finally:
|
||||
await conn.close()
|
||||
|
||||
try:
|
||||
asyncio.run(prepare())
|
||||
except Exception as error:
|
||||
pytest.exit(
|
||||
"PostgreSQL недоступен на %s:%s (%s). Запустите БД: "
|
||||
"docker compose --env-file .env up -d db"
|
||||
% (p["host"], p["port"], type(error).__name__),
|
||||
returncode=2,
|
||||
)
|
||||
|
||||
|
||||
CACHE_URL = os.environ.get("TEST_CACHE_URL", "")
|
||||
|
||||
|
||||
def make_settings(**overrides) -> Settings:
|
||||
"""Настройки приложения для тестов с переопределением полей."""
|
||||
base = Settings.from_env(
|
||||
{
|
||||
"DATABASE_URL": sqlalchemy_url(),
|
||||
"DB_STARTUP_WAIT_SECONDS": "5",
|
||||
"LOG_LEVEL": "INFO",
|
||||
"CACHE_URL": CACHE_URL,
|
||||
}
|
||||
)
|
||||
return Settings(**{**base.__dict__, **overrides})
|
||||
|
||||
|
||||
def run_sql(query: str, *args):
|
||||
"""Выполнить SQL в тестовой БД напрямую и вернуть строки."""
|
||||
p = database_parts()
|
||||
|
||||
async def go():
|
||||
conn = await asyncpg.connect(
|
||||
user=p["user"],
|
||||
password=p["password"],
|
||||
host=p["host"],
|
||||
port=p["port"],
|
||||
database=TEST_DB_NAME,
|
||||
timeout=5,
|
||||
)
|
||||
try:
|
||||
return await conn.fetch(query, *args)
|
||||
finally:
|
||||
await conn.close()
|
||||
|
||||
return asyncio.run(go())
|
||||
|
||||
|
||||
@pytest.fixture(scope="session")
|
||||
def client(test_database):
|
||||
"""Клиент приложения, общий для всего прогона."""
|
||||
with TestClient(
|
||||
create_app(make_settings()), raise_server_exceptions=False
|
||||
) as test_client:
|
||||
yield test_client
|
||||
|
||||
|
||||
class Person:
|
||||
"""Зарегистрированный пользователь с токеном и заголовками."""
|
||||
|
||||
def __init__(self, data: dict, password: str, token: str):
|
||||
self.data = data
|
||||
self.id = data["id"]
|
||||
self.username = data["username"]
|
||||
self.password = password
|
||||
self.token = token
|
||||
self.headers = {"Authorization": "Bearer " + token}
|
||||
|
||||
|
||||
def basic_header(username: str, password: str) -> dict:
|
||||
"""Заголовок Authorization: Basic."""
|
||||
raw = (username + ":" + password).encode("utf-8")
|
||||
return {"Authorization": "Basic " + base64.b64encode(raw).decode()}
|
||||
|
||||
|
||||
def register_and_login(client: TestClient, name: str = "") -> Person:
|
||||
"""Зарегистрировать уникального пользователя и войти."""
|
||||
username = ("u_" + name + "_" + uuid.uuid4().hex[:10]).lower()
|
||||
password = "T3st-pass-" + uuid.uuid4().hex
|
||||
created = client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": username,
|
||||
"display_name": "Тест " + name,
|
||||
"password": password,
|
||||
},
|
||||
)
|
||||
assert created.status_code == 201, created.text
|
||||
session = client.post(
|
||||
"/api/v1/auth/sessions", headers=basic_header(username, password)
|
||||
)
|
||||
assert session.status_code == 201, session.text
|
||||
return Person(created.json(), password, session.json()["token"])
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def make_user(client):
|
||||
"""Фабрика пользователей."""
|
||||
return lambda name="": register_and_login(client, name)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def make_chat(client):
|
||||
"""Фабрика чатов."""
|
||||
|
||||
def factory(owner: Person, *others: Person, title: str = "Чат") -> dict:
|
||||
members = [owner.id] + [p.id for p in others]
|
||||
reply = client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": title, "member_ids": members},
|
||||
headers=owner.headers,
|
||||
)
|
||||
assert reply.status_code == 201, reply.text
|
||||
return reply.json()
|
||||
|
||||
return factory
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def alice(make_user):
|
||||
"""Пользователь alice."""
|
||||
return make_user("alice")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def bob(make_user):
|
||||
"""Пользователь bob."""
|
||||
return make_user("bob")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def eve(make_user):
|
||||
"""Пользователь eve, не состоящий в чате."""
|
||||
return make_user("eve")
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def chat(make_chat, alice, bob):
|
||||
"""Чат alice и bob."""
|
||||
return make_chat(alice, bob)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def log_lines():
|
||||
"""Собрать сообщения лога приложения."""
|
||||
import logging
|
||||
|
||||
lines = []
|
||||
|
||||
class Collector(logging.Handler):
|
||||
def emit(self, record):
|
||||
lines.append(record.getMessage())
|
||||
|
||||
handler = Collector()
|
||||
logger = logging.getLogger("messenger")
|
||||
logger.addHandler(handler)
|
||||
yield lines
|
||||
logger.removeHandler(handler)
|
||||
|
||||
|
||||
def assert_error(reply, status: int, code: str):
|
||||
"""Проверить статус, код и формат тела ошибки."""
|
||||
assert reply.status_code == status, reply.text
|
||||
body = reply.json()
|
||||
assert set(body) == {"error"}
|
||||
assert set(body["error"]) == {"code", "message", "request_id"}
|
||||
assert body["error"]["code"] == code
|
||||
assert body["error"]["message"]
|
||||
assert body["error"]["request_id"] == reply.headers["X-Request-Id"]
|
||||
@@ -0,0 +1,193 @@
|
||||
"""Регистрация, вход по Basic, доступ по Bearer и выход."""
|
||||
|
||||
import base64
|
||||
import uuid
|
||||
|
||||
import pytest
|
||||
|
||||
from conftest import assert_error, basic_header, register_and_login
|
||||
|
||||
BAD_BASIC = [
|
||||
"Basic",
|
||||
"Basic !!!not-base64!!!",
|
||||
"Basic " + base64.b64encode(b"nocolon").decode(),
|
||||
"Basic " + base64.b64encode("имя:password-123456".encode()).decode(),
|
||||
"Basic " + base64.b64encode(b"user:\xff\xfe-bad-utf8").decode(),
|
||||
"Bearer abc",
|
||||
"",
|
||||
]
|
||||
|
||||
|
||||
def test_register_returns_user_without_secrets(client):
|
||||
reply = client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": "reg_" + uuid.uuid4().hex[:8],
|
||||
"display_name": "Имя",
|
||||
"password": "long-enough-pass",
|
||||
},
|
||||
)
|
||||
assert reply.status_code == 201
|
||||
assert set(reply.json()) == {"id", "username", "display_name", "created_at"}
|
||||
assert "password" not in reply.text and "hash" not in reply.text
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"password", [None, "", "short", "a" * 11, "a" * 129, 123456789012, "пароль"]
|
||||
)
|
||||
def test_register_password_rules(client, password):
|
||||
body = {"username": "pw_" + uuid.uuid4().hex[:8], "display_name": "x"}
|
||||
if password is not None:
|
||||
body["password"] = password
|
||||
assert_error(client.post("/api/v1/users", json=body), 400, "invalid_request")
|
||||
|
||||
|
||||
def test_register_password_border_lengths(client):
|
||||
for password in ["a" * 12, "я" * 128, "p:a:s:s:w:o:r:d:1:2:3"]:
|
||||
body = {
|
||||
"username": "pb_" + uuid.uuid4().hex[:8],
|
||||
"display_name": "x",
|
||||
"password": password,
|
||||
}
|
||||
assert client.post("/api/v1/users", json=body).status_code == 201
|
||||
|
||||
|
||||
def test_login_success_shape(client, alice):
|
||||
reply = client.post(
|
||||
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
|
||||
)
|
||||
assert reply.status_code == 201
|
||||
data = reply.json()
|
||||
assert set(data) == {"token", "token_type", "expires_at", "user"}
|
||||
assert data["token_type"] == "Bearer" and len(data["token"]) >= 32
|
||||
assert data["user"] == alice.data
|
||||
assert data["expires_at"].endswith("Z")
|
||||
|
||||
|
||||
def test_each_login_gives_new_token(client, alice):
|
||||
second = client.post(
|
||||
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
|
||||
).json()["token"]
|
||||
assert second != alice.token
|
||||
|
||||
|
||||
def test_wrong_password_and_unknown_user_look_the_same(client, alice):
|
||||
wrong = client.post(
|
||||
"/api/v1/auth/sessions",
|
||||
headers=basic_header(alice.username, "wrong-password-123"),
|
||||
)
|
||||
unknown = client.post(
|
||||
"/api/v1/auth/sessions",
|
||||
headers=basic_header("no_such_user_x", "wrong-password-123"),
|
||||
)
|
||||
assert_error(wrong, 401, "unauthorized")
|
||||
assert_error(unknown, 401, "unauthorized")
|
||||
assert wrong.headers["WWW-Authenticate"] == unknown.headers["WWW-Authenticate"]
|
||||
assert wrong.headers["WWW-Authenticate"].startswith('Basic realm="messenger"')
|
||||
assert wrong.json()["error"]["message"] == unknown.json()["error"]["message"]
|
||||
|
||||
|
||||
@pytest.mark.parametrize("header", BAD_BASIC)
|
||||
def test_malformed_basic_is_401(client, header):
|
||||
reply = client.post("/api/v1/auth/sessions", headers={"Authorization": header})
|
||||
assert_error(reply, 401, "unauthorized")
|
||||
assert reply.headers["WWW-Authenticate"].startswith("Basic")
|
||||
|
||||
|
||||
def test_login_without_header_is_401(client):
|
||||
assert_error(client.post("/api/v1/auth/sessions"), 401, "unauthorized")
|
||||
|
||||
|
||||
def test_password_with_colon_and_unicode_works(client):
|
||||
for password in ["pass:with:colons:123", "пароль-с-юникодом-😀-123"]:
|
||||
username = "uc_" + uuid.uuid4().hex[:8]
|
||||
client.post(
|
||||
"/api/v1/users",
|
||||
json={"username": username, "display_name": "x", "password": password},
|
||||
)
|
||||
reply = client.post(
|
||||
"/api/v1/auth/sessions", headers=basic_header(username, password)
|
||||
)
|
||||
assert reply.status_code == 201, password
|
||||
|
||||
|
||||
def test_bearer_token_gives_access(client, alice):
|
||||
reply = client.get("/api/v1/users/me", headers=alice.headers)
|
||||
assert reply.status_code == 200 and reply.json() == alice.data
|
||||
|
||||
|
||||
def test_business_endpoint_rejects_basic(client, alice):
|
||||
reply = client.get(
|
||||
"/api/v1/users/me", headers=basic_header(alice.username, alice.password)
|
||||
)
|
||||
assert_error(reply, 401, "unauthorized")
|
||||
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"header",
|
||||
["", "Bearer", "Bearer short", "Bearer " + "x" * 43, "Token abc", "bearer"],
|
||||
)
|
||||
def test_bad_or_unknown_bearer_is_401(client, header):
|
||||
headers = {"Authorization": header} if header else {}
|
||||
reply = client.get("/api/v1/users/me", headers=headers)
|
||||
assert_error(reply, 401, "unauthorized")
|
||||
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def test_x_user_id_alone_gives_no_access(client, alice):
|
||||
assert_error(
|
||||
client.get("/api/v1/users/me", headers={"X-User-Id": alice.id}),
|
||||
401,
|
||||
"unauthorized",
|
||||
)
|
||||
|
||||
|
||||
def test_x_user_id_does_not_change_owner_of_session(client, alice, bob):
|
||||
reply = client.get(
|
||||
"/api/v1/users/me", headers={**alice.headers, "X-User-Id": bob.id}
|
||||
)
|
||||
assert reply.json()["id"] == alice.id
|
||||
|
||||
|
||||
def test_logout_revokes_token_and_repeat_is_401(client, alice):
|
||||
first = client.delete("/api/v1/auth/sessions/current", headers=alice.headers)
|
||||
assert first.status_code == 204 and first.content == b""
|
||||
assert_error(
|
||||
client.get("/api/v1/users/me", headers=alice.headers), 401, "unauthorized"
|
||||
)
|
||||
assert_error(
|
||||
client.delete("/api/v1/auth/sessions/current", headers=alice.headers),
|
||||
401,
|
||||
"unauthorized",
|
||||
)
|
||||
|
||||
|
||||
def test_logout_without_token_is_401(client):
|
||||
assert_error(client.delete("/api/v1/auth/sessions/current"), 401, "unauthorized")
|
||||
|
||||
|
||||
def test_logout_revokes_only_current_session(client, alice):
|
||||
second = client.post(
|
||||
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
|
||||
).json()["token"]
|
||||
client.delete("/api/v1/auth/sessions/current", headers=alice.headers)
|
||||
assert (
|
||||
client.get(
|
||||
"/api/v1/users/me", headers={"Authorization": "Bearer " + second}
|
||||
).status_code
|
||||
== 200
|
||||
)
|
||||
|
||||
|
||||
def test_session_lives_longer_than_300_seconds(client, alice):
|
||||
"""Сессия по умолчанию живёт не меньше 300 секунд."""
|
||||
from datetime import datetime, timezone
|
||||
|
||||
data = client.post(
|
||||
"/api/v1/auth/sessions", headers=basic_header(alice.username, alice.password)
|
||||
).json()
|
||||
left = datetime.fromisoformat(data["expires_at"][:-1] + "+00:00") - datetime.now(
|
||||
timezone.utc
|
||||
)
|
||||
assert left.total_seconds() > 300
|
||||
@@ -0,0 +1,190 @@
|
||||
"""Кэш сессий в Redis: попадания, TTL, отзыв и недоступность Redis."""
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import time
|
||||
from dataclasses import replace
|
||||
|
||||
import pytest
|
||||
import redis
|
||||
from fastapi.testclient import TestClient
|
||||
from redis.asyncio import Redis as AsyncRedis
|
||||
|
||||
from app.main import create_app
|
||||
from conftest import CACHE_URL, assert_error, make_settings, register_and_login, run_sql
|
||||
|
||||
pytestmark = pytest.mark.skipif(
|
||||
not CACHE_URL, reason="TEST_CACHE_URL не задан (запускайте тесты в контейнере)"
|
||||
)
|
||||
|
||||
DEAD_REDIS = "redis://127.0.0.1:1/0"
|
||||
|
||||
|
||||
def key_for(person) -> str:
|
||||
"""Ключ Redis для токена пользователя."""
|
||||
return "session:" + hashlib.sha256(person.token.encode()).hexdigest()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def store():
|
||||
"""Синхронный клиент тестовой базы Redis."""
|
||||
client = redis.Redis.from_url(CACHE_URL, decode_responses=True)
|
||||
client.flushdb()
|
||||
yield client
|
||||
client.close()
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def cached(store):
|
||||
"""Клиент приложения с включённым кэшем."""
|
||||
with TestClient(create_app(make_settings()), raise_server_exceptions=False) as app_client:
|
||||
yield app_client
|
||||
|
||||
|
||||
def test_token_check_is_served_from_cache_with_bounded_ttl(cached, store):
|
||||
person = register_and_login(cached, "cache")
|
||||
stats = cached.app.state.cache.stats
|
||||
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
assert stats["misses"] == 1 and stats["hits"] == 0
|
||||
|
||||
ttl_ms = store.pttl(key_for(person))
|
||||
assert 0 < ttl_ms <= 60_000
|
||||
value = json.loads(store.get(key_for(person)))
|
||||
assert set(value) == {"id", "username", "display_name", "created_at"}
|
||||
assert (value["id"], value["username"]) == (person.id, person.username)
|
||||
|
||||
for _ in range(5):
|
||||
reply = cached.get("/api/v1/users/me", headers=person.headers)
|
||||
assert reply.status_code == 200 and reply.json() == person.data
|
||||
assert stats["hits"] == 5
|
||||
|
||||
|
||||
def test_cache_never_stores_raw_tokens_or_passwords(cached, store):
|
||||
person = register_and_login(cached, "secret")
|
||||
cached.get("/api/v1/users/me", headers=person.headers)
|
||||
dump = " ".join(k + "=" + (store.get(k) or "") for k in store.scan_iter())
|
||||
assert person.token not in dump
|
||||
assert person.password not in dump
|
||||
assert "scrypt" not in dump
|
||||
|
||||
|
||||
def test_logout_revokes_cached_session(cached, store):
|
||||
person = register_and_login(cached, "logout")
|
||||
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
assert store.get(key_for(person)) is not None
|
||||
|
||||
assert cached.delete("/api/v1/auth/sessions/current", headers=person.headers).status_code == 204
|
||||
assert store.get(key_for(person)) == "revoked"
|
||||
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
|
||||
assert_error(
|
||||
cached.delete("/api/v1/auth/sessions/current", headers=person.headers), 401, "unauthorized"
|
||||
)
|
||||
|
||||
|
||||
def test_late_cache_fill_cannot_resurrect_revoked_session(cached, store):
|
||||
"""Запоздалая запись в кэш не отменяет отзыв сессии."""
|
||||
person = register_and_login(cached, "race")
|
||||
cached.delete("/api/v1/auth/sessions/current", headers=person.headers)
|
||||
token_hash = hashlib.sha256(person.token.encode()).hexdigest()
|
||||
stale = {k: person.data[k] for k in ("id", "username", "display_name", "created_at")}
|
||||
cached.portal.call(cached.app.state.cache.put, token_hash, stale, 3600.0)
|
||||
assert store.get(key_for(person)) == "revoked"
|
||||
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
|
||||
|
||||
|
||||
def test_flushed_cache_loses_nothing(cached, store):
|
||||
"""После очистки Redis сессия читается из PostgreSQL."""
|
||||
person = register_and_login(cached, "flush")
|
||||
cached.get("/api/v1/users/me", headers=person.headers)
|
||||
store.flushdb()
|
||||
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
assert store.exists(key_for(person))
|
||||
|
||||
|
||||
def test_cache_does_not_extend_short_session():
|
||||
"""TTL записи в кэше не больше остатка сессии."""
|
||||
settings = make_settings(session_ttl_seconds=1)
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as short:
|
||||
person = register_and_login(short, "short")
|
||||
assert short.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
time.sleep(2.2)
|
||||
reply = short.get("/api/v1/users/me", headers=person.headers)
|
||||
assert_error(reply, 401, "unauthorized")
|
||||
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def test_staleness_after_out_of_band_delete_is_bounded_by_cache_ttl(store):
|
||||
"""Удаление сессии мимо API видно не позже CACHE_TTL_SECONDS."""
|
||||
settings = make_settings(cache_ttl_seconds=1)
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
person = register_and_login(app_client, "bounded")
|
||||
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
run_sql("DELETE FROM sessions WHERE token_hash = $1",
|
||||
hashlib.sha256(person.token.encode()).hexdigest())
|
||||
time.sleep(1.3)
|
||||
assert_error(app_client.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
|
||||
|
||||
|
||||
def test_redis_down_requests_bypass_cache_and_stay_fast():
|
||||
settings = make_settings(cache_url=DEAD_REDIS)
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
assert app_client.get("/health/ready").status_code == 200
|
||||
alice = register_and_login(app_client, "nocache_a")
|
||||
bob = register_and_login(app_client, "nocache_b")
|
||||
started = time.monotonic()
|
||||
assert app_client.get("/api/v1/users/me", headers=alice.headers).json() == alice.data
|
||||
chat = app_client.post(
|
||||
"/api/v1/chats", json={"title": "без кэша", "member_ids": [alice.id, bob.id]},
|
||||
headers=alice.headers,
|
||||
)
|
||||
assert chat.status_code == 201
|
||||
path = "/api/v1/chats/%s/messages" % chat.json()["id"]
|
||||
assert app_client.post(path, json={"text": "привет"}, headers=alice.headers).status_code == 201
|
||||
assert len(app_client.get(path, headers=bob.headers).json()["items"]) == 1
|
||||
assert time.monotonic() - started < 3
|
||||
assert app_client.app.state.cache.stats["errors"] >= 1
|
||||
|
||||
assert app_client.delete("/api/v1/auth/sessions/current", headers=alice.headers).status_code == 204
|
||||
assert_error(app_client.get("/api/v1/users/me", headers=alice.headers), 401, "unauthorized")
|
||||
|
||||
|
||||
def test_redis_down_never_trusts_anonymous_or_unknown_tokens():
|
||||
settings = make_settings(cache_url=DEAD_REDIS)
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
person = register_and_login(app_client, "anon")
|
||||
for headers in (
|
||||
{},
|
||||
{"X-User-Id": person.id},
|
||||
{"Authorization": "Bearer " + "B" * 43},
|
||||
{"Authorization": "Basic " + "eDp5"},
|
||||
):
|
||||
reply = app_client.get("/api/v1/users/me", headers=headers)
|
||||
assert_error(reply, 401, "unauthorized")
|
||||
|
||||
|
||||
def test_revocation_lost_while_redis_down_is_flushed_on_recovery(cached, store):
|
||||
"""Отзыв, потерянный при сбое Redis, приводит к очистке кэша."""
|
||||
cache = cached.app.state.cache
|
||||
person = register_and_login(cached, "lost")
|
||||
assert cached.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
assert store.exists(key_for(person))
|
||||
|
||||
working = cache.client
|
||||
cache.client = AsyncRedis.from_url(DEAD_REDIS, socket_connect_timeout=0.2, socket_timeout=0.2)
|
||||
cache.retry_seconds = 0
|
||||
assert cached.delete("/api/v1/auth/sessions/current", headers=person.headers).status_code == 204
|
||||
assert cache.dirty is True
|
||||
assert store.exists(key_for(person)), "старая запись осталась в Redis -- ровно опасный случай"
|
||||
|
||||
cache.client = working
|
||||
assert_error(cached.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
|
||||
assert cache.dirty is False
|
||||
assert not store.exists(key_for(person))
|
||||
|
||||
|
||||
def test_without_cache_url_cache_is_off():
|
||||
settings = replace(make_settings(), cache_url="")
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
assert app_client.app.state.cache.enabled is False
|
||||
person = register_and_login(app_client, "off")
|
||||
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
@@ -0,0 +1,61 @@
|
||||
"""Параллельная запись: сообщения не теряются и не дублируются."""
|
||||
|
||||
import threading
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
CLIENTS = 10
|
||||
PER_CLIENT = 10
|
||||
|
||||
|
||||
def test_100_messages_from_10_clients_in_parallel(client, make_user, make_chat):
|
||||
people = [make_user("c%d" % n) for n in range(CLIENTS)]
|
||||
chat = make_chat(people[0], *people[1:])
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
start_together = threading.Barrier(CLIENTS)
|
||||
|
||||
def worker(index):
|
||||
start_together.wait()
|
||||
return [
|
||||
client.post(
|
||||
url,
|
||||
json={"text": "c%d-m%d" % (index, n)},
|
||||
headers=people[index].headers,
|
||||
).status_code
|
||||
for n in range(PER_CLIENT)
|
||||
]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
results = list(pool.map(worker, range(CLIENTS)))
|
||||
assert all(code == 201 for codes in results for code in codes)
|
||||
|
||||
page = client.get(url + "?limit=100", headers=people[0].headers).json()
|
||||
items = page["items"]
|
||||
assert len(items) == 100 and page["next_cursor"] is None
|
||||
assert len({m["id"] for m in items}) == 100
|
||||
assert {m["text"] for m in items} == {
|
||||
"c%d-m%d" % (c, n) for c in range(CLIENTS) for n in range(PER_CLIENT)
|
||||
}
|
||||
stamps = [m["created_at"] for m in items]
|
||||
assert stamps == sorted(stamps)
|
||||
for index in range(CLIENTS):
|
||||
own = [m["text"] for m in items if m["sender_id"] == people[index].id]
|
||||
assert own == ["c%d-m%d" % (index, n) for n in range(PER_CLIENT)]
|
||||
|
||||
|
||||
def test_parallel_chat_creation_and_reading(client, make_user):
|
||||
owner, friend = make_user("owner"), make_user("friend")
|
||||
|
||||
def create(number):
|
||||
made = client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": "n%d" % number, "member_ids": [owner.id, friend.id]},
|
||||
headers=owner.headers,
|
||||
)
|
||||
listing = client.get("/api/v1/chats?limit=100", headers=friend.headers)
|
||||
return made.status_code, listing.status_code
|
||||
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
results = list(pool.map(create, range(30)))
|
||||
assert all(r == (201, 200) for r in results)
|
||||
final = client.get("/api/v1/chats?limit=100", headers=friend.headers).json()
|
||||
assert len(final["items"]) == 30 and len({c["id"] for c in final["items"]}) == 30
|
||||
@@ -0,0 +1,95 @@
|
||||
"""Общие свойства API: заголовки, формат ошибок, health и логи."""
|
||||
|
||||
import re
|
||||
|
||||
from conftest import assert_error
|
||||
|
||||
|
||||
def test_health_endpoints(client):
|
||||
assert client.get("/health/live").json() == {"status": "ok"}
|
||||
assert client.get("/health/ready").json() == {"status": "ok"}
|
||||
|
||||
|
||||
def test_every_response_has_unique_request_id(client, alice):
|
||||
seen = set()
|
||||
for reply in [
|
||||
client.get("/health/live"),
|
||||
client.get("/health/ready"),
|
||||
client.get("/api/v1/users/me", headers=alice.headers),
|
||||
client.get("/api/v1/users/me"),
|
||||
client.get("/no/such/page"),
|
||||
client.delete("/api/v1/chats"),
|
||||
]:
|
||||
assert reply.headers.get("X-Request-Id")
|
||||
seen.add(reply.headers["X-Request-Id"])
|
||||
assert len(seen) == 6
|
||||
|
||||
|
||||
def test_unknown_path_is_404_in_common_format(client):
|
||||
assert_error(client.get("/api/v1/nothing"), 404, "not_found")
|
||||
|
||||
|
||||
def test_trailing_slash_is_not_redirected(client, alice):
|
||||
assert_error(
|
||||
client.get("/api/v1/chats/", headers=alice.headers, follow_redirects=False),
|
||||
404,
|
||||
"not_found",
|
||||
)
|
||||
|
||||
|
||||
def test_wrong_method_is_405_in_common_format(client):
|
||||
assert_error(client.delete("/api/v1/users"), 405, "invalid_request")
|
||||
|
||||
|
||||
def test_two_users_one_chat_two_messages(client, alice, bob, eve, chat):
|
||||
"""Двое переписываются, посторонний получает 404."""
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert (
|
||||
client.post(
|
||||
url, json={"text": "Привет, Боб!"}, headers=alice.headers
|
||||
).status_code
|
||||
== 201
|
||||
)
|
||||
assert (
|
||||
client.post(
|
||||
url, json={"text": "Привет, Алиса!"}, headers=bob.headers
|
||||
).status_code
|
||||
== 201
|
||||
)
|
||||
history = client.get(url, headers=alice.headers).json()["items"]
|
||||
assert [m["text"] for m in history] == ["Привет, Боб!", "Привет, Алиса!"]
|
||||
assert [m["sender_id"] for m in history] == [alice.id, bob.id]
|
||||
assert client.get(url, headers=eve.headers).status_code == 404
|
||||
|
||||
|
||||
def test_chat_response_shape(client, alice, bob, chat):
|
||||
assert set(chat) == {"id", "title", "member_ids", "created_at"}
|
||||
assert set(chat["member_ids"]) == {alice.id, bob.id}
|
||||
assert re.fullmatch(r"\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{6}Z", chat["created_at"])
|
||||
assert client.get("/api/v1/chats/" + chat["id"], headers=bob.headers).json() == chat
|
||||
|
||||
|
||||
def test_unexpected_exception_gives_500_without_details(client, log_lines):
|
||||
async def boom():
|
||||
raise RuntimeError("ТАЙНЫЙ-ТЕКСТ-ИЗ-ОШИБКИ")
|
||||
|
||||
client.app.add_api_route("/boom", boom)
|
||||
reply = client.get("/boom")
|
||||
assert_error(reply, 500, "internal_error")
|
||||
assert "ТАЙНЫЙ" not in reply.text
|
||||
assert not any("ТАЙНЫЙ" in line for line in log_lines)
|
||||
assert any("unhandled_error" in line for line in log_lines)
|
||||
|
||||
|
||||
def test_logs_have_requests_but_no_secrets(client, alice, chat, log_lines):
|
||||
"""В логе есть запросы, но нет текста сообщений, паролей и токенов."""
|
||||
secret = "ОЧЕНЬ-СЕКРЕТНОЕ-СООБЩЕНИЕ-12345"
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
client.post(url, json={"text": secret}, headers=alice.headers)
|
||||
client.get(url, headers=alice.headers)
|
||||
joined = "\n".join(log_lines)
|
||||
assert (
|
||||
"method=POST" in joined and "status=201" in joined and "request_id=" in joined
|
||||
)
|
||||
for hidden in (secret, alice.token, alice.password):
|
||||
assert hidden not in joined
|
||||
@@ -0,0 +1,172 @@
|
||||
"""Содержимое PostgreSQL: хеши, ограничения, миграции и атомарность."""
|
||||
|
||||
import asyncio
|
||||
import uuid
|
||||
|
||||
import asyncpg
|
||||
import pytest
|
||||
|
||||
from app.db import create_engine
|
||||
from app.migrate import run_migrations
|
||||
from conftest import make_settings, run_sql
|
||||
|
||||
|
||||
def test_password_is_stored_as_scrypt_hash_not_plaintext(client, make_user):
|
||||
one, two = make_user("hash1"), make_user("hash2")
|
||||
rows = run_sql(
|
||||
"SELECT username, password_hash FROM users WHERE username = ANY($1)",
|
||||
[one.username, two.username],
|
||||
)
|
||||
hashes = {row["username"]: row["password_hash"] for row in rows}
|
||||
assert hashes[one.username].startswith("scrypt$")
|
||||
assert one.password not in hashes[one.username]
|
||||
assert hashes[one.username] != hashes[two.username]
|
||||
|
||||
|
||||
def test_same_password_gives_different_hashes(client):
|
||||
password = "same-password-for-both"
|
||||
for _ in range(2):
|
||||
client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": "sp_" + uuid.uuid4().hex[:10],
|
||||
"display_name": "x",
|
||||
"password": password,
|
||||
},
|
||||
)
|
||||
rows = run_sql("SELECT password_hash FROM users ORDER BY created_at DESC LIMIT 2")
|
||||
assert rows[0]["password_hash"] != rows[1]["password_hash"]
|
||||
|
||||
|
||||
def test_session_table_keeps_token_hash_not_token(client, alice):
|
||||
rows = run_sql(
|
||||
"SELECT token_hash FROM sessions WHERE user_id = $1", uuid.UUID(alice.id)
|
||||
)
|
||||
assert len(rows) == 1
|
||||
assert len(rows[0]["token_hash"]) == 64 and rows[0]["token_hash"] != alice.token
|
||||
assert alice.token not in rows[0]["token_hash"]
|
||||
|
||||
|
||||
def test_message_is_really_in_the_database(client, alice, chat):
|
||||
client.post(
|
||||
"/api/v1/chats/" + chat["id"] + "/messages",
|
||||
json={"text": "в базе"},
|
||||
headers=alice.headers,
|
||||
)
|
||||
rows = run_sql(
|
||||
"SELECT text, sender_id FROM messages WHERE chat_id = $1", uuid.UUID(chat["id"])
|
||||
)
|
||||
assert [(r["text"], str(r["sender_id"])) for r in rows] == [("в базе", alice.id)]
|
||||
|
||||
|
||||
def test_migrations_can_run_again_without_duplicating_anything(client, alice):
|
||||
users_before = run_sql("SELECT count(*) AS n FROM users")[0]["n"]
|
||||
versions_before = [
|
||||
r["version"]
|
||||
for r in run_sql("SELECT version FROM schema_migrations ORDER BY version")
|
||||
]
|
||||
|
||||
async def twice():
|
||||
engine = create_engine(make_settings())
|
||||
try:
|
||||
return [await run_migrations(engine), await run_migrations(engine)]
|
||||
finally:
|
||||
await engine.dispose()
|
||||
|
||||
first, second = asyncio.run(twice())
|
||||
assert first == [] and second == []
|
||||
assert run_sql("SELECT count(*) AS n FROM users")[0]["n"] == users_before
|
||||
assert [
|
||||
r["version"]
|
||||
for r in run_sql("SELECT version FROM schema_migrations ORDER BY version")
|
||||
] == versions_before
|
||||
assert versions_before == ["0001_init.sql"]
|
||||
|
||||
|
||||
def test_expected_tables_and_indexes_exist(client):
|
||||
tables = {
|
||||
r["tablename"]
|
||||
for r in run_sql("SELECT tablename FROM pg_tables WHERE schemaname = 'public'")
|
||||
}
|
||||
assert {
|
||||
"users",
|
||||
"chats",
|
||||
"chat_members",
|
||||
"messages",
|
||||
"sessions",
|
||||
"schema_migrations",
|
||||
} <= tables
|
||||
indexes = {
|
||||
r["indexname"]
|
||||
for r in run_sql("SELECT indexname FROM pg_indexes WHERE schemaname = 'public'")
|
||||
}
|
||||
assert "messages_chat_created_idx" in indexes
|
||||
|
||||
|
||||
def count_constraints(table: str, kind: str) -> int:
|
||||
"""Число ограничений заданного типа у таблицы."""
|
||||
rows = run_sql(
|
||||
"SELECT count(*) AS n FROM pg_constraint WHERE conrelid = $1::regclass AND contype::text = $2",
|
||||
table,
|
||||
kind,
|
||||
)
|
||||
return rows[0]["n"]
|
||||
|
||||
|
||||
def test_primary_and_foreign_keys_are_declared(client):
|
||||
for table in ("users", "chats", "chat_members", "messages", "sessions"):
|
||||
assert count_constraints(table, "p") == 1, table
|
||||
assert count_constraints("users", "u") == 1
|
||||
assert count_constraints("chat_members", "f") == 2
|
||||
assert count_constraints("messages", "f") == 2
|
||||
assert count_constraints("sessions", "f") == 1
|
||||
|
||||
|
||||
def test_database_itself_rejects_bad_rows(client, alice, chat):
|
||||
chat_id, user_id = uuid.UUID(chat["id"]), uuid.UUID(alice.id)
|
||||
with pytest.raises(asyncpg.ForeignKeyViolationError):
|
||||
run_sql(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, 'x')",
|
||||
uuid.uuid4(),
|
||||
uuid.uuid4(),
|
||||
user_id,
|
||||
)
|
||||
with pytest.raises(asyncpg.CheckViolationError):
|
||||
run_sql(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, '')",
|
||||
uuid.uuid4(),
|
||||
chat_id,
|
||||
user_id,
|
||||
)
|
||||
with pytest.raises(asyncpg.UniqueViolationError):
|
||||
run_sql(
|
||||
"INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)",
|
||||
chat_id,
|
||||
user_id,
|
||||
)
|
||||
with pytest.raises(asyncpg.CheckViolationError):
|
||||
run_sql(
|
||||
"INSERT INTO users (id, username, display_name, password_hash) VALUES ($1, 'BadName', 'x', 'h')",
|
||||
uuid.uuid4(),
|
||||
)
|
||||
|
||||
|
||||
def test_chat_creation_is_atomic(client, alice):
|
||||
"""Неизвестный участник: ни чата, ни участников в БД."""
|
||||
title = "atomic-" + uuid.uuid4().hex
|
||||
reply = client.post(
|
||||
"/api/v1/chats",
|
||||
json={"title": title, "member_ids": [alice.id, str(uuid.uuid4())]},
|
||||
headers=alice.headers,
|
||||
)
|
||||
assert reply.status_code == 400
|
||||
assert (
|
||||
run_sql("SELECT count(*) AS n FROM chats WHERE title = $1", title)[0]["n"] == 0
|
||||
)
|
||||
|
||||
|
||||
def test_successful_chat_has_all_members_in_database(client, alice, bob, chat):
|
||||
rows = run_sql(
|
||||
"SELECT user_id FROM chat_members WHERE chat_id = $1", uuid.UUID(chat["id"])
|
||||
)
|
||||
assert {str(r["user_id"]) for r in rows} == {alice.id, bob.id}
|
||||
@@ -0,0 +1,77 @@
|
||||
"""Недоступная БД: ответ 503 и отказ анонимным запросам."""
|
||||
|
||||
from dataclasses import replace
|
||||
|
||||
import pytest
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.db import create_engine, create_sessionmaker
|
||||
from app.main import create_app
|
||||
from conftest import CACHE_URL, assert_error, make_settings, register_and_login
|
||||
|
||||
|
||||
def test_database_down_gives_503_and_never_trusts_anyone():
|
||||
settings = make_settings(cache_url="")
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
person = register_and_login(app_client, "down")
|
||||
assert (
|
||||
app_client.get("/api/v1/users/me", headers=person.headers).status_code
|
||||
== 200
|
||||
)
|
||||
|
||||
dead = replace(
|
||||
settings,
|
||||
database_url="postgresql+asyncpg://x:y@127.0.0.1:1/none",
|
||||
db_pool_timeout=1,
|
||||
)
|
||||
app_client.app.state.sessionmaker = create_sessionmaker(create_engine(dead))
|
||||
|
||||
assert app_client.get("/health/live").status_code == 200
|
||||
assert_error(app_client.get("/health/ready"), 503, "unavailable")
|
||||
assert_error(
|
||||
app_client.get("/api/v1/users/me", headers=person.headers),
|
||||
503,
|
||||
"unavailable",
|
||||
)
|
||||
assert_error(
|
||||
app_client.post(
|
||||
"/api/v1/users",
|
||||
json={
|
||||
"username": "abcdef",
|
||||
"display_name": "x",
|
||||
"password": "long-enough-password",
|
||||
},
|
||||
),
|
||||
503,
|
||||
"unavailable",
|
||||
)
|
||||
reply = app_client.get("/api/v1/chats")
|
||||
assert reply.status_code in (401, 503) and reply.status_code != 200
|
||||
|
||||
|
||||
def test_database_down_with_cache_up_still_needs_database_for_data():
|
||||
"""При живом Redis операции с данными без БД всё равно дают 503."""
|
||||
if not CACHE_URL:
|
||||
pytest.skip("TEST_CACHE_URL не задан (тест для контейнера с Redis)")
|
||||
settings = make_settings()
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
person = register_and_login(app_client, "down_cache")
|
||||
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
|
||||
dead = replace(
|
||||
settings,
|
||||
database_url="postgresql+asyncpg://x:y@127.0.0.1:1/none",
|
||||
db_pool_timeout=1,
|
||||
)
|
||||
app_client.app.state.sessionmaker = create_sessionmaker(create_engine(dead))
|
||||
|
||||
assert_error(app_client.get("/health/ready"), 503, "unavailable")
|
||||
assert_error(app_client.get("/api/v1/chats", headers=person.headers), 503, "unavailable")
|
||||
assert_error(
|
||||
app_client.post("/api/v1/chats", json={"title": "x", "member_ids": [person.id]},
|
||||
headers=person.headers),
|
||||
503, "unavailable",
|
||||
)
|
||||
assert_error(app_client.get("/api/v1/chats"), 401, "unauthorized")
|
||||
unknown = {"Authorization": "Bearer " + "A" * 43}
|
||||
assert app_client.get("/api/v1/users/me", headers=unknown).status_code == 503
|
||||
@@ -0,0 +1,45 @@
|
||||
"""Повторный username: 409, в том числе при одновременной регистрации."""
|
||||
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from conftest import assert_error, run_sql
|
||||
|
||||
|
||||
def body(username: str, display_name: str = "Имя") -> dict:
|
||||
"""Тело регистрации."""
|
||||
return {"username": username, "display_name": display_name, "password": "long-enough-password"}
|
||||
|
||||
|
||||
def test_second_registration_with_same_username_is_409(client):
|
||||
name = "dup_" + uuid.uuid4().hex[:10]
|
||||
assert client.post("/api/v1/users", json=body(name)).status_code == 201
|
||||
assert_error(client.post("/api/v1/users", json=body(name, "Другое имя")), 409, "conflict")
|
||||
|
||||
|
||||
def test_duplicate_does_not_replace_original_user(client):
|
||||
name = "dup_" + uuid.uuid4().hex[:10]
|
||||
first = client.post("/api/v1/users", json=body(name, "Первый")).json()
|
||||
client.post("/api/v1/users", json=body(name, "Второй"))
|
||||
rows = run_sql("SELECT display_name FROM users WHERE username = $1", name)
|
||||
assert [row["display_name"] for row in rows] == ["Первый"]
|
||||
assert first["display_name"] == "Первый"
|
||||
|
||||
|
||||
def test_username_is_case_sensitive_lowercase_only(client):
|
||||
name = "dup_" + uuid.uuid4().hex[:10]
|
||||
assert client.post("/api/v1/users", json=body(name)).status_code == 201
|
||||
assert_error(client.post("/api/v1/users", json=body(name.upper())), 400, "invalid_request")
|
||||
|
||||
|
||||
def test_parallel_registration_of_same_username_creates_exactly_one(client):
|
||||
name = "race_" + uuid.uuid4().hex[:10]
|
||||
|
||||
def register(_):
|
||||
return client.post("/api/v1/users", json=body(name)).status_code
|
||||
|
||||
with ThreadPoolExecutor(max_workers=10) as pool:
|
||||
codes = list(pool.map(register, range(10)))
|
||||
assert codes.count(201) == 1
|
||||
assert codes.count(409) == 9
|
||||
assert len(run_sql("SELECT 1 FROM users WHERE username = $1", name)) == 1
|
||||
@@ -0,0 +1,73 @@
|
||||
"""Текст сообщения: пустые строки, длина и Unicode."""
|
||||
|
||||
import pytest
|
||||
|
||||
from conftest import assert_error
|
||||
|
||||
|
||||
@pytest.mark.parametrize("text", ["", " ", " ", "\n", "\t \n", " ", " "])
|
||||
def test_blank_text_is_rejected(client, alice, chat, text):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert_error(
|
||||
client.post(url, json={"text": text}, headers=alice.headers),
|
||||
400,
|
||||
"invalid_request",
|
||||
)
|
||||
assert client.get(url, headers=alice.headers).json()["items"] == []
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body", [{}, {"text": None}, {"text": 123}, {"text": ["a"]}, {"message": "hi"}]
|
||||
)
|
||||
def test_missing_or_wrong_type_text_is_rejected(client, alice, chat, body):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert_error(
|
||||
client.post(url, json=body, headers=alice.headers), 400, "invalid_request"
|
||||
)
|
||||
|
||||
|
||||
def test_text_length_is_counted_in_characters(client, alice, chat):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert (
|
||||
client.post(url, json={"text": "я" * 4000}, headers=alice.headers).status_code
|
||||
== 201
|
||||
)
|
||||
assert (
|
||||
client.post(url, json={"text": "😀" * 4000}, headers=alice.headers).status_code
|
||||
== 201
|
||||
)
|
||||
assert_error(
|
||||
client.post(url, json={"text": "я" * 4001}, headers=alice.headers),
|
||||
400,
|
||||
"invalid_request",
|
||||
)
|
||||
|
||||
|
||||
def test_nul_character_is_400_not_500(client, alice, chat):
|
||||
"""Символ NUL отклоняется с 400."""
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert_error(
|
||||
client.post(url, json={"text": "a\x00b"}, headers=alice.headers),
|
||||
400,
|
||||
"invalid_request",
|
||||
)
|
||||
|
||||
|
||||
def test_unicode_survives_the_database(client, alice, bob, chat):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
text = " Привет, мир 👋 你好 ✓ é "
|
||||
sent = client.post(url, json={"text": text}, headers=alice.headers)
|
||||
assert sent.status_code == 201 and sent.json()["text"] == text
|
||||
assert client.get(url, headers=bob.headers).json()["items"][0]["text"] == text
|
||||
assert sent.headers["content-type"].split(";")[0] == "application/json"
|
||||
|
||||
|
||||
def test_message_has_correct_fields(client, alice, chat):
|
||||
data = client.post(
|
||||
"/api/v1/chats/" + chat["id"] + "/messages",
|
||||
json={"text": "hi"},
|
||||
headers=alice.headers,
|
||||
).json()
|
||||
assert set(data) == {"id", "chat_id", "sender_id", "text", "created_at"}
|
||||
assert data["chat_id"] == chat["id"] and data["sender_id"] == alice.id
|
||||
assert data["created_at"].endswith("Z")
|
||||
@@ -0,0 +1,52 @@
|
||||
"""План запроса истории на 10 000 сообщениях: индекс без полного сканирования."""
|
||||
|
||||
import asyncio
|
||||
|
||||
import asyncpg
|
||||
import pytest
|
||||
|
||||
from app import explain
|
||||
from app.crud import history_query
|
||||
from conftest import database_parts, make_settings, TEST_DB_NAME
|
||||
from app.db import create_engine
|
||||
|
||||
|
||||
def plan_for(cursor_offset):
|
||||
"""Заполнить данные и вернуть число сообщений и план запроса страницы."""
|
||||
p = database_parts()
|
||||
|
||||
async def go():
|
||||
conn = await asyncpg.connect(database=TEST_DB_NAME, timeout=5, **p)
|
||||
try:
|
||||
await explain.seed(conn, 30000)
|
||||
count = await conn.fetchval(
|
||||
"SELECT count(*) FROM messages WHERE chat_id = $1", explain.BIG_CHAT
|
||||
)
|
||||
after = None
|
||||
if cursor_offset:
|
||||
row = await conn.fetchrow(
|
||||
"SELECT created_at, id FROM messages WHERE chat_id = $1"
|
||||
" ORDER BY created_at, id OFFSET $2 LIMIT 1",
|
||||
explain.BIG_CHAT, cursor_offset,
|
||||
)
|
||||
after = (row["created_at"], row["id"])
|
||||
engine = create_engine(make_settings())
|
||||
query = history_query(explain.BIG_CHAT, after, 50).compile(dialect=engine.dialect)
|
||||
await engine.dispose()
|
||||
params = [query.params[name] for name in query.positiontup]
|
||||
rows = await conn.fetch("EXPLAIN (ANALYZE, BUFFERS) " + query.string, *params)
|
||||
return count, "\n".join(r[0] for r in rows)
|
||||
finally:
|
||||
await conn.close()
|
||||
|
||||
return asyncio.run(go())
|
||||
|
||||
|
||||
@pytest.mark.parametrize("cursor_offset", [0, 9000])
|
||||
def test_history_page_uses_index_without_full_scan(cursor_offset):
|
||||
count, plan = plan_for(cursor_offset)
|
||||
assert count >= 10000
|
||||
assert "Index Scan using messages_chat_created_idx" in plan, plan
|
||||
assert "Seq Scan" not in plan, plan
|
||||
assert "Sort" not in plan, plan
|
||||
assert "rows=51 loops=1" in plan, plan
|
||||
@@ -0,0 +1,65 @@
|
||||
"""Доступ к чужому чату: 404 для посторонних, 401 без токена."""
|
||||
|
||||
import uuid
|
||||
|
||||
from conftest import assert_error
|
||||
|
||||
|
||||
def test_outsider_cannot_read_chat(client, eve, chat):
|
||||
assert_error(client.get("/api/v1/chats/" + chat["id"], headers=eve.headers), 404, "not_found")
|
||||
|
||||
|
||||
def test_outsider_cannot_read_history(client, alice, eve, chat):
|
||||
client.post("/api/v1/chats/" + chat["id"] + "/messages", json={"text": "секрет"}, headers=alice.headers)
|
||||
reply = client.get("/api/v1/chats/" + chat["id"] + "/messages", headers=eve.headers)
|
||||
assert_error(reply, 404, "not_found")
|
||||
assert "секрет" not in reply.text
|
||||
|
||||
|
||||
def test_outsider_cannot_write(client, alice, eve, chat):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert_error(client.post(url, json={"text": "чужое"}, headers=eve.headers), 404, "not_found")
|
||||
assert client.get(url, headers=alice.headers).json()["items"] == []
|
||||
|
||||
|
||||
def test_outsider_gets_404_even_with_bad_body(client, eve, chat):
|
||||
"""Проверка доступа выполняется раньше проверки тела."""
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert_error(client.post(url, json={"text": ""}, headers=eve.headers), 404, "not_found")
|
||||
|
||||
|
||||
def test_unknown_chat_looks_the_same_as_foreign(client, eve, chat):
|
||||
foreign = client.get("/api/v1/chats/" + chat["id"], headers=eve.headers)
|
||||
missing = client.get("/api/v1/chats/" + str(uuid.uuid4()), headers=eve.headers)
|
||||
assert foreign.status_code == missing.status_code == 404
|
||||
assert foreign.json()["error"]["message"] == missing.json()["error"]["message"]
|
||||
|
||||
|
||||
def test_chat_list_shows_only_own_chats(client, bob, eve, chat):
|
||||
mine = client.get("/api/v1/chats", headers=bob.headers).json()["items"]
|
||||
others = client.get("/api/v1/chats", headers=eve.headers).json()["items"]
|
||||
assert [c["id"] for c in mine] == [chat["id"]]
|
||||
assert others == []
|
||||
|
||||
|
||||
def test_bad_chat_id_is_400(client, alice):
|
||||
assert_error(client.get("/api/v1/chats/not-a-uuid", headers=alice.headers), 400, "invalid_request")
|
||||
|
||||
|
||||
def test_no_token_is_401_everywhere(client, chat):
|
||||
chat_url = "/api/v1/chats/" + chat["id"]
|
||||
for url in ["/api/v1/users/me", "/api/v1/chats", chat_url, chat_url + "/messages"]:
|
||||
assert_error(client.get(url), 401, "unauthorized")
|
||||
assert_error(client.post("/api/v1/chats", json={"title": "x", "member_ids": []}), 401, "unauthorized")
|
||||
assert_error(client.post(chat_url + "/messages", json={"text": "x"}), 401, "unauthorized")
|
||||
|
||||
|
||||
def test_401_comes_before_404(client, chat):
|
||||
"""Без токена существование чата не раскрывается."""
|
||||
assert_error(client.get("/api/v1/chats/" + chat["id"] + "/messages"), 401, "unauthorized")
|
||||
|
||||
|
||||
def test_member_can_read_and_write(client, alice, bob, chat):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
assert client.post(url, json={"text": "от Боба"}, headers=bob.headers).status_code == 201
|
||||
assert client.get(url, headers=alice.headers).json()["items"][0]["text"] == "от Боба"
|
||||
@@ -0,0 +1,115 @@
|
||||
"""Некорректный JSON и поля: 400, 413 и 415."""
|
||||
|
||||
import uuid
|
||||
|
||||
import pytest
|
||||
|
||||
from conftest import assert_error
|
||||
|
||||
JSON = {"Content-Type": "application/json"}
|
||||
PASSWORD = "long-enough-password"
|
||||
|
||||
|
||||
def valid(**changes) -> dict:
|
||||
"""Корректное тело регистрации с изменёнными полями."""
|
||||
body = {"username": "j_" + uuid.uuid4().hex[:10], "display_name": "Имя", "password": PASSWORD}
|
||||
body.update(changes)
|
||||
return {key: value for key, value in body.items() if value is not None}
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"raw",
|
||||
[
|
||||
b"{",
|
||||
b"not json at all",
|
||||
b"",
|
||||
b'{"username": "abc",}',
|
||||
b"\xff\xfe\x00",
|
||||
b'{"username": NaN}',
|
||||
b'["username"]',
|
||||
b'"text"',
|
||||
b"null",
|
||||
],
|
||||
)
|
||||
def test_registration_rejects_broken_json(client, raw):
|
||||
assert_error(client.post("/api/v1/users", content=raw, headers=JSON), 400, "invalid_request")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"changes",
|
||||
[
|
||||
{"username": None},
|
||||
{"display_name": None},
|
||||
{"password": None},
|
||||
{"username": 123},
|
||||
{"display_name": 5},
|
||||
{"display_name": None, "extra_field": 1},
|
||||
{"role": "admin"},
|
||||
{"username": "ab"},
|
||||
{"username": "a" * 33},
|
||||
{"username": "Alice"},
|
||||
{"username": "al ice"},
|
||||
{"username": "алиса"},
|
||||
{"username": "alice\n"},
|
||||
{"display_name": ""},
|
||||
{"display_name": " "},
|
||||
{"display_name": "я" * 101},
|
||||
{"display_name": "a\x00b"},
|
||||
],
|
||||
)
|
||||
def test_registration_rejects_bad_fields(client, changes):
|
||||
assert_error(client.post("/api/v1/users", json=valid(**changes)), 400, "invalid_request")
|
||||
|
||||
|
||||
def test_border_values_are_accepted(client):
|
||||
assert client.post("/api/v1/users", json=valid(display_name="я" * 100)).status_code == 201
|
||||
assert client.post("/api/v1/users", json=valid(username=uuid.uuid4().hex, display_name="😀")).status_code == 201
|
||||
|
||||
|
||||
def test_lone_surrogate_is_400_not_500(client):
|
||||
raw = b'{"username": "abcdef", "display_name": "\\ud800", "password": "long-enough-password"}'
|
||||
assert_error(client.post("/api/v1/users", content=raw, headers=JSON), 400, "invalid_request")
|
||||
|
||||
|
||||
def test_wrong_or_missing_content_type_is_415(client):
|
||||
body = b'{"username":"abc","display_name":"x","password":"long-enough-password"}'
|
||||
assert_error(client.post("/api/v1/users", content=body, headers={"Content-Type": "text/plain"}), 415, "unsupported_media_type")
|
||||
assert_error(client.post("/api/v1/users", content=body), 415, "unsupported_media_type")
|
||||
|
||||
|
||||
def test_huge_body_is_413(client):
|
||||
big = b'{"username": "abc", "display_name": "' + b"x" * (300 * 1024) + b'"}'
|
||||
assert_error(client.post("/api/v1/users", content=big, headers=JSON), 413, "payload_too_large")
|
||||
|
||||
|
||||
def test_broken_json_in_message_and_chat(client, alice, chat):
|
||||
headers = {**JSON, **alice.headers}
|
||||
assert_error(client.post("/api/v1/chats/" + chat["id"] + "/messages", content=b"{oops", headers=headers), 400, "invalid_request")
|
||||
assert_error(client.post("/api/v1/chats", content=b"[", headers=headers), 400, "invalid_request")
|
||||
|
||||
|
||||
def test_sender_id_in_message_is_rejected(client, alice, bob, chat):
|
||||
"""Поле sender_id в теле сообщения запрещено."""
|
||||
reply = client.post(
|
||||
"/api/v1/chats/" + chat["id"] + "/messages", json={"text": "привет", "sender_id": bob.id}, headers=alice.headers
|
||||
)
|
||||
assert_error(reply, 400, "invalid_request")
|
||||
|
||||
|
||||
def test_chat_body_validation(client, alice, bob):
|
||||
unknown = str(uuid.uuid4())
|
||||
cases = [
|
||||
{"title": "x", "member_ids": []},
|
||||
{"title": "", "member_ids": [alice.id]},
|
||||
{"title": " ", "member_ids": [alice.id]},
|
||||
{"title": "x" * 101, "member_ids": [alice.id]},
|
||||
{"title": "x", "member_ids": [alice.id, alice.id]},
|
||||
{"title": "x", "member_ids": [alice.id, unknown]},
|
||||
{"title": "x", "member_ids": [bob.id]},
|
||||
{"title": "x", "member_ids": ["не-uuid"]},
|
||||
{"title": "x", "member_ids": alice.id},
|
||||
{"title": "x"},
|
||||
{"title": "x", "member_ids": [alice.id], "extra": 1},
|
||||
]
|
||||
for body in cases:
|
||||
assert_error(client.post("/api/v1/chats", json=body, headers=alice.headers), 400, "invalid_request")
|
||||
@@ -0,0 +1,170 @@
|
||||
"""Пагинация истории и списка чатов по keyset-курсору."""
|
||||
|
||||
from urllib.parse import quote
|
||||
|
||||
from conftest import assert_error
|
||||
|
||||
|
||||
def send_many(client, person, chat, count, prefix="msg"):
|
||||
"""Отправить несколько сообщений в чат."""
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
for number in range(count):
|
||||
reply = client.post(
|
||||
url, json={"text": "%s-%02d" % (prefix, number)}, headers=person.headers
|
||||
)
|
||||
assert reply.status_code == 201
|
||||
|
||||
|
||||
def walk(client, person, chat, limit):
|
||||
"""Пройти историю страницами; вернуть элементы и число страниц."""
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
items, pages, cursor = [], 0, None
|
||||
while True:
|
||||
query = "?limit=%d" % limit + (
|
||||
"&cursor=" + quote(cursor, safe="") if cursor else ""
|
||||
)
|
||||
data = client.get(url + query, headers=person.headers).json()
|
||||
assert set(data) == {"items", "next_cursor"} and len(data["items"]) <= limit
|
||||
items += data["items"]
|
||||
pages += 1
|
||||
cursor = data["next_cursor"]
|
||||
if cursor is None:
|
||||
return items, pages
|
||||
assert pages < 1000, "бесконечный обход"
|
||||
|
||||
|
||||
def test_walk_25_messages_by_7(client, alice, bob, chat):
|
||||
send_many(client, alice, chat, 25)
|
||||
items, pages = walk(client, bob, chat, 7)
|
||||
assert pages == 4
|
||||
assert [m["text"] for m in items] == ["msg-%02d" % n for n in range(25)]
|
||||
assert len({m["id"] for m in items}) == 25
|
||||
|
||||
|
||||
def test_exact_multiple_has_no_empty_extra_page(client, alice, chat):
|
||||
send_many(client, alice, chat, 10)
|
||||
items, pages = walk(client, alice, chat, 5)
|
||||
assert len(items) == 10 and pages == 2
|
||||
|
||||
|
||||
def test_limit_one_walks_everything(client, alice, chat):
|
||||
send_many(client, alice, chat, 6)
|
||||
items, pages = walk(client, alice, chat, 1)
|
||||
assert len(items) == 6 and pages == 6
|
||||
|
||||
|
||||
def test_default_limit_is_50_and_max_is_100(client, alice, chat):
|
||||
send_many(client, alice, chat, 120)
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
default = client.get(url, headers=alice.headers).json()
|
||||
assert len(default["items"]) == 50 and default["next_cursor"]
|
||||
biggest = client.get(url + "?limit=100", headers=alice.headers).json()
|
||||
assert len(biggest["items"]) == 100 and biggest["next_cursor"]
|
||||
|
||||
|
||||
def test_empty_history(client, alice, chat):
|
||||
data = client.get(
|
||||
"/api/v1/chats/" + chat["id"] + "/messages", headers=alice.headers
|
||||
).json()
|
||||
assert data == {"items": [], "next_cursor": None}
|
||||
|
||||
|
||||
def test_limit_can_change_between_pages(client, alice, chat):
|
||||
send_many(client, alice, chat, 9)
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
first = client.get(url + "?limit=2", headers=alice.headers).json()
|
||||
second = client.get(
|
||||
url + "?limit=100&cursor=" + quote(first["next_cursor"], safe=""),
|
||||
headers=alice.headers,
|
||||
).json()
|
||||
assert [m["text"] for m in first["items"] + second["items"]] == [
|
||||
"msg-%02d" % n for n in range(9)
|
||||
]
|
||||
assert second["next_cursor"] is None
|
||||
|
||||
|
||||
def test_messages_sent_during_walk_appear_at_the_end(client, alice, chat):
|
||||
send_many(client, alice, chat, 4)
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
first = client.get(url + "?limit=2", headers=alice.headers).json()
|
||||
send_many(client, alice, chat, 1, prefix="late")
|
||||
rest = client.get(
|
||||
url + "?limit=10&cursor=" + quote(first["next_cursor"], safe=""),
|
||||
headers=alice.headers,
|
||||
).json()
|
||||
texts = [m["text"] for m in first["items"] + rest["items"]]
|
||||
assert texts == ["msg-00", "msg-01", "msg-02", "msg-03", "late-00"]
|
||||
|
||||
|
||||
def test_created_at_is_increasing_and_utc(client, alice, chat):
|
||||
send_many(client, alice, chat, 30)
|
||||
items, _ = walk(client, alice, chat, 100)
|
||||
stamps = [m["created_at"] for m in items]
|
||||
assert stamps == sorted(stamps) and len(set(stamps)) == 30
|
||||
assert all(s.endswith("Z") and "T" in s for s in stamps)
|
||||
|
||||
|
||||
def test_bad_limit_values(client, alice, chat):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
for bad in ["0", "101", "-1", "abc", "1.5", "", "+5", " 5", "٣"]:
|
||||
assert_error(
|
||||
client.get(url + "?limit=" + quote(bad), headers=alice.headers),
|
||||
400,
|
||||
"invalid_request",
|
||||
)
|
||||
assert client.get(url + "?limit=1", headers=alice.headers).status_code == 200
|
||||
assert client.get(url + "?limit=100", headers=alice.headers).status_code == 200
|
||||
|
||||
|
||||
def test_garbage_cursor_is_400(client, alice, chat):
|
||||
url = "/api/v1/chats/" + chat["id"] + "/messages"
|
||||
for bad in ["garbage", "!!!", "e30", "a" * 600, "eyJzIjoibWVzc2FnZXM6eCJ9"]:
|
||||
assert_error(
|
||||
client.get(url + "?cursor=" + quote(bad), headers=alice.headers),
|
||||
400,
|
||||
"invalid_request",
|
||||
)
|
||||
|
||||
|
||||
def test_cursor_from_another_chat_is_400(client, alice, bob, make_chat, chat):
|
||||
other = make_chat(alice, bob, title="Второй чат")
|
||||
send_many(client, alice, chat, 5)
|
||||
send_many(client, alice, other, 5)
|
||||
first = client.get(
|
||||
"/api/v1/chats/" + chat["id"] + "/messages?limit=2", headers=alice.headers
|
||||
).json()
|
||||
reply = client.get(
|
||||
"/api/v1/chats/"
|
||||
+ other["id"]
|
||||
+ "/messages?cursor="
|
||||
+ quote(first["next_cursor"], safe=""),
|
||||
headers=alice.headers,
|
||||
)
|
||||
assert_error(reply, 400, "invalid_request")
|
||||
|
||||
|
||||
def test_chat_list_pagination(client, alice, bob, make_chat):
|
||||
created = [make_chat(alice, bob, title="Чат %02d" % n)["id"] for n in range(5)]
|
||||
seen, cursor = [], None
|
||||
while True:
|
||||
query = "?limit=2" + ("&cursor=" + quote(cursor, safe="") if cursor else "")
|
||||
data = client.get("/api/v1/chats" + query, headers=bob.headers).json()
|
||||
seen += [c["id"] for c in data["items"]]
|
||||
cursor = data["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
assert seen == created
|
||||
|
||||
|
||||
def test_chat_list_cursor_cannot_be_used_for_messages(
|
||||
client, alice, bob, make_chat, chat
|
||||
):
|
||||
make_chat(alice, bob, title="ещё")
|
||||
cursor = client.get("/api/v1/chats?limit=1", headers=alice.headers).json()[
|
||||
"next_cursor"
|
||||
]
|
||||
reply = client.get(
|
||||
"/api/v1/chats/" + chat["id"] + "/messages?cursor=" + quote(cursor, safe=""),
|
||||
headers=alice.headers,
|
||||
)
|
||||
assert_error(reply, 400, "invalid_request")
|
||||
@@ -0,0 +1,56 @@
|
||||
"""Истечение сессий."""
|
||||
|
||||
import time
|
||||
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.main import create_app
|
||||
from conftest import assert_error, make_settings, register_and_login
|
||||
|
||||
|
||||
def test_session_expires_after_ttl():
|
||||
with TestClient(
|
||||
create_app(make_settings(session_ttl_seconds=1)), raise_server_exceptions=False
|
||||
) as short:
|
||||
person = register_and_login(short, "ttl")
|
||||
assert short.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
time.sleep(2.2)
|
||||
reply = short.get("/api/v1/users/me", headers=person.headers)
|
||||
assert_error(reply, 401, "unauthorized")
|
||||
assert reply.headers["WWW-Authenticate"] == 'Bearer realm="messenger"'
|
||||
|
||||
|
||||
def test_expired_sessions_are_cleaned_on_next_login():
|
||||
"""Истёкшие сессии удаляются при следующем входе."""
|
||||
from conftest import basic_header, run_sql
|
||||
import uuid
|
||||
|
||||
with TestClient(
|
||||
create_app(make_settings(session_ttl_seconds=1)), raise_server_exceptions=False
|
||||
) as short:
|
||||
person = register_and_login(short, "clean")
|
||||
time.sleep(1.5)
|
||||
short.post(
|
||||
"/api/v1/auth/sessions",
|
||||
headers=basic_header(person.username, person.password),
|
||||
)
|
||||
rows = run_sql(
|
||||
"SELECT token_hash FROM sessions WHERE user_id = $1", uuid.UUID(person.id)
|
||||
)
|
||||
assert len(rows) == 1
|
||||
|
||||
|
||||
def test_short_ttl_from_environment_variable():
|
||||
"""Короткий SESSION_TTL_SECONDS из окружения."""
|
||||
from conftest import CACHE_URL, sqlalchemy_url
|
||||
from app.config import Settings
|
||||
|
||||
settings = Settings.from_env(
|
||||
{"DATABASE_URL": sqlalchemy_url(), "SESSION_TTL_SECONDS": "2", "CACHE_URL": CACHE_URL}
|
||||
)
|
||||
assert settings.session_ttl_seconds == 2
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as short:
|
||||
person = register_and_login(short, "envttl")
|
||||
assert short.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
time.sleep(2.5)
|
||||
assert_error(short.get("/api/v1/users/me", headers=person.headers), 401, "unauthorized")
|
||||
@@ -0,0 +1,69 @@
|
||||
"""Транзакции, пул соединений и таймауты."""
|
||||
|
||||
import time
|
||||
import uuid
|
||||
|
||||
import httpx
|
||||
from fastapi.testclient import TestClient
|
||||
from sqlalchemy.exc import OperationalError
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.main import create_app
|
||||
from app.models import ChatMember
|
||||
from conftest import assert_error, make_settings, register_and_login, run_sql
|
||||
|
||||
|
||||
def test_failure_after_chat_insert_rolls_back_whole_operation(client, alice, bob, monkeypatch):
|
||||
"""Сбой после вставки чата откатывает всю операцию."""
|
||||
real_execute = AsyncSession.execute
|
||||
|
||||
async def failing_execute(self, statement, *args, **kwargs):
|
||||
if getattr(getattr(statement, "table", None), "name", None) == ChatMember.__tablename__:
|
||||
raise OperationalError("INSERT INTO chat_members", {}, Exception("injected"))
|
||||
return await real_execute(self, statement, *args, **kwargs)
|
||||
|
||||
monkeypatch.setattr(AsyncSession, "execute", failing_execute)
|
||||
title = "rollback-" + uuid.uuid4().hex
|
||||
reply = client.post(
|
||||
"/api/v1/chats", json={"title": title, "member_ids": [alice.id, bob.id]},
|
||||
headers=alice.headers,
|
||||
)
|
||||
monkeypatch.undo()
|
||||
|
||||
assert_error(reply, 503, "unavailable")
|
||||
assert "injected" not in reply.text and "chat_members" not in reply.text
|
||||
assert run_sql("SELECT count(*) AS n FROM chats WHERE title = $1", title)[0]["n"] == 0
|
||||
assert run_sql(
|
||||
"SELECT count(*) AS n FROM chat_members m JOIN chats c ON c.id = m.chat_id"
|
||||
" WHERE c.title = $1", title,
|
||||
)[0]["n"] == 0
|
||||
|
||||
|
||||
def test_pool_is_bounded_by_settings():
|
||||
settings = make_settings(db_pool_size=3, db_max_overflow=2, db_pool_timeout=4)
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
pool = app_client.app.state.engine.pool
|
||||
assert pool.size() == 3
|
||||
assert pool._max_overflow == 2
|
||||
assert pool._timeout == 4
|
||||
|
||||
|
||||
def test_exhausted_pool_gives_fast_503():
|
||||
"""Занятый пул даёт 503 за время DB_POOL_TIMEOUT."""
|
||||
settings = make_settings(db_pool_size=1, db_max_overflow=0, db_pool_timeout=1, cache_url="")
|
||||
with TestClient(create_app(settings), raise_server_exceptions=False) as app_client:
|
||||
person = register_and_login(app_client, "pool")
|
||||
app = app_client.app
|
||||
|
||||
async def scenario():
|
||||
async with app.state.engine.connect():
|
||||
transport = httpx.ASGITransport(app=app)
|
||||
async with httpx.AsyncClient(transport=transport, base_url="http://t") as http:
|
||||
started = time.monotonic()
|
||||
reply = await http.get("/api/v1/users/me", headers=person.headers)
|
||||
return reply, time.monotonic() - started
|
||||
|
||||
reply, elapsed = app_client.portal.call(scenario)
|
||||
assert_error(reply, 503, "unavailable")
|
||||
assert elapsed < 3
|
||||
assert app_client.get("/api/v1/users/me", headers=person.headers).status_code == 200
|
||||
Reference in New Issue
Block a user