forked from mtusi2026/mtusi2026lab2
исправление замечаний
This commit is contained in:
@@ -11,11 +11,11 @@ export BASE_URL
|
||||
export BASE_URL_TTL
|
||||
|
||||
.PHONY: help check validate test load test-persistence \
|
||||
secrets up down ps logs student-test race expiry failure-valkey failure-postgres db-test explain demo cache-stats
|
||||
secrets up down ps logs student-test race expiry failure-valkey failure-postgres failure-valkey-pause db-test explain demo cache-stats
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "secrets/up/down/ps/logs: stand; student-test, race, expiry, failure-valkey, failure-postgres, db-test, explain, demo, cache-stats: own checks"
|
||||
@echo "secrets/up/down/ps/logs: stand; student-test, race, expiry, failure-valkey, failure-postgres, failure-valkey-pause, db-test, explain, demo, cache-stats: own checks"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -70,6 +70,10 @@ failure-valkey:
|
||||
failure-postgres:
|
||||
$(PYTHON) student-tests/dependency_failure.py postgres
|
||||
|
||||
# Valkey на паузе (данные в нём сохраняются), logout, снова в строю: токен должен остаться отозванным.
|
||||
failure-valkey-pause:
|
||||
$(PYTHON) student-tests/cache_revocation.py
|
||||
|
||||
db-test:
|
||||
docker compose --profile tools run --rm db-test
|
||||
|
||||
|
||||
@@ -27,6 +27,7 @@ make db-test
|
||||
make expiry PYTHON=python
|
||||
make failure-valkey PYTHON=python
|
||||
make failure-postgres PYTHON=python
|
||||
make failure-valkey-pause PYTHON=python
|
||||
make explain > evidence/explain-history.txt
|
||||
```
|
||||
|
||||
@@ -75,7 +76,8 @@ 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, затем кладёт в кэш вместо записи о сессии отметку «отозвано» (на 30 с). Запись о сессии кладётся в кэш только если ключа нет (`SET NX`), поэтому запрос, прочитавший сессию из базы за мгновение до logout, не может вернуть её в кэш после logout;
|
||||
- поколение кэша: каждая запись о сессии помечена поколением процесса (случайное значение при старте). При любой ошибке Valkey процесс начинает новое поколение и записям старого больше не доверяет. Если Valkey был недоступен в момент logout (например, `docker compose pause`), запись о сессии осталась в кэше, но после возвращения Valkey она старого поколения: проверка идёт в PostgreSQL, там сессия отозвана — 401. Отметки «отозвано» действуют в любом поколении: они только запрещают;
|
||||
- persistence у Valkey выключена: кэш после рестарта пустой, данные снова берутся из PostgreSQL;
|
||||
- если Valkey недоступен, API его обходит и работает напрямую с PostgreSQL. После первой ошибки запросы перестают обращаться к кэшу, а фоновый поток раз в 5 с делает PING и, когда Valkey вернулся, снова включает кэш. Так ожидание подключения к пропавшему Valkey не попадает в запросы пользователей;
|
||||
- у Valkey ACL: пользователь `default` выключен, `messenger` (пароль из secrets) может только get/set/del/ping и только по ключам `sess:*`, `health` (без пароля) — только ping/info/dbsize.
|
||||
@@ -106,6 +108,8 @@ Durability: PostgreSQL с fsync=on, synchronous_commit=on, full_page_writes=on (
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | PASS: lab2 public API scenario | evidence/test.txt |
|
||||
| Замечание к MR: отозванный токен после возвращения Valkey | make failure-valkey-pause (pause valkey → logout → unpause) | во время паузы logout 204 → 401; после unpause 24 проверки за 12 с, GET и POST — всегда 401; другие токены работают | evidence/failure-valkey-pause.txt |
|
||||
| Замечание к MR: граничная дата в cursor | make student-test (test_bad_cursor_returns_400) | 0001-01-01T00:00:00+14:00 и 9999-12-31T23:59:59-14:00 в курсоре → 400, не 500 | evidence/student-test.txt |
|
||||
| Строки с U+0000 сохраняются (нашёл сам по замечанию к похожей работе) | make student-test (test_nul_character_is_stored) | display_name, title и text с U+0000 → 201, читаются без изменений; вход с таким логином → 401, не 500 | evidence/student-test.txt |
|
||||
| Структура skeleton и контракт не изменены | make check | PASS: offline skeleton structure | evidence/check.txt |
|
||||
| 3: минимум lab1 сохранён, переход на новую аутентификацию | make test, make student-test (тесты lab1 переведены на пароль и Bearer) | smoke PASS; Ran 22 tests, OK | evidence/test.txt, evidence/student-test.txt |
|
||||
@@ -141,6 +145,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 | весь make test-persistence (создание данных, hook, ожидание готовности, проверка) — 12,5 с; потерь нет |
|
||||
| docker compose stop valkey | API работает без кэша | ready 200, вход, сообщения, logout работают; первый запрос после остановки ждал около 4 с (на нём обнаружился сбой: подключение к остановленному контейнеру), дальше запросы десятки мс, в том числе через 6 с | после start valkey кэш включается сам в течение 5 с; потерь нет |
|
||||
| docker compose pause valkey, logout, unpause (данные в кэше сохранились) | отозванный токен не оживает | во время паузы 401; после unpause кэш снова включился, но запись до сбоя старого поколения — 401 при каждой из 24 проверок | кэш снова работает через ≤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 уникальны | потерь нет |
|
||||
@@ -150,7 +155,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 при этом не перезапускался).
|
||||
- Поколение кэша своё у каждого процесса API. Если logout во время сбоя Valkey прошёл через один экземпляр (например, api-short-ttl), а другой экземпляр сбоя не заметил, второй может до 30 с доверять своей старой записи. В lab2 основной API один; для нескольких реплик (lab3) поколение нужно хранить общим.
|
||||
- Приложение подключается к PostgreSQL пользователем-владельцем базы. Отдельная роль с минимальными правами — в lab7.
|
||||
- Basic по HTTP передаёт пароль открыто (base64 — это не шифрование). Допустимо только на локальном стенде, TLS — в lab7.
|
||||
- Старые сессии чистятся только при входе того же пользователя; периодической очистки нет.
|
||||
|
||||
+2
-2
@@ -1,8 +1,8 @@
|
||||
docker compose --profile ttl up -d --wait api-short-ttl
|
||||
Container mtusi-lab2-valkey-1 Running
|
||||
Container mtusi-lab2-postgres-1 Running
|
||||
Container mtusi-lab2-api-short-ttl-1 Creating
|
||||
Container mtusi-lab2-api-short-ttl-1 Created
|
||||
Container mtusi-lab2-api-short-ttl-1 Recreate
|
||||
Container mtusi-lab2-api-short-ttl-1 Recreated
|
||||
Container mtusi-lab2-postgres-1 Waiting
|
||||
Container mtusi-lab2-valkey-1 Waiting
|
||||
Container mtusi-lab2-valkey-1 Healthy
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
python student-tests/cache_revocation.py
|
||||
pausing valkey (docker compose pause valkey): данные в кэше сохраняются
|
||||
во время паузы: logout -> 204, тот же токен -> 401
|
||||
unpausing valkey
|
||||
после unpause: 23 проверок за 12 с, отозванный токен всегда 401 (и GET, и POST)
|
||||
действующие токены других пользователей работают
|
||||
PASS: revoked session stays revoked after Valkey comes back with stale data
|
||||
@@ -5,7 +5,7 @@ existing token: GET /users/me -> 200 (4015 ms), сессия проверена
|
||||
POST message -> 201, история читается
|
||||
register + login new user -> 201
|
||||
logout -> 204, затем тот же токен -> 401 (отзыв записан в PostgreSQL)
|
||||
10 x GET /users/me без кэша: max 16 ms (кэш не ждём на каждом запросе)
|
||||
10 x GET /users/me без кэша: max 32 ms (кэш не ждём на каждом запросе)
|
||||
через 6 с, ещё 10 x GET /users/me: max 31 ms (повторные попытки — в фоне)
|
||||
starting valkey again
|
||||
after recovery: прежний токен работает, подтверждённые сообщения на месте
|
||||
|
||||
+13
-13
@@ -1,21 +1,21 @@
|
||||
docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}"
|
||||
SERVICE CONTAINER ID STATUS
|
||||
api 719af7c38c2d Up 41 seconds (healthy)
|
||||
api-short-ttl 047512285fe6 Up 8 hours (healthy)
|
||||
postgres 094d2f567e2e Up 8 hours (healthy)
|
||||
valkey 195f4a7b30f1 Up 7 hours (healthy)
|
||||
api 5d506a14e681 Up About a minute (healthy)
|
||||
api-short-ttl 6e433cfb380a Up 9 seconds (healthy)
|
||||
postgres 094d2f567e2e Up 22 seconds (healthy)
|
||||
valkey 195f4a7b30f1 Up 44 seconds (healthy)
|
||||
python tests/resilience.py --mode persistence --action-script "scripts/restart.cmd" --base-url "http://127.0.0.1:8080"
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
|
||||
real 0m12.535s
|
||||
user 0m0.015s
|
||||
sys 0m0.015s
|
||||
real 0m10.093s
|
||||
user 0m0.031s
|
||||
sys 0m0.000s
|
||||
docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}"
|
||||
SERVICE CONTAINER ID STATUS
|
||||
api 719af7c38c2d Up 3 seconds (health: starting)
|
||||
api-short-ttl 047512285fe6 Up 8 hours (healthy)
|
||||
postgres 094d2f567e2e Up 9 seconds (healthy)
|
||||
valkey 195f4a7b30f1 Up 9 seconds (healthy)
|
||||
api-1 | 2026-10-09 17:57:26,685 INFO messenger.db: Миграции применены: 003_text_as_bytes
|
||||
api-1 | 2026-10-09 17:58:17,783 INFO messenger.db: Миграции: новых нет, схема актуальна
|
||||
api 5d506a14e681 Up 2 seconds (health: starting)
|
||||
api-short-ttl 6e433cfb380a Up 20 seconds (healthy)
|
||||
postgres 094d2f567e2e Up 7 seconds (healthy)
|
||||
valkey 195f4a7b30f1 Up 7 seconds (healthy)
|
||||
api-1 | 2026-10-09 21:17:33,062 INFO messenger.db: Миграции: новых нет, схема актуальна
|
||||
api-1 | 2026-10-09 21:19:16,340 INFO messenger.db: Миграции: новых нет, схема актуальна
|
||||
|
||||
@@ -23,6 +23,6 @@ test_wrong_password_and_unknown_user_look_the_same (test_auth.AuthTest.test_wron
|
||||
test_x_user_id_does_not_change_identity (test_auth.AuthTest.test_x_user_id_does_not_change_identity) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 22 tests in 3.300s
|
||||
Ran 22 tests in 2.609s
|
||||
|
||||
OK
|
||||
|
||||
+2
-2
@@ -1,7 +1,7 @@
|
||||
docker compose exec -T valkey valkey-cli --user health --pass none --no-auth-warning dbsize
|
||||
2
|
||||
5
|
||||
docker compose exec -T valkey valkey-cli --user health --pass none --no-auth-warning info stats | grep -E "keyspace_(hits|misses)"
|
||||
keyspace_hits:14
|
||||
keyspace_hits:16
|
||||
keyspace_misses:2
|
||||
docker compose exec -T valkey valkey-cli --user health --pass none --no-auth-warning get sess:anything
|
||||
NOPERM User health has no permissions to run the 'get' command
|
||||
|
||||
@@ -26,7 +26,7 @@ def decode_cursor(scope: str, cursor: str | None) -> tuple[datetime, uuid.UUID]
|
||||
return None
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode("ascii")))
|
||||
except ValueError: # не ASCII, не base64 или не JSON
|
||||
except (ValueError, RecursionError): # не ASCII, не base64, не JSON или слишком глубокая вложенность
|
||||
raise InvalidRequest("Неверный cursor") from None
|
||||
well_formed = isinstance(data, list) and len(data) == 3 and all(isinstance(x, str) for x in data)
|
||||
if not well_formed or data[0] != scope:
|
||||
@@ -34,8 +34,11 @@ def decode_cursor(scope: str, cursor: str | None) -> tuple[datetime, uuid.UUID]
|
||||
try:
|
||||
created_at = datetime.fromisoformat(data[1].replace("Z", "+00:00"))
|
||||
item_id = uuid.UUID(data[2])
|
||||
except ValueError:
|
||||
if created_at.tzinfo is None:
|
||||
raise ValueError("время без часового пояса")
|
||||
# Перевод в UTC может выйти за пределы годов 1–9999 (например, 0001-01-01T00:00+14:00):
|
||||
# Python бросает OverflowError. Это тоже испорченный курсор -> 400, а не 500.
|
||||
created_at = created_at.astimezone(timezone.utc)
|
||||
except (ValueError, OverflowError):
|
||||
raise InvalidRequest("Неверный cursor") from None
|
||||
if created_at.tzinfo is None:
|
||||
raise InvalidRequest("Неверный cursor")
|
||||
return created_at.astimezone(timezone.utc), item_id
|
||||
return created_at, item_id
|
||||
|
||||
+40
-16
@@ -10,7 +10,16 @@
|
||||
Политика кэша:
|
||||
- запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии): кэш никогда
|
||||
не продлевает сессию, а истёкшая запись к тому же отбрасывается по expires_at;
|
||||
- logout: сначала отметка revoked_at в PostgreSQL, затем удаление ключа из кэша;
|
||||
- logout: сначала отметка revoked_at в PostgreSQL, затем в кэш вместо записи о сессии
|
||||
кладётся отметка «отозвано» (tombstone). Новая запись о сессии кладётся только если ключа
|
||||
нет (SET NX), поэтому запрос, который прочитал сессию из базы до logout, не сможет
|
||||
«воскресить» её в кэше после logout;
|
||||
- поколение кэша: каждая запись о сессии помечена поколением процесса. При любом сбое
|
||||
Valkey процесс начинает новое поколение и больше не доверяет записям старого. Пока Valkey
|
||||
был недоступен, logout не мог убрать запись из кэша; после возвращения Valkey эта старая
|
||||
запись всё ещё лежит там, но она старого поколения, поэтому проверка идёт в PostgreSQL,
|
||||
а там сессия отозвана -> 401. Отметки «отозвано» действуют в любом поколении: они только
|
||||
запрещают, а не разрешают;
|
||||
- если Valkey недоступен, его обходят: всё работает напрямую через PostgreSQL.
|
||||
После первого сбоя запросы вообще перестают обращаться к кэшу, а фоновый поток раз в
|
||||
CACHE_RETRY_AFTER_SECONDS проверяет (PING), вернулся ли Valkey. Так ожидание подключения
|
||||
@@ -19,6 +28,7 @@
|
||||
"""
|
||||
import json
|
||||
import logging
|
||||
import secrets
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import asdict, dataclass
|
||||
@@ -46,6 +56,8 @@ class SessionCache:
|
||||
self._client = None
|
||||
self._down = False # True = кэш считается недоступным, запросы его не трогают
|
||||
self._lock = threading.Lock()
|
||||
# Поколение: случайное при старте процесса и новое после каждого сбоя Valkey.
|
||||
self.generation = secrets.token_hex(8)
|
||||
if url:
|
||||
timeout = config.CACHE_TIMEOUT_MS / 1000
|
||||
pool = valkey.BlockingConnectionPool.from_url(
|
||||
@@ -67,6 +79,8 @@ class SessionCache:
|
||||
|
||||
def _failed(self, operation: str, exc: Exception) -> None:
|
||||
with self._lock:
|
||||
# Новое поколение при КАЖДОЙ ошибке: всё, что лежит в кэше сейчас, больше не доверенное.
|
||||
self.generation = secrets.token_hex(8)
|
||||
if self._down: # уже знаем о сбое, фоновая проверка уже запущена
|
||||
return
|
||||
self._down = True
|
||||
@@ -81,7 +95,7 @@ class SessionCache:
|
||||
if self.ping():
|
||||
with self._lock:
|
||||
self._down = False
|
||||
log.info("Valkey снова доступен: кэш сессий включён")
|
||||
log.info("Valkey снова доступен: кэш сессий включён (записи до сбоя не используются)")
|
||||
return
|
||||
|
||||
def get(self, key: bytes) -> dict | None:
|
||||
@@ -94,21 +108,24 @@ class SessionCache:
|
||||
return None
|
||||
return None if raw is None else json.loads(raw)
|
||||
|
||||
def set(self, key: bytes, value: dict, ttl_ms: int) -> None:
|
||||
def add(self, key: bytes, value: dict, ttl_ms: int) -> None:
|
||||
"""Положить запись, только если ключа ещё нет (SET NX): отметку «отозвано» не затираем."""
|
||||
if not self._available() or ttl_ms < 100:
|
||||
return
|
||||
try:
|
||||
self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms)
|
||||
self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms, nx=True)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("set", exc)
|
||||
|
||||
def delete(self, key: bytes) -> None:
|
||||
def mark_revoked(self, key: bytes) -> None:
|
||||
"""Заменить запись о сессии отметкой «отозвано» на SESSION_CACHE_TTL_SECONDS."""
|
||||
if not self._available():
|
||||
return
|
||||
return # запись в кэше осталась, но после сбоя она старого поколения и не доверенная
|
||||
try:
|
||||
self._client.delete(self.PREFIX + key.hex())
|
||||
self._client.set(self.PREFIX + key.hex(), json.dumps({"revoked": True}),
|
||||
px=config.SESSION_CACHE_TTL_SECONDS * 1000)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("delete", exc)
|
||||
self._failed("set", exc)
|
||||
|
||||
def ping(self) -> bool:
|
||||
try:
|
||||
@@ -137,30 +154,37 @@ class Sessions:
|
||||
return None
|
||||
token = security.new_token()
|
||||
key = security.token_hash(token)
|
||||
generation = self.cache.generation
|
||||
expires_at = self.store.create_session(key, user.id, self.ttl_seconds)
|
||||
self._remember(key, user, expires_at) # write-through: следующий запрос сразу попадёт в кэш
|
||||
self._remember(key, user, expires_at, generation) # следующий запрос сразу попадёт в кэш
|
||||
return token, ts(expires_at), user
|
||||
|
||||
def authenticate(self, token: str) -> AuthContext | None:
|
||||
key = security.token_hash(token)
|
||||
# Поколение запоминаем ДО чтения: если во время запроса случится сбой Valkey,
|
||||
# то, что мы положим в кэш, окажется старого поколения и доверенным не будет.
|
||||
generation = self.cache.generation
|
||||
cached = self.cache.get(key)
|
||||
if cached is not None:
|
||||
if cached.get("revoked"):
|
||||
return None # logout уже был
|
||||
expires_at = datetime.fromisoformat(cached["expires_at"])
|
||||
if expires_at > datetime.now(timezone.utc):
|
||||
if cached.get("gen") == generation and expires_at > datetime.now(timezone.utc):
|
||||
return AuthContext(User(**cached["user"]), key)
|
||||
found = self.store.get_session(key) # промах кэша или кэш недоступен -> PostgreSQL
|
||||
# запись старого поколения или истёкшая -> проверяем по источнику истины
|
||||
found = self.store.get_session(key) # промах кэша, недоверенная запись или кэш недоступен
|
||||
if found is None:
|
||||
return None
|
||||
user, expires_at = found
|
||||
self._remember(key, user, expires_at)
|
||||
self._remember(key, user, expires_at, generation)
|
||||
return AuthContext(user, key)
|
||||
|
||||
def logout(self, auth: AuthContext) -> None:
|
||||
self.store.revoke_session(auth.token_hash) # сначала источник истины
|
||||
self.cache.delete(auth.token_hash) # затем инвалидация кэша
|
||||
self.store.revoke_session(auth.token_hash) # сначала источник истины
|
||||
self.cache.mark_revoked(auth.token_hash) # затем инвалидация кэша
|
||||
|
||||
def _remember(self, key: bytes, user: User, expires_at: datetime) -> None:
|
||||
def _remember(self, key: bytes, user: User, expires_at: datetime, generation: str) -> None:
|
||||
left = expires_at - datetime.now(timezone.utc)
|
||||
ttl = min(timedelta(seconds=config.SESSION_CACHE_TTL_SECONDS), left)
|
||||
self.cache.set(key, {"user": asdict(user), "expires_at": expires_at.isoformat()},
|
||||
self.cache.add(key, {"user": asdict(user), "expires_at": expires_at.isoformat(), "gen": generation},
|
||||
int(ttl.total_seconds() * 1000))
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Отозванный токен не «воскресает» из кэша после возвращения Valkey (замечание к MR).
|
||||
|
||||
Запуск: make failure-valkey-pause
|
||||
|
||||
Сценарий преподавателя: Valkey ставится на паузу (docker compose pause) — процесс жив,
|
||||
данные в его памяти сохраняются, но он не отвечает. В это время делается logout: PostgreSQL
|
||||
отзывает сессию, а убрать запись из кэша нельзя. После unpause в кэше всё ещё лежит старая
|
||||
запись «токен -> пользователь». Она не должна снова пропускать этот токен.
|
||||
"""
|
||||
import time
|
||||
|
||||
from helpers import Client, check, compose, run, wait_ready
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
dave = api.user("dave")
|
||||
for _ in range(2): # запись о сессии dave точно лежит в кэше
|
||||
api.call("GET", "/api/v1/users/me", actor=dave, schema="User")
|
||||
|
||||
print("pausing valkey (docker compose pause valkey): данные в кэше сохраняются")
|
||||
compose("pause", "valkey")
|
||||
try:
|
||||
api.call("GET", "/api/v1/users/me", actor=dave, schema="User") # этот запрос обнаруживает сбой кэша
|
||||
api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=dave)
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=dave)
|
||||
print("во время паузы: logout -> 204, тот же токен -> 401")
|
||||
finally:
|
||||
print("unpausing valkey")
|
||||
compose("unpause", "valkey")
|
||||
|
||||
wait_ready(api)
|
||||
# Фоновая проверка возвращает кэш в работу в течение 5 с. Смотрим 12 с — дольше, чем она.
|
||||
deadline = time.monotonic() + 12
|
||||
checks = 0
|
||||
while time.monotonic() < deadline:
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=dave)
|
||||
api.call("POST", "/api/v1/chats", 401, actor=dave, body={"title": "x", "member_ids": [dave["id"]]})
|
||||
checks += 1
|
||||
time.sleep(0.5)
|
||||
print(f"после unpause: {checks} проверок за 12 с, отозванный токен всегда 401 (и GET, и POST)")
|
||||
|
||||
api.call("GET", "/api/v1/users/me", actor=alice, schema="User")
|
||||
api.message(bob, chat, "после возвращения Valkey")
|
||||
print("действующие токены других пользователей работают")
|
||||
print("PASS: revoked session stays revoked after Valkey comes back with stale data")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -140,8 +140,12 @@ class MessengerApiTest(unittest.TestCase):
|
||||
# Курсор правильной формы, но с испорченным временем/UUID: 400, а не ошибка БД (500).
|
||||
import base64
|
||||
import json
|
||||
for bad in (["messages:" + chat_a["id"], "not-a-time", str(uuid.uuid4())],
|
||||
["messages:" + chat_a["id"], "2026-01-01T00:00:00.000000Z", "not-a-uuid"]):
|
||||
scope = "messages:" + chat_a["id"]
|
||||
for bad in ([scope, "not-a-time", str(uuid.uuid4())],
|
||||
[scope, "2026-01-01T00:00:00.000000Z", "not-a-uuid"],
|
||||
[scope, "2026-01-01T00:00:00", str(uuid.uuid4())], # без часового пояса
|
||||
[scope, "0001-01-01T00:00:00+14:00", str(uuid.uuid4())], # в UTC это год 0
|
||||
[scope, "9999-12-31T23:59:59-14:00", str(uuid.uuid4())]): # в UTC это год 10000
|
||||
forged = base64.urlsafe_b64encode(json.dumps(bad).encode()).decode()
|
||||
self.api.call("GET", self.messages_path(chat_a["id"]) + "?cursor=" + forged, 400, actor=self.alice)
|
||||
for limit in ("0", "101", "abc"):
|
||||
|
||||
Reference in New Issue
Block a user