From e73988a3088f1e8bbdbf428b1260f57fdb7e371d Mon Sep 17 00:00:00 2001 From: Tmribob Date: Fri, 6 Nov 2026 16:13:16 +0300 Subject: [PATCH] Fix durable logout and add grade-5 research --- .github/pull_request_template.md | 11 ++- Makefile | 6 +- REPORT.md | 21 +++++- evidence/research-history-backup.txt | 87 ++++++++++++++++++++++ evidence/test-degradation-grade5.txt | 10 +++ scripts/research-history-backup.sh | 35 +++++++++ scripts/research-history-backup.sql | 105 +++++++++++++++++++++++++++ src/sessions.py | 21 ++---- student-tests/test_degradation.py | 53 +++++++++++++- 9 files changed, 324 insertions(+), 25 deletions(-) create mode 100644 evidence/research-history-backup.txt create mode 100644 evidence/test-degradation-grade5.txt create mode 100755 scripts/research-history-backup.sh create mode 100644 scripts/research-history-backup.sql diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index e5cca5b6..e132fdf3 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,12 +1,13 @@ ## Лабораторная 2 Автор / группа: Тимофей Александров, БВТ2301 -Целевая оценка (3/4/5): 4 -Трек 5, если заявлен: не заявлен +Целевая оценка (3/4/5): 5 +Трек 5: трек 2 «План запроса и восстановление» Что реализовано и что перенесено: - Перенесено из lab1: контракт API, keyset-пагинация, health-эндпоинты, регистрация пользователей. - Новое в lab2: PostgreSQL источник истины (миграции 001-003), Valkey кэш сессий, Argon2id пароли, Basic только на POST /auth/sessions, Bearer на остальных эндпоинтах, транзакционное создание чата, idempotency-ключи, circuit breaker на Valkey, graceful degradation при отказе кэша/БД, bounded connection pool с таймаутами. +- Исправлено по ревью: Valkey больше не авторизует cache-hit самостоятельно. Каждая Bearer-сессия подтверждается в PostgreSQL, поэтому токен, отозванный при outage кэша, остаётся 401 после рестарта API и возврата старого Valkey-тома. Команды запуска из чистого clone: ```sh @@ -20,22 +21,24 @@ python3 tests/resilience.py --mode persistence --action-script scripts/restart.s cd student-tests && BASE_URL=http://127.0.0.1:8080 python3 -u -B -m unittest -v test_api test_race test_degradation sh scripts/test-ttl.sh sh scripts/explain-history.sh +sh scripts/research-history-backup.sh ``` Результаты проверок и ссылка на REPORT.md: - Smoke: PASS: lab2 public API scenario - check_contract: PASS: offline skeleton structure, local refs and Python syntax - validate_openapi: PASS: full OpenAPI 3.1 and JSON Schema validation -- Student tests: 26/26 OK (duplicate_username_race, chat_creation_rolls_back, bounded_pool) +- Student tests: 26/26 OK; degradation 2/2 OK, включая durable logout после cache outage/API restart - Persistence: PASS: persistence preserved confirmed data and existing session - TTL: 4/4 OK, 6.1 с (стенд SESSION_TTL_SECONDS=2, :8081) - Degradation: OK — cached_p50=16 мс, cache_down_p50=39 мс, cache_down_p95=78 мс - EXPLAIN: 12 000 сообщений, Index Scan, 4 буфера, 0.208 мс +- Трек 5: 100 000 сообщений в 101 чате (90 000/100); composite index 0.128 мс / 6 buffers, chat-only 89.728 мс / 1525 buffers; backup/restore aggregates совпали. - Нагрузка: 25.5 rps, 523 запроса, 0 ошибок, p50 125 мс, p95 328 мс - Подробности: REPORT.md Ограничения / известные ошибки: -- Один процесс api: локальный кэш отозванных токенов и circuit breaker не разделяются между репликами (решено в lab3). +- Один процесс api; репликация API — область следующей лабораторной. - Нагрузочный тест закрытого цикла содержит coordinated omission. - make в среде отсутствует, команды выполнялись напрямую. diff --git a/Makefile b/Makefile index b3240786..0b0720bc 100644 --- a/Makefile +++ b/Makefile @@ -7,13 +7,14 @@ ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) STUDENT_DIR = student-tests -.PHONY: help check validate test load test-persistence run bootstrap up down test-student test-ttl test-degradation explain +.PHONY: help check validate test load test-persistence run bootstrap up down test-student test-ttl test-degradation explain research-history-backup help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @echo "bootstrap/up/down: local Compose stand; run: API without Docker (needs DATABASE_URL/CACHE_URL)" @echo "test-student: own functional+race tests; test-ttl: expiry on the short-TTL stand; test-degradation: cache/DB outages" @echo "explain: seed 12k messages and capture EXPLAIN (ANALYZE, BUFFERS) into evidence/" + @echo "research-history-backup: grade-5 100k index comparison and PostgreSQL backup/restore" check: $(PYTHON) scripts/check_contract.py @@ -56,3 +57,6 @@ test-degradation: explain: sh scripts/explain-history.sh + +research-history-backup: + sh scripts/research-history-backup.sh diff --git a/REPORT.md b/REPORT.md index 3d56a04c..446a1386 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,7 +1,7 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO (заполняется перед публикацией PR) -- Целевая оценка; выбранный трек 5, если нужен: **4** (трек 5 не заявлен) +- Автор, группа: Тимофей Александров, БВТ2301 +- Целевая оценка; выбранный трек 5, если нужен: **5**, трек 2 «План запроса и восстановление» - Commit/PR: TODO после публикации - Использованные источники, библиблиотеки и помощь ИИ: README/COURSE/CONTRIBUTING этого skeleton, `contracts/README.md` и `tests/README.md`; документация PostgreSQL (transactions, EXPLAIN), Valkey (persistence), RFC 7617 (Basic), OWASP Password Storage Cheat Sheet (Argon2id). Библиотеки: FastAPI/Starlette/uvicorn, psycopg 3 + psycopg-pool, redis-py, argon2-cffi (списки в `requirements.txt`). @@ -31,6 +31,7 @@ sh scripts/test-ttl.sh # = make test-ttl (отдельный cd student-tests && STUDENT_DOCKER_TESTS=1 BASE_URL=http://127.0.0.1:8080 \ python3 -u -B -m unittest -v test_api test_race test_degradation sh scripts/explain-history.sh # = make explain (EXPLAIN ANALYZE на 12 000 сообщений) +sh scripts/research-history-backup.sh # трек 5: 100 000 сообщений, сравнение индексов, backup/restore ``` Безопасная остановка с сохранением данных: `docker compose --env-file .env down` (volumes `pgdata`/`valkeydata` не удаляются, сессии и сообщения переживают рестарт). Намеренное удаление учебных данных: `docker compose --env-file .env down -v`. На Windows эквивалент restart-hook для `tests/resilience.py` — `scripts/restart.cmd` (тот же сценарий, что и `scripts/restart.sh`: `down` без `-v`, затем `up -d --wait`; Python не умеет запускать `.sh` напрямую, ошибка `WinError 193`). @@ -43,7 +44,7 @@ URL вида `http://127.0.0.1:8080`, а не `localhost`: Compose публик **Что перенесено из lab1.** Тот же контракт и та же логика keyset-пагинации, но хранилище заменено с in-memory dict на PostgreSQL; `X-User-Id` больше не используется нигде (входящее поле игнорируется, проверено тестом); вместо Basic-входа на каждый запрос — Basic только на `POST /api/v1/auth/sessions` и Bearer-токен на остальных. -**Источник истины и кэш.** Сессии живут в таблице `sessions` (хранится только SHA-256 токена). Valkey хранит тот же токен под `session:` максимум `CACHE_TTL_SECONDS=300` с и одновременно не дольше остатка жизни сессии. Кэш записывается при логине и при каждом cache-miss, инвалидируется логаутом через tombstone `revoked` (а не `DEL`: устаревшая запись обязана стать недействительной). Если Valkey недоступен — каждый запрос просто идёт в PostgreSQL; кэш-ошибка никогда не означает «авторизован». Плюс 5-секундный circuit breaker: после первой ошибки соединения Valkey пропускается ~5 с, чтобы отказ не стоил таймаута на каждый запрос (до внедрения breaker падение кэша стоило ~1031 мс на запрос, стало 39 мс). +**Источник истины и кэш.** Сессии живут в таблице `sessions` (хранится только SHA-256 токена). Valkey хранит публичный снимок пользователя под `session:` максимум `CACHE_TTL_SECONDS=300` с и одновременно не дольше остатка жизни сессии. Кэш инвалидируется логаутом через tombstone `revoked`. PostgreSQL подтверждает, что сессия не отозвана и не истекла **на каждом Bearer-запросе**: cache-hit никогда сам по себе не авторизует. Поэтому недоставленный tombstone при остановленном Valkey, рестарт API и восстановление старого кэша не могут воскресить токен. Если Valkey недоступен — запрос всё равно работает через PostgreSQL; кэш-ошибка никогда не означает «авторизован». Плюс 5-секундный circuit breaker. **Транзакционные границы.** Создание чата (`chats` + строки `chat_members`) — одна транзакция: ошибка хотя бы одного участника откатывает всё (проверено: в таблицах остаётся 0 строк). Регистрация и отправка сообщения — по одной транзакции. Миграции — версионированный раннер `src/migrate.py`: одна транзакция + `pg_advisory_xact_lock`, таблица `schema_migrations`, повторный запуск печатает `migrations_up_to_date` и не дублирует данные; запуск идемпотентен и защищён от параллельных контейнеров. @@ -70,6 +71,8 @@ URL вида `http://127.0.0.1:8080`, а не `localhost`: Compose публик | Индекс истории, EXPLAIN ≥ 10 000 строк, без OFFSET | `sh scripts/explain-history.sh` | 12 000 сообщений: страница глубоко в истории — **Index Scan, 4 буфера, 0.208 мс**; вариант `OFFSET` (не используется) — **Seq Scan + Sort, 205 буферов, 14.0 мс** | `evidence/explain-history.txt` | | Автопроверка expiry при коротком TTL, logout, неверный пароль | `sh scripts/test-ttl.sh` (стенд `SESSION_TTL_SECONDS=2`, :8081) | **4/4 OK, 6.1 с**; кэш не продлевает жизнь токену, logout мгновенен и при закэшированной сессии | `evidence/test-ttl.txt` | | Недоступность Redis/Valkey и БД | `STUDENT_DOCKER_TESTS=1 python3 -m unittest -v test_degradation` | **OK, 21.4 с**: `cached_p50=16 мс`, `cache_down_p50=39 мс`, `cache_down_p95=78 мс`, `/health/ready` остаётся 200 при падении кэша и становится 503 `unavailable` при падении БД, запись отказывает за **2.05 с**, восстановление **0.58 с**, после восстановления та же сессия и те же сообщения | `evidence/test-degradation.txt` | +| Durable logout при cache outage + API restart | `test_logout_remains_revoked_after_cache_outage_and_api_restart` | **OK**: после logout при остановленном Valkey, рестарта API и возврата прежнего Valkey-тома старый токен получает 401 на `/users/me`, чат и POST сообщения | `evidence/test-degradation-grade5.txt` | +| Трек 5: 100k, два плана, backup/restore | `sh scripts/research-history-backup.sh` | 100 000 сообщений, 101 чат (90 000/100); composite index: 0.128 мс, 6 buffers; chat-only alternative: 89.728 мс, 1525 buffers; source/restore totals совпали | `evidence/research-history-backup.txt` | | Нагрузочный прогон (не оценочный критерий) | `python3 tests/load.py … --duration 20 --concurrency 4` | **25.5 успешных req/s, 523 запроса, 0 ошибок**, p50 **125 мс**, p95 **328 мс**, p99 **484 мс** | `evidence/load.json`, `evidence/load.txt` | Дополнительно: `docker compose --env-file .env ps` показывает `api/postgres/valkey — healthy`; на стенде 204 пользователя, 68 чатов, 13 286 сообщений, 174 сессии (синтетические). @@ -89,11 +92,21 @@ URL вида `http://127.0.0.1:8080`, а не `localhost`: Compose публик Сиреневой AOF (`--appendfsync everysec`) в Valkey: потеря до ~1 с кэша при жёстком выключении ВМ не критична, так как PostgreSQL — источник истины. +## Трек 5 — План запроса и восстановление + +**Гипотеза.** Для глубокой keyset-страницы в неравномерном распределении чатов составной индекс `(chat_id, created_at, id)` будет заметно дешевле индекса только по `chat_id`, потому что сразу удовлетворяет фильтр, порядок и курсор. + +**Методика.** `scripts/research-history-backup.sql` создаёт идемпотентный синтетический набор: 90 000 сообщений в одном hot-чате и 100 чатов по 100 сообщений (всего 100 000, 101 чат). Для одного и того же cursor после 80 000 сообщений сняты `EXPLAIN (ANALYZE, BUFFERS)` production-индекса и временной альтернативы `chat_id`-only; изменение второй схемы происходит в транзакции и завершается `ROLLBACK`, поэтому production-индекс не меняется. Далее `pg_dump -Fc` восстанавливается в новый `messenger_grade5_restore`, а число сообщений, минимальная/максимальная дата и сумма длин текстов сравниваются между источником и восстановленной БД. + +**Результат.** Production composite index дал `Index Scan`, 6 shared buffers и 0.128 мс. Альтернатива дала `Parallel Seq Scan + top-N Sort`, 1525 buffers и 89.728 мс. Backup/restore сохранил одинаковые агрегаты: `100000 | 2026-02-01T00:00:00.001Z | 2026-02-02T00:00:10.1Z | 1697294`. + +**Ограничения.** Замер выполнен один раз на Docker Desktop, без CPU/RAM-лимитов и с прогретым buffer cache; абсолютные времена не являются производственной оценкой. Восстановление проверяет данные приложения, но не моделирует потерю WAL между последним backup и аварией. + ## Ограничения и следующие шаги - **Выдерживается:** отказ Valkey (полный обход кэша), кратковременный отказ PostgreSQL (ограниченная ошибка и быстрый возврат), рестарт всего стека с сохранением данных. **Не выдерживается:** одновременный выход обоих хранилищ из-под `up --wait` (стенд перестаёт готовиться — это ожидаемо), потеря PostgreSQL-тома вместе с контейнером. - Один процесс `api`: локальный кэш отозванных токенов и circuit breaker не разделяются между репликами. Для уровня 3 с несколькими репликами (`X-Instance-Id`, failover) нужно вынести отзов в общее хранилище и согласовать поведение между инстансами. - Нагрузочный тест закрытого цикла содержит coordinated omission и накладные издержки клиента; это не доказательство ёмкости. Повторов и замера CPU/RAM не делалось — цифры выше относятся к одному прогону. -- EXPLAIN снят на 12 000 сообщений (требование ≥10 000 выполнено), но без неравномерного распределения по чатам и без backup/restore — это уже трек 5, который не заявлен. +- Исследование трека 5 использует 100 000 синтетических сообщений и отдельную restored-БД, но не моделирует репликацию PostgreSQL или point-in-time recovery. - Кэш-запись — best effort: при недоступном Valkey запись пропускается, а не блокирует ответ (источник истины не затронут). - `make` в среде отсутствует, поэтому все команды выполнялись напрямую; `Makefile` сохранён для Linux/CI. diff --git a/evidence/research-history-backup.txt b/evidence/research-history-backup.txt new file mode 100644 index 00000000..9fb31ca5 --- /dev/null +++ b/evidence/research-history-backup.txt @@ -0,0 +1,87 @@ +Timing is on. +INSERT 0 1 +Time: 13.869 ms +INSERT 0 1 +Time: 4.424 ms +INSERT 0 1 +Time: 12.415 ms +INSERT 0 100 +Time: 21.993 ms +INSERT 0 100 +Time: 28.881 ms +INSERT 0 90000 +Time: 13459.359 ms (00:13.459) +INSERT 0 10000 +Time: 1345.306 ms (00:01.345) +ANALYZE +Time: 406.609 ms +=== dataset shape === + research_messages | research_chats | largest_chat_messages | smallest_chat_messages +-------------------+----------------+-----------------------+------------------------ + 100000 | 101 | 90000 | 100 +(1 row) + +Time: 266.713 ms +=== source integrity summary === + count | first_message | last_message | text_bytes +--------+----------------------------+--------------------------+------------ + 100000 | 2026-02-01 00:00:00.001+00 | 2026-02-02 00:00:10.1+00 | 1697294 +(1 row) + +Time: 75.790 ms +=== index A: production composite (chat_id, created_at, id) === + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=0.42..17.44 rows=50 width=73) (actual time=0.022..0.060 rows=50 loops=1) + Buffers: shared hit=6 + -> Index Scan using messages_chat_order_idx on messages (cost=0.42..5720.16 rows=16804 width=73) (actual time=0.020..0.048 rows=50 loops=1) + Index Cond: ((chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'::uuid) AND (ROW(created_at, id) > ROW('2026-02-01 00:01:20+00'::timestamp with time zone, '1b846638-5f59-3b99-00f4-160ef4a51437'::uuid))) + Buffers: shared hit=6 + Planning: + Buffers: shared hit=6 + Planning Time: 0.352 ms + Execution Time: 0.128 ms +(9 rows) + +Time: 1.572 ms +=== index B: chat_id-only alternative (temporary, rolled back) === +BEGIN +Time: 0.244 ms +DROP INDEX +Time: 19.803 ms +CREATE INDEX +Time: 223.602 ms +ANALYZE +Time: 342.025 ms + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=4006.30..4012.05 rows=50 width=73) (actual time=70.068..89.652 rows=50 loops=1) + Buffers: shared hit=1525 + -> Gather Merge (cost=4006.30..5145.03 rows=9902 width=73) (actual time=70.063..89.630 rows=50 loops=1) + Workers Planned: 1 + Workers Launched: 1 + Buffers: shared hit=1525 + -> Sort (cost=3006.29..3031.05 rows=9902 width=73) (actual time=42.016..42.177 rows=41 loops=2) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 31kB + Buffers: shared hit=1525 + Worker 0: Sort Method: top-N heapsort Memory: 31kB + -> Parallel Seq Scan on messages (cost=0.00..2677.35 rows=9902 width=73) (actual time=31.887..40.024 rows=5000 loops=2) + Filter: ((chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'::uuid) AND (ROW(created_at, id) > ROW('2026-02-01 00:01:20+00'::timestamp with time zone, '1b846638-5f59-3b99-00f4-160ef4a51437'::uuid))) + Rows Removed by Filter: 51700 + Buffers: shared hit=1510 + Planning: + Buffers: shared hit=20 read=1 + Planning Time: 0.790 ms + Execution Time: 89.728 ms +(19 rows) + +Time: 92.602 ms +ROLLBACK +Time: 4.178 ms +=== backup === +NOTICE: database "messenger_grade5_restore" does not exist, skipping +=== source integrity === +100000|2026-02-01 00:00:00.001+00|2026-02-02 00:00:10.1+00|1697294 +=== restored integrity === +100000|2026-02-01 00:00:00.001+00|2026-02-02 00:00:10.1+00|1697294 diff --git a/evidence/test-degradation-grade5.txt b/evidence/test-degradation-grade5.txt new file mode 100644 index 00000000..fd9ee600 --- /dev/null +++ b/evidence/test-degradation-grade5.txt @@ -0,0 +1,10 @@ +test_logout_remains_revoked_after_cache_outage_and_api_restart (test_degradation.DependencyOutages.test_logout_remains_revoked_after_cache_outage_and_api_restart) ... ok +test_valkey_loss_degrades_then_postgres_loss_is_bounded (test_degradation.DependencyOutages.test_valkey_loss_degrades_t +hen_postgres_loss_is_bounded) ... ok + +---------------------------------------------------------------------- +Ran 2 tests in 40.822s + +OK + + outage summary: {"cached_p50_ms": 15.0, "cache_down_p50_ms": 15.0, "cache_down_p95_ms": 32.0, "db_down_write_seconds": 2.06, "recovery_seconds": 3.92} diff --git a/scripts/research-history-backup.sh b/scripts/research-history-backup.sh new file mode 100755 index 00000000..91df6ce0 --- /dev/null +++ b/scripts/research-history-backup.sh @@ -0,0 +1,35 @@ +#!/bin/sh +# Grade-5 track 2: build the 100k uneven fixture, compare two index choices, +# then backup and restore into a separate database and compare integrity sums. +# The normal messenger database and its named volume are never removed. +set -eu +cd "$(dirname "$0")/.." + +ENV_FILE="${COMPOSE_ENV_FILE:-.env}" +mkdir -p evidence + +docker compose --env-file "$ENV_FILE" exec -T postgres \ + psql -X -U messenger -d messenger -v ON_ERROR_STOP=1 -f - \ + < scripts/research-history-backup.sql > evidence/research-history-backup.txt 2>&1 + +{ + printf '%s\n' '=== backup ===' + docker compose --env-file "$ENV_FILE" exec -T postgres sh -ceu ' + rm -f /tmp/lab2-grade5.dump + pg_dump -U messenger -d messenger --format=custom --file=/tmp/lab2-grade5.dump + dropdb -U messenger --if-exists messenger_grade5_restore + createdb -U messenger messenger_grade5_restore + pg_restore -U messenger -d messenger_grade5_restore --exit-on-error /tmp/lab2-grade5.dump + ' + printf '%s\n' '=== source integrity ===' + docker compose --env-file "$ENV_FILE" exec -T postgres \ + psql -X -U messenger -d messenger -At -F '|' -c \ + "SELECT count(*), min(created_at), max(created_at), sum(length(text)) FROM messages WHERE sender_id = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';" + printf '%s\n' '=== restored integrity ===' + docker compose --env-file "$ENV_FILE" exec -T postgres \ + psql -X -U messenger -d messenger_grade5_restore -At -F '|' -c \ + "SELECT count(*), min(created_at), max(created_at), sum(length(text)) FROM messages WHERE sender_id = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';" +} >> evidence/research-history-backup.txt 2>&1 + +cat evidence/research-history-backup.txt +printf '%s\n' 'saved evidence/research-history-backup.txt' diff --git a/scripts/research-history-backup.sql b/scripts/research-history-backup.sql new file mode 100644 index 00000000..255b4f64 --- /dev/null +++ b/scripts/research-history-backup.sql @@ -0,0 +1,105 @@ +-- Grade-5 track 2: query-plan comparison on >=100k messages with highly +-- uneven chat sizes. The deterministic fixture is isolated by username/title +-- prefixes and can safely be re-run on the same persistent volume. +\set ON_ERROR_STOP on +\timing on + +INSERT INTO users (id, username, display_name, password_hash, created_at) +VALUES ('aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', 'research_seed_user', + 'Research seed user', 'not-a-usable-hash', now()) +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chats (id, title, created_at) +VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', 'research-hot-chat', now()) +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chat_members (chat_id, user_id, joined_at) +VALUES ('bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', now()) +ON CONFLICT DO NOTHING; + +-- One hot chat with 90k messages and 100 cold chats with 100 messages each. +-- md5() yields stable 32 hex characters and PostgreSQL accepts it as UUID. +INSERT INTO chats (id, title, created_at) +SELECT md5('research-cold-chat-' || n)::uuid, 'research-cold-chat-' || n, now() +FROM generate_series(1, 100) AS n +ON CONFLICT (id) DO NOTHING; + +INSERT INTO chat_members (chat_id, user_id, joined_at) +SELECT md5('research-cold-chat-' || n)::uuid, + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', now() +FROM generate_series(1, 100) AS n +ON CONFLICT DO NOTHING; + +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT md5('research-hot-message-' || n)::uuid, + 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb', + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', + 'hot message ' || n, + timestamptz '2026-02-01 00:00:00+00' + make_interval(secs => n * 0.001) +FROM generate_series(1, 90000) AS n +ON CONFLICT (id) DO NOTHING; + +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT md5('research-cold-message-' || chat_n || '-' || message_n)::uuid, + md5('research-cold-chat-' || chat_n)::uuid, + 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa', + 'cold message ' || chat_n || '-' || message_n, + timestamptz '2026-02-02 00:00:00+00' + + make_interval(secs => (chat_n * 100 + message_n) * 0.001) +FROM generate_series(1, 100) AS chat_n, + generate_series(1, 100) AS message_n +ON CONFLICT (id) DO NOTHING; + +ANALYZE messages; + +\echo '=== dataset shape ===' +SELECT count(*) AS research_messages, + count(DISTINCT chat_id) AS research_chats, + max(per_chat.count) AS largest_chat_messages, + min(per_chat.count) AS smallest_chat_messages +FROM messages +JOIN ( + SELECT chat_id, count(*) + FROM messages + WHERE sender_id = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa' + GROUP BY chat_id +) AS per_chat USING (chat_id) +WHERE messages.sender_id = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'; + +\echo '=== source integrity summary ===' +SELECT count(*) AS count, + min(created_at) AS first_message, + max(created_at) AS last_message, + sum(length(text)) AS text_bytes +FROM messages +WHERE sender_id = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'; + +\echo '=== index A: production composite (chat_id, created_at, id) ===' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb' + AND (created_at, id) > ( + timestamptz '2026-02-01 00:01:20+00', + md5('research-hot-message-80000')::uuid + ) +ORDER BY created_at, id +LIMIT 50; + +\echo '=== index B: chat_id-only alternative (temporary, rolled back) ===' +BEGIN; +DROP INDEX messages_chat_order_idx; +CREATE INDEX messages_research_chat_only_idx ON messages (chat_id); +ANALYZE messages; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb' + AND (created_at, id) > ( + timestamptz '2026-02-01 00:01:20+00', + md5('research-hot-message-80000')::uuid + ) +ORDER BY created_at, id +LIMIT 50; +ROLLBACK; diff --git a/src/sessions.py b/src/sessions.py index 03dd2b9b..b27e37e9 100644 --- a/src/sessions.py +++ b/src/sessions.py @@ -270,18 +270,8 @@ async def resolve_session( "Session token is expired or revoked", {"WWW-Authenticate": 'Bearer realm="messenger"'}, ) - state, payload = await cache.lookup(hashed) - if state == HIT and payload is not None: - if payload["expires_epoch"] > time.time(): - try: - user_id = uuid.UUID(payload["user"]["id"]) - except (ValueError, TypeError, KeyError): - user_id = None - if user_id is not None: - return user_id, payload["user"] - else: - await cache.revoke(hashed, None) - elif state == TOMBSTONE: + state, _payload = await cache.lookup(hashed) + if state == TOMBSTONE: raise ApiProblem( 401, "unauthorized", @@ -289,6 +279,11 @@ async def resolve_session( {"WWW-Authenticate": 'Bearer realm="messenger"'}, ) + # PostgreSQL is the authoritative revocation store. A cache value can only + # accelerate the immutable user snapshot; it must never be enough to grant + # access on its own. In particular this makes logout durable across API + # restarts and Valkey outages/restores, where a tombstone may not yet have + # reached the shared cache. async with pool.connection() as connection: async with connection.cursor() as cursor: row = await store.session_user(cursor, hashed) @@ -301,6 +296,7 @@ async def resolve_session( {"WWW-Authenticate": 'Bearer realm="messenger"'}, ) user = _user_payload(row) + # Refresh an old cache hit after PostgreSQL has confirmed it is still live. await cache.remember(hashed, user, row["expires_at"]) return uuid.UUID(user["id"]), user @@ -326,4 +322,3 @@ async def purge_expired(pool: AsyncConnectionPool) -> int: async with pool.connection() as connection: async with connection.cursor() as cursor: return await store.purge_expired_sessions(cursor) - diff --git a/student-tests/test_degradation.py b/student-tests/test_degradation.py index f4c23811..bb8972b2 100644 --- a/student-tests/test_degradation.py +++ b/student-tests/test_degradation.py @@ -46,9 +46,13 @@ def wait_ready(expected: int, seconds: float) -> float: deadline = started + seconds last = None while time.monotonic() < deadline: - last = common.request("GET", "/health/ready", timeout=5) - if last.status == expected: - return time.monotonic() - started + try: + last = common.request("GET", "/health/ready", timeout=5) + if last.status == expected: + return time.monotonic() - started + except OSError: + # The TCP listener may be replaced during `compose restart`. + pass time.sleep(0.5) raise AssertionError( "readiness did not reach %s within %.0fs (last=%s %r)" @@ -58,6 +62,49 @@ def wait_ready(expected: int, seconds: float) -> float: @unittest.skipUnless(ENABLED, "set STUDENT_DOCKER_TESTS=1 to stop real containers") class DependencyOutages(unittest.TestCase): + def test_logout_remains_revoked_after_cache_outage_and_api_restart(self) -> None: + """A stale Valkey hit must never resurrect a PostgreSQL-revoked token.""" + alice = common.actor("revoked") + chat = common.create_chat(alice.token, [alice.id], "Durable logout") + # Store the live session in Valkey before its simulated outage. + self.assertEqual(common.request("GET", "/api/v1/users/me", token=alice.token).status, 200) + try: + compose("stop", "valkey") + logout = common.request("DELETE", "/api/v1/auth/sessions/current", token=alice.token) + self.assertEqual(logout.status, 204, logout.json) + + # Lose the local pending tombstone, then restore Valkey's old volume. + compose("restart", "api") + compose("start", "valkey") + wait_ready(200, 90) + + common.expect_error( + self, common.request("GET", "/api/v1/users/me", token=alice.token), 401, "unauthorized" + ) + common.expect_error( + self, + common.request("GET", "/api/v1/chats/" + chat["id"], token=alice.token), + 401, + "unauthorized", + ) + common.expect_error( + self, + common.request( + "POST", + "/api/v1/chats/" + chat["id"] + "/messages", + body={"text": "must not be accepted"}, + token=alice.token, + ), + 401, + "unauthorized", + ) + finally: + compose("start", "valkey", "postgres", "api") + try: + wait_ready(200, 90) + except AssertionError: + pass + def test_valkey_loss_degrades_then_postgres_loss_is_bounded(self) -> None: alice = common.actor("degrade") chat = common.create_chat(alice.token, [alice.id], "Устойчивость")