diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 177d700..d0657b5 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -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. - [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. - [ ] Контракт и публичные тесты не ослаблены. diff --git a/Makefile b/Makefile index 7edf1cf..dbcf8b8 100644 --- a/Makefile +++ b/Makefile @@ -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" diff --git a/REPORT.md b/REPORT.md index cf71be5..454720d 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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:` → `{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: "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. diff --git a/evidence/dependency_failure.json b/evidence/dependency_failure.json index 6a26336..d533df0 100644 --- a/evidence/dependency_failure.json +++ b/evidence/dependency_failure.json @@ -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", diff --git a/evidence/explain_history.txt b/evidence/explain_history.txt index 3a56f62..3a817e7 100644 Binary files a/evidence/explain_history.txt and b/evidence/explain_history.txt differ diff --git a/evidence/load.json b/evidence/load.json index ab9cdc2..177f5dd 100644 --- a/evidence/load.json +++ b/evidence/load.json @@ -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." } diff --git a/evidence/revocation_partition.txt b/evidence/revocation_partition.txt new file mode 100644 index 0000000..9780374 --- /dev/null +++ b/evidence/revocation_partition.txt @@ -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] diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt index f7e46bd..1c7506e 100644 --- a/evidence/student-tests.txt +++ b/evidence/student-tests.txt @@ -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 diff --git a/migrations/002_session_cache_invalidations.sql b/migrations/002_session_cache_invalidations.sql new file mode 100644 index 0000000..1c26116 --- /dev/null +++ b/migrations/002_session_cache_invalidations.sql @@ -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); diff --git a/src/main.py b/src/main.py index f46ec51..bb39bf0 100644 --- a/src/main.py +++ b/src/main.py @@ -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: diff --git a/src/sessions.py b/src/sessions.py index 97803db..d906fea 100644 --- a/src/sessions.py +++ b/src/sessions.py @@ -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 diff --git a/src/storage.py b/src/storage.py index 9cc8ded..581aed4 100644 --- a/src/storage.py +++ b/src/storage.py @@ -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: diff --git a/student-tests/dependency_failure.py b/student-tests/dependency_failure.py index ec33b2f..fbfb5c1 100644 --- a/student-tests/dependency_failure.py +++ b/student-tests/dependency_failure.py @@ -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) diff --git a/student-tests/revocation_partition.py b/student-tests/revocation_partition.py new file mode 100644 index 0000000..da4c7e5 --- /dev/null +++ b/student-tests/revocation_partition.py @@ -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() 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", diff --git a/student-tests/test_session_cache.py b/student-tests/test_session_cache.py new file mode 100644 index 0000000..e097270 --- /dev/null +++ b/student-tests/test_session_cache.py @@ -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)