diff --git a/REPORT.md b/REPORT.md index 3b3288c1..b0eedd9c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -25,6 +25,7 @@ make test-persistence ACTION_SCRIPT=scripts/restart.sh python student-tests/run.py --base-url http://localhost:8080 python student-tests/race.py --base-url http://localhost:8080 python student-tests/outage.py --base-url http://localhost:8080 +python student-tests/logout_cache.py --base-url http://localhost:8080 docker compose --env-file .env --profile ttl up -d api-ttl python student-tests/expiry.py --base-url http://localhost:8081 docker compose cp student-tests/rollback_check.py api:/tmp/rollback_check.py @@ -67,7 +68,8 @@ docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql - Источник истины — таблица `sessions` в PostgreSQL. Срок задаёт `expires_at = now + SESSION_TTL_SECONDS`, рестарт его не продлевает. - Чтение Bearer: сначала Redis `sess:`; промах → `SELECT … WHERE revoked_at IS NULL AND expires_at > now()` → запись в кэш. - Политика expiry кэша: TTL ключа = `min(SESSION_CACHE_TTL_SECONDS=60, время до expires_at)`, при чтении из кэша дополнительно сверяется `exp`. Кэш никогда не продлевает сессию. -- Инвалидация: logout сначала ставит `revoked_at` в PostgreSQL, затем удаляет ключ из Redis. +- Инвалидация (logout) атомарна для БД и кэша (`app/sessions.py`, `revoke`): в одной транзакции `UPDATE sessions SET revoked_at` и затем `DEL` ключа в Redis. Если Redis не ответил (остановлен, приостановлен, таймаут), транзакция откатывается и клиент получает `503 unavailable`: logout не подтверждён, сессия остаётся согласованной. `204` возвращается только когда отозвано и в БД, и в кэше, поэтому после `204` старый токен не принимается никогда, в том числе после восстановления Redis. +- Гонка «параллельное чтение кладёт отозванную сессию в кэш после DEL» закрыта блокировкой: чтение сессии из БД идёт с `SELECT … FOR SHARE` и кладёт её в кэш, не отпуская строку; `UPDATE` в logout ждёт окончания такого чтения и удаляет ключ уже после него. - Redis недоступен / flush / рестарт → кэш обходится, всё читается из PostgreSQL; сессии не теряются. Поэтому Redis запущен без persistence (`--save "" --appendonly no`) — осознанно: он не единственное хранилище. - PostgreSQL недоступен → `503 unavailable` (обработчик `OperationalError`/`PoolTimeout`), `/health/ready` = 503, `/health/live` = 200. Неизвестный токен никогда не принимается. @@ -102,6 +104,8 @@ docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql | Basic только на `/auth/sessions`, Bearer, `X-User-Id` не даёт доступ | `student-tests/run.py` (раздел «аутентификация») | Basic на бизнес-endpoint → 401; `X-User-Id` → 401 и не подменяет владельца | `evidence/student-tests.txt` | | Неверный пароль, неизвестный user | `run.py` | одинаковый 401 + `WWW-Authenticate: Basic …` | `evidence/student-tests.txt` | | Logout | `run.py` | 204 → токен 401 → повторный logout 401 | `evidence/student-tests.txt` | +| Logout при приостановленном Redis | `logout_cache.py` (прогрев кэша → `docker compose pause redis` → logout → `unpause` → старый токен) | logout не подтверждается (503, не 204); после восстановления повторный logout → 204, старый токен → 401. На версии до исправления: 204 и старый токен снова принимался | `evidence/logout-cache.txt` | +| Тип содержимого | `run.py` (раздел «Content-Type») | корректный JSON с `text/plain` → 415 `unsupported_media_type`; без токена сначала 401; `application/json; charset=utf-8` принимается; битый JSON → 400 | `evidence/student-tests.txt` | | Expiry при коротком TTL | `expiry.py` против `api-ttl` (TTL=2) | `expires_at` ≈ +2 c; до истечения 200, после — 401 (кэш не продлил сессию) | `evidence/expiry.txt` | | Гонка регистрации одного username | `run.py`: 20 параллельных POST | ровно один 201 и девятнадцать 409 | `evidence/student-tests.txt` | | Конкурентная запись | `race.py`: 10 клиентов × 10 сообщений | 100 принято, 100 уникальных в истории | `evidence/student-tests.txt` | @@ -134,7 +138,7 @@ docker compose exec postgres psql -U messenger -d messenger -f /tmp/explain.sql ## Ограничения и следующие шаги -- Если при logout Redis недоступен, а потом вернулся с сохранёнными данными, ключ отозванной сессии может прожить до `SESSION_CACHE_TTL_SECONDS` (60 c). В нашей конфигурации Redis без persistence, поэтому после его рестарта кэш пуст; окно до 60 с остаётся только при сетевом разрыве — осознанный компромисс. +- Пока Redis недоступен, logout возвращает 503 и его нужно повторить после восстановления: так отзыв никогда не подтверждается без инвалидации кэша. Остальные операции в это время работают в обход кэша. - При недоступном PostgreSQL сессия из кэша ещё распознаётся, но любое действие с данными получает 503. - Durability: ответ 201 означает COMMIT в PostgreSQL с настройками по умолчанию (`synchronous_commit=on`, fsync). Реплик и бэкапов нет — отказ диска с volume означает потерю данных. - `created_at` назначает API по своим UTC-часам; при равных метках порядок задаёт `id`. При нескольких репликах (lab3) часы разных хостов могут расходиться. diff --git a/app/main.py b/app/main.py index c610735c..702bb0a1 100644 --- a/app/main.py +++ b/app/main.py @@ -168,6 +168,15 @@ def _parse_basic(request: Request) -> tuple[str, str]: return username, password +def require_json(request: Request) -> None: + """Тип тела проверяем ДО валидации тела: не JSON → 415, а не 400. + Подключается после current_user, поэтому без токена по-прежнему сначала 401. + Параметры вроде '; charset=utf-8' допустимы.""" + media_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower() + if media_type != "application/json": + raise ApiError(415, "unsupported_media_type", "Content-Type must be application/json") + + # ============================================================================ # 4. МОДЕЛИ ВВОДА # ============================================================================ @@ -252,7 +261,7 @@ async def health_ready(request: Request): # -------- users и сессии -------- @app.post("/api/v1/users", status_code=201) -async def create_user(body: CreateUser): +async def create_user(body: CreateUser, _json: None = Depends(require_json)): # Argon2 намеренно медленный — считаем в пуле потоков, чтобы не блокировать event loop. password_hash = await run_in_threadpool(security.hash_password, body.password) async with db.get_pool().connection() as conn: @@ -282,7 +291,12 @@ async def create_session(request: Request): @app.delete("/api/v1/auth/sessions/current", status_code=204) async def delete_session(request: Request, user: dict = Depends(current_user)): - if not await sessions.revoke(db.get_pool(), request.state.token): + try: + revoked = await sessions.revoke(db.get_pool(), request.state.token) + except sessions.CacheUnavailable: + # 204 только при гарантированном отзыве; иначе ограниченная ошибка, повторить позже. + raise ApiError(503, "unavailable", "session cache unavailable, logout not confirmed") + if not revoked: raise unauthorized() return Response(status_code=204) @@ -294,7 +308,8 @@ async def get_me(user: dict = Depends(current_user)): # -------- chats -------- @app.post("/api/v1/chats", status_code=201) -async def create_chat(body: CreateChat, user: dict = Depends(current_user)): +async def create_chat(body: CreateChat, user: dict = Depends(current_user), + _json: None = Depends(require_json)): members = body.member_ids if not (1 <= len(members) <= 100): raise ApiError(400, "invalid_request", "member_ids must have 1..100 items") @@ -340,7 +355,8 @@ async def get_chat(chat_id: str, user: dict = Depends(current_user)): # -------- messages -------- @app.post("/api/v1/chats/{chat_id}/messages", status_code=201) -async def send_message(chat_id: str, body: CreateMessage, user: dict = Depends(current_user)): +async def send_message(chat_id: str, body: CreateMessage, user: dict = Depends(current_user), + _json: None = Depends(require_json)): async with db.get_pool().connection() as conn: chat = await accessible_chat(conn, chat_id, user) # Отправитель — из сессии, а не из тела запроса. diff --git a/app/sessions.py b/app/sessions.py index a4764516..5f9ced65 100644 --- a/app/sessions.py +++ b/app/sessions.py @@ -10,8 +10,14 @@ TTL ключа в Redis = min(SESSION_CACHE_TTL_SECONDS, время до expires_at), поэтому кэш никогда не продлевает сессию. -Инвалидация: logout сначала помечает revoked_at в PostgreSQL, затем удаляет -ключ из Redis. Отозванную сессию из кэша больше не прочитать. +Инвалидация (logout) — атомарно для БД и кэша: + в одной транзакции UPDATE sessions SET revoked_at (строка блокируется), + затем DEL ключа в Redis. Если Redis не ответил — транзакция откатывается и + клиент получает 503: logout НЕ подтверждён, 204 отдаётся только когда + копии отозванной сессии в кэше гарантированно нет. + Гонка «чтение кладёт старую сессию в кэш после DEL» закрыта блокировкой: + чтение из БД идёт с FOR SHARE и кладёт в кэш, не отпуская строку, поэтому + logout ждёт окончания такого чтения и удаляет ключ уже после него. Отказ Redis: кэш обходится, всё читается из PostgreSQL (медленнее, но верно). Flush/рестарт Redis: кэш пустой → сессии восстанавливаются из PostgreSQL. @@ -90,15 +96,21 @@ async def _cache_put(th: bytes, user: dict, expires_at: datetime) -> None: log.warning("redis unavailable on write, skipping cache: %s", type(exc).__name__) -async def _cache_delete(th: bytes) -> None: +class CacheUnavailable(Exception): + """Redis не подтвердил удаление ключа — отзыв сессии нельзя гарантировать.""" + + +async def _cache_delete_strict(th: bytes) -> None: + """Удалить копию сессии из кэша или поднять CacheUnavailable. + Молча проглатывать ошибку нельзя: если Redis «приостановлен», ключ + переживёт сбой и после восстановления отозванный токен снова примут.""" if _redis is None: return try: await _redis.delete(_key(th)) except (RedisError, OSError) as exc: - # Сессия уже отозвана в PostgreSQL. Если Redis пережил сбой с данными, - # устаревший ключ проживёт не дольше SESSION_CACHE_TTL_SECONDS. log.warning("redis unavailable on invalidate: %s", type(exc).__name__) + raise CacheUnavailable() from exc async def create_session(conn, user_id) -> tuple[str, datetime]: @@ -121,28 +133,36 @@ async def resolve(pool, token: str, load_user) -> dict | None: return cached["user"] return None async with pool.connection() as conn: + # FOR SHARE: пока эта транзакция не закончилась (вместе с записью в кэш), + # logout не сможет отозвать строку — он дождётся и удалит ключ после нас. cur = await conn.execute( "SELECT user_id, expires_at FROM sessions " - "WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now()", + "WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() " + "FOR SHARE", (th,)) row = await cur.fetchone() if row is None: return None user = await load_user(conn, row[0]) - if user is None: - return None - await _cache_put(th, user, row[1]) + if user is None: + return None + await _cache_put(th, user, row[1]) return user async def revoke(pool, token: str) -> bool: - """Отозвать сессию. True — была действующая и теперь отозвана.""" + """Отозвать сессию. True — была действующая и теперь отозвана (и в БД, и в кэше). + False — сессии нет/уже отозвана. CacheUnavailable — Redis не ответил: + транзакция откатана, сессия осталась действующей, logout не подтверждён.""" th = token_hash(token) async with pool.connection() as conn: - cur = await conn.execute( - "UPDATE sessions SET revoked_at = now() " - "WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() " - "RETURNING 1", (th,)) - ok = await cur.fetchone() is not None - await _cache_delete(th) - return ok + async with conn.transaction(): + cur = await conn.execute( + "UPDATE sessions SET revoked_at = now() " + "WHERE token_hash = %s AND revoked_at IS NULL AND expires_at > now() " + "RETURNING 1", (th,)) + if await cur.fetchone() is None: + return False + # Внутри транзакции: ошибка Redis → исключение → ROLLBACK отзыва. + await _cache_delete_strict(th) + return True diff --git a/evidence/logout-cache.txt b/evidence/logout-cache.txt new file mode 100644 index 00000000..602bbff5 --- /dev/null +++ b/evidence/logout-cache.txt @@ -0,0 +1,27 @@ +# 2026-10-22T10:10Z, Redis приостановлен процессным сигналом (в Docker: docker compose pause/unpause redis) +$ python student-tests/logout_cache.py + ok - session is warmed up in cache +== Redis приостановлен == + $ kill -STOP 4026 + ok - logout is NOT confirmed while cache cannot be invalidated (got 503, expected 503) + $ kill -CONT 4026 +== Redis восстановлен == + ok - unconfirmed logout left the session consistent and valid (got 200) + ok - retry logout after Redis recovery -> 204 (got 204) + ok - old token after confirmed logout -> 401, no stale cache copy (got 401) + ok - old token still rejected on repeat (got 401) + +6 passed, 0 failed + +# Для сравнения: та же проверка на версии ДО исправления (commit dbdb66456a) + ok - session is warmed up in cache +== Redis приостановлен == + $ kill -STOP 6663 + FAIL - logout is NOT confirmed while cache cannot be invalidated (got 204, expected 503) + $ kill -CONT 6663 +== Redis восстановлен == + FAIL - after a 204 the old token is rejected after Redis recovery (got 200) + FAIL - old token after confirmed logout -> 401, no stale cache copy (got 200) + FAIL - old token still rejected on repeat (got 200) + +1 passed, 4 failed diff --git a/student-tests/logout_cache.py b/student-tests/logout_cache.py new file mode 100644 index 00000000..04ae3725 --- /dev/null +++ b/student-tests/logout_cache.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +""" +Logout при приостановленном Redis (замечание к app/sessions.py). + +Сценарий преподавателя: прогреть сессию в кэше, приостановить Redis, сделать +logout, восстановить Redis и проверить старый токен. +Требование: 204 только при гарантированном отзыве; после 204 старый токен +никогда не принимается, в том числе после восстановления Redis. + + python student-tests/logout_cache.py --base-url http://localhost:8080 +(по умолчанию сам делает docker compose pause/unpause redis) +""" +import argparse +import shlex +import subprocess +import time + +from common import Api, Report + +COMPOSE = "docker compose --env-file .env" + + +def sh(cmd: str): + print(f" $ {cmd}") + subprocess.run(shlex.split(cmd), check=True, stdout=subprocess.DEVNULL) + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--base-url", default="http://localhost:8080") + ap.add_argument("--pause-redis", default=f"{COMPOSE} pause redis") + ap.add_argument("--unpause-redis", default=f"{COMPOSE} unpause redis") + args = ap.parse_args() + api, r = Api(args.base_url), Report() + + user = api.new_user("logoutcache") + token = user["token"] + for _ in range(2): # первый запрос кладёт сессию в Redis, второй читает из кэша + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + r.check(st == 200, "session is warmed up in cache") + + print("== Redis приостановлен ==") + sh(args.pause_redis) + try: + st_logout, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token) + r.check(st_logout != 204, + f"logout is NOT confirmed while cache cannot be invalidated (got {st_logout}, expected 503)") + finally: + sh(args.unpause_redis) + time.sleep(0.5) + + print("== Redis восстановлен ==") + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + if st_logout == 204: + r.check(st == 401, f"after a 204 the old token is rejected after Redis recovery (got {st})") + else: + r.check(st == 200, f"unconfirmed logout left the session consistent and valid (got {st})") + st, _, _ = api.call("DELETE", "/api/v1/auth/sessions/current", token=token) + r.check(st == 204, f"retry logout after Redis recovery -> 204 (got {st})") + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + r.check(st == 401, f"old token after confirmed logout -> 401, no stale cache copy (got {st})") + st, _, _ = api.call("GET", "/api/v1/users/me", token=token) + r.check(st == 401, f"old token still rejected on repeat (got {st})") + r.finish() + + +if __name__ == "__main__": + main() diff --git a/student-tests/run.py b/student-tests/run.py index 52cc3fe5..00661af2 100644 --- a/student-tests/run.py +++ b/student-tests/run.py @@ -8,6 +8,7 @@ """ import argparse import base64 +import json import uuid from concurrent.futures import ThreadPoolExecutor @@ -100,6 +101,19 @@ def main(): st, _, _ = api.call("GET", f"/api/v1/chats/{other['id']}/messages?cursor={p['next_cursor']}", token=alice["token"]) r.check(st == 400, "cursor from another chat -> 400") + print("== Content-Type ==") + body = json.dumps({"username": "ct_" + uuid.uuid4().hex[:8], "display_name": "c", "password": PASSWORD}).encode() + st, _, _ = api.raw("POST", "/api/v1/users", body, {"Content-Type": "text/plain"}) + r.check(st == 415, f"valid JSON with text/plain -> 415 (got {st})") + st, _, _ = api.raw("POST", mpath, json.dumps({"text": "x"}).encode(), + {"Content-Type": "text/plain", "Authorization": "Bearer " + alice["token"]}) + r.check(st == 415, f"message with text/plain -> 415 (got {st})") + st, _, _ = api.raw("POST", "/api/v1/chats", b"{}", {"Content-Type": "text/plain"}) + r.check(st == 401, f"text/plain without token -> 401 first (got {st})") + st, _, _ = api.raw("POST", mpath, json.dumps({"text": "utf8"}).encode(), + {"Content-Type": "application/json; charset=utf-8", "Authorization": "Bearer " + alice["token"]}) + r.check(st == 201, f"application/json; charset=utf-8 accepted (got {st})") + r.finish()