forked from mtusi2026/mtusi2026lab2
Фиксы подтверждённых проблем
This commit is contained in:
@@ -6,9 +6,9 @@
|
||||
|
||||
Что реализовано и что перенесено: перенесён API lab1 (модели, ошибки, курсоры, Dockerfile, тесты); хранилище — PostgreSQL с миграциями; Argon2id, Basic → opaque Bearer-сессия с TTL и logout; Redis — кэш проверок сессии с обходом при отказе. Подробно — REPORT.md, «Архитектура и решения».
|
||||
Команды запуска из чистого clone: `python scripts/init_secrets.py`, `cp .env.example .env`, `docker compose --env-file .env up -d --build --wait` (REPORT.md, «Запуск из чистого clone»).
|
||||
Результаты проверок и ссылка на REPORT.md: smoke, persistence, 28 собственных тестов, race, отказ Redis/БД, EXPLAIN — evidence/, таблицы в REPORT.md.
|
||||
Ограничения / известные ошибки: один host/БД/Redis; окно до 60 с для logout при сетевом разрыве с Redis; HTTP только для локального стенда (REPORT.md, «Ограничения»).
|
||||
Источники и использование ИИ: см. REPORT.md.
|
||||
Результаты проверок и ссылка на REPORT.md: smoke, persistence, 32 собственных теста, отзыв при разрыве с Redis, race, отказ Redis/БД, EXPLAIN — evidence/, таблицы в REPORT.md.
|
||||
Ограничения / известные ошибки: один host/БД/Redis; при сбое инвалидации кэша другие реплики перестают доверять кэшу не позже чем через 1 с; HTTP только для локального стенда (REPORT.md, «Ограничения»). Исправления по ревью — REPORT.md, «Исправления по ревью».
|
||||
Источники и использование ИИ: см. шапку REPORT.md.
|
||||
|
||||
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
|
||||
- [ ] Контракт и публичные тесты не ослаблены.
|
||||
|
||||
@@ -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 secrets up down migrate test-student test-expiry test-storage test-failures explain
|
||||
.PHONY: help check validate test load test-persistence secrets up down migrate test-student test-expiry test-storage test-failures test-revocation explain
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@@ -51,11 +51,14 @@ test-expiry:
|
||||
|
||||
test-storage:
|
||||
$(COMPOSE) run --rm --no-deps -v "$(CURDIR)/student-tests:/app/student-tests:ro" api \
|
||||
python -m unittest discover -s student-tests -p test_storage_rollback.py -v
|
||||
sh -c "python -m unittest discover -s student-tests -p test_storage_rollback.py -v && python -m unittest discover -s student-tests -p test_session_cache.py -v"
|
||||
|
||||
test-failures:
|
||||
$(PYTHON) student-tests/dependency_failure.py --base-url "$(BASE_URL)" --output evidence/dependency_failure.json
|
||||
|
||||
test-revocation:
|
||||
$(PYTHON) student-tests/revocation_partition.py --base-url "$(BASE_URL)" | tee evidence/revocation_partition.txt
|
||||
|
||||
explain:
|
||||
$(COMPOSE) exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 < scripts/sql/explain_history.sql > evidence/explain_history.txt
|
||||
@echo "saved evidence/explain_history.txt"
|
||||
|
||||
@@ -5,6 +5,11 @@
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: Python, FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.2.3 + psycopg-pool 3.2.4, redis-py 5.2.1, argon2-cffi 23.1.0; PostgreSQL 16, Redis 7; документация PostgreSQL (transactions, EXPLAIN), Redis persistence, RFC 7617. Помощь ИИ использовалась при переносе кода lab1 на PostgreSQL, написании тестов и формулировке отчёта.
|
||||
|
||||
## Исправления по ревью
|
||||
|
||||
1. **Отозванный токен снова получал доступ после восстановления связи с Redis.** Ошибка записи «надгробия» при logout поглощалась, а положительной записи кэша доверяли до её истечения. Исправлено долгом инвалидации в PostgreSQL: он фиксируется в той же транзакции, что и отзыв, и пока не погашен, кэшу не доверяют. Подробности — в разделе «Роль Redis». Добавлены тесты `test_session_cache.py`, `revocation_partition.py` и фаза partition в `dependency_failure.py`; сравнение до/после — в `evidence/revocation_partition.txt`. Попутно найдена и исправлена регрессия самого исправления: при недоступной БД ответ занимал 2 × 3 с, теперь 3 с.
|
||||
2. **Вход принимал JSON-тело.** `POST /auth/sessions` с телом теперь возвращает 400 до проверки пароля и до создания сессии; тест `test_login_with_body_rejected`.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
**Версии.** Образ API: `python:3.12.7-slim-bookworm`; `postgres:16.4-alpine`; `redis:7.4.1-alpine`. Зависимости Python закреплены точными версиями в `requirements.txt`. Требуются Docker Desktop (Compose v2) и Python 3.9+ для тестов (только стандартная библиотека).
|
||||
@@ -41,11 +46,14 @@ docker compose --profile ttl up -d --wait api-short-ttl
|
||||
python student-tests/run_all.py --expiry-url http://localhost:8081 # make test-expiry
|
||||
|
||||
# Rollback на уровне БД с внедрённым сбоем (внутри compose-сети, БД наружу не публикуется):
|
||||
make test-storage
|
||||
make test-storage # + test_session_cache.py: отзыв при сбое инвалидации кэша
|
||||
|
||||
# Отказ Redis и PostgreSQL (останавливает и снова запускает контейнеры):
|
||||
python student-tests/dependency_failure.py --output evidence/dependency_failure.json # make test-failures
|
||||
|
||||
# Отзыв токена при разрыве API<->Redis без рестарта Redis (замечание ревью №1):
|
||||
python student-tests/revocation_partition.py # make test-revocation
|
||||
|
||||
# План запроса истории на 52 000 сообщениях (данные создаются и откатываются в одной транзакции):
|
||||
make explain # PowerShell: Get-Content scripts/sql/explain_history.sql | docker compose exec -T postgres psql -U messenger -d messenger > evidence/explain_history.txt
|
||||
```
|
||||
@@ -81,8 +89,9 @@ make explain # PowerShell: Get-Content scripts/sql/explain_history.sql | dock
|
||||
| `chat_members` | PK `(chat_id, user_id)`; FK → chats (CASCADE), FK → users; `UNIQUE(chat_id, position)` | `(user_id, chat_id)` — «мои чаты» |
|
||||
| `messages` | PK `id`; FK → chats, FK → users; CHECK длины text 1–4000 | `(chat_id, created_at, id)` — история и keyset |
|
||||
| `sessions` | PK `token_hash` (SHA-256 токена, 32 байта); FK → users; `expires_at`, `revoked_at` | `user_id`, `expires_at` |
|
||||
| `session_cache_invalidations` | PK `token_hash`; `revoked_at` | `revoked_at` — сверка и удаление старых строк |
|
||||
|
||||
Миграции версионируются файлами `migrations/NNN_*.sql` и таблицей `schema_migrations`. Каждая миграция и отметка о ней — одна транзакция; одновременный старт нескольких API сериализуется `pg_advisory_lock`. Повторный запуск — no-op (проверено тестом `test_migrations_are_idempotent`).
|
||||
Миграции: `001_init` (основная схема) и `002_session_cache_invalidations` (долг инвалидации кэша, добавлена по ревью). Они версионируются файлами `migrations/NNN_*.sql` и таблицей `schema_migrations`. Каждая миграция и отметка о ней — одна транзакция; одновременный старт нескольких API сериализуется `pg_advisory_lock`. Повторный запуск — no-op (проверено тестом `test_migrations_are_idempotent`).
|
||||
|
||||
### Транзакционные границы
|
||||
|
||||
@@ -90,12 +99,12 @@ make explain # PowerShell: Get-Content scripts/sql/explain_history.sql | dock
|
||||
- **Создание чата** — одна транзакция: `INSERT chats` → `INSERT chat_members` (в порядке `member_ids`). Существование участников проверяет FK; при неизвестном id откатывается всё, включая строку чата и уже вставленных участников → 400.
|
||||
- **Отправка сообщения** — один оператор `INSERT … SELECT … WHERE EXISTS(членство)`: проверка доступа и запись атомарны. `created_at` назначает БД (`clock_timestamp()`), ответ отдаётся после COMMIT.
|
||||
- **Чтение истории** — проверка членства и выборка страницы в одном соединении; snapshot между HTTP-страницами не обещается (как в контракте). При конкурентных вставках порядок определяется часами БД; сообщение с меньшим `created_at`, закоммиченное после чтения страницы, может быть пропущено уже прошедшим курсором — допустимое ограничение keyset по времени.
|
||||
- **Вход** — `INSERT sessions` (expires_at = `clock_timestamp() + TTL` по часам БД, поэтому рестарт API не продлевает TTL). **Logout** — `UPDATE sessions SET revoked_at` (момент отзыва = COMMIT), затем инвалидация кэша.
|
||||
- **Вход** — `INSERT sessions` (expires_at = `clock_timestamp() + TTL` по часам БД, поэтому рестарт API не продлевает TTL). **Logout** — одна транзакция: `UPDATE sessions SET revoked_at` + строка «долга инвалидации» в `session_cache_invalidations` (момент отзыва = COMMIT); затем «надгробие» в Redis и удаление долга.
|
||||
|
||||
### Аутентификация
|
||||
|
||||
- Пароли: **Argon2id** (`argon2-cffi`, m = 19 MiB, t = 2, p = 1 — рекомендация OWASP), пароль 12–128 code points хешируется целиком в UTF-8, без усечения. Для несуществующего username выполняется проверка против хеша-«пустышки», чтобы время ответа не выдавало наличие пользователя; ответ 401 одинаковый.
|
||||
- Basic разбирается строго: base64 → UTF-8 → разделение по **первому** двоеточию (двоеточие в пароле допустимо). Неверные/битые credentials → 401 `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`.
|
||||
- Basic разбирается строго: base64 → UTF-8 → разделение по **первому** двоеточию (двоеточие в пароле допустимо). Неверные/битые credentials → 401 `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Вход принимает **только** заголовок: любое тело запроса (JSON или нет) → 400 `invalid_request` до проверки пароля и до создания сессии (исправлено по ревью, `test_login_with_body_rejected`).
|
||||
- Токен: `secrets.token_urlsafe(32)` — 256 бит, непрозрачный. В БД и Redis хранится только SHA-256 токена: для 256-битного случайного значения перебор невозможен, а KDF лишь замедлил бы каждый запрос (в отличие от пароля, где KDF защищает низкоэнтропийный секрет).
|
||||
- Сначала аутентификация (dependency `current_user`), затем доступ к чату: посторонний получает 404, а не 403.
|
||||
|
||||
@@ -104,13 +113,20 @@ make explain # PowerShell: Get-Content scripts/sql/explain_history.sql | dock
|
||||
- **Источник истины** для сессий — PostgreSQL. Redis хранит `sess:<sha256>` → `{user, expires_at}`.
|
||||
- **Заполнение:** промах → запрос в PostgreSQL → `SET NX PX=min(SESSION_CACHE_TTL_SECONDS=60 с, время до expires_at)`. Запись кэша никогда не живёт дольше сессии, поэтому истечение работает и при попадании в кэш (тест `test_session_expires_even_when_cached`).
|
||||
- **Инвалидация при logout:** после COMMIT отзыва в PostgreSQL выполняется `SET sess:<hash> "revoked" PX=60 с` (обычный SET перезаписывает). Заполнение идёт через `SET NX`, поэтому параллельный запрос, прочитавший сессию до отзыва, не может вернуть в кэш валидную запись поверх «надгробия».
|
||||
- **Если «надгробие» записать не удалось** (исправлено по ревью). В первой версии ошибка Redis при logout поглощалась, и после восстановления связи с тем же, не перезапущенным Redis старая положительная запись снова пускала отозванный токен до своего истечения (~60 с). Теперь:
|
||||
1. вместе с `revoked_at` в той же транзакции фиксируется строка в `session_cache_invalidations` (миграция `002`); она удаляется только после успешной записи «надгробия»;
|
||||
2. пока такие строки есть, положительным попаданиям кэша **не доверяют**: каждый токен проверяется в PostgreSQL, отозванный получает 401. Реплика, выполнившая logout, переключается сразу, до ответа 204;
|
||||
3. не чаще раза в секунду API сверяется с этой таблицей. Он дописывает недостающие «надгробия» в Redis и гасит долг. Строки старше `SESSION_CACHE_TTL_SECONDS + 5` удаляются без записи: положительная запись к этому моменту уже истекла;
|
||||
4. долг хранится в PostgreSQL, поэтому он переживает рестарт API. Новый процесс не доверяет кэшу до первой сверки.
|
||||
|
||||
Отзыв по-прежнему не зависит от доступности Redis: logout возвращает 204, а PostgreSQL остаётся единственным источником истины.
|
||||
- **Persistence:** отключена сознательно (`--save "" --appendonly no`), `maxmemory 64mb`, `allkeys-lru`. После flush/рестарта Redis кэш пуст, все проверки идут в PostgreSQL и заново наполняют кэш; сессии не теряются, потому что Redis не единственное их хранилище.
|
||||
- **Отказ Redis:** таймаут операций 250 мс; при ошибке кэш пропускается на 5 с (circuit breaker), запросы обслуживаются через PostgreSQL. Readiness от Redis не зависит.
|
||||
- **Эффект:** за прогон собственных тестов и 30-секундной нагрузки Redis показал `keyspace_hits=9979`, `keyspace_misses=31` — почти все проверки токена обслужены без обращения к PostgreSQL.
|
||||
- **Эффект:** за 30 с нагрузки (счётчики сброшены перед прогоном) Redis показал `keyspace_hits=8655`, `keyspace_misses=1` — проверки токена обслужены без обращения к PostgreSQL.
|
||||
|
||||
### Отказ PostgreSQL
|
||||
|
||||
PostgreSQL — критичная зависимость: `/health/ready` → 503; запросы к данным → `503 unavailable` за ≤ 3 с (ожидание соединения из пула) без текста драйвера/SQL. Анонимный запрос отклоняется 401 ещё до обращения к БД; неизвестный токен при недоступной БД не принимается (503). Ранее проверенный токен, ещё лежащий в кэше, может получить 200 на `GET /users/me` (≤ 60 с), но любые операции с данными всё равно получают 503. Пул проверяет соединения при выдаче (`check_connection`), поэтому после возврата БД API восстанавливается без рестарта.
|
||||
PostgreSQL — критичная зависимость: `/health/ready` → 503; запросы к данным → `503 unavailable` за ≤ 3 с (ожидание соединения из пула) без текста драйвера/SQL. Анонимный запрос отклоняется 401 ещё до обращения к БД; неизвестный токен при недоступной БД не принимается (503). Кэшу без связи с БД не доверяют: сверка долга инвалидации требует PostgreSQL, поэтому при её недоступности и токен из кэша получает 503 (ошибка сверки сразу превращается в 503, без второго ожидания пула). Пул проверяет соединения при выдаче (`check_connection`), поэтому после возврата БД API восстанавливается без рестарта.
|
||||
|
||||
### Соответствие `.env.example` и реальной конфигурации
|
||||
|
||||
@@ -150,12 +166,12 @@ Bootstrap: схема создаётся миграциями при перво
|
||||
| Структура/контракт | `make check`, `make validate` | оба PASS | `evidence/check.txt` |
|
||||
| Данные и действующие сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` — тот же токен читает те же сообщения | `evidence/persistence.txt` |
|
||||
| Hook реально перезапускает процессы | PID до/после hook | postgres 1212→1269, redis 1222→1279, api 1228→1286; пользователей 51→51, действующих сессий 42→42 | `evidence/restart_processes.txt` |
|
||||
| PK/FK, UNIQUE(username), миграции с нуля | `migrations/001_init.sql`; старт на пустой БД | `migrations applied at startup: ['001_init']` | `migrations/001_init.sql` |
|
||||
| PK/FK, UNIQUE(username), миграции с нуля | `migrations/001_init.sql`; старт на пустой БД | на пустой БД: `migrations applied at startup: ['001_init', '002_session_cache_invalidations']` | `migrations/` |
|
||||
| Повторный запуск миграций без дублирования | `python -m src.migrate`; `test_migrations_are_idempotent` | `schema is up to date; nothing applied`; в `schema_migrations` одна строка | `evidence/student-tests.txt` |
|
||||
| Атомарное создание чата | `test_unknown_member_rolls_back_whole_chat`, `test_failure_after_inserts_leaves_nothing` | после ошибки нет ни чата, ни участников | `evidence/student-tests.txt` |
|
||||
| Basic только на `POST /auth/sessions`, остальное Bearer | `test_basic_on_business_endpoint_rejected`, smoke | Basic на `/users/me` → 401 `WWW-Authenticate: Bearer` | `evidence/student-tests.txt` |
|
||||
| X-User-Id не даёт доступа | `test_x_user_id_gives_no_access`, smoke | 401 без Bearer; с Bearer владелец не меняется | `evidence/student-tests.txt` |
|
||||
| Срок жизни и отзыв сессии | `test_session_expires_even_when_cached`, `test_logout_revokes_only_current_session` | после TTL и после logout → 401; повторный logout → 401 | `evidence/student-tests.txt` |
|
||||
| Срок жизни и отзыв сессии | `test_session_expires_even_when_cached`, `test_logout_revokes_only_current_session` | после TTL и после logout → 401; повторный logout → 401; вход с телом → 400 | `evidence/student-tests.txt` |
|
||||
| Пароли — password KDF | `test_passwords_stored_as_argon2id` | в БД `$argon2id$…`, plaintext отсутствует | `evidence/student-tests.txt` |
|
||||
| Secrets/volumes не в Git | `.gitignore` (`secrets/`, `.env`, `volumes/`, `data/`), секреты в отдельных файлах | после `init_secrets.py` и `git add -A` в индекс не попадают `secrets/` и `.env` | `.gitignore` |
|
||||
|
||||
@@ -163,7 +179,7 @@ Bootstrap: схема создаётся миграциями при перво
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Redis реально используется для сессий с TTL; описаны источник истины, expiry, инвалидация | код `src/sessions.py`; нагрузка | `keyspace_hits=9979 / misses=31` (свои тесты + 30 с нагрузки); TTL записи ≤ min(60 с, остаток сессии); «надгробие» при logout; без persistence — обосновано выше | раздел «Роль Redis», `evidence/load.json` |
|
||||
| Redis реально используется для сессий с TTL; описаны источник истины, expiry, инвалидация | код `src/sessions.py`; нагрузка | `keyspace_hits=8655 / misses=1` за 30 с нагрузки; TTL записи ≤ min(60 с, остаток сессии); «надгробие» при logout; без persistence — обосновано выше | раздел «Роль Redis», `evidence/load.json` |
|
||||
| Параметризованные запросы | `src/storage.py` | только плейсхолдеры `%s` psycopg; в SQL подставляются лишь константные фрагменты кода | `src/storage.py` |
|
||||
| Ограниченный пул и таймауты | `src/db.py`, `.env.example` | пул 1..10, ожидание 3 с, connect 3 с, statement 5 с, Redis 250 мс | `src/db.py`, `src/config.py` |
|
||||
| Гонка регистрации одинакового username | `test_same_username_parallel_registration` (16 параллельных запросов, Barrier) | ровно 1×201 и 15×409; входит только победитель | `evidence/student-tests.txt` |
|
||||
@@ -172,8 +188,10 @@ Bootstrap: схема создаётся миграциями при перво
|
||||
| Пагинация без полного скана | тот же EXPLAIN | `Index Cond: chat_id = … AND ROW(created_at,id) > ROW(…)`, читается limit+1 = 51 строка | `evidence/explain_history.txt` |
|
||||
| Автотест expiry при коротком TTL | `test_session_expires_even_when_cached` на API с `SESSION_TTL_SECONDS=2` | 200, 200 (из кэша) → через TTL+1.5 с 401; logout истёкшим → 401; новый вход → 201 | `evidence/student-tests.txt` |
|
||||
| Автотест logout и неверного пароля | `test_logout_revokes_only_current_session`, `test_wrong_password_and_unknown_user_look_the_same`, `test_malformed_basic_headers` | все PASS | `evidence/student-tests.txt` |
|
||||
| Автотест недоступности Redis | `dependency_failure.py` | API обходит кэш: чтение/запись/вход/logout работают, max задержка 6 мс, readiness 200 | `evidence/dependency_failure.json` |
|
||||
| Автотест недоступности БД | `dependency_failure.py` | live 200, ready 503; запись/чтение/вход → 503 `unavailable` за 3.0 с; анонимный → 401; неизвестный токен → 503; восстановление 0.45 с; отклонённая запись не сохранилась | `evidence/dependency_failure.json` |
|
||||
| Автотест недоступности Redis | `dependency_failure.py` | API обходит кэш: чтение/запись/вход/logout работают, max задержка 8 мс, readiness 200 | `evidence/dependency_failure.json` |
|
||||
| Отзыв при разрыве связи с живым Redis (замечание ревью №1) | `dependency_failure.py`, фаза partition; `revocation_partition.py`; `test_session_cache.py` (заглушка Redis, реальная PostgreSQL) | logout → 204; отозванный токен — только 401 во время разрыва, сразу после восстановления и 8 с после (дольше circuit breaker). Первая версия на том же сценарии: `[200, 401]`. Тест с заглушкой падает, если вернуть доверие положительному кэшу (проверено мутацией) | `evidence/revocation_partition.txt`, `evidence/dependency_failure.json`, `evidence/student-tests.txt` |
|
||||
| Строгий формат входа (замечание ревью №2) | `test_login_with_body_rejected` | правильный Basic + `{"unexpected":true}` / `{}` / не-JSON / form → 400, без тела → 201 | `evidence/student-tests.txt` |
|
||||
| Автотест недоступности БД | `dependency_failure.py` | live 200, ready 503; запись/чтение/вход → 503 `unavailable` за 3.0 с; анонимный → 401; неизвестный токен → 503; восстановление 0.6 с; отклонённая запись не сохранилась | `evidence/dependency_failure.json` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
@@ -181,13 +199,13 @@ Bootstrap: схема создаётся миграциями при перво
|
||||
|
||||
**Гипотеза 2.** Составной индекс `(chat_id, created_at, id)` делает стоимость страницы истории независимой от глубины курсора. На 52 000 сообщениях первая и «10 000-я» страница стоят одинаково (4–5 буферов, < 0.1 мс), тогда как OFFSET и запрос без индекса читают весь чат/таблицу (695 буферов) и растут линейно с объёмом.
|
||||
|
||||
**Нагрузка** (`tests/load.py`, closed-loop POST сообщений, без retry): 30 с, concurrency 4, без прогрева; 9 842 успешных запроса, 0 ошибок, 327 RPS; p50 11.8 мс, p95 17.4 мс, p99 20.9 мс (только успешные). Стенд: 2 vCPU / 8 GB, без CPU/RAM-лимитов, клиент на той же машине; CPU/RAM процессов не измерялись. Это пропускная способность HTTP-подтверждений в этом профиле, а не максимум системы. Для сравнения, lab1 (in-memory) на другом ноутбуке давала 254 RPS — значения разных машин несопоставимы.
|
||||
**Нагрузка** (`tests/load.py`, closed-loop POST сообщений, без retry): 30 с, concurrency 4, без прогрева; 8 655 успешных запросов, 0 ошибок, 287 RPS; p50 13.2 мс, p95 20.2 мс, p99 24.3 мс (только успешные). До исправлений ревью тот же прогон давал 327 RPS, p95 17.4 мс. Разница в пределах разброса между запусками на общей виртуальной машине: повторов для статистики не делалось. Сверка долга добавляет не больше одного запроса к PostgreSQL в секунду. Стенд: 2 vCPU / 8 GB, без CPU/RAM-лимитов, клиент на той же машине; CPU/RAM процессов не измерялись. Это пропускная способность HTTP-подтверждений в этом профиле, а не максимум системы. Для сравнения, lab1 (in-memory) на другом ноутбуке давала 254 RPS — значения разных машин несопоставимы.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| Рестарт API + PostgreSQL + Redis (hook) | данные и сессии сохраняются | тот же токен читает ту же историю; пользователей и сессий столько же | готовность через 2.6 с после начала hook; потерь нет |
|
||||
| Остановка Redis | обход кэша, работа через PostgreSQL | все операции 200/201/204, max 6 мс, readiness 200 | без восстановления; после возврата кэш наполняется заново |
|
||||
| Остановка PostgreSQL | 503 на данные, 401 анониму, live 200 | 503 `unavailable` за 3.0 с, ready 503, аноним 401 | 0.45 с после старта БД; запись во время отказа не сохранена (клиент получил 503) |
|
||||
| Остановка Redis | обход кэша, работа через PostgreSQL | все операции 200/201/204, max 8 мс, readiness 200 | без восстановления; после возврата кэш наполняется заново |
|
||||
| Остановка PostgreSQL | 503 на данные, 401 анониму, live 200 | 503 `unavailable` за 3.0 с, ready 503, аноним 401 | 0.6 с после старта БД; запись во время отказа не сохранена (клиент получил 503) |
|
||||
| 16 одинаковых регистраций одновременно | ровно одна успешна | 1×201, 15×409 | — |
|
||||
| Сбой между INSERT chats и chat_members | полный откат | 0 строк чата и участников | — |
|
||||
|
||||
@@ -195,8 +213,8 @@ Bootstrap: схема создаётся миграциями при перво
|
||||
|
||||
- Один API, одна PostgreSQL, один Redis на одном Docker-host: отказ host или диска БД не выдерживается; репликации и бэкапов нет (бэкап/восстановление — трек 2 уровня 5, не заявлен).
|
||||
- Durability зависит от настроек PostgreSQL по умолчанию (`fsync=on`, `synchronous_commit=on`): подтверждённый 201 означает COMMIT, записанный в WAL на локальный диск.
|
||||
- Окно кэша: если logout выполнен при недоступном Redis, а Redis при этом не перезапускался (сетевой разрыв), отозванный токен может приниматься из кэша до `SESSION_CACHE_TTL_SECONDS` (60 с). При рестарте Redis кэш пуст, и окна нет. Сокращается уменьшением TTL кэша.
|
||||
- При недоступной БД токен из кэша ещё ≤ 60 с проходит аутентификацию, но операции с данными получают 503.
|
||||
- Отзыв при сбое Redis: для реплики, выполнившей logout, окна нет. Другая реплика (в compose это `api-short-ttl`, в lab3 — реплики за LB), у которой связь с Redis не рвалась, узнаёт о долге при следующей сверке, то есть не позже чем через 1 с после ответа 204. Если logout прошёл успешно, окна нет ни у кого.
|
||||
- Пока долг инвалидации не погашен (Redis недоступен), все проверки токена идут в PostgreSQL: кэш не разгружает базу до восстановления связи.
|
||||
- Basic/Bearer идут по HTTP — допустимо только на локальном учебном стенде; TLS — lab7.
|
||||
- Пароль Redis передаётся в `redis-server` аргументом командной строки внутри контейнера (виден в списке процессов контейнера); hardening — lab7.
|
||||
- Приложенные результаты сняты на нативном стенде без Docker (см. «Доказательства»); compose-конфигурация проверена `docker compose config`, перед сдачей нужно прогнать те же сценарии на compose.
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
{
|
||||
"base_url": "http://127.0.0.1:8080",
|
||||
"timings": {
|
||||
"redis_down_first_request_s": 0.0,
|
||||
"redis_down_max_write_s": 0.031,
|
||||
"postgres_down_write_s": 3.0,
|
||||
"postgres_recovery_s": 0.02
|
||||
"redis_down_first_request_s": 0.015,
|
||||
"redis_down_max_write_s": 0.047,
|
||||
"postgres_down_write_s": 3.015,
|
||||
"postgres_recovery_s": -1
|
||||
},
|
||||
"checks": [
|
||||
{
|
||||
"check": "redis down: existing token still valid via PostgreSQL",
|
||||
"ok": true,
|
||||
"detail": "0.000s"
|
||||
"detail": "0.015s"
|
||||
},
|
||||
{
|
||||
"check": "redis down: writes succeed",
|
||||
@@ -20,7 +20,7 @@
|
||||
{
|
||||
"check": "redis down: bounded latency",
|
||||
"ok": true,
|
||||
"detail": "max 0.031s over 10 requests"
|
||||
"detail": "max 0.047s over 10 requests"
|
||||
},
|
||||
{
|
||||
"check": "redis down: readiness stays 200 (cache is not critical)",
|
||||
@@ -57,6 +57,26 @@
|
||||
"ok": true,
|
||||
"detail": ""
|
||||
},
|
||||
{
|
||||
"check": "redis partition: logout -> 204",
|
||||
"ok": true,
|
||||
"detail": "status 204, 0.000s"
|
||||
},
|
||||
{
|
||||
"check": "redis partition: revoked token -> 401",
|
||||
"ok": true,
|
||||
"detail": ""
|
||||
},
|
||||
{
|
||||
"check": "redis healed (same data): revoked token stays 401 for 8 s",
|
||||
"ok": true,
|
||||
"detail": "[401]"
|
||||
},
|
||||
{
|
||||
"check": "redis healed: valid token works",
|
||||
"ok": true,
|
||||
"detail": ""
|
||||
},
|
||||
{
|
||||
"check": "postgres down: liveness 200",
|
||||
"ok": true,
|
||||
@@ -75,12 +95,12 @@
|
||||
{
|
||||
"check": "postgres down: unknown token is not accepted (503)",
|
||||
"ok": true,
|
||||
"detail": "status 503, 3.000s"
|
||||
"detail": "status 503, 3.016s"
|
||||
},
|
||||
{
|
||||
"check": "postgres down: write -> 503 within bound",
|
||||
"ok": true,
|
||||
"detail": "status 503, 3.000s"
|
||||
"detail": "status 503, 3.015s"
|
||||
},
|
||||
{
|
||||
"check": "postgres down: history read -> 503",
|
||||
|
||||
Binary file not shown.
+6
-6
@@ -2,16 +2,16 @@
|
||||
"lab": 2,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 30.0,
|
||||
"elapsed_seconds": 30.096,
|
||||
"elapsed_seconds": 30.122,
|
||||
"concurrency": 4,
|
||||
"successful_requests": 9842,
|
||||
"successful_requests": 8655,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 327.024,
|
||||
"successful_rps": 287.333,
|
||||
"successful_latency_ms": {
|
||||
"p50": 11.831,
|
||||
"p95": 17.414,
|
||||
"p99": 20.949
|
||||
"p50": 13.173,
|
||||
"p95": 20.194,
|
||||
"p99": 24.284
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
# Регрессия замечания ревью №1: прогрев кэша -> разрыв API<->Redis (iptables REJECT tcp-reset, Redis НЕ перезапускается)
|
||||
# -> logout -> восстановление связи -> опрос старого токена 8 с (дольше circuit breaker 5 с).
|
||||
# Скрипт: student-tests/revocation_partition.py --partition/--heal "iptables ... tcp-reset" (тот же сценарий входит в student-tests/dependency_failure.py)
|
||||
--- до исправления (первая сдача)
|
||||
logout during partition: 204
|
||||
revoked token statuses over 8 s after heal: [200, 401]
|
||||
--- после исправления
|
||||
logout during partition: 204
|
||||
revoked token statuses over 8 s after heal: [401]
|
||||
@@ -14,6 +14,8 @@ test_registration_without_password_returns_400 (test_api.ApiBehaviorTests.test_r
|
||||
test_sender_id_in_body_rejected (test_api.ApiBehaviorTests.test_sender_id_in_body_rejected) ... ok
|
||||
test_short_password_returns_400 (test_api.ApiBehaviorTests.test_short_password_returns_400) ... ok
|
||||
test_basic_on_business_endpoint_rejected (test_auth.AuthTests.test_basic_on_business_endpoint_rejected) ... ok
|
||||
test_login_with_body_rejected (test_auth.AuthTests.test_login_with_body_rejected)
|
||||
Контракт: вход — только заголовок Basic, без тела. Лишний ввод -> 400, сессии нет. ... ok
|
||||
test_logout_revokes_only_current_session (test_auth.AuthTests.test_logout_revokes_only_current_session) ... ok
|
||||
test_malformed_basic_headers (test_auth.AuthTests.test_malformed_basic_headers) ... ok
|
||||
test_password_with_colon_and_unicode (test_auth.AuthTests.test_password_with_colon_and_unicode) ... ok
|
||||
@@ -26,13 +28,19 @@ test_unknown_member_rolls_back_whole_chat (test_concurrency.ChatRollbackTests.te
|
||||
Чат вставляется первым, затем участники по порядку (сначала сам владелец). ... ok
|
||||
test_same_username_parallel_registration (test_concurrency.RegistrationRaceTests.test_same_username_parallel_registration) ... ok
|
||||
test_session_expires_even_when_cached (test_expiry.ExpiryTests.test_session_expires_even_when_cached) ... ok
|
||||
test_debt_survives_api_restart (test_session_cache.SessionRevocationCacheTests.test_debt_survives_api_restart)
|
||||
Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу. ... logout: cache invalidation deferred; positive cache disabled
|
||||
ok
|
||||
test_normal_logout_leaves_no_debt (test_session_cache.SessionRevocationCacheTests.test_normal_logout_leaves_no_debt) ... ok
|
||||
test_revoked_token_rejected_after_partition_heals (test_session_cache.SessionRevocationCacheTests.test_revoked_token_rejected_after_partition_heals) ... logout: cache invalidation deferred; positive cache disabled
|
||||
ok
|
||||
test_failure_after_inserts_leaves_nothing (test_storage_rollback.StorageRollbackTests.test_failure_after_inserts_leaves_nothing) ... ok
|
||||
test_migrations_are_idempotent (test_storage_rollback.StorageRollbackTests.test_migrations_are_idempotent) ... ok
|
||||
test_no_orphan_chats_in_database (test_storage_rollback.StorageRollbackTests.test_no_orphan_chats_in_database) ... ok
|
||||
test_passwords_stored_as_argon2id (test_storage_rollback.StorageRollbackTests.test_passwords_stored_as_argon2id) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 28 tests in 6.224s
|
||||
Ran 32 tests in 7.657s
|
||||
|
||||
OK
|
||||
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
-- 002: надёжная инвалидация кэша сессий.
|
||||
-- Строка вставляется В ТОЙ ЖЕ транзакции, что и sessions.revoked_at, и удаляется
|
||||
-- только после того, как в Redis записано «надгробие» для этого токена.
|
||||
-- Пока в таблице есть строки, API не доверяет положительным записям кэша
|
||||
-- и проверяет каждый токен в PostgreSQL (см. src/sessions.py).
|
||||
CREATE TABLE session_cache_invalidations (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
revoked_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
CONSTRAINT session_cache_invalidations_hash_len CHECK (octet_length(token_hash) = 32)
|
||||
);
|
||||
|
||||
CREATE INDEX session_cache_invalidations_revoked_at_idx
|
||||
ON session_cache_invalidations (revoked_at);
|
||||
+12
-1
@@ -270,7 +270,18 @@ def get_current_user(user: User = Depends(current_user)) -> User:
|
||||
|
||||
# sessions
|
||||
|
||||
@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201)
|
||||
async def require_empty_body(request: Request) -> None:
|
||||
"""Вход — только заголовок Authorization: Basic, без тела (контракт).
|
||||
|
||||
Любые байты в теле (JSON или нет) — 400. Проверка выполняется до
|
||||
дорогой проверки пароля и до создания сессии.
|
||||
"""
|
||||
if await request.body():
|
||||
raise bad_request("Request body is not allowed")
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201,
|
||||
dependencies=[Depends(require_empty_body)])
|
||||
def create_session(request: Request) -> Session:
|
||||
credentials = parse_basic(request.headers.get("Authorization"))
|
||||
if credentials is None:
|
||||
|
||||
+80
-7
@@ -15,6 +15,22 @@
|
||||
Заполнение кэша идёт через SET NX, поэтому параллельный запрос, прочитавший
|
||||
сессию до отзыва, не может перезаписать «надгробие» валидной записью.
|
||||
|
||||
Надёжность отзыва при сбое Redis
|
||||
--------------------------------
|
||||
Отзыв в PostgreSQL и строка-«долг» в session_cache_invalidations пишутся
|
||||
ОДНОЙ транзакцией (миграция 002). Строка удаляется только после успешной
|
||||
записи «надгробия» в Redis. Если записать его не удалось (таймаут, обрыв
|
||||
связи, Redis заморожен), на кэш больше нельзя полагаться: в нём могла
|
||||
остаться положительная запись отозванного токена. Поэтому:
|
||||
* пока долг не погашен, положительные попадания кэша НЕ принимаются —
|
||||
каждый токен проверяется в PostgreSQL (отозванный -> 401);
|
||||
* не чаще раза в секунду API пытается погасить долг: пишет надгробия в
|
||||
Redis и удаляет строки; строки старше SESSION_CACHE_TTL + 5 с удаляются
|
||||
без записи (любая положительная запись к этому моменту уже истекла);
|
||||
* наличие долга перечитывается из PostgreSQL не реже раза в секунду, так что
|
||||
и другие реплики (lab3) перестают доверять кэшу не позже чем через 1 с;
|
||||
реплика, выполнившая logout, — сразу, до ответа 204.
|
||||
|
||||
Отказ Redis
|
||||
-----------
|
||||
Любая ошибка Redis (таймаут 250 мс) -> кэш пропускается, проверка идёт в
|
||||
@@ -115,13 +131,18 @@ class SessionCache:
|
||||
except redis.RedisError as exc:
|
||||
self._failed(exc)
|
||||
|
||||
def revoke(self, digest: bytes) -> None:
|
||||
def revoke(self, digest: bytes) -> bool:
|
||||
"""True — надгробие записано (или кэша нет вовсе); False — не удалось."""
|
||||
if self.client is None:
|
||||
return
|
||||
return True
|
||||
if not self._available():
|
||||
return False
|
||||
try:
|
||||
self.client.set(self.key(digest), REVOKED, px=self.ttl_ms)
|
||||
return True
|
||||
except redis.RedisError as exc:
|
||||
self._failed(exc)
|
||||
return False
|
||||
|
||||
def ping(self) -> bool:
|
||||
if self.client is None:
|
||||
@@ -133,22 +154,64 @@ class SessionCache:
|
||||
|
||||
|
||||
class SessionService:
|
||||
# Как часто перечитывать из PostgreSQL наличие непогашенных инвалидаций.
|
||||
RECHECK_SECONDS = 1.0
|
||||
|
||||
def __init__(self, storage: Storage, cache: SessionCache, settings: Settings) -> None:
|
||||
self.storage = storage
|
||||
self.cache = cache
|
||||
self.ttl = settings.session_ttl_seconds
|
||||
# Строки старше этого возраста можно удалять без записи в Redis.
|
||||
self.stale_after = settings.session_cache_ttl_seconds + 5
|
||||
self._lock = threading.Lock()
|
||||
self._pending = True # до первой сверки с БД кэшу не доверяем
|
||||
self._checked_at = float("-inf")
|
||||
|
||||
def create(self, user: User) -> Tuple[str, datetime]:
|
||||
token = new_token()
|
||||
expires_at = self.storage.create_session(token_digest(token), user.id, self.ttl)
|
||||
return token, expires_at
|
||||
|
||||
def _reconcile(self) -> None:
|
||||
"""Погасить долг инвалидации; вызывается под self._lock."""
|
||||
try:
|
||||
rows = self.storage.pending_invalidations()
|
||||
done = []
|
||||
for digest, age in rows:
|
||||
if age > self.stale_after or self.cache.revoke(digest):
|
||||
done.append(digest)
|
||||
else:
|
||||
break # Redis всё ещё недоступен — попробуем позже
|
||||
self.storage.delete_invalidations(done)
|
||||
self._pending = len(done) < len(rows) or len(rows) >= 500
|
||||
if rows and not self._pending:
|
||||
log.info("cache invalidation backlog cleared (%d)", len(done))
|
||||
except Exception as exc: # PostgreSQL недоступна: доверять кэшу нельзя
|
||||
log.warning("cannot verify cache invalidations: %s", type(exc).__name__)
|
||||
self._pending = True
|
||||
# Пробрасываем сразу (-> 503): иначе запрос ждал бы пул второй раз
|
||||
# в find_session и отвечал за 2 x DB_POOL_TIMEOUT_SECONDS.
|
||||
raise
|
||||
|
||||
def cache_trusted(self) -> bool:
|
||||
now = time.monotonic()
|
||||
if now - self._checked_at < self.RECHECK_SECONDS:
|
||||
return not self._pending
|
||||
with self._lock:
|
||||
if now - self._checked_at >= self.RECHECK_SECONDS:
|
||||
self._reconcile()
|
||||
self._checked_at = time.monotonic()
|
||||
return not self._pending
|
||||
|
||||
def resolve(self, token: str) -> Optional[User]:
|
||||
digest = token_digest(token)
|
||||
# Сначала сверка (она может дописать надгробия в Redis), и только
|
||||
# потом чтение кэша — иначе прочитанная до сверки запись устарела бы.
|
||||
trusted = self.cache_trusted()
|
||||
cached = self.cache.get(digest)
|
||||
if cached == REVOKED:
|
||||
return None
|
||||
if cached is not None:
|
||||
if cached is not None and trusted:
|
||||
user, expires_at = cached
|
||||
if expires_at > datetime.now(timezone.utc):
|
||||
return user
|
||||
@@ -161,7 +224,17 @@ class SessionService:
|
||||
|
||||
def revoke(self, token: str) -> bool:
|
||||
digest = token_digest(token)
|
||||
revoked = self.storage.revoke_session(digest)
|
||||
if revoked:
|
||||
self.cache.revoke(digest)
|
||||
return revoked
|
||||
if not self.storage.revoke_session(digest): # COMMIT: отзыв + долг инвалидации
|
||||
return False
|
||||
if self.cache.revoke(digest):
|
||||
try:
|
||||
self.storage.delete_invalidations([digest])
|
||||
except Exception:
|
||||
pass # строка останется и будет удалена при следующей сверке
|
||||
else:
|
||||
# Надгробие не записано: до погашения долга кэшу не доверяем.
|
||||
with self._lock:
|
||||
self._pending = True
|
||||
self._checked_at = time.monotonic()
|
||||
log.warning("logout: cache invalidation deferred; positive cache disabled")
|
||||
return True
|
||||
|
||||
+50
-10
@@ -109,19 +109,59 @@ class Storage:
|
||||
return _user(row), row["expires_at"]
|
||||
|
||||
def revoke_session(self, token_hash: bytes) -> bool:
|
||||
"""Отзыв и долг «инвалидировать кэш» фиксируются одним COMMIT."""
|
||||
with self.pool.connection() as conn:
|
||||
row = conn.execute(
|
||||
"""
|
||||
UPDATE sessions SET revoked_at = clock_timestamp()
|
||||
WHERE token_hash = %s
|
||||
AND revoked_at IS NULL
|
||||
AND expires_at > clock_timestamp()
|
||||
RETURNING 1
|
||||
""",
|
||||
(token_hash,),
|
||||
).fetchone()
|
||||
with conn.transaction():
|
||||
row = conn.execute(
|
||||
"""
|
||||
UPDATE sessions SET revoked_at = clock_timestamp()
|
||||
WHERE token_hash = %s
|
||||
AND revoked_at IS NULL
|
||||
AND expires_at > clock_timestamp()
|
||||
RETURNING 1
|
||||
""",
|
||||
(token_hash,),
|
||||
).fetchone()
|
||||
if row is not None:
|
||||
conn.execute(
|
||||
"""
|
||||
INSERT INTO session_cache_invalidations (token_hash)
|
||||
VALUES (%s) ON CONFLICT (token_hash) DO NOTHING
|
||||
""",
|
||||
(token_hash,),
|
||||
)
|
||||
return row is not None
|
||||
|
||||
# долг инвалидации кэша
|
||||
|
||||
def has_pending_invalidations(self) -> bool:
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute(
|
||||
"SELECT EXISTS (SELECT 1 FROM session_cache_invalidations)"
|
||||
).fetchone()[0]
|
||||
|
||||
def pending_invalidations(self, limit: int = 500) -> List[Tuple[bytes, float]]:
|
||||
"""[(token_hash, возраст в секундах)] — самые старые первыми."""
|
||||
with self.pool.connection() as conn:
|
||||
rows = conn.execute(
|
||||
"""
|
||||
SELECT token_hash, EXTRACT(EPOCH FROM clock_timestamp() - revoked_at)
|
||||
FROM session_cache_invalidations
|
||||
ORDER BY revoked_at LIMIT %s
|
||||
""",
|
||||
(limit,),
|
||||
).fetchall()
|
||||
return [(bytes(h), float(age)) for h, age in rows]
|
||||
|
||||
def delete_invalidations(self, token_hashes: Sequence[bytes]) -> None:
|
||||
if not token_hashes:
|
||||
return
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute(
|
||||
"DELETE FROM session_cache_invalidations WHERE token_hash = ANY(%s)",
|
||||
(list(token_hashes),),
|
||||
)
|
||||
|
||||
# chats
|
||||
|
||||
def _insert_members(self, conn, chat_id: UUID, member_ids: Sequence[UUID]) -> None:
|
||||
|
||||
@@ -14,6 +14,10 @@ unittest. По умолчанию использует docker compose из ко
|
||||
* Redis недоступен -> API обходит кэш, всё работает через PostgreSQL,
|
||||
readiness = 200, задержка ограничена таймаутом Redis (250 мс) и
|
||||
circuit breaker'ом; logout по-прежнему отзывает сессию.
|
||||
* Разрыв сети API <-> Redis БЕЗ рестарта Redis (данные кэша живы) и logout
|
||||
во время разрыва -> logout 204, и отозванный токен получает 401 и во время
|
||||
разрыва, и сразу после восстановления связи, и после закрытия circuit
|
||||
breaker (регрессия: раньше доверяли старой положительной записи ~60 с).
|
||||
* PostgreSQL недоступна -> /health/live = 200, /health/ready = 503,
|
||||
запросы к данным -> 503 unavailable за ограниченное время; анонимный
|
||||
запрос -> 401; неизвестный токен не принимается (503, а не 200).
|
||||
@@ -79,6 +83,11 @@ def main():
|
||||
p.add_argument("--base-url", default="http://127.0.0.1:8080")
|
||||
p.add_argument("--stop-redis", default="docker compose stop redis")
|
||||
p.add_argument("--start-redis", default="docker compose up -d --wait redis")
|
||||
p.add_argument("--partition-redis",
|
||||
default="docker network disconnect messenger-lab2_backend messenger-lab2-redis-1",
|
||||
help="cut API<->Redis network WITHOUT restarting Redis")
|
||||
p.add_argument("--heal-redis",
|
||||
default="docker network connect --alias redis messenger-lab2_backend messenger-lab2-redis-1")
|
||||
p.add_argument("--stop-postgres", default="docker compose stop postgres")
|
||||
p.add_argument("--start-postgres", default="docker compose up -d --wait postgres")
|
||||
p.add_argument("--output")
|
||||
@@ -127,7 +136,30 @@ def main():
|
||||
check("redis back: requests ok",
|
||||
request("GET", "/api/v1/users/me", token=alice["_token"]).status == 200)
|
||||
|
||||
# 2. PostgreSQL недоступна
|
||||
# 2. Разрыв связи с живым Redis + logout (замечание ревью №1)
|
||||
carol = actor("dep")
|
||||
for _ in range(2): # промах -> запись в кэш, затем попадание
|
||||
request("GET", "/api/v1/users/me", token=carol["_token"])
|
||||
run(args.partition_redis)
|
||||
try:
|
||||
r = request("DELETE", "/api/v1/auth/sessions/current", token=carol["_token"])
|
||||
check("redis partition: logout -> 204", r.status == 204, "status %d, %.3fs" % (r.status, r.elapsed))
|
||||
check("redis partition: revoked token -> 401",
|
||||
request("GET", "/api/v1/users/me", token=carol["_token"]).status == 401)
|
||||
finally:
|
||||
run(args.heal_redis)
|
||||
# Опрашиваем дольше CACHE_RETRY_AFTER_SECONDS (5 с): после закрытия circuit
|
||||
# breaker API снова читает Redis, где жила положительная запись этого токена.
|
||||
statuses = set()
|
||||
deadline = time.monotonic() + 8
|
||||
while time.monotonic() < deadline:
|
||||
statuses.add(request("GET", "/api/v1/users/me", token=carol["_token"]).status)
|
||||
statuses.add(request("POST", path, token=carol["_token"], payload={"text": "revoked"}).status)
|
||||
time.sleep(0.25)
|
||||
check("redis healed (same data): revoked token stays 401 for 8 s", statuses == {401}, str(sorted(statuses)))
|
||||
check("redis healed: valid token works", request("GET", "/api/v1/users/me", token=alice["_token"]).status == 200)
|
||||
|
||||
# 3. PostgreSQL недоступна
|
||||
run(args.stop_postgres)
|
||||
try:
|
||||
check("postgres down: liveness 200", request("GET", "/health/live").status == 200)
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Минимальное воспроизведение замечания ревью №1 (отзыв токена при разрыве с Redis).
|
||||
|
||||
Прогрев кэша -> разрыв сети API<->Redis без рестарта Redis -> logout ->
|
||||
восстановление связи -> 8 с опроса старого токена (дольше circuit breaker).
|
||||
Ожидается только 401. По умолчанию — команды docker compose-стенда:
|
||||
python student-tests/revocation_partition.py --base-url http://127.0.0.1:8080
|
||||
"""
|
||||
import argparse, shlex, subprocess, sys, time
|
||||
from pathlib import Path
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
||||
import common
|
||||
from common import actor, request
|
||||
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument("--base-url", default="http://127.0.0.1:8080")
|
||||
p.add_argument("--partition", default="docker network disconnect messenger-lab2_backend messenger-lab2-redis-1")
|
||||
p.add_argument("--heal", default="docker network connect --alias redis messenger-lab2_backend messenger-lab2-redis-1")
|
||||
args = p.parse_args()
|
||||
common.BASE_URL = args.base_url.rstrip("/")
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
def run(cmd):
|
||||
subprocess.run(shlex.split(cmd), cwd=ROOT, check=True)
|
||||
a = actor("repro"); t = a["_token"]
|
||||
for _ in range(2): request("GET","/api/v1/users/me",token=t)
|
||||
run(args.partition)
|
||||
try:
|
||||
print("logout during partition:", request("DELETE","/api/v1/auth/sessions/current",token=t).status)
|
||||
finally:
|
||||
run(args.heal)
|
||||
seen=set(); end=time.monotonic()+8
|
||||
while time.monotonic()<end:
|
||||
seen.add(request("GET","/api/v1/users/me",token=t).status); time.sleep(0.25)
|
||||
print("revoked token statuses over 8 s after heal:", sorted(seen))
|
||||
ok = seen == {401}
|
||||
print("PASS" if ok else "FAIL", ": revoked token never accepted after partition heals")
|
||||
sys.exit(0 if ok else 1)
|
||||
@@ -53,6 +53,26 @@ class AuthTests(unittest.TestCase):
|
||||
token = login(user)
|
||||
self.assertEqual(request("GET", "/api/v1/users/me", token=token).json["id"], user["id"])
|
||||
|
||||
def test_login_with_body_rejected(self):
|
||||
"""Контракт: вход — только заголовок Basic, без тела. Лишний ввод -> 400, сессии нет."""
|
||||
user = register("body")
|
||||
auth = {"Authorization": basic(user["username"], user["_password"])}
|
||||
cases = [
|
||||
dict(payload={"unexpected": True}),
|
||||
dict(payload={}),
|
||||
dict(raw=b"not json at all"),
|
||||
dict(raw=b"username=x&password=y", headers={"Content-Type": "application/x-www-form-urlencoded"}),
|
||||
]
|
||||
for case in cases:
|
||||
headers = dict(auth)
|
||||
headers.update(case.pop("headers", {}))
|
||||
r = request("POST", "/api/v1/auth/sessions", headers=headers, **case)
|
||||
self.assertEqual(r.status, 400, (case, r.json))
|
||||
self.assertEqual(r.json["error"]["code"], "invalid_request")
|
||||
self.assertNotIn("token", r.json)
|
||||
# Без тела тот же заголовок работает.
|
||||
self.assertEqual(request("POST", "/api/v1/auth/sessions", headers=auth).status, 201)
|
||||
|
||||
def test_basic_on_business_endpoint_rejected(self):
|
||||
user = register("basic")
|
||||
r = request("GET", "/api/v1/users/me",
|
||||
|
||||
@@ -0,0 +1,149 @@
|
||||
"""Отзыв сессии при сбое инвалидации кэша (регрессия замечания ревью №1).
|
||||
|
||||
Сценарий ревью: прогретый кэш -> связь API с Redis разорвана -> logout (204)
|
||||
-> связь восстановлена с ТЕМ ЖЕ Redis, без его рестарта, положительная запись
|
||||
отозванного токена ещё жива. Ожидание: токен отклоняется сразу, а не через
|
||||
SESSION_CACHE_TTL_SECONDS.
|
||||
|
||||
Redis здесь заменён управляемой заглушкой с тем же интерфейсом, что и
|
||||
SessionCache (get/put/revoke): «разрыв» = операции падают, но данные заглушки
|
||||
сохраняются — ровно как у живого Redis за сетевым разрывом. PostgreSQL —
|
||||
настоящая (нужен DATABASE_URL/DATABASE_URL_FILE, иначе тест пропускается):
|
||||
make test-storage
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import unittest
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||||
|
||||
HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE"))
|
||||
|
||||
|
||||
class PartitionableCache:
|
||||
"""Кэш, который «помнит» данные во время разрыва, но недоступен для API."""
|
||||
|
||||
def __init__(self):
|
||||
self.data = {}
|
||||
self.partitioned = False
|
||||
|
||||
def get(self, digest):
|
||||
from src.sessions import REVOKED
|
||||
if self.partitioned:
|
||||
return None
|
||||
value = self.data.get(digest)
|
||||
if value is None:
|
||||
return None
|
||||
if value == REVOKED:
|
||||
return REVOKED
|
||||
user, expires_at = value
|
||||
return (user, expires_at) if expires_at > datetime.now(timezone.utc) else None
|
||||
|
||||
def put(self, digest, user, expires_at):
|
||||
if not self.partitioned:
|
||||
self.data.setdefault(digest, (user, expires_at)) # SET NX
|
||||
|
||||
def revoke(self, digest):
|
||||
from src.sessions import REVOKED
|
||||
if self.partitioned:
|
||||
return False
|
||||
self.data[digest] = REVOKED
|
||||
return True
|
||||
|
||||
|
||||
@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured")
|
||||
class SessionRevocationCacheTests(unittest.TestCase):
|
||||
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
from src.config import load_settings
|
||||
from src.db import create_pool, wait_and_migrate
|
||||
from src.security import hash_password
|
||||
from src.storage import Storage
|
||||
|
||||
cls.settings = load_settings()
|
||||
wait_and_migrate(cls.settings)
|
||||
cls.pool = create_pool(cls.settings)
|
||||
cls.pool.wait(timeout=10)
|
||||
cls.storage = Storage(cls.pool)
|
||||
cls.user = cls.storage.create_user("rvk_" + uuid.uuid4().hex[:12], "Revoke",
|
||||
hash_password("Revoke-test-password"))
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.pool.close()
|
||||
|
||||
def service(self, cache):
|
||||
from src.sessions import SessionService
|
||||
return SessionService(self.storage, cache, self.settings)
|
||||
|
||||
def pending(self, digest):
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute("SELECT count(*) FROM session_cache_invalidations WHERE token_hash = %s",
|
||||
(digest,)).fetchone()[0]
|
||||
|
||||
def warm(self, svc, cache, token):
|
||||
from src.security import token_digest
|
||||
self.assertEqual(svc.resolve(token).id, self.user.id)
|
||||
self.assertIsInstance(cache.data.get(token_digest(token)), tuple, "cache was not warmed")
|
||||
|
||||
def test_revoked_token_rejected_after_partition_heals(self):
|
||||
from src.security import token_digest
|
||||
cache = PartitionableCache()
|
||||
svc = self.service(cache)
|
||||
token, _ = svc.create(self.user)
|
||||
digest = token_digest(token)
|
||||
self.warm(svc, cache, token)
|
||||
|
||||
cache.partitioned = True
|
||||
self.assertTrue(svc.revoke(token), "logout must succeed (PostgreSQL is the source of truth)")
|
||||
self.assertIsInstance(cache.data[digest], tuple, "precondition: stale positive entry survived")
|
||||
self.assertEqual(self.pending(digest), 1, "invalidation debt must be committed with revoked_at")
|
||||
self.assertIsNone(svc.resolve(token), "during partition")
|
||||
|
||||
cache.partitioned = False # тот же «Redis», данные не потеряны
|
||||
self.assertIsNone(svc.resolve(token), "immediately after partition heals")
|
||||
time.sleep(svc.RECHECK_SECONDS + 0.1)
|
||||
self.assertIsNone(svc.resolve(token), "after reconciliation")
|
||||
self.assertEqual(cache.data[digest], "revoked", "reconciliation must write the tombstone")
|
||||
self.assertEqual(self.pending(digest), 0, "debt must be cleared after the tombstone")
|
||||
|
||||
# После погашения долга кэшу снова доверяют: другой токен обслуживается из кэша.
|
||||
other, _ = svc.create(self.user)
|
||||
self.warm(svc, cache, other)
|
||||
|
||||
def test_debt_survives_api_restart(self):
|
||||
"""Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу."""
|
||||
from src.security import token_digest
|
||||
cache = PartitionableCache()
|
||||
svc = self.service(cache)
|
||||
token, _ = svc.create(self.user)
|
||||
self.warm(svc, cache, token)
|
||||
cache.partitioned = True
|
||||
self.assertTrue(svc.revoke(token))
|
||||
del svc # «рестарт API»: состояние процесса потеряно
|
||||
|
||||
cache.partitioned = False
|
||||
restarted = self.service(cache)
|
||||
self.assertIsNone(restarted.resolve(token))
|
||||
self.assertEqual(cache.data[token_digest(token)], "revoked")
|
||||
|
||||
def test_normal_logout_leaves_no_debt(self):
|
||||
from src.security import token_digest
|
||||
cache = PartitionableCache()
|
||||
svc = self.service(cache)
|
||||
token, _ = svc.create(self.user)
|
||||
self.warm(svc, cache, token)
|
||||
self.assertTrue(svc.revoke(token))
|
||||
self.assertEqual(cache.data[token_digest(token)], "revoked")
|
||||
self.assertEqual(self.pending(token_digest(token)), 0)
|
||||
self.assertIsNone(svc.resolve(token))
|
||||
self.assertFalse(svc.revoke(token), "second logout must fail")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(verbosity=2)
|
||||
Reference in New Issue
Block a user