forked from mtusi2026/mtusi2026lab2
Исправить logout при сбое записи в кэш сессий
This commit is contained in:
@@ -77,6 +77,10 @@ migrate (one-shot) ──> postgres : применение migrations/*.sql
|
||||
- **Источник истины — PostgreSQL.** Valkey хранит `session:<sha256 hex>` → `{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). Это не раскрывает данных.
|
||||
|
||||
+3
-2
@@ -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")
|
||||
|
||||
+40
-5
@@ -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()
|
||||
|
||||
@@ -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
|
||||
@@ -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")
|
||||
|
||||
Reference in New Issue
Block a user