Исправления по ревью: 415 для не-JSON, logout атомарен с инвалидацией кэша
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
2026-10-22 13:31:03 +03:00
parent dbdb66456a
commit 9e7c792e9d
6 changed files with 172 additions and 23 deletions
+6 -2
View File
@@ -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:<sha256>`; промах → `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) часы разных хостов могут расходиться.
+20 -4
View File
@@ -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)
# Отправитель — из сессии, а не из тела запроса.
+37 -17
View File
@@ -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
+27
View File
@@ -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
+68
View File
@@ -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()
+14
View File
@@ -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()