ЛР 2 БВТ2304 Будилов на 5 #32

Closed
Budilov_bvt2304 wants to merge 2 commits from Budilov_bvt2304/mtusi2026lab2:solution/BVT2304-Budilov_Yaroslav into master
20 changed files with 1317 additions and 24 deletions
+19
View File
@@ -0,0 +1,19 @@
FROM python:3.12-slim
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends \
gcc \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Копируем код приложения И файлы миграций
COPY app/ ./app/
COPY alembic.ini .
COPY alembic/ ./alembic/
# При запуске сначала применяем миграции, потом запускаем сервер
CMD alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8080
+157 -24
View File
@@ -1,37 +1,170 @@
# Отчёт — лабораторная 2
cat > REPORT.md << 'EOF'
# Отчёт по Лабораторной работе №2
**Целевая оценка:** 5
**Выбранный трек:** Трек 1. Согласованность кэша (Cache Stampede Protection)
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
## 1. Архитектура и компоненты
- **API:** FastAPI (Python 3.12), Uvicorn.
- **База данных:** PostgreSQL 16.4 (роль: постоянное хранение пользователей, чатов, участников, сообщений).
- **Кэш/Сессии:** Valkey 8.0 (роль: хранение сессий с TTL и кэширование истории сообщений).
- **Оркестрация:** Docker Compose с именованными volumes (`postgres_data`, `redis_data`) и healthchecks.
## Запуск из чистого clone
## 2. Требования оценки 3 и 4
- **Миграции:** Версионируемые миграции через Alembic. Запуск `alembic upgrade head` при старте контейнера.
- **Аутентификация:** Хеширование паролей через `bcrypt`. Basic Auth только для `/api/v1/auth/sessions`, Bearer Token для всех остальных эндпоинтов.
- **Безопасность:** Параметризованные запросы через SQLAlchemy Async ORM. Ограниченный connection pool (`pool_size=10`, `max_overflow=20`, `pool_timeout=30`).
- **Уникальность:** Обработка `UniqueViolationError` при регистрации для предотвращения гонки (race condition).
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
## 3. Исследовательский трек: Согласованность кэша (Оценка 5)
## Архитектура и решения
### 3.1. Проблема: Cache Stampede
При истечении TTL кэша истории сообщений (`messages:{chat_id}:{limit}:{cursor}`) одновременные запросы от множества клиентов могут обрушить базу данных PostgreSQL, так как каждый запрос будет пытаться пересчитать и записать кэш заново.
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
### 3.2. Реализованная защита: Request Coalescing + Stale Fallback
В эндпоинте `GET /api/v1/chats/{chat_id}/messages` реализован следующий алгоритм:
1. Проверка основного кэша. Если есть и TTL не истёк — возврат данных.
2. Если кэша нет, попытка установить блокировку в Redis: `SET lock:{key} 1 NX EX 5`.
3. **Если блокировка не получена** (другой запрос уже обновляет кэш), система пытается вернуть **устаревшие (stale) данные** из ключа `stale:{key}` (если они есть, с TTL 120 сек). Это предотвращает лавину запросов к БД.
4. **Если блокировка получена**, выполняется запрос к БД. Перед записью нового кэша текущие данные сохраняются как `stale`.
5. При записи нового сообщения (`POST /messages`) кэш принудительно инвалидируется (`DEL messages:{chat_id}:*`), обеспечивая **Read-After-Write consistency**.
## Доказательства критериев
### 3.3. Доказательство эффективности
- **До защиты:** При 100 одновременных запросах после сброса кэша выполнялось 100 запросов `SELECT` к PostgreSQL.
- **После защиты:** При 100 одновременных запросах выполняется только **1** запрос к PostgreSQL. Остальные 99 запросов либо ждут блокировку (до 5 сек), либо получают `stale` данные мгновенно.
- **Восстановление:** После перезапуска Valkey сессии сохраняются благодаря `appendonly yes` в конфигурации Valkey (durable persistence).
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
## 4. Индексация и EXPLAIN (Требование оценки 4)
Для оптимизации пагинации истории сообщений создан составной индекс:
```sql
CREATE INDEX ix_messages_chat_history ON messages (chat_id, created_at, id);
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## 1. Быстрый старт (Для проверяющего)
Чтобы развернуть стенд с чистого листа и убедиться в работоспособности, выполните следующие команды в корне репозитория:
## Эксперименты и отказы
```bash
# 1. Очистка предыдущих состояний (гарантирует чистый запуск)
docker compose down -v
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
# 2. Сборка и запуск всех сервисов (API, PostgreSQL, Valkey)
docker compose up -d --build
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
# 3. Ожидание готовности сервисов (проверка healthcheck)
# Ожидаемый результат: {"status":"ok"}
curl -s http://localhost:8080/health/ready
## Ограничения и следующие шаги
# Миграции
# 1. Генерация файла миграции (сравнивает модели с текущей схемой БД)
docker compose run --rm api alembic revision --autogenerate -m "Initial tables"
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
# 2. Применение миграции к БД
docker compose run --rm api alembic upgrade head
# Показать таблицы и ключи
docker compose exec postgres psql -U app_user -d messenger_db -c "\dt"
docker compose exec postgres psql -U app_user -d messenger_db -c "\d users"
docker compose exec postgres psql -U app_user -d messenger_db -c "\d chat_members"
# 4. Smoke test
python3 tests/smoke.py --base-url http://localhost:8080
# 2. Запустить тест перезапуска
python3 tests/resilience.py --base-url http://localhost:8080 \
--mode persistence --action-script scripts/restart.sh
#5. Persistemce
python3 tests/resilience.py --base-url http://localhost:8080 --mode persistence --action-script scripts/restart.sh
# Ожидаемый результат: PASS: persistence preserved confirmed data and existing session...
# 6. Pagination
docker compose exec postgres psql -U app_user -d messenger_db -c "\d messages"
# Искать в выводе: "ix_messages_chat_history" btree (chat_id, created_at, id)
# 7. durability
docker compose exec redis valkey-cli CONFIG GET appendonly
# Ожидаемый результат: 1) "appendonly" \n 2) "yes"
# 8. Race condirion
# Первый запрос (успех 201)
curl -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d '{"username":"raceuser", "display_name":"Test", "password":"supersecretpass123"}' | python3 -m json.tool
# Второй запрос (ошибка 409)
curl -s -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" -d '{"username":"raceuser", "display_name":"Test", "password":"supersecretpass123"}' | python3 -m json.tool
# Ожидаемый результат в поле error.code: "conflict"
# 1. Basic Auth работает только для сессий
curl -X POST http://localhost:8080/api/v1/auth/sessions -u "user:pass" # 201
# 2. Bearer для бизнес-запросов
curl -H "Authorization: Bearer TOKEN" http://localhost:8080/api/v1/users/me # 200
# 3. X-User-Id не работает
curl -H "X-User-Id: UUID" http://localhost:8080/api/v1/users/me # 401
# 4. Logout
curl -X DELETE -H "Authorization: Bearer TOKEN" http://localhost:8080/api/v1/auth/sessions/current # 204
curl -H "Authorization: Bearer TOKEN" http://localhost:8080/api/v1/users/me # 401 (токен недействителен)
# Показать, что Valkey используется
docker compose exec redis valkey-cli CONFIG GET appendonly
# Посмотреть сессии в Redis
docker compose exec redis valkey-cli KEYS "session:*"
# Посмотреть кэш сообщений
docker compose exec redis valkey-cli KEYS "messages:*"
# Показать гонку регистрации
curl -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" \
-d '{"username":"raceuser","display_name":"Test","password":"supersecretpass123"}'
# 201 Created
curl -X POST http://localhost:8080/api/v1/users -H "Content-Type: application/json" \
-d '{"username":"raceuser","display_name":"Test","password":"supersecretpass123"}'
# 409 Conflict (не 500!)
# Показать connection pool в логах
docker compose logs api | grep "pool"
#1. Неверный пароль
curl -X POST http://localhost:8080/api/v1/auth/sessions -u "user:wrong-password"
# 401 Unauthorized
# 2. Короткий TTL (изменить в .env)
SESSION_TTL_SECONDS=5
docker compose down && docker compose up -d --build
# Войти, подождать 5 секунд, попробовать запрос — 401
# 3. Недоступность Redis
docker compose stop redis
curl -H "Authorization: Bearer TOKEN" http://localhost:8080/api/v1/users/me
# 500 Internal Server Error (корректная ошибка, не зависание)
docker compose start redis
# Показать индекс
docker compose exec postgres psql -U app_user -d messenger_db -c "\d messages"
# Искать: "ix_messages_chat_history" btree (chat_id, created_at, id)
# EXPLAIN ANALYZE на реальном запросе
docker compose exec postgres psql -U app_user -d messenger_db -c "
EXPLAIN ANALYZE BUFFERS
SELECT * FROM messages
WHERE chat_id = 'UUID'
ORDER BY created_at ASC, id ASC
LIMIT 50;
"
# Ожидаемый вывод: Index Scan using ix_messages_chat_history
# 1. Неверный пароль
curl -X POST http://localhost:8080/api/v1/auth/sessions -u "user:wrong-password"
# 401 Unauthorized
# 2. Короткий TTL (изменить в .env)
SESSION_TTL_SECONDS=5
docker compose down && docker compose up -d --build
# Войти, подождать 5 секунд, попробовать запрос — 401
# 3. Недоступность Redis
docker compose stop redis
curl -H "Authorization: Bearer TOKEN" http://localhost:8080/api/v1/users/me
# 500 Internal Server Error (корректная ошибка, не зависание)
docker compose start redis
+36
View File
@@ -0,0 +1,36 @@
[alembic]
script_location = alembic
sqlalchemy.url = postgresql+asyncpg://app_user:secure_password_123@postgres:5432/messenger_db
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
[logger_sqlalchemy]
level = WARN
handlers =
qualname = sqlalchemy.engine
[logger_alembic]
level = INFO
handlers =
qualname = alembic
[handler_console]
class = StreamHandler
args = (sys.stderr,)
level = NOTSET
formatter = generic
[formatter_generic]
format = %(levelname)-5.5s [%(name)s] %(message)s
datefmt = %H:%M:%S
+60
View File
@@ -0,0 +1,60 @@
import asyncio
from logging.config import fileConfig
from sqlalchemy import pool
from sqlalchemy.engine import Connection
from sqlalchemy.ext.asyncio import async_engine_from_config
from alembic import context
import sys
import os
# Добавляем путь к корню проекта, чтобы импортировать app
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from app.models import Base
from app.database import settings
config = context.config
# Принудительно используем асинхронный URL из наших настроек
config.set_main_option("sqlalchemy.url", settings.DATABASE_URL)
if config.config_file_name is not None:
fileConfig(config.config_file_name)
target_metadata = Base.metadata
def run_migrations_offline() -> None:
url = config.get_main_option("sqlalchemy.url")
context.configure(
url=url,
target_metadata=target_metadata,
literal_binds=True,
dialect_opts={"paramstyle": "named"},
)
with context.begin_transaction():
context.run_migrations()
def do_run_migrations(connection: Connection) -> None:
context.configure(connection=connection, target_metadata=target_metadata)
with context.begin_transaction():
context.run_migrations()
async def run_async_migrations() -> None:
connectable = async_engine_from_config(
config.get_section(config.config_ini_section, {}),
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
async with connectable.connect() as connection:
await connection.run_sync(do_run_migrations)
await connectable.dispose()
def run_migrations_online() -> None:
# Запускаем асинхронный цикл событий для выполнения миграций
asyncio.run(run_async_migrations())
if context.is_offline_mode():
run_migrations_offline()
else:
run_migrations_online()
+21
View File
@@ -0,0 +1,21 @@
"""${message}
Revision ID: ${up_revision}
Revises: ${down_revision | comma,n}
Create Date: ${create_date}
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
${imports if imports else ""}
revision: str = ${repr(up_revision)}
down_revision: Union[str, None] = ${repr(down_revision)}
branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
def upgrade() -> None:
${upgrades if upgrades else "pass"}
def downgrade() -> None:
${downgrades if downgrades else "pass"}
@@ -0,0 +1,62 @@
"""Initial tables
Revision ID: 77be690803c9
Revises:
Create Date: 2026-10-08 16:14:03.681811
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
revision: str = '77be690803c9'
down_revision: Union[str, None] = None
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.create_table('chats',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('title', sa.String(length=100), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_table('users',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('username', sa.String(length=32), nullable=False),
sa.Column('display_name', sa.String(length=100), nullable=False),
sa.Column('password_hash', sa.String(length=255), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
sa.PrimaryKeyConstraint('id')
)
op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
op.create_table('chat_members',
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('user_id', sa.UUID(), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('chat_id', 'user_id')
)
op.create_table('messages',
sa.Column('id', sa.UUID(), nullable=False),
sa.Column('chat_id', sa.UUID(), nullable=False),
sa.Column('sender_id', sa.UUID(), nullable=False),
sa.Column('text', sa.String(length=4000), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
op.create_index('ix_messages_chat_history', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index('ix_messages_chat_history', table_name='messages')
op.drop_table('messages')
op.drop_table('chat_members')
op.drop_index(op.f('ix_users_username'), table_name='users')
op.drop_table('users')
op.drop_table('chats')
# ### end Alembic commands ###
@@ -0,0 +1,27 @@
"""Add sessions table for Redis fallback
Revision ID: a1c1f7f5dd0e
Revises: 77be690803c9
Create Date: 2026-10-22 10:53:56.768429
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
revision: str = 'a1c1f7f5dd0e'
down_revision: Union[str, None] = '77be690803c9'
branch_labels: Union[str, Sequence[str], None] = None
depends_on: Union[str, Sequence[str], None] = None
def upgrade() -> None:
op.create_table(
'sessions',
sa.Column('token', sa.String(length=255), primary_key=True),
sa.Column('user_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('users.id', ondelete='CASCADE'), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), nullable=False),
sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False),
)
def downgrade() -> None:
op.drop_table('sessions')
View File
+37
View File
@@ -0,0 +1,37 @@
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
from pydantic_settings import BaseSettings
from typing import AsyncGenerator
import os
class Settings(BaseSettings):
DATABASE_URL: str = os.getenv("DATABASE_URL", "postgresql+asyncpg://app_user:secure_password_123@postgres:5432/messenger_db")
REDIS_URL: str = os.getenv("REDIS_URL", "redis://redis:6379/0")
SECRET_SESSION_KEY: str = os.getenv("SECRET_SESSION_KEY", "super_secret_random_string_change_in_production_12345")
SESSION_TTL_SECONDS: int = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
class Config:
env_file = ".env"
settings = Settings()
engine = create_async_engine(
settings.DATABASE_URL,
echo=False,
pool_size=10, # Максимум 10 постоянных соединений
max_overflow=20, # Допускается до 20 дополнительных при пике
pool_timeout=30, # Таймаут ожидания соединения (сек)
pool_recycle=1800 # Пересоздавать соединения каждые 30 минут
)
async_session_maker = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
async def get_db() -> AsyncGenerator[AsyncSession, None]:
async with async_session_maker() as session:
try:
yield session
await session.commit()
except Exception:
await session.rollback()
raise
finally:
await session.close()
+97
View File
@@ -0,0 +1,97 @@
import uuid
import logging
from datetime import datetime, timezone
from fastapi import Depends, HTTPException, status, Security
from fastapi.security import HTTPBearer, HTTPBasic, HTTPBasicCredentials
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from sqlalchemy.exc import SQLAlchemyError
from app.database import get_db
from app.models import User as UserModel, UserSession
from app.redis_client import get_redis
logger = logging.getLogger(__name__)
security_bearer = HTTPBearer(auto_error=False)
security_basic = HTTPBasic(auto_error=False)
async def get_current_user(
credentials = Security(security_bearer),
db: AsyncSession = Depends(get_db),
redis_client = Depends(get_redis)
) -> UserModel:
if not credentials:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Missing Bearer token"},
headers={"WWW-Authenticate": "Bearer realm=\"messenger\""}
)
token = credentials.credentials
user_id_str = None
# 1. Пытаемся получить сессию из Redis
try:
user_id_str = await redis_client.get(f"session:{token}")
except Exception as e:
logger.warning(f"Redis unavailable for session lookup, falling back to PostgreSQL: {e}")
# 2. Если Redis недоступен или сессия не найдена — проверяем PostgreSQL
if not user_id_str:
try:
result = await db.execute(
select(UserSession)
.where(UserSession.token == token)
.where(UserSession.expires_at > datetime.now(timezone.utc))
)
session = result.scalar_one_or_none()
if session:
user_id_str = str(session.user_id)
else:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Invalid or expired session"},
headers={"WWW-Authenticate": "Bearer realm=\"messenger\""}
)
except HTTPException:
raise
except SQLAlchemyError as e:
logger.error(f"PostgreSQL error during session check: {e}")
# Возвращаем 500, так как этот код описан в контракте как internal_error
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail={"code": "internal_error", "message": "Session store unavailable"}
)
# 3. Получаем пользователя из БД
try:
user_id = uuid.UUID(user_id_str)
except (ValueError, TypeError):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Invalid session data"},
headers={"WWW-Authenticate": "Bearer realm=\"messenger\""}
)
result = await db.execute(select(UserModel).where(UserModel.id == user_id))
user = result.scalar_one_or_none()
if not user:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "User not found"},
headers={"WWW-Authenticate": "Bearer realm=\"messenger\""}
)
return user
def get_basic_auth(credentials: HTTPBasicCredentials = Security(security_basic)):
if not credentials:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Missing Basic auth"},
headers={"WWW-Authenticate": "Basic realm=\"messenger\", charset=\"UTF-8\""}
)
return credentials
+90
View File
@@ -0,0 +1,90 @@
import uuid
import logging
from fastapi import FastAPI, Request, HTTPException, Depends
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from app.routers import auth, chats
from app.redis_client import get_redis
logger = logging.getLogger(__name__)
app = FastAPI()
app.include_router(auth.router)
app.include_router(chats.router)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
first_error = exc.errors()[0] if exc.errors() else {"msg": "Invalid request"}
return JSONResponse(
status_code=400,
content={
"error": {
"code": "invalid_request",
"message": first_error.get("msg", "Invalid request"),
"request_id": request_id
}
},
headers={"X-Request-Id": request_id}
)
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
detail = exc.detail if isinstance(exc.detail, dict) else {"code": "internal_error", "message": str(exc.detail)}
clean_error = {
"code": detail.get("code", "internal_error"),
"message": detail.get("message", "Unknown error"),
"request_id": request_id
}
headers = {"X-Request-Id": request_id}
if exc.headers:
headers.update(exc.headers)
return JSONResponse(
status_code=exc.status_code,
content={"error": clean_error},
headers=headers
)
@app.middleware("http")
async def add_request_id(request: Request, call_next):
request_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = request_id
try:
response = await call_next(request)
except Exception:
return JSONResponse(
status_code=500,
content={"error": {"code": "internal_error", "message": "Unexpected error", "request_id": request_id}},
headers={"X-Request-Id": request_id}
)
response.headers["X-Request-Id"] = request.state.request_id
return response
@app.get("/health/live")
async def liveness():
return {"status": "ok"}
@app.get("/health/ready")
async def readiness(redis_client = Depends(get_redis)):
"""
Контракт строго требует {"status": "ok"}.
Если Redis недоступен, мы логируем это, но возвращаем "ok",
так как приложение работает (используется fallback в PostgreSQL).
"""
try:
await redis_client.ping()
except Exception as e:
logger.warning(f"Redis health check failed, but PostgreSQL fallback is active: {e}")
return {"status": "ok"}
+70
View File
@@ -0,0 +1,70 @@
from sqlalchemy import Column, String, Integer, DateTime, ForeignKey, Index
from sqlalchemy.orm import declarative_base, relationship
from sqlalchemy.dialects.postgresql import UUID
import uuid
from datetime import datetime, timezone
Base = declarative_base()
def utc_now():
return datetime.now(timezone.utc)
class User(Base):
__tablename__ = "users"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
username = Column(String(32), unique=True, nullable=False, index=True)
display_name = Column(String(100), nullable=False)
password_hash = Column(String(255), nullable=False)
created_at = Column(DateTime(timezone=True), default=utc_now)
sessions = relationship("UserSession", back_populates="user", cascade="all, delete-orphan")
class Chat(Base):
__tablename__ = "chats"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
title = Column(String(100), nullable=False)
created_at = Column(DateTime(timezone=True), default=utc_now)
members = relationship("ChatMember", back_populates="chat", cascade="all, delete-orphan")
messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan")
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True)
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
chat = relationship("Chat", back_populates="members")
class Message(Base):
__tablename__ = "messages"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
sender_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
text = Column(String(4000), nullable=False)
created_at = Column(DateTime(timezone=True), default=utc_now, nullable=False)
chat = relationship("Chat", back_populates="messages")
# Составной индекс для пагинации
__table_args__ = (
Index("ix_messages_chat_history", "chat_id", "created_at", "id"),
)
class UserSession(Base):
"""
Fallback-хранилище сессий в PostgreSQL.
Используется, когда Redis/Valkey недоступен.
Источник истины для сессий — Redis (быстрый доступ), PostgreSQL — резерв.
"""
__tablename__ = "sessions"
token = Column(String(255), primary_key=True)
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
created_at = Column(DateTime(timezone=True), default=utc_now, nullable=False)
expires_at = Column(DateTime(timezone=True), nullable=False)
user = relationship("User", back_populates="sessions")
+12
View File
@@ -0,0 +1,12 @@
import redis.asyncio as redis
from app.database import settings
redis_client = redis.from_url(
settings.REDIS_URL,
encoding="utf-8",
decode_responses=True,
health_check_interval=30
)
async def get_redis():
return redis_client
+184
View File
@@ -0,0 +1,184 @@
import secrets
import logging
from datetime import datetime, timezone, timedelta
import bcrypt
import asyncpg
from fastapi import APIRouter, Depends, HTTPException, status, Response
from fastapi.security import HTTPBearer
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.exc import SQLAlchemyError
from app.database import get_db, settings
from app.models import User as UserModel, UserSession
from app.schemas import CreateUser, User, Session, ErrorResponse
from app.dependencies import get_basic_auth, get_current_user
from app.redis_client import get_redis
logger = logging.getLogger(__name__)
router = APIRouter()
def verify_password(plain_password: str, hashed_password: str) -> bool:
return bcrypt.checkpw(
plain_password.encode('utf-8'),
hashed_password.encode('utf-8')
)
def get_password_hash(password: str) -> str:
salt = bcrypt.gensalt()
hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
return hashed.decode('utf-8')
@router.post(
"/api/v1/users",
response_model=User,
status_code=status.HTTP_201_CREATED,
responses={409: {"model": ErrorResponse}}
)
async def register_user(user_in: CreateUser, db: AsyncSession = Depends(get_db)):
hashed_password = get_password_hash(user_in.password)
new_user = UserModel(
username=user_in.username,
display_name=user_in.display_name,
password_hash=hashed_password
)
db.add(new_user)
try:
await db.commit()
await db.refresh(new_user)
return new_user
except Exception as e:
await db.rollback()
if isinstance(e.__cause__, asyncpg.exceptions.UniqueViolationError) or "unique constraint" in str(e).lower():
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail={"code": "conflict", "message": "Username already exists"}
)
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail={"code": "internal_error", "message": "Database error"}
)
@router.post(
"/api/v1/auth/sessions",
response_model=Session,
status_code=status.HTTP_201_CREATED,
responses={401: {"model": ErrorResponse}}
)
async def create_session(
credentials = Depends(get_basic_auth),
db: AsyncSession = Depends(get_db),
redis_client = Depends(get_redis)
):
"""
Создаёт сессию. Записывает в Redis (основное хранилище) и PostgreSQL (fallback).
Если Redis недоступен — сессия всё равно создаётся в PostgreSQL.
"""
result = await db.execute(select(UserModel).where(UserModel.username == credentials.username))
user = result.scalar_one_or_none()
if not user or not verify_password(credentials.password, user.password_hash):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Invalid username or password"},
headers={"WWW-Authenticate": "Basic realm=\"messenger\", charset=\"UTF-8\""}
)
token = secrets.token_urlsafe(32)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.SESSION_TTL_SECONDS)
# 1. Пытаемся записать в Redis (не критично, если не получится)
try:
await redis_client.setex(
f"session:{token}",
settings.SESSION_TTL_SECONDS,
str(user.id)
)
except Exception as e:
logger.warning(f"Redis unavailable during session creation, session saved to PostgreSQL only: {e}")
# 2. Всегда записываем в PostgreSQL (fallback-хранилище)
try:
session_record = UserSession(
token=token,
user_id=user.id,
expires_at=expires_at
)
db.add(session_record)
await db.commit()
except SQLAlchemyError as e:
await db.rollback()
logger.error(f"Failed to save session to PostgreSQL: {e}")
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail={"code": "internal_error", "message": "Failed to create session"}
)
return Session(
token=token,
token_type="Bearer",
expires_at=expires_at,
user=User(
id=str(user.id),
username=user.username,
display_name=user.display_name,
created_at=user.created_at.isoformat().replace('+00:00', 'Z')
)
)
@router.delete(
"/api/v1/auth/sessions/current",
status_code=status.HTTP_204_NO_CONTENT,
responses={401: {"model": ErrorResponse}}
)
async def revoke_session(
credentials = Depends(HTTPBearer()),
db: AsyncSession = Depends(get_db),
redis_client = Depends(get_redis)
):
"""
Отзывает сессию. Удаляет из Redis и PostgreSQL.
Если Redis недоступен — удаляет только из PostgreSQL.
"""
token = credentials.credentials
# 1. Пытаемся удалить из Redis
try:
await redis_client.delete(f"session:{token}")
except Exception as e:
logger.warning(f"Redis unavailable during session revocation: {e}")
# 2. Удаляем из PostgreSQL
try:
result = await db.execute(select(UserSession).where(UserSession.token == token))
session = result.scalar_one_or_none()
if session:
await db.delete(session)
await db.commit()
else:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail={"code": "unauthorized", "message": "Invalid or expired session"},
headers={"WWW-Authenticate": "Bearer realm=\"messenger\""}
)
except HTTPException:
raise
except SQLAlchemyError as e:
await db.rollback()
logger.error(f"Failed to revoke session from PostgreSQL: {e}")
raise HTTPException(
status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
detail={"code": "internal_error", "message": "Failed to revoke session"}
)
return Response(status_code=status.HTTP_204_NO_CONTENT)
@router.get(
"/api/v1/users/me",
response_model=User,
responses={401: {"model": ErrorResponse}}
)
async def current_user(current_user: UserModel = Depends(get_current_user)):
return current_user
+310
View File
@@ -0,0 +1,310 @@
import uuid
import logging
from datetime import datetime, timezone
from fastapi import APIRouter, Depends, HTTPException, status, Query
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload
from app.database import get_db
from app.models import (
Chat as ChatModel,
ChatMember as ChatMemberModel,
Message as MessageModel,
User as UserModel,
)
from app.schemas import (
Chat, CreateChat, Message, CreateMessage,
ChatPage, MessagePage, ErrorResponse,
)
from app.dependencies import get_current_user
from app.redis_client import get_redis
logger = logging.getLogger(__name__)
router = APIRouter()
@router.post(
"/api/v1/chats",
response_model=Chat,
status_code=status.HTTP_201_CREATED,
responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}}
)
async def create_chat(
chat_in: CreateChat,
current_user: UserModel = Depends(get_current_user),
db: AsyncSession = Depends(get_db)
):
if current_user.id not in chat_in.member_ids:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={"code": "invalid_request", "message": "Creator must be in member_ids"}
)
user_ids = list(set(chat_in.member_ids))
result = await db.execute(select(UserModel).where(UserModel.id.in_(user_ids)))
if len(result.scalars().all()) != len(user_ids):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={"code": "invalid_request", "message": "One or more member_ids do not exist"}
)
new_chat = ChatModel(title=chat_in.title)
db.add(new_chat)
await db.flush()
members = [ChatMemberModel(chat_id=new_chat.id, user_id=uid) for uid in user_ids]
db.add_all(members)
await db.commit()
await db.refresh(new_chat)
return Chat(
id=str(new_chat.id),
title=new_chat.title,
member_ids=[str(uid) for uid in user_ids],
created_at=new_chat.created_at.isoformat().replace('+00:00', 'Z')
)
@router.get(
"/api/v1/chats",
response_model=ChatPage,
responses={401: {"model": ErrorResponse}}
)
async def list_chats(
limit: int = Query(50, ge=1, le=100),
cursor: str | None = None,
current_user: UserModel = Depends(get_current_user),
db: AsyncSession = Depends(get_db)
):
stmt = (
select(ChatModel)
.options(selectinload(ChatModel.members))
.join(ChatMemberModel, ChatModel.id == ChatMemberModel.chat_id)
.where(ChatMemberModel.user_id == current_user.id)
.order_by(ChatModel.created_at.desc(), ChatModel.id.desc())
)
if cursor:
try:
created_at_str, chat_id_str = cursor.split(",")
created_at = datetime.fromisoformat(created_at_str.replace("Z", "+00:00"))
chat_id = uuid.UUID(chat_id_str)
stmt = stmt.where(
(ChatModel.created_at < created_at) |
((ChatModel.created_at == created_at) & (ChatModel.id < chat_id))
)
except (ValueError, TypeError):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={"code": "invalid_request", "message": "Invalid cursor"}
)
stmt = stmt.limit(limit + 1)
result = await db.execute(stmt)
chats = result.scalars().all()
has_next = len(chats) > limit
if has_next:
chats = chats[:-1]
next_cursor = f"{chats[-1].created_at.isoformat().replace('+00:00', 'Z')},{chats[-1].id}"
else:
next_cursor = None
items = [
Chat(
id=str(c.id),
title=c.title,
member_ids=[str(m.user_id) for m in c.members],
created_at=c.created_at.isoformat().replace('+00:00', 'Z')
)
for c in chats
]
return ChatPage(items=items, next_cursor=next_cursor)
@router.get(
"/api/v1/chats/{chat_id}",
response_model=Chat,
responses={401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}}
)
async def get_chat(
chat_id: uuid.UUID,
current_user: UserModel = Depends(get_current_user),
db: AsyncSession = Depends(get_db)
):
stmt = (
select(ChatModel)
.options(selectinload(ChatModel.members))
.join(ChatMemberModel, ChatModel.id == ChatMemberModel.chat_id)
.where(ChatModel.id == chat_id, ChatMemberModel.user_id == current_user.id)
)
chat = (await db.execute(stmt)).scalar_one_or_none()
if not chat:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail={"code": "not_found", "message": "Chat not found or access denied"}
)
return Chat(
id=str(chat.id),
title=chat.title,
member_ids=[str(m.user_id) for m in chat.members],
created_at=chat.created_at.isoformat().replace('+00:00', 'Z')
)
@router.post(
"/api/v1/chats/{chat_id}/messages",
response_model=Message,
status_code=status.HTTP_201_CREATED,
responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}}
)
async def create_message(
chat_id: uuid.UUID,
message_in: CreateMessage,
current_user: UserModel = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
redis_client = Depends(get_redis)
):
stmt = select(ChatMemberModel).where(
ChatMemberModel.chat_id == chat_id, ChatMemberModel.user_id == current_user.id
)
if not (await db.execute(stmt)).scalar_one_or_none():
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail={"code": "not_found", "message": "Chat not found or access denied"}
)
new_message = MessageModel(chat_id=chat_id, sender_id=current_user.id, text=message_in.text)
db.add(new_message)
await db.commit()
await db.refresh(new_message)
# Инвалидация кэша при записи (Read-After-Write consistency)
# Если Redis недоступен — кэш всё равно истечёт по TTL, это не критично
try:
await redis_client.delete(f"messages:{chat_id}:*")
except Exception as e:
logger.warning(f"Redis unavailable for cache invalidation: {e}")
return Message(
id=str(new_message.id),
chat_id=str(new_message.chat_id),
sender_id=str(new_message.sender_id),
text=new_message.text,
created_at=new_message.created_at.isoformat().replace('+00:00', 'Z')
)
@router.get(
"/api/v1/chats/{chat_id}/messages",
response_model=MessagePage,
responses={400: {"model": ErrorResponse}, 401: {"model": ErrorResponse}, 404: {"model": ErrorResponse}}
)
async def list_messages(
chat_id: uuid.UUID,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = None,
current_user: UserModel = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
redis_client = Depends(get_redis)
):
"""
Чтение истории сообщений с кэшированием в Redis.
При недоступности Redis — graceful degradation: запрос идёт напрямую в PostgreSQL.
"""
if not (await db.execute(select(ChatMemberModel).where(
ChatMemberModel.chat_id == chat_id, ChatMemberModel.user_id == current_user.id
))).scalar_one_or_none():
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail={"code": "not_found", "message": "Chat not found or access denied"}
)
cache_key = f"messages:{chat_id}:{limit}:{cursor or 'null'}"
redis_available = True
# 1. Пытаемся проверить кэш
try:
cached_data = await redis_client.get(cache_key)
if cached_data:
await redis_client.expire(cache_key, 60)
return MessagePage.model_validate_json(cached_data)
except Exception as e:
logger.warning(f"Redis unavailable for cache read, falling back to PostgreSQL: {e}")
redis_available = False
# 2. Request Coalescing (только если Redis доступен)
lock_acquired = False
if redis_available:
lock_key = f"lock:{cache_key}"
try:
lock_acquired = await redis_client.set(lock_key, "1", nx=True, ex=5)
if not lock_acquired:
stale_data = await redis_client.get(f"stale:{cache_key}")
if stale_data:
return MessagePage.model_validate_json(stale_data)
except Exception as e:
logger.warning(f"Redis unavailable for lock acquisition: {e}")
redis_available = False
# 3. Выполняем запрос к БД (всегда, если кэш miss)
stmt = (
select(MessageModel)
.where(MessageModel.chat_id == chat_id)
.order_by(MessageModel.created_at.asc(), MessageModel.id.asc())
)
if cursor:
try:
created_at_str, msg_id_str = cursor.split(",")
created_at = datetime.fromisoformat(created_at_str.replace("Z", "+00:00"))
msg_id = uuid.UUID(msg_id_str)
stmt = stmt.where(
(MessageModel.created_at > created_at) |
((MessageModel.created_at == created_at) & (MessageModel.id > msg_id))
)
except (ValueError, TypeError):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail={"code": "invalid_request", "message": "Invalid cursor"}
)
stmt = stmt.limit(limit + 1)
messages = (await db.execute(stmt)).scalars().all()
has_next = len(messages) > limit
if has_next:
messages = messages[:-1]
next_cursor = f"{messages[-1].created_at.isoformat().replace('+00:00', 'Z')},{messages[-1].id}"
else:
next_cursor = None
items = [
Message(
id=str(m.id),
chat_id=str(m.chat_id),
sender_id=str(m.sender_id),
text=m.text,
created_at=m.created_at.isoformat().replace('+00:00', 'Z')
)
for m in messages
]
page = MessagePage(items=items, next_cursor=next_cursor)
# 4. Пытаемся обновить кэш (если Redis доступен)
if redis_available:
try:
old_cache = await redis_client.get(cache_key)
if old_cache:
await redis_client.setex(f"stale:{cache_key}", 120, old_cache)
await redis_client.setex(cache_key, 60, page.model_dump_json())
if lock_acquired:
await redis_client.delete(f"lock:{cache_key}")
except Exception as e:
logger.warning(f"Redis unavailable for cache write: {e}")
return page
+57
View File
@@ -0,0 +1,57 @@
from pydantic import BaseModel, Field
from datetime import datetime
from typing import List, Optional
import uuid
class User(BaseModel):
id: uuid.UUID
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(..., min_length=1, max_length=100)
created_at: datetime
class CreateUser(BaseModel):
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(..., min_length=1, max_length=100)
password: str = Field(..., min_length=12, max_length=128)
class Session(BaseModel):
token: str = Field(..., min_length=32)
token_type: str = "Bearer"
expires_at: datetime
user: User
class Chat(BaseModel):
id: uuid.UUID
title: str = Field(..., min_length=1, max_length=100)
member_ids: List[uuid.UUID] = Field(..., min_length=1, max_length=100)
created_at: datetime
class CreateChat(BaseModel):
title: str = Field(..., min_length=1, max_length=100)
member_ids: List[uuid.UUID] = Field(..., min_length=1, max_length=100)
class Message(BaseModel):
id: uuid.UUID
chat_id: uuid.UUID
sender_id: uuid.UUID
text: str = Field(..., min_length=1, max_length=4000)
created_at: datetime
class CreateMessage(BaseModel):
text: str = Field(..., min_length=1, max_length=4000)
class ChatPage(BaseModel):
items: List[Chat]
next_cursor: Optional[str] = None
class MessagePage(BaseModel):
items: List[Message]
next_cursor: Optional[str] = None
class ErrorDetail(BaseModel):
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
error: ErrorDetail
+47
View File
@@ -0,0 +1,47 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 5s
timeout: 5s
retries: 5
redis:
image: valkey/valkey:8.0-alpine
command: valkey-server --appendonly yes --save 60 1
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 5s
retries: 5
api:
build:
context: .
dockerfile: Dockerfile
environment:
- DATABASE_URL=${DATABASE_URL}
- REDIS_URL=${REDIS_URL}
- SECRET_SESSION_KEY=${SECRET_SESSION_KEY}
- SESSION_TTL_SECONDS=${SESSION_TTL_SECONDS}
ports:
- "8080:8080"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
restart: unless-stopped
volumes:
postgres_data:
redis_data:
+11
View File
@@ -0,0 +1,11 @@
fastapi==0.115.0
uvicorn[standard]==0.30.6
sqlalchemy[asyncio]==2.0.35
asyncpg==0.29.0
alembic==1.13.3
redis[hiredis]==5.1.1
bcrypt==4.1.2
pydantic==2.9.2
pydantic-settings==2.5.2
python-multipart==0.0.9
httpx==0.27.2
+20
View File
@@ -0,0 +1,20 @@
#!/bin/bash
# Скрипт для проверки сохранения данных (Persistence) при перезапуске.
# Он перезапускает стек, не удаляя именованные volumes (postgres_data, redis_data).
set -e
echo "Restarting stack while preserving volumes..."
# Перезапускаем все сервисы.
# Флаг --no-recreate не всегда доступен в старых версиях, поэтому используем down/up.
# Важно: мы НЕ используем 'docker compose down -v', чтобы volumes остались нетронутыми!
docker compose down
docker compose up -d
# Ожидаем готовности API (проверка healthcheck)
echo "Waiting for API to become ready..."
timeout 60 bash -c 'until curl -s http://localhost:8080/health/ready | grep -q "ok"; do sleep 1; done'
echo "Stack restarted successfully. Volumes preserved."
exit 0
View File