diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 7bbd74b4..9cb6820b 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,19 +1,20 @@ ## Лабораторная 2 Автор / группа: Синюк Максим / БПИ2301 -Целевая оценка (3/4/5): 4 -Трек 1 (на оценку 5): "" +Целевая оценка (3/4/5): 5 +Трек 1 (на оценку 5): "Согласованность кэша" Что реализовано и что перенесено: перенесены пользовательские тесты, валидация(перенастроена на пароль), роуты(перенастроены на защиту по токену сессии) Команды запуска из чистого clone: cd mtusi2026lab2 | docker compose -d --build | docker compose logs api --tail 50 Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO +Ограничения / известные ошибки: описано в REPORT.md Источники и использование ИИ: TODO pool_size и pool_timeout защищают БД от исчерпания соединений (Connection Exhaustion) при DDoS или всплесках трафика, параметризованные запросы/безопасный ORM, Проверены гонка регистрации одинакового username(test_duplicate_username) и rollback составной операции. Кэш сессий хранится в Redis, он ускоряет проверку токена сложностью O(1) - cache hit, в случае cache miss/недоступности Redis запрос идёт в БД, а затем кэшируется(Redis is recovered). Источник истины — PostgreSQL таблица sessions.Политика expiry: TTL = SESSION_TTL_SECONDS (совпадает с БД). Инвалидация: при logout ключ удаляется; при истечении TTL — автоматически. TTL задаётся в переменных окружения .env Источник истины БД. Так Race condition на создание уже существующего username защищено в миграции CONSTRAINT users_username_unique. Обоснование индекса messages_chat_created_id_idx в БД путём генерации 10 000 сообщений и выполнения EXPLAIN (ANALYZE, BUFFERS) в results/explain_comparison.txt При недоступности кэша происходит его обход и обращение в БД. Ограниченная ошибка при его недоступности обрабатывается через в декораторе @application.exception_handler к функции def db_unavailable_handler(OperationalError) +Тесты stale read, cache stampede, restart redis проведены успешно, логи в файле results/cache_consistency.log. Описание в REPORT.md - [+] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. - [+] Контракт и публичные тесты не ослаблены. diff --git a/REPORT.md b/REPORT.md index 5a767914..4424a2f4 100644 --- a/REPORT.md +++ b/REPORT.md @@ -44,12 +44,35 @@ TODO: добавить отдельную строку для каждого з ## Эксперименты и отказы TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Эксперименты проведены при одинаковых лимитах: 2CPU/2GiB. +Тест 1: Stale Read при Logout +- **Результат:** PASS — токен корректно отклоняется после logout (401 Unauthorized) +- **Механизм:** `invalidate_session(token_hash)` удаляет ключ из Redis при logout + +Тест 2: Cache Stampede (100 параллельных запросов после истечения TTL) +- **Время выполнения:** 1.58 секунды +- **Успешных аутентификаций:** 100/100 (0 ошибок) +- **Статистика SQL (pg_stat_statements):** + - `SELECT FROM sessions WHERE token_hash = $1`: 210 вызовов, **0.07 мс в среднем** + - `INSERT INTO sessions`: 203 вызова, 1.00 мс в среднем + - `DELETE FROM sessions`: 2 вызова, 1.27 мс в среднем +- **Вывод:** Connection pool PostgreSQL (10 соединений) корректно распределил нагрузку. + Средняя latency проверки токена 0.07 мс доказывает эффективность индекса по `token_hash`. +Тест 3: Восстановление после рестарта Redis (Graceful Degradation) +- **Redis DOWN:** Fallback на PostgreSQL → 200 OK (0 потерянных запросов) +- **Redis UP:** Кэш автоматически заполняется при следующих запросах +- **Результат:** PASS — полная функциональность при недоступности кэша | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | | TODO | TODO | TODO | TODO | +| Прогон тестов через scripts/cache_consistency_test.py | Успешное выполнение тестов 1-3 | Результат сохранён в results/cache_consistency.log | Потери запросов и данных нет ## Ограничения и следующие шаги TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Asyncio lock работает только в рамках одного процесса. При горизонтальном масштабировании (несколько инстансов API) нужен распределённый lock (Redis Redlock или PostgreSQL advisory locks). +Джиттер TTL — эвристический. 10% джиттер снижает вероятность stampede, но не устраняет его полностью. Более надёжное решение — probabilistic early expiration (проверка TTL и обновление с вероятностью 1 - (remaining_ttl / total_ttl)). +Не измерена деградация при длительном отказе Redis. Если Redis недоступен >5 минут, все запросы идут в БД, что может привести к исчерпанию connection pool. Нужен circuit breaker. +Тест cache stampede синтетический. В реальности TTL сессий разный (зависит от времени логина), поэтому массовое истечение маловероятно. Более реалистичный сценарий — резкий рост трафика после восстановления Redis. diff --git a/docker-compose.yaml b/docker-compose.yaml index 4d868ec6..c0c39ad3 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -28,8 +28,11 @@ services: POSTGRES_USER: ${POSTGRES_USER} POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} POSTGRES_DB: ${POSTGRES_DB} + ports: + - "127.0.0.1:5433:5432" volumes: - pgdata:/var/lib/postgresql/data + command: postgres -c shared_preload_libraries=pg_stat_statements healthcheck: test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] interval: 5s @@ -41,6 +44,8 @@ services: redis: image: redis:8.10-alpine command: redis-server --appendonly yes --save 60 1 + ports: + - "127.0.0.1:6379:6379" volumes: - redisdata:/data healthcheck: diff --git a/requirements.txt b/requirements.txt index 50104190..9f3df1b6 100644 Binary files a/requirements.txt and b/requirements.txt differ diff --git a/scripts/cache_consistency_test.py b/scripts/cache_consistency_test.py new file mode 100644 index 00000000..2bdf9491 --- /dev/null +++ b/scripts/cache_consistency_test.py @@ -0,0 +1,168 @@ +import asyncio +import os +import time +import uuid +import base64 +import httpx +from sqlalchemy import text +from src.database import engine +from src.auth.tokens import generate_token, hash_token +from src.auth.password import hash_password +from src.services.session_cache import invalidate_session, cache_session + + +os.environ["DATABASE_URL"] = "postgresql+asyncpg://mtusi:1878@127.0.0.1:5433/mtusi-messenger" + +from sqlalchemy import text +from src.database import engine + +BASE_URL = "http://localhost:8080" + + +async def create_user(username: str, password: str = "SecurePassword123!") -> dict: + + async with httpx.AsyncClient() as client: + response = await client.post(f"{BASE_URL}/api/v1/users", json={ + "username": username, + "display_name": f"Test {username}", + "password": password}) + response.raise_for_status() + + return response.json() + + +async def login(username: str, password: str = "SecurePassword123!") -> str: + + credentials = base64.b64encode(f"{username}:{password}".encode()).decode() + async with httpx.AsyncClient() as client: + response = await client.post(f"{BASE_URL}/api/v1/auth/sessions", headers={"Authorization": f"Basic {credentials}"}) + response.raise_for_status() + + return response.json()["token"] + + +async def test_stale_read(): + print("Stale Read при Logout") + + username = f"test_stale_{uuid.uuid4().hex[:8]}" + user = await create_user(username) + token = await login(username) + + async with httpx.AsyncClient() as client: + response = await client.get(f"{BASE_URL}/api/v1/users/me", headers={"Authorization": f"Bearer {token}"}) + assert response.status_code == 200, "Token should work before logout" + + print("Token works before logout") + + async with httpx.AsyncClient() as client: + response = await client.delete( + f"{BASE_URL}/api/v1/auth/sessions/current", + headers={"Authorization": f"Bearer {token}"} + ) + assert response.status_code == 204, f"Logout failed: {response.status_code}" + print("Logout successful") + + async with httpx.AsyncClient() as client: + response = await client.get( + f"{BASE_URL}/api/v1/users/me", + headers={"Authorization": f"Bearer {token}"} + ) + if response.status_code == 401: + print("Token correctly rejected after logout (no stale cache read)") + return True + else: + print(f"stale read detected: token still works after logout (status={response.status_code})") + return False + + +async def test_cache_stampede(): + print("Cache Stampede (массовый miss кэша)") + + username = f"test_stampede_{uuid.uuid4().hex[:8]}" + await create_user(username) + + tokens = [await login(username) for _ in range(100)] + print(f"Created {len(tokens)} sessions") + + print("Waiting for TTL expiration (11s)...") + await asyncio.sleep(11) + + print("Sending 100 parallel requests...") + start_time = time.time() + + async with httpx.AsyncClient(timeout=30.0) as client: + async def make_request(token: str): + response = await client.get( + f"{BASE_URL}/api/v1/users/me", + headers={"Authorization": f"Bearer {token}"} + ) + return response.status_code + + tasks = [make_request(token) for token in tokens] + results = await asyncio.gather(*tasks) + + elapsed = time.time() - start_time + success_count = sum(1 for r in results if r == 200) + + print(f"Completed in {elapsed:.2f}s") + print(f"Successful authentications: {success_count}/{len(tokens)}") + + return elapsed, success_count + + +async def test_redis_restart(): + print("Восстановление после рестарта Redis") + + username = f"test_restart_{uuid.uuid4().hex[:8]}" + user = await create_user(username) + token = await login(username) + + async with httpx.AsyncClient() as client: + response = await client.get(f"{BASE_URL}/api/v1/users/me", headers={"Authorization": f"Bearer {token}"}) + assert response.status_code == 200 + + print("Token works before Redis restart") + + print("Stopping Redis container") + proc = await asyncio.create_subprocess_exec("docker", "compose", "stop", "redis") + await proc.wait() + await asyncio.sleep(5) + + async with httpx.AsyncClient() as client: + response = await client.get(f"{BASE_URL}/api/v1/users/me", headers={"Authorization": f"Bearer {token}"} + ) + if response.status_code == 200: + print("Fallback to DB works (Redis down)") + else: + print(f"Fallback failed: {response.status_code}") + + print("Starting Redis container") + proc = await asyncio.create_subprocess_exec("docker", "compose", "start", "redis") + await proc.wait() + await asyncio.sleep(5) + + async with httpx.AsyncClient() as client: + response = await client.get(f"{BASE_URL}/api/v1/users/me", headers={"Authorization": f"Bearer {token}"} + ) + if response.status_code == 200: + print("Token works after Redis restart") + else: + print(f"Recovery failed: {response.status_code}") + + +async def main(): + print("Запуск 3 тестов для Редиса. Stale Read, Cache Stampede, Redis Restart") + + stale_read_passed = await test_stale_read() + + stampede_time, stampede_success = await test_cache_stampede() + + await test_redis_restart() + + print("SUMMARY") + print(f"Stale read protection: {'PASS' if stale_read_passed else 'FAIL'}") + print(f"Cache stampede: {stampede_success}/100 successful, {stampede_time:.2f}s") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/scripts/explain_messages.py b/scripts/explain_messages.py index d855ea8f..460a3989 100644 --- a/scripts/explain_messages.py +++ b/scripts/explain_messages.py @@ -86,7 +86,6 @@ async def main(): report_lines.append("KEY OBSERVATIONS") report_lines.append("Variant 1 uses 'Index Scan using messages_chat_created_id_idx'") report_lines.append("Variant 2 uses 'Seq Scan' + 'Sort' (full table scan)") - report_lines.append("Compare 'Buffers: shared hit=...' and 'Execution Time'") report = "\n".join(report_lines) print("\n" + report) diff --git a/src/api/dependencies.py b/src/api/dependencies.py index 5033db47..c0d1b7e2 100644 --- a/src/api/dependencies.py +++ b/src/api/dependencies.py @@ -4,12 +4,16 @@ from src.api.repositories.main_repo import Repository from src.models.users import User from src.auth.tokens import hash_token from sqlalchemy.ext.asyncio import AsyncSession +import asyncio +from src.redis_client import get_redis from src.database import get_db from src.services.session_cache import invalidate_session, get_cached_user_id, cache_session type DbSession = Annotated[AsyncSession, Depends(get_db)] ##Dependency Injection +_session_refresh_locks: dict[str, asyncio.Lock] = {} + async def get_current_user(request: Request, session: DbSession) -> User: repo = Repository(session) @@ -25,31 +29,60 @@ async def get_current_user(request: Request, session: DbSession) -> User: raw_token = auth_header[7:] token_hash = hash_token(raw_token) - cached_user_id = await get_cached_user_id(token_hash) - if cached_user_id is not None: - user = await repo.users.get(cached_user_id) + redis_is_alive = get_redis() is not None + + if redis_is_alive: + + cached_user_id = await get_cached_user_id(token_hash) + if cached_user_id is not None: + user = await repo.users.get_by_id(cached_user_id) if user: - return user + return user await invalidate_session(token_hash) - current_session = await repo.sessions.get_by_token_hash(token_hash) - if not current_session: - raise HTTPException( - status_code=status.HTTP_401_UNAUTHORIZED, - detail="invalid or expired token", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, - ) + lock = _session_refresh_locks.setdefault(token_hash, asyncio.Lock()) - user = await repo.users.get_by_id(current_session.user_id) - if not user: - raise HTTPException( - status_code=status.HTTP_401_UNAUTHORIZED, - detail="user not found", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, - ) + async with lock: + cached_user_id = await get_cached_user_id(token_hash) + if cached_user_id is not None: + user = await repo.users.get_by_id(cached_user_id) + if user: + return user - await cache_session(token_hash, user.id) - return user + + current_session = await repo.sessions.get_by_token_hash(token_hash) + if not current_session: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid or expired token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + + user = await repo.users.get_by_id(current_session.user_id) + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="user not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + + await cache_session(token_hash, user.id) + return user + + else: + current_session = await repo.sessions.get_by_token_hash(token_hash) + if not current_session: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="invalid or expired token", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + + user = await repo.users.get_by_id(current_session.user_id) + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="user not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + + return user type CurrentUser = Annotated[User, Depends(get_current_user)] \ No newline at end of file diff --git a/src/services/session_cache.py b/src/services/session_cache.py index fbbe05a6..e15e8ceb 100644 --- a/src/services/session_cache.py +++ b/src/services/session_cache.py @@ -1,23 +1,34 @@ import uuid +import random from src.redis_client import get_redis from redis.exceptions import RedisError from src.config import settings SESSION_PREFIX = "session:" +LOCK_PREFIX = "lock:session:" +CACHE_TTL_JITTER = 0.1 def _key(token_hash: str) -> str: return f"{SESSION_PREFIX}{token_hash}" -async def cache_session(token_hash: str, user_id: uuid.UUID) -> None: +def _lock_key(token_hash: str) -> str: + return f"{LOCK_PREFIX}{token_hash}" + + +async def cache_session(token_hash: str, user_id: uuid.UUID, ttl: int | None = None) -> None: r = get_redis() if not r: return + effective_ttl = ttl or settings.SESSION_TTL_SECONDS + jitter = int(effective_ttl * CACHE_TTL_JITTER * (2 * random.random() - 1)) + final_ttl = max(1, effective_ttl + jitter) + try: - await r.setex(_key(token_hash), settings.SESSION_TTL_SECONDS, str(user_id)) + await r.setex(_key(token_hash), final_ttl, str(user_id)) except RedisError: pass @@ -43,4 +54,25 @@ async def invalidate_session(token_hash: str) -> None: await r.delete(_key(token_hash)) except RedisError: pass - \ No newline at end of file + + +async def invalidate_all_user_sessions(user_id: uuid.UUID) -> int: + + r = get_redis() + if not r: + return 0 + + try: + pattern = f"{SESSION_PREFIX}*" + keys = [] + async for key in r.scan_iter(match=pattern, count=100): + value = r.get(key) + if value and uuid.UUID(value) == user_id: + keys.append(key) + + if keys: + await r.delete(*keys) + return len(keys) + + except RedisError: + return 0 \ No newline at end of file