From 90a0532809b35d79445e3fad32b4a23ed71ff0c4 Mon Sep 17 00:00:00 2001 From: Pavel Grigorev Date: Sat, 31 Oct 2026 10:25:02 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9E=D1=82=D0=B7=D1=8B=D0=B2=D0=B0=D1=82?= =?UTF-8?q?=D1=8C=20=D1=81=D0=B5=D1=81=D1=81=D0=B8=D1=8E=20=D0=B2=20=D0=BA?= =?UTF-8?q?=D1=8D=D1=88=D0=B5=20=D0=B4=D0=BE=20=D1=83=D0=B4=D0=B0=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D1=8F=20=D0=B2=20PostgreSQL?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 15 ++++---- evidence/README.md | 2 +- evidence/expiry.txt | 2 +- evidence/failure.txt | 30 ++++++++------- evidence/smoke.txt | 2 +- evidence/student-tests.txt | 10 ++++- src/auth.py | 11 ++++-- src/cache.py | 26 ++++++++----- student-tests/failure_check.py | 7 +++- student-tests/test_cache.py | 67 ++++++++++++++++++++++++++++++++++ 10 files changed, 131 insertions(+), 41 deletions(-) create mode 100644 student-tests/test_cache.py diff --git a/REPORT.md b/REPORT.md index 4a8161b9..e79fb1a2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -67,9 +67,9 @@ migrate (one-shot) ──► postgres сеть backend: internal, по **Транзакционные границы.** Регистрация — один INSERT, гонку решает UNIQUE (`unique_violation` → 409). Вход — удаление истёкших сессий пользователя и вставка новой в одной транзакции. **Создание чата** — `INSERT chats` и `INSERT chat_members … FROM unnest(...) WITH ORDINALITY` в одной явной транзакции; неизвестный участник вызывает `foreign_key_violation`, откатывается всё (→ 400). Сообщение — один `INSERT … SELECT … WHERE EXISTS(членство)`, проверка доступа и запись атомарны. Чтение истории — проверка членства и keyset-SELECT на одном соединении. Все запросы параметризованы. -**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout удаляет строку сессии (204), повтор — 401. +**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout сначала записывает в Valkey отметку отзыва (tombstone), затем удаляет строку сессии (204), повтор — 401; если отметку записать нельзя, logout отвечает 503 и ничего не меняет (см. «Роль Valkey»). -**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside). TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. Инвалидация: logout удаляет строку в PostgreSQL, затем `DEL` в Valkey. Известное окно: гонка «чтение сессии из БД ↔ logout» может вернуть отозванную запись в кэш не дольше 60 с. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. +**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside) командой `SET … NX`. TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. **Инвалидация fail-closed:** logout сначала записывает tombstone `revoked` с TTL 60 с (запись обязательна и выполняется даже в окне обхода кэша), и только после успеха удаляет строку в PostgreSQL; при недоступном Valkey logout отвечает 503 и не меняет ничего, токен остаётся действительным до повторного logout. Tombstone видят все реплики (→ 401), а `SET NX` не даёт запоздавшему запросу, прочитавшему сессию до удаления, затереть его положительной записью. Без этого (найдено при проверке: `docker compose pause valkey` → logout 204 → после unpause токен снова 200 ещё ~54 с) отозванный токен жил до истечения кэша — регрессионный тест `test_cache.py`. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с. **Readiness.** Критична только PostgreSQL (`SELECT 1` из пула за ≤ 1 с); Valkey некритичен. Отказ БД: `OperationalError`/`PoolTimeout` → 503 `unavailable` за ≤ ~2 с; запрос без проверенной сессии никогда не получает 200. @@ -102,14 +102,14 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | 3: создание чата атомарно | `test_chat_creation_is_rolled_back` | в логе PostgreSQL FK-ошибка с UUID несуществующего участника, количество строк chats/chat_members не изменилось | `student-tests.txt` | | 3: Basic только на входе, Bearer на остальном, X-User-Id не даёт доступ, expiry и logout, KDF | `test_auth.py`, `test_db.py` | Basic/X-User-Id/мусор → 401 Bearer; X-User-Id не подменяет пользователя; logout → 204, повтор 401; `password_hash` начинается с `$argon2id$`, в sessions — sha256 токена | `student-tests.txt` | | 3: secrets/volumes не в Git | `git status --ignored` | `.env`, `secrets/`, `backups/` игнорируются | `.gitignore` | -| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py` | TTL ключа сессии в Valkey ≤ TTL сессии | `expiry.txt` | +| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py`; `test_cache.py` | TTL ключа сессии в Valkey ≤ TTL сессии; logout при `pause valkey` → 503, токен не «воскресает»; после logout в кэше tombstone, `SET NX` его не затирает; потеря записи кэша — только промах | `expiry.txt`, `student-tests.txt` | | 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/db.py` | `%s`-параметры везде; пул 1..10, wait 2 с, statement_timeout 5 с, connect 3 с | код | | 4: гонка регистрации одного username | `test_parallel_registration_of_same_username` | 20 одновременных: 1×201 + 19×409; вход только с паролем победителя | `student-tests.txt` | | 4: rollback составной операции | см. «создание чата атомарно» | — | `student-tests.txt` | | 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений, без полного scan | `python research/track2.py explain` | 200 000 сообщений; `Limit → Index Scan using messages_chat_history_idx`, без Sort; 9–13 буферов на первой и на 90%-й странице чата из 100 000 | `explain-history.txt` | | 4: expiry при коротком SESSION_TTL_SECONDS | `python student-tests/expiry_check.py --ttl 2` | сразу 200, через 3,5 с 401 с Bearer challenge, logout истёкшим → 401 | `expiry.txt` | | 4: logout, неверный пароль | `test_auth.py` | см. выше; неверный пароль и несуществующий логин — одинаковый 401 | `student-tests.txt` | -| 4: недоступность Redis/БД | `python student-tests/failure_check.py` | Valkey stop: всё 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с); PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | +| 4: недоступность Redis/БД | `python student-tests/failure_check.py`, `test_cache.py` | Valkey stop: чтение и запись 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с), logout → 503 за 1,0 с (отзыв не подтверждён), после восстановления logout 204 → 401; PostgreSQL stop: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта тот же токен и данные | `failure.txt` | | 4 (из lab1): SIGTERM | `student-tests/sigterm_check.py` | `docker stop` 0,57 с, exit 0, 5xx — 0 | `sigterm.txt` | | 5, трек 2 | `python research/track2.py all` | см. следующий раздел | `track2/` | @@ -191,7 +191,8 @@ migrate (one-shot) ──► postgres сеть backend: internal, по | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | | restart api + postgres + valkey (`restart.sh`) | данные и прежний токен сохраняются | PASS, тот же токен | ≈ 10 с до ready; потерь нет | -| `docker compose stop valkey` | обход кэша, всё работает | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с | мгновенно; потерь нет | +| `docker compose stop valkey` | обход кэша; отзыв сессии не теряется | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с; logout → 503 | мгновенно; потерь нет | +| `docker compose pause valkey` + logout | отозванный токен не работает | logout → 503; после unpause повтор → 204, затем 401 (и через 6 с) | — | | `docker compose stop postgres` | ограниченный 503, анонимный не проходит | 503 за ≈ 2 с, неизвестный токен 503, ready 503, live 200 | ready через 13,1 с после stop (включая ~10 с проверок во время отказа); потерь нет | | SESSION_TTL_SECONDS=2 | истечение сессии | 401 через 3,5 с | — | | SIGTERM api | корректная остановка | 0,57 с, exit 0 | — | @@ -199,8 +200,8 @@ migrate (one-shot) ──► postgres сеть backend: internal, по ## Ограничения и следующие шаги -- Выдерживается: рестарт любого контейнера, отказ Valkey (деградация без ошибок), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. -- Окно устаревания кэша сессий при гонке с logout — до 60 с (TTL); закрыть можно tombstone-ключом при logout. +- Выдерживается: рестарт любого контейнера, отказ Valkey (чтение и запись через PostgreSQL; только logout отвечает 503 до восстановления кэша), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа. +- Logout недоступен (503), пока недоступен Valkey: это осознанный выбор fail-closed — нельзя подтвердить отзыв, не убрав положительную запись из кэша. При `pause` команда записи tombstone может выполниться после возобновления: тогда токен после ответа 503 временно (≤ 60 с) получает 401 — ошибка в безопасную сторону. - Valkey без пароля и TLS — допустимо только во внутренней сети учебного стенда; TLS для внешнего API появится в lab7, Basic по HTTP — только локально. - Rate limiting входа (защита от перебора паролей) не реализован. - Истёкшие сессии удаляются при следующем входе пользователя; фоновой чистки нет (индекс `expires_at` готов для неё). diff --git a/evidence/README.md b/evidence/README.md index ef8b205c..93b3199a 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -10,7 +10,7 @@ | --- | --- | --- | | `smoke.txt` | `python tests/smoke.py --base-url http://127.0.0.1:8080` | публичный сценарий lab2 | | `persistence.txt` | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS + `docker compose ps` до/после, строки остановки/старта из логов, volumes | -| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 37 собственных тестов: API, аутентификация, гонки, rollback, миграции | +| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 40 собственных тестов: API, аутентификация, кэш сессий и отзыв, гонки, rollback, миграции | | `expiry.txt` | `python student-tests/expiry_check.py --ttl 2` | истечение сессии и TTL ключа в Valkey | | `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey и PostgreSQL | | `sigterm.txt` | `python student-tests/sigterm_check.py` | остановка API по SIGTERM | diff --git a/evidence/expiry.txt b/evidence/expiry.txt index 91dc987f..38cee458 100644 --- a/evidence/expiry.txt +++ b/evidence/expiry.txt @@ -1,5 +1,5 @@ # python student-tests/expiry_check.py --ttl 2 -# date: 2026-10-29T09:20:36Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:20:24Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM пересоздаю api с SESSION_TTL_SECONDS=2 сразу после входа: /users/me -> 200 diff --git a/evidence/failure.txt b/evidence/failure.txt index 684924de..a769e019 100644 --- a/evidence/failure.txt +++ b/evidence/failure.txt @@ -1,24 +1,26 @@ # python student-tests/failure_check.py -# date: 2026-10-30T13:48:15Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:21:03Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM 1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL первый запрос: обнаружение отказа кэша -> 200 за 1.01 с OK - GET /users/me действующим токеном -> 200 за 0.02 с OK + GET /users/me действующим токеном -> 200 за 0.01 с OK POST сообщение -> 201 за 0.02 с OK неизвестный токен -> 401 за 0.01 с OK - без Authorization -> 401 за 0.00 с OK - /health/ready (Valkey некритичен) -> 200 за 0.00 с OK - регистрация и вход без кэша -> 200 за 0.05 с OK - logout без кэша -> 204 за 0.01 с OK - отозванный токен -> 401 за 0.00 с OK + без Authorization -> 401 за 0.02 с OK + /health/ready (Valkey некритичен) -> 200 за 0.01 с OK + регистрация и вход без кэша -> 200 за 0.13 с OK + logout без кэша: отзыв не подтверждён -> 503 за 1.01 с OK + токен после неудачного logout работает -> 200 за 0.03 с OK + logout после восстановления Valkey -> 204 за 0.04 с OK + отозванный токен -> 401 за 0.01 с OK 2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит GET история -> 503 за 2.01 с OK - POST сообщение -> 503 за 2.02 с OK - неизвестный токен (не 200!) -> 503 за 2.00 с OK - без Authorization -> 401 за 0.00 с OK - вход по Basic верным паролем -> 503 за 2.00 с OK - /health/live -> 200 за 0.02 с OK - /health/ready -> 503 за 1.00 с OK -3. PostgreSQL запущен: готовность через 15.3 с после остановки + POST сообщение -> 503 за 2.01 с OK + неизвестный токен (не 200!) -> 503 за 2.01 с OK + без Authorization -> 401 за 0.01 с OK + вход по Basic верным паролем -> 503 за 2.01 с OK + /health/live -> 200 за 0.01 с OK + /health/ready -> 503 за 1.01 с OK +3. PostgreSQL запущен: готовность через 15.5 с после остановки прежний токен -> 200; история: ['до отказа', 'без кэша'] PASS: отказы Valkey и PostgreSQL обработаны diff --git a/evidence/smoke.txt b/evidence/smoke.txt index 6600b557..4f2010f0 100644 --- a/evidence/smoke.txt +++ b/evidence/smoke.txt @@ -1,4 +1,4 @@ # python tests/smoke.py --base-url http://127.0.0.1:8080 -# date: 2026-10-30T13:48:39Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:19:12Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt index 355ffb89..77fe5378 100644 --- a/evidence/student-tests.txt +++ b/evidence/student-tests.txt @@ -1,5 +1,5 @@ # python -m unittest discover -s student-tests -v -# date: 2026-10-30T13:48:04Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM +# date: 2026-10-31T07:19:13Z; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username) Повторная регистрация того же username -> 409 conflict ... ok @@ -63,6 +63,12 @@ test_password_length_limits (test_auth.RegistrationTest.test_password_length_lim Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом ... ok test_password_required_and_not_blank (test_auth.RegistrationTest.test_password_required_and_not_blank) Без password или из одних пробелов -> 400 ... ok +test_logout_during_cache_outage_never_leaves_token_alive (test_cache.SessionCacheTest.test_logout_during_cache_outage_never_leaves_token_alive) +Valkey на паузе: logout не отвечает 204, пока отзыв не записан в кэш; после восстановления токен отзывается ... ok +test_lost_cache_entry_does_not_log_out (test_cache.SessionCacheTest.test_lost_cache_entry_does_not_log_out) +Потеря записи кэша (DEL/FLUSH) — только промах: сессия читается из PostgreSQL ... ok +test_tombstone_blocks_stale_cache_fill (test_cache.SessionCacheTest.test_tombstone_blocks_stale_cache_fill) +После logout в кэше tombstone; запоздалая запись положительной сессии (SET NX) не может его затереть ... ok test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) 100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории ... ok test_parallel_registration_of_same_username (test_concurrency.ConcurrencyTest.test_parallel_registration_of_same_username) @@ -77,7 +83,7 @@ test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_ В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok ---------------------------------------------------------------------- -Ran 37 tests in 11.022s +Ran 40 tests in 37.533s OK diff --git a/src/auth.py b/src/auth.py index 62048f7e..03670144 100644 --- a/src/auth.py +++ b/src/auth.py @@ -7,10 +7,10 @@ import secrets from argon2 import PasswordHasher from argon2.exceptions import InvalidHashError, VerificationError -from cache import cache +from cache import REVOKED, CacheUnavailable, cache from config import settings from db import iso -from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, unauthorized +from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, ApiError, unauthorized import store USERNAME = re.compile(r'^[a-z0-9_]{3,32}$') @@ -78,6 +78,8 @@ def authenticate(header): raise unauthorized(BEARER_CHALLENGE) digest = token_hash(token) user = cache.get(digest) + if user == REVOKED: + raise unauthorized(BEARER_CHALLENGE) if user is None: row = store.session_user(digest) if row is None: @@ -88,5 +90,8 @@ def authenticate(header): def logout(session): + try: + cache.revoke(session['token_hash']) + except CacheUnavailable: + raise ApiError(503, 'Отзыв сессии временно недоступен') from None store.delete_session(session['token_hash']) - cache.delete(session['token_hash']) diff --git a/src/cache.py b/src/cache.py index 2c3a83fe..38353d01 100644 --- a/src/cache.py +++ b/src/cache.py @@ -10,6 +10,11 @@ from config import settings log = logging.getLogger('messenger.cache') BYPASS_SECONDS = 5 +REVOKED = 'revoked' + + +class CacheUnavailable(Exception): + pass class SessionCache: @@ -19,14 +24,18 @@ class SessionCache: self.max_ttl = max_ttl self.bypass_until = 0.0 - def _run(self, action): - if self.client is None or time.monotonic() < self.bypass_until: + def _run(self, action, required=False): + if self.client is None: + return None + if not required and time.monotonic() < self.bypass_until: return None try: return action(self.client) except redis.RedisError as error: log.warning('session cache unavailable (%s), using PostgreSQL for %ds', type(error).__name__, BYPASS_SECONDS) self.bypass_until = time.monotonic() + BYPASS_SECONDS + if required: + raise CacheUnavailable from None return None @staticmethod @@ -35,8 +44,8 @@ class SessionCache: def get(self, token_hash): raw = self._run(lambda c: c.get(self.key(token_hash))) - if not raw: - return None + if not raw or raw == REVOKED: + return raw or None entry = json.loads(raw) if entry['expires_at'] <= time.time(): return None @@ -48,13 +57,10 @@ class SessionCache: if ttl <= 0: return value = json.dumps({'user': user, 'expires_at': expires_at.timestamp()}, ensure_ascii=False) - self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl)) + self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl, nx=True)) - def delete(self, token_hash): - self._run(lambda c: c.delete(self.key(token_hash))) - - def ping(self): - return bool(self._run(lambda c: c.ping())) + def revoke(self, token_hash): + self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), required=True) cache = SessionCache(settings.cache_url, settings.session_cache_ttl) diff --git a/student-tests/failure_check.py b/student-tests/failure_check.py index 4c93d293..62ce1db8 100644 --- a/student-tests/failure_check.py +++ b/student-tests/failure_check.py @@ -48,10 +48,13 @@ def main(): started = time.monotonic() other = new_user('nocache') expect('регистрация и вход без кэша', (200, time.monotonic() - started), [200], 1) - expect('logout без кэша', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1) - expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1) + expect('logout без кэша: отзыв не подтверждён', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [503], 1.5) + expect('токен после неудачного logout работает', timed('GET', '/api/v1/users/me', other['token']), [200], 1) finally: compose('up', '-d', '--wait', 'valkey') + time.sleep(6) + expect('logout после восстановления Valkey', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1) + expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1) print('2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит') compose('stop', 'postgres') diff --git a/student-tests/test_cache.py b/student-tests/test_cache.py new file mode 100644 index 00000000..bb0b5d73 --- /dev/null +++ b/student-tests/test_cache.py @@ -0,0 +1,67 @@ +import hashlib +import json +import time +import unittest + +from helpers import call, compose, new_user + +BYPASS_SECONDS = 5 + + +def key(token): + return 'session:' + hashlib.sha256(token.encode()).hexdigest() + + +def valkey(*args): + return compose('exec', '-T', 'valkey', 'valkey-cli', *args) + + +def me(token): + return call('GET', '/api/v1/users/me', token=token)[0] + + +def logout(token): + return call('DELETE', '/api/v1/auth/sessions/current', token=token)[0] + + +class SessionCacheTest(unittest.TestCase): + def test_logout_during_cache_outage_never_leaves_token_alive(self): + """Valkey на паузе: logout не отвечает 204, пока отзыв не записан в кэш; после восстановления токен отзывается""" + alice = new_user('revoke') + self.assertEqual(me(alice['token']), 200) + compose('pause', 'valkey') + try: + status = logout(alice['token']) + finally: + compose('unpause', 'valkey') + time.sleep(BYPASS_SECONDS + 1) + if status == 204: + self.assertEqual(me(alice['token']), 401, '204 на logout, но токен остался рабочим') + else: + self.assertEqual(status, 503) + self.assertEqual(logout(alice['token']), 204) + self.assertEqual(me(alice['token']), 401) + time.sleep(BYPASS_SECONDS + 1) + self.assertEqual(me(alice['token']), 401) + + def test_tombstone_blocks_stale_cache_fill(self): + """После logout в кэше tombstone; запоздалая запись положительной сессии (SET NX) не может его затереть""" + alice = new_user('tombstone') + self.assertEqual(me(alice['token']), 200) + self.assertEqual(logout(alice['token']), 204) + self.assertEqual(valkey('GET', key(alice['token'])), 'revoked') + stale = json.dumps({'user': {'id': alice['id']}, 'expires_at': time.time() + 3600}) + self.assertEqual(valkey('SET', key(alice['token']), stale, 'EX', '60', 'NX'), '') + self.assertEqual(me(alice['token']), 401) + + def test_lost_cache_entry_does_not_log_out(self): + """Потеря записи кэша (DEL/FLUSH) — только промах: сессия читается из PostgreSQL""" + alice = new_user('miss') + self.assertEqual(me(alice['token']), 200) + valkey('DEL', key(alice['token'])) + self.assertEqual(me(alice['token']), 200) + self.assertNotEqual(valkey('GET', key(alice['token'])), '') + + +if __name__ == '__main__': + unittest.main()