diff --git a/REPORT.md b/REPORT.md index 7fb98fe..9134736 100644 --- a/REPORT.md +++ b/REPORT.md @@ -77,6 +77,10 @@ migrate (one-shot) ──> postgres : применение migrations/*.sql - **Источник истины — PostgreSQL.** Valkey хранит `session:` → `{user, expires_at}`, чтобы не ходить в БД на каждом запросе; `/users/me` обслуживается вообще без БД. - **Expiry:** TTL записи = `min(остаток сессии, SESSION_CACHE_MAX_SECONDS=300)`, плюс при чтении из кэша сравнивается `expires_at`. Просроченная сессия не принимается ни из кэша, ни из БД. - **Инвалидация:** при logout сначала `revoked_at` в PostgreSQL, затем в Valkey пишется **надгробие** `revoked` (а не DEL). Заполнение кэша идёт через `SET NX`, поэтому параллельный запрос, прочитавший БД до отзыва, не сможет вернуть сессию в кэш. +- **Сбой записи tombstone (исправлено по замечанию к PR):** раньше ошибка записи в Valkey проглатывалась и logout отвечал 204, хотя в кэше оставалась действующая запись сессии; после восстановления Valkey отозванный токен снова получал 200 до 5 минут. Теперь: + - logout отвечает **503** («не подтверждён»), если tombstone не записан; сессия в PostgreSQL при этом уже отозвана; + - хеш токена запоминается в процессе как «отзыв ожидает записи», и запись из кэша для него игнорируется: проверка идёт в PostgreSQL → 401; + - фоновая задача раз в секунду повторяет запись tombstone, пока Valkey не ответит, но не дольше `SESSION_CACHE_MAX_SECONDS` (за это время устаревшая запись истекла бы сама). - **Persistence не нужна и выключена** (`save ""`, `appendonly no`): после flush или рестарта Valkey первая проверка идёт в PostgreSQL. Потеря кэша ничего не ломает, это подтверждает тест сохранности, где Valkey тоже перезапускается. - **Отказ Valkey:** таймаут 0.3 с, затем circuit breaker на 5 с, в течение которых кэш не используется. Readiness при этом остаётся 200: Valkey не критичен. - Конфигурация с `requirepass` лежит в секрете `secrets/valkey.conf`, порт наружу не публикуется. @@ -102,7 +106,7 @@ migrate (one-shot) ──> postgres : применение migrations/*.sql ## Доказательства критериев -Файлы в `evidence/` сняты 2026-10-07 (explain_history) и 2026-10-08 UTC (остальные) на MacBook (Apple Silicon, Docker Desktop, без CPU/RAM-лимитов в compose). +Файлы в `evidence/` сняты 2026-10-07 (explain_history), 2026-10-08 UTC (основные) и 2026-10-15 UTC (logout_cache_failure, на отдельном стенде с портом 18280) на MacBook (Apple Silicon, Docker Desktop, без CPU/RAM-лимитов в compose). | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | @@ -119,6 +123,7 @@ migrate (one-shot) ──> postgres : применение migrations/*.sql | 4: индекс истории + EXPLAIN на ≥10 000 | `make explain` | 70 000 сообщений, в чате 20 000; с индексом Index Scan, 4 буфера, 0.03 мс на первой и глубокой (#15000) странице; без индекса Seq Scan + Sort, 940 буферов, 3–4 мс | `evidence/explain_history.txt` | | 4: expiry при коротком TTL | `auth_test.py` против `api-short-ttl` (TTL=2) | через 3 с → 401 (и из кэша) | `evidence/student_tests.txt` | | 4: logout, неверный пароль | `auth_test.py` | неверный пароль и неизвестный user дают одинаковый 401 | `evidence/student_tests.txt` | +| 4: logout при сбое записи в кэш | `dependency_test.py` (`docker compose pause valkey` во время logout) | до исправления: 204 и отозванный токен → 200 из кэша; после: 503, токен → 401, tombstone дописан после `unpause` | `evidence/logout_cache_failure.txt` | | 4: недоступность Redis/БД | `dependency_test.py` | Valkey stop: ready=200, запросы ~4 мс; PostgreSQL stop: live=200, ready и бизнес-запросы 503 мгновенно, непроверенный токен → 503, без токена 401; после start всё восстанавливается без рестарта API | `evidence/student_tests.txt` | | Graceful shutdown (из lab1) | `sigterm_test.sh` | `docker compose stop api` → exit 0 за < 1 с | `evidence/student_tests.txt` | @@ -128,13 +133,14 @@ migrate (one-shot) ──> postgres : применение migrations/*.sql | --- | --- | --- | --- | | `scripts/restart.sh`: stop api, valkey, postgres → up | данные и сессия на месте, токен тот же | PASS, кэш пустой, сессии берутся из PostgreSQL | ~11 с весь hook / потерь нет | | `docker compose stop valkey` | API работает без кэша | 200, ~4 мс на запрос (breaker), revoked-токен 401 | мгновенно / потерь нет (кэш) | +| `docker compose pause valkey` во время logout | logout не сообщает об успехе, отозванный токен не принимается | 503; после `unpause` токен → 401, tombstone записан фоновой задачей | ~1 с после восстановления Valkey / потерь нет | | `docker compose stop postgres` | 503 без зависаний, анонимный доступ не появляется | ready 503, бизнес 503, live 200, всё за < 0.1 с | API восстанавливается сам после `start postgres`, без своего рестарта; подтверждённые данные целы | | SIGTERM api | graceful exit 0 | exit 0, «Application shutdown complete» | `docker compose up -d --wait api` | ## Ограничения и следующие шаги - Один Docker-host, по одному PostgreSQL и Valkey, без репликации: потеря host или диска = потеря сервиса (бэкапы не настроены, это трек 2 пятёрки). -- Если logout пришёлся на момент сетевой недоступности Valkey, а сам Valkey при этом не перезапускался, старая запись в кэше может жить до `SESSION_CACHE_MAX_SECONDS` (≤ 5 мин). Это осознанная граница: TTL кэша ограничен именно поэтому. +- Защита от устаревшей записи после неудачного logout живёт в памяти процесса API. Если сам API перезапустится до того, как Valkey снова станет доступен, или (с lab3) запрос придёт на другую реплику, устаревшая запись может приниматься до `SESSION_CACHE_MAX_SECONDS` (≤ 5 мин). Клиент при этом получил 503, а не 204. Для нескольких реплик нужен общий механизм, например версия сессии в кэше или pub/sub-инвалидация. - Просроченные строки `sessions` не удаляются автоматически (есть индекс `expires_at` для будущей периодической очистки). - `/health/ready` не проверяет Valkey намеренно. - Тело запроса проверяется до аутентификации: на неавторизованный запрос с битым JSON вернётся 400, а не 401 (особенность FastAPI). Это не раскрывает данных. diff --git a/app/auth.py b/app/auth.py index fc6d1f2..298a65d 100644 --- a/app/auth.py +++ b/app/auth.py @@ -14,7 +14,7 @@ from starlette.concurrency import run_in_threadpool from app import config from app.cache import REVOKED, SessionCache -from app.errors import BASIC_CHALLENGE, unauthorized +from app.errors import BASIC_CHALLENGE, ApiError, unauthorized from app.storage import Store, fmt_ts, user_row _hasher = PasswordHasher() @@ -109,4 +109,5 @@ async def logout(store: Store, cache: SessionCache, header: Optional[str]) -> No if expires_at is None: raise unauthorized("session expired or revoked") remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds()) + 1 - await cache.revoke(digest, remaining) + if not await cache.revoke(digest, remaining): + raise ApiError(503, "unavailable", "logout not confirmed by session cache, retry later") diff --git a/app/cache.py b/app/cache.py index 7600b48..02db961 100644 --- a/app/cache.py +++ b/app/cache.py @@ -1,9 +1,10 @@ from __future__ import annotations +import asyncio import json import logging import time -from typing import Optional, Union +from typing import Dict, Optional, Set, Union import redis.asyncio as redis from redis.exceptions import RedisError @@ -19,6 +20,8 @@ class SessionCache: def __init__(self, url: Optional[str]): self._client: Optional[redis.Redis] = None self._down_until = 0.0 + self._pending_revokes: Dict[bytes, float] = {} + self._retry_tasks: Set[asyncio.Task] = set() if url: pool = redis.BlockingConnectionPool.from_url( url, @@ -45,8 +48,17 @@ class SessionCache: def _key(token_hash: bytes) -> str: return "session:" + token_hash.hex() + def _revoke_pending(self, token_hash: bytes) -> bool: + deadline = self._pending_revokes.get(token_hash) + if deadline is None: + return False + if time.monotonic() >= deadline: + self._pending_revokes.pop(token_hash, None) + return False + return True + async def get(self, token_hash: bytes) -> Union[dict, str, None]: - if not self._usable(): + if not self._usable() or self._revoke_pending(token_hash): return None try: raw = await self._client.get(self._key(token_hash)) @@ -69,13 +81,34 @@ class SessionCache: except (RedisError, OSError) as exc: self._failed("set", exc) - async def revoke(self, token_hash: bytes, ttl_seconds: int) -> None: - if self._client is None: - return + async def _write_tombstone(self, token_hash: bytes, ttl_seconds: int) -> bool: try: await self._client.set(self._key(token_hash), REVOKED, ex=max(1, min(ttl_seconds, config.SESSION_CACHE_MAX_SECONDS))) + return True except (RedisError, OSError) as exc: self._failed("revoke", exc) + return False + + async def revoke(self, token_hash: bytes, ttl_seconds: int) -> bool: + if self._client is None: + return True + if await self._write_tombstone(token_hash, ttl_seconds): + return True + deadline = time.monotonic() + config.SESSION_CACHE_MAX_SECONDS + 1 + self._pending_revokes[token_hash] = deadline + task = asyncio.create_task(self._retry_revoke(token_hash, ttl_seconds, deadline)) + self._retry_tasks.add(task) + task.add_done_callback(self._retry_tasks.discard) + return False + + async def _retry_revoke(self, token_hash: bytes, ttl_seconds: int, deadline: float) -> None: + while time.monotonic() < deadline: + await asyncio.sleep(1) + remaining = int(deadline - time.monotonic()) + if remaining > 0 and await self._write_tombstone(token_hash, min(ttl_seconds, remaining)): + logger.info("revocation tombstone written after cache recovery") + break + self._pending_revokes.pop(token_hash, None) async def ping(self) -> bool: if self._client is None: @@ -86,5 +119,7 @@ class SessionCache: return False async def close(self) -> None: + for task in list(self._retry_tasks): + task.cancel() if self._client is not None: await self._client.aclose() diff --git a/evidence/logout_cache_failure.txt b/evidence/logout_cache_failure.txt new file mode 100644 index 0000000..f85551e --- /dev/null +++ b/evidence/logout_cache_failure.txt @@ -0,0 +1,16 @@ +# Logout while the session cache cannot be written (PR feedback) +# date: 2026-10-15T10:56:08Z base commit: 13fa185 + fix in app/cache.py, app/auth.py +# scenario: live session cached -> docker compose pause valkey -> DELETE /auth/sessions/current -> unpause -> wait 6s -> GET /users/me +# before fix: logout 204, revoked token -> 200 from stale cache + +$ python3 student-tests/dependency_test.py +ok - Valkey caches sessions with TTL<=300s and keeps logout tombstones +ok - Valkey stopped: ready=200, reads/writes OK, revoked token 401, 2 ms/request +ok - tombstone write failed during logout -> 503, cached session never accepted again, tombstone repaired +ok - PostgreSQL stopped: live=200, ready/business=503 in 0.0s total, unverified token not trusted +ok - PostgreSQL started again: API recovers without restart, data intact +PASS: 5 checks + +$ docker compose logs api | grep -E "revoke|tombstone" +WARNING:messenger.cache:cache revoke failed (TimeoutError); bypassing cache for 5s +INFO:messenger.cache:revocation tombstone written after cache recovery diff --git a/student-tests/dependency_test.py b/student-tests/dependency_test.py index 2e7a796..67d9b4a 100755 --- a/student-tests/dependency_test.py +++ b/student-tests/dependency_test.py @@ -1,4 +1,5 @@ #!/usr/bin/env python3 +import hashlib import time from stack import BASE_URL, Client, Failure, check, compose, main_wrapper, ok, valkey @@ -48,6 +49,29 @@ def main(): finally: compose("start", "valkey") + paused = c.user("pause") + key = "session:" + hashlib.sha256(paused["token"].encode("ascii")).hexdigest() + deadline = time.monotonic() + 15 + while not valkey("GET", key).startswith("{"): + check(time.monotonic() < deadline, "live session must be cached before the failure") + c.call("GET", "/api/v1/users/me", actor=paused, schema="User") + time.sleep(0.5) + try: + compose("pause", "valkey") + status = c.call("DELETE", "/api/v1/auth/sessions/current", [204, 503], actor=paused)["status"] + finally: + compose("unpause", "valkey") + check(status == 503, "logout must not report success while the cache still holds the live session (got %d)" % status) + time.sleep(6) + c.call("GET", "/api/v1/users/me", 401, actor=paused) + deadline = time.monotonic() + 10 + while valkey("GET", key) != "revoked": + check(time.monotonic() < deadline, "tombstone must be written once Valkey is back") + time.sleep(0.5) + c.call("GET", "/api/v1/users/me", 401, actor=paused) + c.call("DELETE", "/api/v1/auth/sessions/current", 401, actor=paused) + ok("tombstone write failed during logout -> 503, cached session never accepted again, tombstone repaired") + fresh = c.user("dbdown") try: compose("stop", "postgres")