исправление замечаний

This commit is contained in:
2026-10-10 00:22:30 +03:00
parent 1d02ee3f33
commit d0eaaea5b6
12 changed files with 144 additions and 46 deletions
+6 -2
View File
@@ -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
+7 -2
View File
@@ -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
View File
@@ -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
+7
View File
@@ -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
+1 -1
View File
@@ -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
View File
@@ -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: Миграции: новых нет, схема актуальна
+1 -1
View File
@@ -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
View File
@@ -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
+8 -5
View File
@@ -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
View File
@@ -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))
+51
View File
@@ -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)
+6 -2
View File
@@ -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"):