From c881108b3dda9a4d35872610e7e6099befd49d9e Mon Sep 17 00:00:00 2001 From: papapevagemabody Date: Fri, 16 Oct 2026 21:21:41 +0300 Subject: [PATCH] lab2 --- REPORT.md | 8 +++--- evidence/failure-valkey.txt | 26 ++++++++++--------- src/messenger/sessions.py | 40 ++++++++++++++++++++++++----- student-tests/dependency_failure.py | 34 +++++++++++++++++++----- 4 files changed, 80 insertions(+), 28 deletions(-) diff --git a/REPORT.md b/REPORT.md index aa9f03f6..6e16028a 100644 --- a/REPORT.md +++ b/REPORT.md @@ -77,7 +77,7 @@ PostgreSQL и Valkey наружу не опубликованы, доступн - источник истины — таблица `sessions` в PostgreSQL. Она переживает рестарт, срок `expires_at` абсолютный, рестарт его не продлевает; - Valkey — кэш, чтобы не делать SQL-запрос при каждой проверке токена. Ключ `sess:`, значение — пользователь и 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. - Старые сессии чистятся только при входе того же пользователя; периодической очистки нет. diff --git a/evidence/failure-valkey.txt b/evidence/failure-valkey.txt index fd04f824..1c3da12a 100644 --- a/evidence/failure-valkey.txt +++ b/evidence/failure-valkey.txt @@ -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 diff --git a/src/messenger/sessions.py b/src/messenger/sessions.py index fbfdfd80..c9c0c41d 100644 --- a/src/messenger/sessions.py +++ b/src/messenger/sessions.py @@ -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) diff --git a/student-tests/dependency_failure.py b/student-tests/dependency_failure.py index 5fb3a583..a94f2de9 100644 --- a/student-tests/dependency_failure.py +++ b/student-tests/dependency_failure.py @@ -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")