feat-(tests for redis, report updated)
Skeleton contracts / contracts (pull_request) Canceled after 0s

This commit is contained in:
2026-11-14 09:05:30 +03:00
parent 7dcef08d8b
commit 549aa621b3
8 changed files with 288 additions and 27 deletions
+4 -3
View File
@@ -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
- [+] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [+] Контракт и публичные тесты не ослаблены.
+23
View File
@@ -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.
+5
View File
@@ -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:
BIN
View File
Binary file not shown.
+168
View File
@@ -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())
-1
View File
@@ -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)
+53 -20
View File
@@ -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)]
+35 -3
View File
@@ -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
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