Фиксы подтверждённых проблем

This commit is contained in:
2026-10-23 01:33:01 +03:00
parent 43daf18d04
commit 7e8e18be16
16 changed files with 488 additions and 55 deletions
+3 -3
View File
@@ -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.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
+5 -2
View File
@@ -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"
+34 -16
View File
@@ -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.
+28 -8
View File
@@ -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
View File
@@ -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."
}
+9
View File
@@ -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]
+9 -1
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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:
+33 -1
View File
@@ -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)
+37
View File
@@ -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)
+20
View File
@@ -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",
+149
View File
@@ -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)