forked from mtusi2026/mtusi2026lab2
lab2
This commit is contained in:
@@ -77,7 +77,7 @@ PostgreSQL и Valkey наружу не опубликованы, доступн
|
||||
- источник истины — таблица `sessions` в PostgreSQL. Она переживает рестарт, срок `expires_at` абсолютный, рестарт его не продлевает;
|
||||
- Valkey — кэш, чтобы не делать SQL-запрос при каждой проверке токена. Ключ `sess:<sha256 токена>`, значение — пользователь и expires_at;
|
||||
- expiry в кэше: TTL ключа = min(30 с, остаток жизни сессии); кроме того, expires_at проверяется при чтении, поэтому кэш никогда не продлевает сессию;
|
||||
- инвалидация: logout сначала ставит revoked_at в PostgreSQL, затем удаляет ключ из кэша. Если Valkey в момент logout недоступен, запись в кэше может прожить не дольше 30 с — это осознанная граница;
|
||||
- инвалидация: logout сначала ставит revoked_at в PostgreSQL, затем запоминает hash токена в процессе и удаляет ключ из кэша. Если DEL не дошёл, hash всё равно остаётся в памяти процесса: после восстановления Valkey старая запись не принимается. Записи кэша помечены эпохой процесса; при сбое эпоха меняется, и ключи, записанные до него, читаются заново из PostgreSQL;
|
||||
- persistence у Valkey выключена: кэш после рестарта пустой, данные снова берутся из PostgreSQL;
|
||||
- если Valkey недоступен, API его обходит и работает напрямую с PostgreSQL. После первой ошибки запросы перестают обращаться к кэшу, а фоновый поток раз в 5 с делает PING и, когда Valkey вернулся, снова включает кэш. Так ожидание подключения к пропавшему Valkey не попадает в запросы пользователей;
|
||||
- у Valkey ACL: пользователь `default` выключен, `messenger` (пароль из secrets) может только get/set/del/ping и только по ключам `sess:*`, `health` (без пароля) — только ping/info/dbsize.
|
||||
@@ -130,7 +130,7 @@ Durability: PostgreSQL с fsync=on, synchronous_commit=on, full_page_writes=on (
|
||||
| 4: автопроверка expiry при коротком SESSION_TTL_SECONDS | python student-tests/expiry.py (api-short-ttl, TTL=2) | до истечения 200, после — 401 на обоих API | evidence/expiry.txt |
|
||||
| 4: автопроверка logout | student-tests (test_logout_revokes_only_current_session) | 204, затем 401, повторный logout — 401 | evidence/student-test.txt |
|
||||
| 4: автопроверка неверного пароля | student-tests (test_wrong_password_and_unknown_user_look_the_same) | одинаковый 401 для неверного пароля и неизвестного пользователя | evidence/student-test.txt |
|
||||
| 4: недоступность Valkey | python student-tests/dependency_failure.py valkey | ready 200, вход, сообщения и logout работают через PostgreSQL | evidence/failure-valkey.txt |
|
||||
| 4: недоступность Valkey | python student-tests/dependency_failure.py valkey | ready 200, вход и сообщения через PostgreSQL; после unpause отозванный токен остаётся 401 | evidence/failure-valkey.txt |
|
||||
| 4: недоступность БД, аноним не становится доверенным | python student-tests/dependency_failure.py postgres | ready 503; бизнес-запросы 503 unavailable; без токена 401; неизвестный токен не принят; после старта БД прежний токен работает | evidence/failure-postgres.txt |
|
||||
| Выбранный трек 5 | | не выбран | |
|
||||
|
||||
@@ -141,7 +141,7 @@ Durability: PostgreSQL с fsync=on, synchronous_commit=on, full_page_writes=on (
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| restart hook: stop api, restart postgres и valkey, start api (volumes на месте) | данные и токен живы | тот же токен читает то же сообщение; ID контейнеров те же, Up сбросился у api, postgres, valkey; кэш пустой и заполняется из PostgreSQL | весь persistence-тест (создание данных, hook, ожидание готовности, проверка) — 11 с; потерь нет |
|
||||
| docker compose stop valkey | API работает без кэша | ready 200, вход, сообщения, logout работают; первый запрос после остановки ждал около 4 с (на нём обнаружился сбой: подключение к остановленному контейнеру), дальше запросы десятки мс, в том числе через 6 с | после start valkey кэш включается сам в течение 5 с; потерь нет |
|
||||
| docker compose pause valkey (память кэша сохраняется), logout токена, который уже был в кэше, unpause | API работает без кэша; после восстановления отозванный токен остаётся 401 | ready 200, вход, сообщения и logout идут через PostgreSQL; после unpause тот же токен снова 401 | кэш включается сам в течение 5 с; отозванная сессия не оживает |
|
||||
| docker compose stop postgres | ограниченная ошибка, никого не пускаем без проверки | ready 503 за ~1 с, бизнес-запросы 503, без токена 401 | после start postgres прежний токен и сообщения на месте; запросы во время отказа не сохранены (получили 503) |
|
||||
| 20 одновременных регистраций одного username | один победитель | 201 x1, 409 x19 | дублей нет |
|
||||
| 10 клиентов x 10 сообщений одновременно | ровно 100 сообщений | 100, все id уникальны | потерь нет |
|
||||
@@ -151,7 +151,7 @@ Durability: PostgreSQL с fsync=on, synchronous_commit=on, full_page_writes=on (
|
||||
- PostgreSQL одна: если упала она или весь Docker-host, API отвечает 503. Отказоустойчивости к потере хоста нет, бэкапов нет.
|
||||
- Конкурентные вставки: created_at = время начала транзакции. Сообщение, которое закоммитилось позже, может получить более раннее время, и клиент, уже пролиставший дальше по курсору, его не увидит. Повторов нет, но такую запись можно пропустить; это ограничение keyset-пагинации по времени.
|
||||
- Первый запрос после пропадания Valkey ждёт обнаружения сбоя (на Windows/Docker Desktop около 4 с), следующие идут без кэша сразу.
|
||||
- Если Valkey недоступен ровно в момент logout, отозванная сессия может ещё до 30 с проходить по старой записи в кэше (если сам Valkey при этом не перезапускался).
|
||||
- Hash отозванных токенов помнит процесс API. После рестарта самого API их снова подтверждает PostgreSQL; эпоха кэша при этом уже другая, поэтому старый ключ Valkey не оживает.
|
||||
- Приложение подключается к PostgreSQL пользователем-владельцем базы. Отдельная роль с минимальными правами — в lab7.
|
||||
- Basic по HTTP передаёт пароль открыто (base64 — это не шифрование). Допустимо только на локальном стенде, TLS — в lab7.
|
||||
- Старые сессии чистятся только при входе того же пользователя; периодической очистки нет.
|
||||
|
||||
+14
-12
@@ -1,12 +1,14 @@
|
||||
python student-tests/dependency_failure.py valkey
|
||||
stopping valkey (docker compose stop valkey)␍
|
||||
/health/ready -> 200 (0 ms): Valkey не критичен, API готов␍
|
||||
existing token: GET /users/me -> 200 (1141 ms), сессия проверена по PostgreSQL (этот запрос и обнаружил сбой кэша)␍
|
||||
POST message -> 201, история читается␍
|
||||
register + login new user -> 201␍
|
||||
logout -> 204, затем тот же токен -> 401 (отзыв записан в PostgreSQL)␍
|
||||
10 x GET /users/me без кэша: max 16 ms (кэш не ждём на каждом запросе)␍
|
||||
через 6 с, ещё 10 x GET /users/me: max 32 ms (повторные попытки — в фоне)␍
|
||||
starting valkey again␍
|
||||
after recovery: прежний токен работает, подтверждённые сообщения на месте␍
|
||||
PASS: valkey outage handled without trusting anonymous requests␍
|
||||
python student-tests/dependency_failure.py valkey
|
||||
pausing valkey (docker compose pause valkey): данные кэша остаются в памяти
|
||||
/health/ready -> 200 (0 ms): Valkey не критичен, API готов
|
||||
existing token: GET /users/me -> 200 (344 ms), сессия проверена по PostgreSQL (этот запрос и обнаружил сбой кэша)
|
||||
POST message -> 201, история читается
|
||||
register + login new user -> 201
|
||||
logout -> 204, затем тот же токен -> 401 (отзыв записан в PostgreSQL)
|
||||
10 x GET /users/me без кэша: max 32 ms (кэш не ждём на каждом запросе)
|
||||
через 6 с, ещё 10 x GET /users/me: max 31 ms (повторные попытки — в фоне)
|
||||
logout токена из кэша во время паузы -> 401 (отзыв в PostgreSQL)
|
||||
unpausing valkey (docker compose unpause valkey)
|
||||
after Valkey recovery: отозванный токен остаётся 401, из кэша не оживает
|
||||
after recovery: прежний токен работает, подтверждённые сообщения на месте
|
||||
PASS: valkey outage handled without trusting anonymous requests
|
||||
|
||||
@@ -10,7 +10,11 @@
|
||||
Политика кэша:
|
||||
- запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии): кэш никогда
|
||||
не продлевает сессию, а истёкшая запись к тому же отбрасывается по expires_at;
|
||||
- logout: сначала отметка revoked_at в PostgreSQL, затем удаление ключа из кэша;
|
||||
- у каждой записи есть эпоха процесса. После сбоя Valkey эпоха меняется, поэтому
|
||||
ключи, записанные до сбоя, больше не читаются: их заново подтверждают в PostgreSQL;
|
||||
- logout сначала ставит revoked_at в PostgreSQL, затем удаляет ключ из кэша.
|
||||
Hash отозванного токена процесс помнит до своего завершения: даже если DEL не дошёл
|
||||
(Valkey был недоступен) и старый ключ пережил восстановление, кэш его не вернёт;
|
||||
- если Valkey недоступен, его обходят: всё работает напрямую через PostgreSQL.
|
||||
После первого сбоя запросы вообще перестают обращаться к кэшу, а фоновый поток раз в
|
||||
CACHE_RETRY_AFTER_SECONDS проверяет (PING), вернулся ли Valkey. Так ожидание подключения
|
||||
@@ -19,6 +23,7 @@
|
||||
"""
|
||||
import json
|
||||
import logging
|
||||
import secrets
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import asdict, dataclass
|
||||
@@ -46,6 +51,10 @@ class SessionCache:
|
||||
self._client = None
|
||||
self._down = False # True = кэш считается недоступным, запросы его не трогают
|
||||
self._lock = threading.Lock()
|
||||
# 32 бита точно переживают JSON (целые до 2^53). Новая эпоха — при старте процесса
|
||||
# и при каждом сбое: чужие и доаварийные ключи не считаются попаданием.
|
||||
self._epoch = secrets.randbits(32)
|
||||
self._revoked: set[bytes] = set()
|
||||
if url:
|
||||
timeout = config.CACHE_TIMEOUT_MS / 1000
|
||||
pool = valkey.BlockingConnectionPool.from_url(
|
||||
@@ -70,10 +79,20 @@ class SessionCache:
|
||||
if self._down: # уже знаем о сбое, фоновая проверка уже запущена
|
||||
return
|
||||
self._down = True
|
||||
self._epoch = secrets.randbits(32)
|
||||
log.warning("Valkey недоступен (%s при %s): работаем напрямую с PostgreSQL",
|
||||
type(exc).__name__, operation)
|
||||
threading.Thread(target=self._probe_until_back, name="valkey-probe", daemon=True).start()
|
||||
|
||||
def _is_revoked(self, key: bytes) -> bool:
|
||||
with self._lock:
|
||||
return key in self._revoked
|
||||
|
||||
def forget(self, key: bytes) -> None:
|
||||
"""Запомнить отзыв в этом процессе. Вызывается до попытки DEL."""
|
||||
with self._lock:
|
||||
self._revoked.add(key)
|
||||
|
||||
def _probe_until_back(self) -> None:
|
||||
"""Фоновый поток: ждёт возвращения Valkey и снова включает кэш."""
|
||||
while True:
|
||||
@@ -85,24 +104,33 @@ class SessionCache:
|
||||
return
|
||||
|
||||
def get(self, key: bytes) -> dict | None:
|
||||
if not self._available():
|
||||
if self._is_revoked(key) or not self._available():
|
||||
return None
|
||||
try:
|
||||
raw = self._client.get(self.PREFIX + key.hex())
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("get", exc)
|
||||
return None
|
||||
return None if raw is None else json.loads(raw)
|
||||
if raw is None:
|
||||
return None
|
||||
data = json.loads(raw)
|
||||
if data.get("epoch") != self._epoch:
|
||||
return None # запись другого процесса или эпохи до сбоя
|
||||
data.pop("epoch", None)
|
||||
return data
|
||||
|
||||
def set(self, key: bytes, value: dict, ttl_ms: int) -> None:
|
||||
if not self._available() or ttl_ms < 100:
|
||||
if self._is_revoked(key) or not self._available() or ttl_ms < 100:
|
||||
return
|
||||
payload = dict(value)
|
||||
payload["epoch"] = self._epoch
|
||||
try:
|
||||
self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms)
|
||||
self._client.set(self.PREFIX + key.hex(), json.dumps(payload), px=ttl_ms)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("set", exc)
|
||||
|
||||
def delete(self, key: bytes) -> None:
|
||||
self.forget(key)
|
||||
if not self._available():
|
||||
return
|
||||
try:
|
||||
@@ -155,7 +183,7 @@ class Sessions:
|
||||
|
||||
def logout(self, auth: AuthContext) -> None:
|
||||
self.store.revoke_session(auth.token_hash) # сначала источник истины
|
||||
self.cache.delete(auth.token_hash) # затем инвалидация кэша
|
||||
self.cache.delete(auth.token_hash) # отзыв в памяти процесса и DEL в кэше
|
||||
|
||||
def _remember(self, key: bytes, user: User, expires_at: datetime) -> None:
|
||||
left = expires_at - datetime.now(timezone.utc)
|
||||
|
||||
@@ -3,7 +3,9 @@
|
||||
Тест сам останавливает указанный контейнер (docker compose stop), проверяет поведение API
|
||||
и запускает контейнер обратно (docker compose start). Volumes не трогаются.
|
||||
|
||||
valkey — кэш недоступен: API обходит его и работает через PostgreSQL; logout действует сразу.
|
||||
valkey — кэш недоступен (контейнер на паузе, данные в памяти остаются): API обходит его
|
||||
и работает через PostgreSQL. Токен, который уже лежал в кэше и был отозван
|
||||
во время паузы, после unpause остаётся 401 и не оживает из старого ключа.
|
||||
postgres — источник истины недоступен: API отвечает ограниченной ошибкой 503 (без деталей),
|
||||
/health/ready = 503, аноним и неизвестный токен НЕ получают успешный ответ.
|
||||
После запуска БД прежний токен и данные снова доступны.
|
||||
@@ -74,24 +76,44 @@ def main():
|
||||
api = Client()
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
before = api.message(alice, chat, "до отказа " + target)["json"]
|
||||
# Токен прогрет в Valkey до отказа. stop стирает память процесса, pause — нет:
|
||||
# старый ключ переживает восстановление, и кэш не должен вернуть отозванную сессию.
|
||||
revoked = None
|
||||
if target == "valkey":
|
||||
revoked = api.user("revoked")
|
||||
api.call("GET", "/api/v1/users/me", actor=revoked, schema="User")
|
||||
|
||||
print(f"stopping {target} (docker compose stop {target})")
|
||||
compose("stop", target)
|
||||
if target == "valkey":
|
||||
print("pausing valkey (docker compose pause valkey): данные кэша остаются в памяти")
|
||||
compose("pause", target)
|
||||
else:
|
||||
print(f"stopping {target} (docker compose stop {target})")
|
||||
compose("stop", target)
|
||||
try:
|
||||
if target == "valkey":
|
||||
carol = valkey_down(api, alice, bob, chat)
|
||||
api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=revoked)
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=revoked)
|
||||
print("logout токена из кэша во время паузы -> 401 (отзыв в PostgreSQL)")
|
||||
else:
|
||||
postgres_down(api, alice, chat)
|
||||
finally:
|
||||
print(f"starting {target} again")
|
||||
compose("start", target)
|
||||
if target == "valkey":
|
||||
print("unpausing valkey (docker compose unpause valkey)")
|
||||
compose("unpause", target)
|
||||
else:
|
||||
print(f"starting {target} again")
|
||||
compose("start", target)
|
||||
|
||||
wait_ready(api)
|
||||
history, _ = read_history(api, alice, chat["id"])
|
||||
check(before in history, "message confirmed before the outage is lost or changed")
|
||||
api.call("GET", "/api/v1/users/me", actor=alice, schema="User")
|
||||
if target == "valkey":
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=carol) # отозванный токен не «воскрес» из кэша
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=carol)
|
||||
time.sleep(6) # фоновый PING снова включает кэш; старый ключ к этому моменту уже читался бы
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=revoked)
|
||||
print("after Valkey recovery: отозванный токен остаётся 401, из кэша не оживает")
|
||||
print("after recovery: прежний токен работает, подтверждённые сообщения на месте")
|
||||
print(f"PASS: {target} outage handled without trusting anonymous requests")
|
||||
|
||||
|
||||
Reference in New Issue
Block a user