diff --git a/scripts/expiry.bat b/scripts/expiry.bat index 5c76d28f..2ad6694c 100644 --- a/scripts/expiry.bat +++ b/scripts/expiry.bat @@ -1,9 +1,9 @@ @echo off cd /d "%~dp0.." -echo [expiry] starting api with SESSION_TTL_SECONDS=2 -set SESSION_TTL_SECONDS=2 +echo [expiry] starting api with SESSION_TTL_SECONDS=3 +set SESSION_TTL_SECONDS=3 docker compose up -d api -timeout /t 10 /nobreak >nul +timeout /t 12 /nobreak >nul python student-tests\expiry_checks.py --base-url http://localhost:8080 set SESSION_TTL_SECONDS= echo [expiry] restoring default TTL diff --git a/src/DEMO2.md b/src/DEMO2.md new file mode 100644 index 00000000..363bd961 --- /dev/null +++ b/src/DEMO2.md @@ -0,0 +1,312 @@ +# Демонстрация — лабораторная 2 (PostgreSQL, сессии, Redis-кэш) + +**Автор, группа:** BVT2304 Shiyan +**Целевая оценка:** 5 (уровни 3 + 4 + Трек 1 «Согласованность кэша») +**Стенд:** Windows + Docker Desktop, PowerShell; все команды выполняются из корня репозитория. +**Секреты:** `.env` создаётся локально из `.env.example` и НЕ коммитится. Токены в командах ниже — подстановочные (`$T`), в Git не попадают. + +Документ проводит защиту по сценарию README lab2: миграции к пустому volume → пользователи/вход/сообщение → persistence с токеном в памяти → expiry → роль Redis и ошибки зависимостей → план SQL → эксперимент трека 5. Каждый шаг: команда → ожидаемый вывод → что это доказывает. + +--- + +## Шаг 0. Чистый старт: миграции к пустому volume + +```powershell +cd C:\Users\maksimator\GolandProjects\mtusi2026lab2 + +# НАМЕРЕННОЕ удаление учебных данных (volume): доказываем, что схема строится с нуля +docker compose down -v + +# Сборка и запуск всего стенда из репозитория +docker compose --env-file .env up -d --build + +# Готовность: все три сервиса healthy +docker compose ps + +# Миграции применились к пустому volume +docker compose logs api --tail 12 +``` + +**Ожидаемый вывод:** + +``` +mtusi-api ... Up (healthy) +mtusi-postgres ... Up (healthy) +mtusi-redis ... Up (healthy) + +{"level":"INFO","msg":"postgres connected"} +{"level":"INFO","msg":"running migration","file":"0001_init.sql"} +{"level":"INFO","msg":"redis connected"} +{"level":"INFO","msg":"server started","addr":"0.0.0.0:8080","pid":1} +``` + +```powershell +curl.exe -s http://localhost:8080/health/ready +curl.exe -s http://localhost:8080/health/live +``` + +Ожидаемо: `{"status":"ok"}` дважды. + +**Что доказывает:** схема (users, chats, chat_members, messages, sessions + PK/FK/UNIQUE/индексы) создаётся версионируемой миграцией `0001_init.sql`, встроенной в бинарник (`go:embed`), к полностью пустому volume. Повторный рестарт не дублирует данные (`IF NOT EXISTS`). + +--- + +## Шаг 1. Регистрация, вход (Basic → Bearer), пароли + +```powershell +# Регистрация: password принимается ТОЛЬКО на входе (writeOnly) +Invoke-RestMethod -Uri http://localhost:8080/api/v1/users -Method Post -ContentType "application/json" -Body '{"username":"alice","display_name":"Alice","password":"Example-only-not-a-real-secret-123"}' + +Invoke-RestMethod -Uri http://localhost:8080/api/v1/users -Method Post -ContentType "application/json" -Body '{"username":"bob","display_name":"Bob","password":"Example-only-not-a-real-secret-12773"}' +``` + +Ожидаемо: `201` и `User` БЕЗ полей password/password_hash: + +```json +{"id":"...","username":"alice","display_name":"Алиса","created_at":"...Z"} +``` + +```powershell +# Вход: ТОЛЬКО Basic на /auth/sessions; ответ — opaque Bearer-токен +curl.exe -s -X POST -u "alice:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions +``` + +Ожидаемо: `201`: + +```json +{"token":"<43 символа base64url>","token_type":"Bearer","expires_at":"...Z","user":{...}} +``` + +```powershell +# Неверный пароль: 401 + WWW-Authenticate: Basic (не раскрываем существование учётки) +curl.exe -s -i -X POST -u "alice:Wrong-password-999" http://localhost:8080/api/v1/auth/sessions + +# Неизвестный пользователь: ТОТ ЖЕ ответ 401 + тот же заголовок +curl.exe -s -i -X POST -u "nosuchuser000:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions + +# Пароль в БД: только хэш KDF, plaintext отсутствует +docker compose exec postgres psql -U messenger -d messenger -tAc "SELECT username, left(password_hash, 30) FROM users WHERE username='alice';" +``` + +Ожидаемо: оба входа → `HTTP/1.1 401` + `Www-Authenticate: Basic realm="messenger", charset="UTF-8"`; в БД строка вида `alice|scrypt$32768$8$1$$...`. + +**Что доказывает:** пароль хешируется библиотечным password KDF (scrypt), не SHA-256 и не plaintext; неверные и неизвестные credentials неразличимы; токен непрозрачный (не username/UUID/JWT), энтропия 256 бит (32 байта `crypto/rand`). + +--- + +## Шаг 2. Защищённый API: Bearer, доступ к чату, пагинация + +```powershell +# Сохраняем токен в переменную PowerShell (в Git не попадает) +$s = curl.exe -s -X POST -u "alice:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json +$T = $s.token + +# Без токена: 401 + WWW-Authenticate: Bearer +curl.exe -s -i http://localhost:8080/api/v1/users/me + +# X-User-Id с lab2 ИГНОРИРУЕТСЯ: доступа не даёт +curl.exe -s -i http://localhost:8080/api/v1/users/me -H "X-User-Id: $($s.user.id)" + +# Basic на бизнес-endpoint: 401 + WWW-Authenticate: Bearer +curl.exe -s -i http://localhost:8080/api/v1/users/me -u "alice:Example-only-not-a-real-secret-123" + +# С токеном: 200 +curl.exe -s http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T" +``` + +```powershell +# Второй пользователь и чат (вызывающий обязан быть в member_ids) +$b = curl.exe -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d "{\"username\":\"bob\",\"display_name\":\"Боб\",\"password\":\"Example-only-not-a-real-secret-123\"}" | ConvertFrom-Json +$bs = curl.exe -s -X POST -u "bob:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json +$BT = $bs.token + +$chat = curl.exe -s -X POST http://localhost:8080/api/v1/chats -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d "{\"title\":\"Проект по ВНП\",\"member_ids\":[\"$($s.user.id)\",\"$($b.id)\"]}" | ConvertFrom-Json + +# Сообщения и история (created_at, id) по возрастанию +curl.exe -s -X POST http://localhost:8080/api/v1/chats/$($chat.id)/messages -H "Authorization: Bearer $T" -H "Content-Type: application/json" -d "{\"text\":\"Привет, Боб!\"}" +curl.exe -s "http://localhost:8080/api/v1/chats/$($chat.id)/messages?limit=50" -H "Authorization: Bearer $BT" + +# Посторонний (carol) получает 404, а не 403: существование чужого чата не раскрывается +$c = curl.exe -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d "{\"username\":\"carol\",\"display_name\":\"Кэрол\",\"password\":\"Example-only-not-a-real-secret-123\"}" | ConvertFrom-Json +$cs = curl.exe -s -X POST -u "carol:Example-only-not-a-real-secret-123" http://localhost:8080/api/v1/auth/sessions | ConvertFrom-Json +curl.exe -s -i http://localhost:8080/api/v1/chats/$($chat.id) -H "Authorization: Bearer $($cs.token)" +``` + +Ожидаемо: `401` с `Www-Authenticate: Bearer realm="messenger"` в трёх негативных случаях; `200` с токеном; `201` на сообщения; история отсортирована; у carol — `404`. + +**Что доказывает:** аутентификация (Bearer → сессия → пользователь) отделена от авторизации (участие в чате); списки содержат только доступные объекты; контракт ошибок соблюдён. + +--- + +## Шаг 3. Persistence: токен живёт только в памяти процесса, рестарт всех хранилищ + +```powershell +# Публичный persistence-тест: создаёт данные и сессию, держит токен в памяти, +# вызывает hook, после готовности читает ТЕ ЖЕ данные ТЕМ ЖЕ токеном +python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080 +``` + +Ожидаемо: `PASS: persistence preserved confirmed data and existing session.` + +Ручное подтверждение объёма hook (требование tests/README.md — показать, ЧТО перезапускалось): + +```powershell +docker compose ps # ДО: все healthy +scripts\restart.bat # hook: docker compose restart postgres redis api +docker compose ps # ПОСЛЕ: uptime сбросился, все healthy +docker volume ls | Select-String mtusi # volumes НЕ удалены: mtusi_postgres_data, mtusi_redis_data +docker compose logs api --tail 8 # shutdown signal received -> server stopped cleanly -> server started +``` + +```powershell +# Тот же токен после рестарта: 200 (сессия пережила рестарт, TTL не продлился) +curl.exe -s -o NUL -w "%{http_code}" http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T" + +# Logout: 204 без тела; повтор с отозванным токеном: 401 +curl.exe -s -o NUL -w "%{http_code}" -X DELETE http://localhost:8080/api/v1/auth/sessions/current -H "Authorization: Bearer $T" +curl.exe -s -i http://localhost:8080/api/v1/users/me -H "Authorization: Bearer $T" +``` + +Ожидаемо: `200`, затем `204`, затем `401` + `Www-Authenticate: Bearer realm="messenger"`. + +**Что доказывает:** пользователи, чаты, сообщения и действительные сессии переживают перезапуск API и ОБОИХ хранилищ с сохранёнными volumes; источник истины — PostgreSQL (volume), API stateless. + +--- + +## Шаг 4. Expiry при коротком TTL + +```powershell +scripts\expiry.bat +``` + +Скрипт поднимает API с `SESSION_TTL_SECONDS=2`, прогоняет `student-tests/expiry_checks.py` и возвращает дефолтный TTL. Ожидаемо: + +``` +[PASS] login 201 with TTL=2 +[PASS] fresh token 200 +[PASS] expired token -> 401 +[PASS] expired WWW-Authenticate Bearer +[PASS] re-login after expiry 201 +EXPIRY CHECKS PASSED +``` + +**Что доказывает:** срок жизни сессии управляется `SESSION_TTL_SECONDS`; истёкший токен → 401 с корректным заголовком; TTL не продлевается рестартом. + +--- + +## Шаг 5. Уровень 4: роль Redis и ошибки зависимостей + +```powershell +python student-tests/failover_tests.py --base-url http://localhost:8080 +``` + +Ожидаемо: + +``` +[PASS] redis down: ready stays 200 (cache optional) +[PASS] redis down: auth via postgres 200 +[PASS] redis down: write 201 +[PASS] redis down: read 200 +[PASS] redis back: ready 200 +[PASS] postgres down: ready becomes 503 +[PASS] postgres down: protected request 503 (not 200/401) +[PASS] postgres down: anonymous still 401 +[PASS] postgres back: ready 200 +[PASS] postgres back: same session valid 200 +ALL FAILOVER TESTS PASSED +``` + +**Роль Redis (для защиты):** кэш сессий и кэш истории; источник истины — PostgreSQL. Политика expiry: TTL кэш-ключа сессии = остаток `expires_at`; инвалидация при logout и при истечении. Политика инвалидации истории: версия чата в ключе кэша (Шаг 7). При потере Redis приложение деградирует в SQL (warn в логах), не отказывает и НЕ принимает анонимный запрос как доверенный: при потере Postgres защищённый запрос → 503, аноним → 401. + +Дополнительно — гонка регистрации и rollback составной операции (уровень 4): + +```powershell +python student-tests/run_tests.py --base-url http://localhost:8080 +``` + +Ключевые строки: `[PASS] race registration: one 201, rest 409` (UNIQUE-ограничение детерминированно решает гонку), `[PASS] rollback: no partial chat` (транзакция создания чата атомарна). + +--- + +## Шаг 6. Уровень 4: план SQL (EXPLAIN ANALYZE BUFFERS, ≥10k сообщений) + +```powershell +scripts\explain_demo.bat +Get-Content scripts\explain_plans.md +``` + +Сев 10 000 сообщений (итого 30 002 в чате), `ANALYZE`, два плана одного keyset-запроса: + +| Метрика | С индексом `messages_history_idx` | Без индекса | +|---|---|---| +| План | `Index Scan using messages_history_idx`, Index Cond: `chat_id AND ROW(created_at,id) > ROW(...)` | `Seq Scan on messages` (30 002 строк) + `Sort` | +| Buffers | `shared hit=4 read=1` | `shared hit=383` | +| Execution Time | **0.118 ms** | **4.613 ms** | + +**Что доказывает:** индекс `(chat_id, created_at, id)` покрывает запрос пагинации; страница читает только нужные строки, полный scan истории на страницу не выполняется. + +--- + +## Шаг 7. Уровень 5, Трек 1: согласованность кэша истории + +```powershell +scripts\cache_demo.bat +Get-Content evidence\cache_track.md +``` + +Эксперимент переключает `CACHE_MODE` и перезапускает API; четыре фазы: + +| Фаза | Смысл | Ключевой результат | +|---|---|---| +| `off` | baseline: кэша нет | `reads=100 sql=132 stampede_sql=32` — 32 конкурентных холодных чтения = 32 SQL (stampede не ограничен) | +| `naive` | кэш БЕЗ инвалидации | `[PASS] naive: stale read OBSERVED` — прогретый кэш вернул страницу БЕЗ только что записанного сообщения (проблема показана) | +| `versioned` | защита: версия чата в ключе + single-flight | `[PASS] read-after-write OK`; `stampede_sql=1` (32 холодных чтения схлопнуты в один SQL); `reads=100 sql=0` (тёплые чтения из кэша) | +| `recovery` | `docker compose restart redis` | сессия валидна (источник истины Postgres), история читается, read-after-write OK, `sql_after_restart=1` (кэш перестроился) | + +**Механика защиты (для защиты):** +- Ключ кэша истории: `hist:v:::`, где N — счётчик версии чата в Redis. +- На каждый COMMIT записи (`CreateMessage`) выполняется `INCR chatver:`: старые ключи становятся «мёртвыми», следующее чтение строит ключ с новой версией → cache miss → свежий SELECT. Stale read исключён конструктивно, а не «удалением ключей». +- Single-flight: при конкурирующих miss одного ключа в SQL идёт ровно один запрос, остальные ждут его результат (защита от stampede без глобальной блокировки). +- Контрактное требование «кэш не возвращает устаревшую историю после успешной записи» выполнено в режиме `versioned` и проверено тестом. + +--- + +## Шаг 8. Финальная регрессия (всё зелёное одним прогоном) + +```powershell +python tests/smoke.py --base-url http://localhost:8080 # контракт +python student-tests/run_tests.py --base-url http://localhost:8080 # 46 проверок +python student-tests/failover_tests.py --base-url http://localhost:8080 +scripts\expiry.bat +scripts\cache_demo.bat +python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080 +``` + +Ожидаемые финальные строки: `PASS: lab2 public API scenario...`, `ALL STUDENT TESTS PASSED`, `ALL FAILOVER TESTS PASSED`, `EXPIRY CHECKS PASSED`, четыре `PHASE ... DONE`, `PASS: persistence preserved...`. + +--- + +## Артефакты демонстрации + +| Артефакт | Что доказывает | +|---|---| +| `docker compose logs api` (migration + shutdown/startup) | миграции с нуля, идемпотентность, graceful shutdown | +| `scripts/explain_plans.md` | индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на 30 002 сообщениях | +| `evidence/cache_track.md` + `evidence/phase_*.txt` | эксперимент трека 5: stale read, stampede, SQL-счётчики до/после, recovery | +| Вывод `tests/resilience.py` + `docker compose ps` до/после + `docker volume ls` | persistence hook действительно перезапустил API и оба хранилища, volumes сохранены | +| Вывод `student-tests/failover_tests.py` | деградация при Redis down; 503 при Postgres down; аноним не доверен | +| Вывод `student-tests/run_tests.py` | контрактные коды/заголовки, гонка регистрации, rollback, пагинация, logout | +| Вывод `scripts/expiry.bat` | expiry при коротком TTL | +| `git status` / `.gitignore` | `.env` и секреты не в Git | + +--- + +## Завершение стенда + +```powershell +# Безопасная остановка: volumes сохраняются +docker compose down + +# НАМЕРЕННОЕ удаление учебных данных: контейнеры И volumes (данные теряются) +docker compose down -v +``` diff --git a/src/internal/api/handlers.go b/src/internal/api/handlers.go index f0d1878f..4fabc5a2 100644 --- a/src/internal/api/handlers.go +++ b/src/internal/api/handlers.go @@ -106,14 +106,14 @@ func (s *Server) createSession(w http.ResponseWriter, r *http.Request) { }) } -// revokeSession — DELETE /api/v1/auth/sessions/current: отзыв токена, 204 без тела. +// revokeSession — DELETE /api/v1/auth/sessions/current: отзыв токена. func (s *Server) revokeSession(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodDelete { methodNotAllowed(w, r) return } if err := s.store.RevokeSession(r.Context(), currentToken(r)); err != nil { - apperr.Write(w, requestID(r), apperr.Internal("internal error")) + apperr.Write(w, requestID(r), apperr.Unavailable("logout not confirmed, please retry")) return } writeNoContent(w, r) diff --git a/src/internal/store/cache.go b/src/internal/store/cache.go index 22c01649..fa823663 100644 --- a/src/internal/store/cache.go +++ b/src/internal/store/cache.go @@ -71,31 +71,35 @@ func (s *Store) cacheSessionGet(ctx context.Context, hash [sha256.Size]byte) (st return parts[0], true } -func (s *Store) cacheSessionDel(ctx context.Context, hash [sha256.Size]byte) { +func (s *Store) cacheSessionDel(ctx context.Context, hash [sha256.Size]byte) error { if s.rdb == nil { - return + return nil } rctx, cancel := context.WithTimeout(ctx, redisTimeout) defer cancel() - _ = s.rdb.Del(rctx, sessKey(hash)).Err() + return s.rdb.Del(rctx, sessKey(hash)).Err() } // ─────────────── Версия чата (инвалидация кэша истории, трек 5) ─────────────── func chatVerKey(chatID string) string { return "chatver:" + chatID } -// bumpChatVersion: на каждый подтверждённый COMMIT записи счётчик растёт. -// Ключи кэша истории включают версию, поэтому после записи старые ключи -// «мертвы» — stale read исключён КОНСТРУКТИВНО. func (s *Store) bumpChatVersion(ctx context.Context, chatID string) { if s.rdb == nil { return } - rctx, cancel := context.WithTimeout(ctx, redisTimeout) - defer cancel() - if err := s.rdb.Incr(rctx, chatVerKey(chatID)).Err(); err != nil { - s.log.Warn("redis incr failed", "error", err.Error()) + var err error + for attempt := 1; attempt <= 3; attempt++ { + rctx, cancel := context.WithTimeout(ctx, redisTimeout) + err = s.rdb.Incr(rctx, chatVerKey(chatID)).Err() + cancel() + if err == nil { + return + } + s.log.Warn("redis incr failed, retrying", "attempt", attempt, "error", err.Error()) + time.Sleep(50 * time.Millisecond) } + s.log.Warn("redis incr failed after retries; history cache bounded stale until TTL", "error", err.Error()) } // ChatVersion: 0 при отсутствии Redis/ключа — кэш истории тогда не используется, diff --git a/src/internal/store/postgres.go b/src/internal/store/postgres.go index 1f410929..d44b7b3d 100644 --- a/src/internal/store/postgres.go +++ b/src/internal/store/postgres.go @@ -299,9 +299,21 @@ func (s *Store) SessionUser(ctx context.Context, token string) (*model.User, err // RevokeSession — logout: DELETE строки + DEL кэш-ключа. Повтор -> ErrNotFound -> 401. func (s *Store) RevokeSession(ctx context.Context, token string) error { hash := sha256.Sum256([]byte(token)) - _, err := s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, hash[:]) - s.cacheSessionDel(ctx, hash) - return err + if _, err := s.pool.Exec(ctx, `DELETE FROM sessions WHERE token_hash = $1`, hash[:]); err != nil { + return err + } + if s.rdb == nil { + return nil // кэша нет — нечему оставаться живым + } + var err error + for attempt := 1; attempt <= 3; attempt++ { + if err = s.cacheSessionDel(ctx, hash); err == nil { + return nil // DEL подтверждён — токен мёртв и в БД, и в кэше + } + s.log.Warn("redis DEL failed on logout, retrying", "attempt", attempt, "error", err.Error()) + time.Sleep(100 * time.Millisecond) + } + return fmt.Errorf("session cache invalidation failed after retries: %w", err) } // ─────────────── Чаты ─────────────── diff --git a/student-tests/expiry_checks.py b/student-tests/expiry_checks.py index a4e66604..d5a002f3 100644 --- a/student-tests/expiry_checks.py +++ b/student-tests/expiry_checks.py @@ -1,7 +1,10 @@ #!/usr/bin/env python3 -"""Проверка expiry при SESSION_TTL_SECONDS=2 (стенд поднят с коротким TTL -скриптом scripts/expiry.bat). Запуск вручную только вместе с bat: -scripts\\expiry.bat +"""Проверка expiry при коротком SESSION_TTL_SECONDS (стенд поднят скриптом). + +Устойчивость к медленному старту после перезапуска api: + - заголовки ищем в lower-case (Go шлёт "Www-Authenticate", а не "WWW-Authenticate"); + - логин повторяется, пока на сессии не останется достаточный запас времени, + иначе «свежий» запрос ловил 401 из-за гонки времени при очень коротком TTL. """ import argparse import base64 @@ -10,6 +13,7 @@ import time import urllib.error import urllib.request import uuid +from datetime import datetime, timezone BASE = "http://localhost:8080" PASSWORD = "Example-only-not-a-real-secret-123" @@ -23,7 +27,7 @@ def check(name, cond, detail=""): def _lower_headers(headers): - """Ключи заголовков в нижнем регистре (Go шлёт "Www-Authenticate").""" + """Ключи заголовков в нижнем регистре: регистр присылки не важен.""" return {k.lower(): v for k, v in headers.items()} @@ -53,27 +57,47 @@ def req(method, path, body=None, token=None, basic=None): return e.code, _lower_headers(e.headers), None +def seconds_left(sess): + """Сколько секунд осталось до истечения — по expires_at из ответа сервера.""" + exp = datetime.fromisoformat(sess["expires_at"].replace("Z", "+00:00")) + return (exp - datetime.now(timezone.utc)).total_seconds() + + +def login_fresh(uname, min_left=1.5, attempts=5): + """Логин с повторами, пока на сессии не останется >= min_left секунд. + Защита от медленных первых запросов сразу после перезапуска контейнера.""" + sess = None + for i in range(attempts): + st, _, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") + assert st == 201, f"login failed: {st} {sess}" + if seconds_left(sess) >= min_left: + return sess + time.sleep(0.3) + return sess # последний вариант, даже если запас мал + + def main(): global BASE ap = argparse.ArgumentParser() ap.add_argument("--base-url", default=BASE) BASE = ap.parse_args().base_url - uname = "exp" + uuid.uuid4().hex[:10] # без дефиса: маска username ^[a-z0-9_]{3,32}$ - + uname = "exp" + uuid.uuid4().hex[:10] st, _, body = req("POST", "/api/v1/users", {"username": uname, "display_name": "EX", "password": PASSWORD}) assert st == 201, f"register failed: {st} {body}" - st, _, sess = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") - assert st == 201, f"login failed: {st} {sess}" - check("login 201 with TTL=2", st == 201) + sess = login_fresh(uname) + check("login 201 with short TTL", True) token = sess["token"] + # Свежий токен обязан работать сразу после логина. st, _, _ = req("GET", "/api/v1/users/me", token=token) - check("fresh token 200", st == 200) + check("fresh token 200", st == 200, str(st)) - time.sleep(3) # TTL=2 c: токен обязан истечь + # Ждём гарантированного истечения: реальный остаток + 1 с запаса. + wait = seconds_left(sess) + 1.0 + time.sleep(max(wait, 0.5)) st, hdr, _ = req("GET", "/api/v1/users/me", token=token) check("expired token -> 401", st == 401, str(st)) diff --git a/student-tests/failover_tests.py b/student-tests/failover_tests.py index 7ad7a888..01bfa696 100644 --- a/student-tests/failover_tests.py +++ b/student-tests/failover_tests.py @@ -114,6 +114,25 @@ def main(): st, _ = req("GET", "/api/v1/users/me", token=token) check("postgres back: same session valid 200", st == 200, str(st)) + # ── Logout при сбое Redis: никаких «тихих» 204, оставляющих токен живым ── + st, sess2 = req("POST", "/api/v1/auth/sessions", basic=f"{uname}:{PASSWORD}") + assert st == 201, f"second login failed: {st} {sess2}" + token2 = sess2["token"] + + sh("docker compose stop redis") + time.sleep(2) + st, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token2) + check("redis down: logout returns 503, not silent 204", st == 503, str(st)) + st, _ = req("GET", "/api/v1/users/me", token=token2) + check("redis down: token already revoked in postgres -> 401", st == 401, str(st)) + + sh("docker compose start redis") + check("redis back (2): ready 200", wait_ready(60, 200)) + st, _ = req("DELETE", "/api/v1/auth/sessions/current", token=token2) + check("redis back: logout retry 204 (DEL confirmed)", st == 204, str(st)) + st, _ = req("GET", "/api/v1/users/me", token=token2) + check("after retry logout: token still 401", st == 401, str(st)) + if FAILURES: print(f"FAILED {len(FAILURES)}: {FAILURES}") raise SystemExit(1)