ЛР 2 - БПИ2304 - Алексеева Мария - на 4 #11

Open
Maria wants to merge 1 commits from Maria/mtusi2026lab2:solution/BPI2304-Alekseeva into master
39 changed files with 1810 additions and 44 deletions
+20 -28
View File
@@ -1,32 +1,24 @@
# Local/private state
# Секреты
.env
.env.*
!.env.example
secrets/
certs/private/
*.key
*.p12
*.pfx
*.jks
*.pem
*.tfstate*
volumes/
data/
backups/
# Runtime/build artifacts
.venv/
# Python
__pycache__/
*.py[cod]
node_modules/
dist/
build/
target/
bin/
obj/
coverage/
*.pyc
*.pyo
# Виртуальное окружение
.venv/
venv/
# Тесты
.pytest_cache/
# Логи и результаты
*.log
student-tests/evidence/
# Прочее
.DS_Store
.idea/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
# Local editor
.cursor/
+28
View File
@@ -0,0 +1,28 @@
FROM python:3.11-slim
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1
WORKDIR /app
RUN apt-get update \
&& apt-get install -y --no-install-recommends build-essential libpq-dev curl \
&& rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY alembic.ini .
COPY alembic ./alembic
COPY src ./src
RUN useradd -m -u 1000 app && chown -R app:app /app
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=15s --retries=5 \
CMD curl -fsS http://127.0.0.1:8080/health/live || exit 1
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
+75 -16
View File
@@ -1,37 +1,96 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Алексеева Мария, БПИ2304
- Целевая оценка: 4
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: официальная документация FastAPI, SQLAlchemy 2.0, Alembic, PostgreSQL, Redis. Код написан с использованием DeepSeek.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требуется Docker 29+ и Docker Compose v2. Python 3.9+ нужен только для запуска публичных тестов с хоста.
```sh
cp .env.example .env
# в .env задать POSTGRES_PASSWORD, остальное можно оставить по умолчанию
docker compose --env-file .env up -d --build
docker compose ps # все три сервиса должны быть healthy
docker compose exec api alembic upgrade head
curl.exe http://localhost:8080/health/live # {"status":"ok"}
python tests/smoke.py --base-url http://localhost:8080
python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
Остановка: docker compose down (volumes сохраняются). Полный сброс учебных данных: docker compose down -v.
.env содержит только локальные учебные значения и находится в .gitignore
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → FastAPI (uvicorn) → PostgreSQL (источник истины) → Redis (сессии, TTL)
PostgreSQL — источник истины. Все пользователи, чаты, участники и сообщения хранятся здесь. Создание чата и его участников выполняется в одной транзакции.
Redis — сессии с TTL (SESSION_TTL_SECONDS, по умолчанию 3600). Persistence включён (--appendonly yes), сессии переживают рестарт.
Пароли хешируются Argon2id (passlib).
Изменено: X-User-Id заменён на Bearer-сессии с opaque-токенами, состояние перенесено в PostgreSQL, добавлены миграции Alembic, пароли хешируются KDF.
Переменные .env.example: SESSION_TTL_SECONDS используется для TTL сессий; POSTGRES_* и REDIS_* формируют соответствующие URL подключения; APP_HOST и APP_PORT зарезервированы (uvicorn запускается с фиксированными значениями).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|Критерий| Команда |Результат|
|Публичный smoke| python tests/smoke.py --base-url http://localhost:8080| PASS: lab2 public API scenario
|Таблицы и индексы в PostgreSQL|docker compose exec postgres psql -U messenger -d messenger -c "\dt"| 4 таблицы + alembic_version, UNIQUE ix_users_username, индекс idx_messages_chat_created_id
|Basic только на /auth/sessions|curl.exe -i http://localhost:8080/api/v1/users/me -H "Authorization: Basic ..."| 401, WWW-Authenticate: Bearer
|Bearer на защищённых endpoint| curl.exe -i http://localhost:8080/api/v1/users/me| 401, WWW-Authenticate: Bearer realm="messenger"
|Хеширование пароля| SELECT LEFT(password_hash, 30) FROM users| $argon2id$v=19$m=65536,t=2,p=2
|Persistence| python tests/resilience.py --mode persistence ... |PASS: persistence preserved confirmed data and existing session
|Гонка регистрации| python student-tests/test_race_registration.py| [201, 409] — ровно одна победа
|Expiry сессии| python student-tests/test_session_expiry.py при SESSION_TTL_SECONDS=2| PASS: session expiry works
|Недоступность Redis| python student-tests/test_redis_down.py |аноним — 401, Bearer — 503
План запроса истории| EXPLAIN (ANALYZE, BUFFERS) на 10 000 сообщений |Index Scan, ×36 по времени к Seq Scan |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Гипотеза: составной индекс (chat_id, created_at, id) устранит Seq Scan и Sort при чтении истории чата.
Условия: учебный ноутбук (Windows 11, Docker Desktop, 4 vCPU, 8 GiB RAM). В messages 10 000 записей в одном чате.
С индексом (idx_messages_chat_created_id):
Index Scan, Buffers: shared hit=4, Execution Time: 0.046 ms.
Без индекса (enable_indexscan=off, enable_bitmapscan=off):
Seq Scan + top-N heapsort, Buffers: shared hit=130, Execution Time: 1.652 ms.
Итог: ускорение ×36 по времени и ×32 по I/O.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Рестарт api, postgres, redis (volumes сохранены)| данные и сессия живы |PASS в resilience.py| ~10 с, потерь нет
|Остановка Redis| аноним 401, Bearer 503 |так и есть |~2 с после docker compose start redis
|Гонка регистрации |одна 201, одна 409 |так и есть во всех запусках |—
|Expiry при TTL=2 |токен истекает |401 после ожидания |—
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Выдерживается: рестарт API/PostgreSQL/Redis, истечение сессий, недоступность Redis, гонка регистрации.
Не выдерживается: потеря единственного Docker-host, падение PostgreSQL (API вернёт 5xx), сетевые разделения.
Учебные упрощения: HTTP без TLS (нужен в lab7), параметры Argon2id ниже продакшн-рекомендаций, один экземпляр API без балансировщика (lab3), connection pool 10.
+39
View File
@@ -0,0 +1,39 @@
[alembic]
script_location = alembic
prepend_sys_path = .
version_path_separator = os
sqlalchemy.url =
[loggers]
keys = root,sqlalchemy,alembic
[handlers]
keys = console
[formatters]
keys = generic
[logger_root]
level = WARN
handlers = console
qualname =
[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
from src.core.config import settings
from src.db.base import Base
from src.models import models # noqa: F401 — регистрируем модели в Base.metadata
config = context.config
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"},
compare_type=True,
)
with context.begin_transaction():
context.run_migrations()
def do_run_migrations(connection: Connection) -> None:
context.configure(
connection=connection,
target_metadata=target_metadata,
compare_type=True,
)
with context.begin_transaction():
context.run_migrations()
async def run_migrations_online() -> 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()
if context.is_offline_mode():
run_migrations_offline()
else:
asyncio.run(run_migrations_online())
+25
View File
@@ -0,0 +1,25 @@
"""${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,67 @@
"""init tables
Revision ID: 71c939ad8254
Revises:
Create Date: 2026-10-02 12:04:30.713963
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
revision: str = '71c939ad8254'
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), server_default=sa.text('now()'), nullable=False),
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.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name='ck_users_username_format'),
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.Text(), nullable=False),
sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('now()'), nullable=False),
sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], ondelete='CASCADE'),
sa.ForeignKeyConstraint(['sender_id'], ['users.id'], ondelete='CASCADE'),
sa.PrimaryKeyConstraint('id')
)
op.create_index('idx_messages_chat_created_id', 'messages', ['chat_id', 'created_at', 'id'], unique=False)
# ### end Alembic commands ###
def downgrade() -> None:
# ### commands auto generated by Alembic - please adjust! ###
op.drop_index('idx_messages_chat_created_id', 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 ###
+54
View File
@@ -0,0 +1,54 @@
services:
postgres:
image: postgres:16.4-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
interval: 5s
timeout: 3s
retries: 10
networks: [backend]
redis:
image: redis:7.4-alpine
command: ["redis-server", "--appendonly", "yes"]
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
networks: [backend]
api:
build: .
env_file: .env
environment:
POSTGRES_HOST: postgres
REDIS_HOST: redis
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
ports:
- "8080:8080"
volumes:
- ./src:/app/src
- ./alembic:/app/alembic
- ./alembic.ini:/app/alembic.ini
networks: [backend]
volumes:
pgdata:
redisdata:
networks:
backend:
driver: bridge
+10
View File
@@ -0,0 +1,10 @@
fastapi==0.115.0
uvicorn[standard]==0.32.0
sqlalchemy[asyncio]==2.0.36
asyncpg==0.30.0
alembic==1.13.3
pydantic==2.9.2
pydantic-settings==2.5.2
passlib[argon2]==1.7.4
argon2-cffi==23.1.0
redis==5.1.1
+24
View File
@@ -0,0 +1,24 @@
@echo off
setlocal
cd /d "%~dp0\.."
echo [restart] restarting api, postgres, redis (volumes preserved)...
docker compose --env-file .env restart api postgres redis
if errorlevel 1 (
echo [restart] docker compose restart failed
exit /b 1
)
echo [restart] waiting for api to become healthy...
setlocal enabledelayedexpansion
for /L %%i in (1,1,60) do (
for /f "delims=" %%s in ('docker inspect --format="{{.State.Health.Status}}" mtusi2026lab2-api-1 2^>nul') do set STATUS=%%s
if "!STATUS!"=="healthy" (
echo [restart] api is healthy after %%is
exit /b 0
)
timeout /t 1 /nobreak >nul
)
echo [restart] api did not become healthy within 60s
exit /b 1
+18
View File
@@ -0,0 +1,18 @@
#!/usr/bin/env bash
set -euo pipefail
cd "$(dirname "$0")/.."
docker compose --env-file .env restart api postgres redis
for i in $(seq 1 60); do
status=$(docker inspect --format='{{.State.Health.Status}}' mtusi2026lab2-api-1 2>/dev/null || echo "unknown")
if [ "$status" = "healthy" ]; then
echo "api is healthy after ${i}s"
exit 0
fi
sleep 1
done
echo "api did not become healthy within 60s" >&2
exit 1
View File
+131
View File
@@ -0,0 +1,131 @@
import base64
import binascii
import uuid
from datetime import datetime, timedelta, timezone
import redis.asyncio as aioredis
from fastapi import APIRouter, Depends, Header, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.core.config import settings
from src.core.redis import get_redis
from src.core.security import verify_password
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import SessionResponse, UserResponse
from src.services import sessions as sessions_service
from src.services import users as users_service
router = APIRouter(prefix="/api/v1/auth/sessions", tags=["auth"])
def _rid(request: Request) -> str:
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
def _error(
status_code: int,
code: str,
message: str,
request: Request,
challenge: str | None = None,
) -> JSONResponse:
rid = _rid(request)
headers = {"X-Request-Id": rid}
if challenge:
headers["WWW-Authenticate"] = challenge
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers=headers,
)
def _parse_basic(authorization: str | None) -> tuple[str, str] | None:
if not authorization or not authorization.lower().startswith("basic "):
return None
encoded = authorization.split(" ", 1)[1].strip()
try:
decoded = base64.b64decode(encoded, validate=True).decode("utf-8")
except (binascii.Error, UnicodeDecodeError):
return None
if ":" not in decoded:
return None
username, password = decoded.split(":", 1)
return username, password
@router.post("", status_code=201)
async def create_session(
request: Request,
authorization: str | None = Header(default=None),
db: AsyncSession = Depends(get_db),
redis: aioredis.Redis = Depends(get_redis),
):
credentials = _parse_basic(authorization)
if credentials is None:
return _error(
401, "unauthorized", "invalid credentials", request,
challenge='Basic realm="messenger", charset="UTF-8"',
)
username, password = credentials
user = await users_service.get_user_by_username(db, username)
if user is None or not verify_password(password, user.password_hash):
return _error(
401, "unauthorized", "invalid credentials", request,
challenge='Basic realm="messenger", charset="UTF-8"',
)
try:
token = await sessions_service.create_session(redis, user.id)
except (aioredis.RedisError, ConnectionError, OSError):
return _error(
503, "unavailable", "session store unavailable", request,
)
expires_at = datetime.now(timezone.utc) + timedelta(
seconds=settings.session_ttl_seconds
)
payload = SessionResponse(
token=token,
token_type="Bearer",
expires_at=expires_at,
user=UserResponse.model_validate(user),
)
return JSONResponse(
status_code=201,
content=payload.model_dump(mode="json"),
headers={"X-Request-Id": _rid(request)},
)
@router.delete("/current", status_code=204)
async def revoke_current_session(
request: Request,
authorization: str | None = Header(default=None),
current_user: User = Depends(get_current_user),
redis: aioredis.Redis = Depends(get_redis),
):
token = authorization.split(" ", 1)[1].strip()
try:
await sessions_service.revoke_session(redis, token)
except (aioredis.RedisError, ConnectionError, OSError):
return _error(
503, "unavailable", "session store unavailable", request,
)
return JSONResponse(
status_code=204,
content=None,
headers={"X-Request-Id": _rid(request)},
)
+107
View File
@@ -0,0 +1,107 @@
import uuid
from fastapi import APIRouter, Depends, Query, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import (
ChatPage,
ChatResponse,
CreateChatRequest,
)
from src.services import chats as chats_service
router = APIRouter(prefix="/api/v1/chats", tags=["chats"])
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
async def _build_chat_response(
db: AsyncSession,
chat,
) -> ChatResponse:
member_ids = await chats_service.get_member_ids(db, chat.id)
return ChatResponse(
id=chat.id,
title=chat.title,
member_ids=member_ids,
created_at=chat.created_at,
)
@router.post("", status_code=201, response_model=ChatResponse)
async def create_chat(
payload: CreateChatRequest,
request: Request,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
try:
chat = await chats_service.create_chat(
db=db,
title=payload.title,
member_ids=payload.member_ids,
caller_id=current_user.id,
)
except chats_service.CallerNotInMembersError:
return _error(
400, "invalid_request", "caller must be in member_ids", request
)
except chats_service.UnknownMemberError:
return _error(
400, "invalid_request", "unknown member_id", request
)
return await _build_chat_response(db, chat)
@router.get("", response_model=ChatPage)
async def list_chats(
request: Request,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
try:
rows, next_cursor = await chats_service.list_chats_for_user(
db=db,
user_id=current_user.id,
limit=limit,
cursor=cursor,
)
except ValueError:
return _error(400, "invalid_request", "invalid cursor", request)
items = [await _build_chat_response(db, chat) for chat in rows]
return ChatPage(items=items, next_cursor=next_cursor)
@router.get("/{chat_id}", response_model=ChatResponse)
async def get_chat(
chat_id: uuid.UUID,
request: Request,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
if chat is None:
return _error(404, "not_found", "chat not found", request)
return await _build_chat_response(db, chat)
+54
View File
@@ -0,0 +1,54 @@
import uuid
import redis.asyncio as aioredis
from fastapi import Depends, Header, HTTPException, status
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.redis import get_redis
from src.db.session import get_db
from src.models.models import User
from src.services import sessions as sessions_service
from src.services import users as users_service
async def get_current_user(
authorization: str | None = Header(default=None),
db: AsyncSession = Depends(get_db),
redis: aioredis.Redis = Depends(get_redis),
) -> User:
if not authorization or not authorization.lower().startswith("bearer "):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
token = authorization.split(" ", 1)[1].strip()
if not token:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
try:
user_id = await sessions_service.get_session_user_id(redis, token)
except (aioredis.RedisError, ConnectionError, OSError):
# Redis недоступен → не пропускаем запрос, отдаём 503.
raise HTTPException(
status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
detail="session store unavailable",
)
if user_id is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
user = await users_service.get_user_by_id(db, user_id)
if user is None:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="unauthorized",
)
return user
+26
View File
@@ -0,0 +1,26 @@
import uuid
from fastapi import APIRouter, Request
from fastapi.responses import JSONResponse
router = APIRouter()
@router.get("/health/live")
async def live(request: Request):
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
return JSONResponse(
{"status": "ok"},
headers={"X-Request-Id": rid},
)
@router.get("/health/ready")
async def ready(request: Request):
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
# Пока зависимостей нет — всегда говорим ok.
# Позже здесь будем проверять доступность PostgreSQL и Redis.
return JSONResponse(
{"status": "ok"},
headers={"X-Request-Id": rid},
)
+82
View File
@@ -0,0 +1,82 @@
import uuid
from fastapi import APIRouter, Depends, Query, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import (
CreateMessageRequest,
MessagePage,
MessageResponse,
)
from src.services import chats as chats_service
from src.services import messages as messages_service
router = APIRouter(prefix="/api/v1/chats", tags=["messages"])
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
@router.post("/{chat_id}/messages", status_code=201, response_model=MessageResponse)
async def create_message(
chat_id: uuid.UUID,
payload: CreateMessageRequest,
request: Request,
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
if chat is None:
return _error(404, "not_found", "chat not found", request)
message = await messages_service.create_message(
db=db,
chat_id=chat.id,
sender_id=current_user.id,
text=payload.text,
)
return MessageResponse.model_validate(message)
@router.get("/{chat_id}/messages", response_model=MessagePage)
async def list_messages(
chat_id: uuid.UUID,
request: Request,
limit: int = Query(default=50, ge=1, le=100),
cursor: str | None = Query(default=None),
current_user: User = Depends(get_current_user),
db: AsyncSession = Depends(get_db),
):
chat = await chats_service.get_chat_for_user(db, chat_id, current_user.id)
if chat is None:
return _error(404, "not_found", "chat not found", request)
try:
rows, next_cursor = await messages_service.list_messages(
db=db,
chat_id=chat.id,
limit=limit,
cursor=cursor,
)
except ValueError:
return _error(400, "invalid_request", "invalid cursor", request)
items = [MessageResponse.model_validate(m) for m in rows]
return MessagePage(items=items, next_cursor=next_cursor)
+58
View File
@@ -0,0 +1,58 @@
import uuid
from fastapi import APIRouter, Depends, Request
from fastapi.responses import JSONResponse
from sqlalchemy.ext.asyncio import AsyncSession
from src.api.deps import get_current_user
from src.db.session import get_db
from src.models.models import User
from src.schemas.schemas import (
CreateUserRequest,
UserResponse,
)
from src.services import users as users_service
router = APIRouter(prefix="/api/v1/users", tags=["users"])
def _error(status_code: int, code: str, message: str, request: Request) -> JSONResponse:
rid = getattr(request.state, "request_id", None) or str(uuid.uuid4())
return JSONResponse(
status_code=status_code,
content={
"error": {
"code": code,
"message": message,
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
@router.post("", status_code=201, response_model=UserResponse)
async def register_user(
payload: CreateUserRequest,
request: Request,
db: AsyncSession = Depends(get_db),
):
try:
user = await users_service.create_user(
db=db,
username=payload.username,
display_name=payload.display_name,
password=payload.password,
)
except users_service.UsernameTakenError:
return _error(409, "conflict", "username already taken", request)
return UserResponse.model_validate(user)
@router.get("/me", response_model=UserResponse)
async def get_me(
current_user: User = Depends(get_current_user),
):
return UserResponse.model_validate(current_user)
View File
+39
View File
@@ -0,0 +1,39 @@
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
extra="ignore",
)
app_host: str = "0.0.0.0"
app_port: int = 8080
app_env: str = "lab"
session_ttl_seconds: int = 3600
postgres_user: str
postgres_password: str
postgres_db: str
postgres_host: str = "postgres"
postgres_port: int = 5432
redis_host: str = "redis"
redis_port: int = 6379
redis_db: int = 0
@property
def database_url(self) -> str:
return (
f"postgresql+asyncpg://{self.postgres_user}:{self.postgres_password}"
f"@{self.postgres_host}:{self.postgres_port}/{self.postgres_db}"
)
@property
def redis_url(self) -> str:
return f"redis://{self.redis_host}:{self.redis_port}/{self.redis_db}"
settings = Settings()
+16
View File
@@ -0,0 +1,16 @@
import uuid
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
class RequestIdMiddleware(BaseHTTPMiddleware):
"""Гарантирует, что каждый ответ содержит X-Request-Id."""
async def dispatch(self, request: Request, call_next):
rid = request.headers.get("X-Request-Id") or str(uuid.uuid4())
request.state.request_id = rid
response = await call_next(request)
response.headers["X-Request-Id"] = rid
return response
+16
View File
@@ -0,0 +1,16 @@
from collections.abc import AsyncGenerator
import redis.asyncio as aioredis
from src.core.config import settings
redis_client: aioredis.Redis = aioredis.from_url(
settings.redis_url,
encoding="utf-8",
decode_responses=True,
max_connections=50,
)
async def get_redis() -> AsyncGenerator[aioredis.Redis, None]:
yield redis_client
+28
View File
@@ -0,0 +1,28 @@
import secrets
from passlib.context import CryptContext
_pwd_context = CryptContext(
schemes=["argon2"],
deprecated="auto",
argon2__time_cost=2,
argon2__memory_cost=65536, # 64 MiB
argon2__parallelism=2,
argon2__type="ID", # Argon2id
)
def hash_password(password: str) -> str:
return _pwd_context.hash(password)
def verify_password(password: str, password_hash: str) -> bool:
try:
return _pwd_context.verify(password, password_hash)
except ValueError:
return False
def generate_session_token() -> str:
# 32 байта = 256 бит энтропии, hex = 64 символа
return secrets.token_urlsafe(48)
View File
+6
View File
@@ -0,0 +1,6 @@
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
"""Общий базовый класс для всех ORM-моделей."""
pass
+34
View File
@@ -0,0 +1,34 @@
from collections.abc import AsyncGenerator
from sqlalchemy.ext.asyncio import (
AsyncSession,
async_sessionmaker,
create_async_engine,
)
from src.core.config import settings
engine = create_async_engine(
settings.database_url,
echo=False,
pool_size=10,
max_overflow=20,
pool_pre_ping=True,
pool_recycle=1800,
)
async_session_factory = async_sessionmaker(
engine,
class_=AsyncSession,
expire_on_commit=False,
autoflush=False,
)
async def get_db() -> AsyncGenerator[AsyncSession, None]:
async with async_session_factory() as session:
try:
yield session
except Exception:
await session.rollback()
raise
+93
View File
@@ -0,0 +1,93 @@
import uuid
from fastapi import FastAPI, HTTPException, Request
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from src.api import auth, chats, health, messages, users
from src.core.middleware import RequestIdMiddleware
app = FastAPI(
title="MTUSI Messenger — lab2",
version="1.2.0",
)
app.add_middleware(RequestIdMiddleware)
app.include_router(health.router)
app.include_router(users.router)
app.include_router(auth.router)
app.include_router(chats.router)
app.include_router(messages.router)
def _rid(request: Request) -> str:
return getattr(request.state, "request_id", None) or str(uuid.uuid4())
def _code_for(status_code: int) -> str:
return {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
500: "internal_error",
}.get(status_code, "internal_error")
@app.exception_handler(HTTPException)
async def http_exception_with_request_id(request: Request, exc: HTTPException):
rid = _rid(request)
response = JSONResponse(
status_code=exc.status_code,
content={
"error": {
"code": _code_for(exc.status_code),
"message": exc.detail if isinstance(exc.detail, str) else "error",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
if exc.status_code == 401:
response.headers["WWW-Authenticate"] = 'Bearer realm="messenger"'
if exc.headers:
for k, v in exc.headers.items():
response.headers.setdefault(k, v)
return response
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
rid = _rid(request)
return JSONResponse(
status_code=400,
content={
"error": {
"code": "invalid_request",
"message": "invalid request",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
@app.exception_handler(Exception)
async def unhandled_exception_handler(request: Request, exc):
rid = _rid(request)
return JSONResponse(
status_code=500,
content={
"error": {
"code": "internal_error",
"message": "internal error",
"request_id": rid,
}
},
headers={"X-Request-Id": rid},
)
View File
+104
View File
@@ -0,0 +1,104 @@
import uuid
from datetime import datetime
from sqlalchemy import (
CheckConstraint,
DateTime,
ForeignKey,
Index,
String,
Text,
func,
)
from sqlalchemy.dialects.postgresql import UUID
from sqlalchemy.orm import Mapped, mapped_column, relationship
from src.db.base import Base
class User(Base):
__tablename__ = "users"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
)
username: Mapped[str] = mapped_column(
String(32), unique=True, nullable=False, index=True
)
display_name: Mapped[str] = mapped_column(String(100), nullable=False)
password_hash: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=func.now(), nullable=False
)
__table_args__ = (
CheckConstraint(
"username ~ '^[a-z0-9_]{3,32}$'",
name="ck_users_username_format",
),
)
class Chat(Base):
__tablename__ = "chats"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
)
title: Mapped[str] = mapped_column(String(100), nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=func.now(), nullable=False
)
members: Mapped[list["ChatMember"]] = relationship(
back_populates="chat", cascade="all, delete-orphan"
)
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
primary_key=True,
)
user_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
primary_key=True,
)
chat: Mapped["Chat"] = relationship(back_populates="members")
class Message(Base):
__tablename__ = "messages"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
)
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
nullable=False,
)
sender_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
nullable=False,
)
text: Mapped[str] = mapped_column(Text, nullable=False)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True), server_default=func.now(), nullable=False
)
__table_args__ = (
# Ключевой индекс для пагинации истории (оценка 4).
Index(
"idx_messages_chat_created_id",
"chat_id",
"created_at",
"id",
),
)
View File
+105
View File
@@ -0,0 +1,105 @@
import uuid
from datetime import datetime
from pydantic import BaseModel, ConfigDict, Field
# ---------- Health ----------
class HealthResponse(BaseModel):
status: str = "ok"
# ---------- Errors ----------
class ErrorBody(BaseModel):
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
error: ErrorBody
# ---------- Users ----------
USERNAME_PATTERN = r"^[a-z0-9_]{3,32}$"
class CreateUserRequest(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
username: str = Field(pattern=USERNAME_PATTERN)
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
class UserResponse(BaseModel):
model_config = ConfigDict(from_attributes=True, extra="forbid")
id: uuid.UUID
username: str
display_name: str
created_at: datetime
# ---------- Sessions ----------
class SessionResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
token: str
token_type: str = "Bearer"
expires_at: datetime
user: UserResponse
# ---------- Chats ----------
class CreateChatRequest(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
title: str = Field(min_length=1, max_length=100)
member_ids: list[uuid.UUID] = Field(min_length=1, max_length=100)
class ChatResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: uuid.UUID
title: str
member_ids: list[uuid.UUID]
created_at: datetime
class ChatPage(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[ChatResponse]
next_cursor: str | None
# ---------- Messages ----------
class CreateMessageRequest(BaseModel):
model_config = ConfigDict(extra="forbid", str_strip_whitespace=True)
text: str = Field(min_length=1, max_length=4000)
class MessageResponse(BaseModel):
model_config = ConfigDict(from_attributes=True, extra="forbid")
id: uuid.UUID
chat_id: uuid.UUID
sender_id: uuid.UUID
text: str
created_at: datetime
class MessagePage(BaseModel):
model_config = ConfigDict(extra="forbid")
items: list[MessageResponse]
next_cursor: str | None
View File
+124
View File
@@ -0,0 +1,124 @@
import base64
import uuid
from datetime import datetime
from sqlalchemy import and_, or_, select
from sqlalchemy.ext.asyncio import AsyncSession
from src.models.models import Chat, ChatMember, Message
class UnknownMemberError(Exception):
"""Хотя бы один member_id не существует в users."""
class CallerNotInMembersError(Exception):
"""Вызывающий не входит в member_ids."""
class ChatNotFoundError(Exception):
"""Чат не существует или недоступен."""
async def create_chat(
db: AsyncSession,
title: str,
member_ids: list[uuid.UUID],
caller_id: uuid.UUID,
) -> Chat:
unique_ids = set(member_ids)
if caller_id not in unique_ids:
raise CallerNotInMembersError()
# Проверяем, что все users существуют
from src.models.models import User
result = await db.execute(select(User.id).where(User.id.in_(unique_ids)))
existing = {row[0] for row in result.all()}
missing = unique_ids - existing
if missing:
raise UnknownMemberError()
chat = Chat(title=title)
db.add(chat)
await db.flush() # получаем chat.id
for uid in unique_ids:
db.add(ChatMember(chat_id=chat.id, user_id=uid))
await db.commit()
await db.refresh(chat)
return chat
async def get_chat_for_user(
db: AsyncSession,
chat_id: uuid.UUID,
user_id: uuid.UUID,
) -> Chat | None:
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(Chat.id == chat_id, ChatMember.user_id == user_id)
)
result = await db.execute(stmt)
return result.scalar_one_or_none()
async def get_member_ids(
db: AsyncSession,
chat_id: uuid.UUID,
) -> list[uuid.UUID]:
stmt = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)
result = await db.execute(stmt)
return [row[0] for row in result.all()]
# ---------- Пагинация списка чатов ----------
def encode_cursor(created_at: datetime, chat_id: uuid.UUID) -> str:
raw = f"{created_at.isoformat()}|{chat_id}"
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]:
try:
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
ts_str, id_str = raw.split("|", 1)
return datetime.fromisoformat(ts_str), uuid.UUID(id_str)
except (ValueError, UnicodeDecodeError) as exc:
raise ValueError("invalid cursor") from exc
async def list_chats_for_user(
db: AsyncSession,
user_id: uuid.UUID,
limit: int,
cursor: str | None,
) -> tuple[list[Chat], str | None]:
stmt = (
select(Chat)
.join(ChatMember, ChatMember.chat_id == Chat.id)
.where(ChatMember.user_id == user_id)
.order_by(Chat.created_at.asc(), Chat.id.asc())
.limit(limit + 1)
)
if cursor:
cursor_ts, cursor_id = decode_cursor(cursor)
stmt = stmt.where(
or_(
Chat.created_at > cursor_ts,
and_(Chat.created_at == cursor_ts, Chat.id > cursor_id),
)
)
result = await db.execute(stmt)
rows = list(result.scalars().all())
next_cursor: str | None = None
if len(rows) > limit:
last = rows[limit - 1]
next_cursor = encode_cursor(last.created_at, last.id)
rows = rows[:limit]
return rows, next_cursor
+76
View File
@@ -0,0 +1,76 @@
import base64
import uuid
from datetime import datetime
from sqlalchemy import and_, or_, select
from sqlalchemy.ext.asyncio import AsyncSession
from src.models.models import Message
def encode_cursor(created_at: datetime, message_id: uuid.UUID) -> str:
raw = f"{created_at.isoformat()}|{message_id}"
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(cursor: str) -> tuple[datetime, uuid.UUID]:
try:
raw = base64.urlsafe_b64decode(cursor.encode()).decode()
ts_str, id_str = raw.split("|", 1)
return datetime.fromisoformat(ts_str), uuid.UUID(id_str)
except (ValueError, UnicodeDecodeError) as exc:
raise ValueError("invalid cursor") from exc
async def create_message(
db: AsyncSession,
chat_id: uuid.UUID,
sender_id: uuid.UUID,
text: str,
) -> Message:
message = Message(
chat_id=chat_id,
sender_id=sender_id,
text=text,
)
db.add(message)
await db.commit()
await db.refresh(message)
return message
async def list_messages(
db: AsyncSession,
chat_id: uuid.UUID,
limit: int,
cursor: str | None,
) -> tuple[list[Message], str | None]:
stmt = (
select(Message)
.where(Message.chat_id == chat_id)
.order_by(Message.created_at.asc(), Message.id.asc())
.limit(limit + 1)
)
if cursor:
cursor_ts, cursor_id = decode_cursor(cursor)
stmt = stmt.where(
or_(
Message.created_at > cursor_ts,
and_(
Message.created_at == cursor_ts,
Message.id > cursor_id,
),
)
)
result = await db.execute(stmt)
rows = list(result.scalars().all())
next_cursor: str | None = None
if len(rows) > limit:
last = rows[limit - 1]
next_cursor = encode_cursor(last.created_at, last.id)
rows = rows[:limit]
return rows, next_cursor
+50
View File
@@ -0,0 +1,50 @@
import uuid
import redis.asyncio as aioredis
from src.core.config import settings
from src.core.security import generate_session_token
KEY_PREFIX = "session:"
def _key(token: str) -> str:
return KEY_PREFIX + token
async def create_session(
redis: aioredis.Redis,
user_id: uuid.UUID,
ttl_seconds: int | None = None,
) -> str:
token = generate_session_token()
ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds
await redis.set(_key(token), str(user_id), ex=ttl)
return token
async def get_session_user_id(
redis: aioredis.Redis,
token: str,
) -> uuid.UUID | None:
value = await redis.get(_key(token))
if value is None:
return None
try:
return uuid.UUID(value)
except ValueError:
return None
async def revoke_session(redis: aioredis.Redis, token: str) -> None:
await redis.delete(_key(token))
async def touch_session(
redis: aioredis.Redis,
token: str,
ttl_seconds: int | None = None,
) -> None:
"""Продлить TTL сессии (опционально)."""
ttl = ttl_seconds if ttl_seconds is not None else settings.session_ttl_seconds
await redis.expire(_key(token), ttl)
+51
View File
@@ -0,0 +1,51 @@
import uuid
from sqlalchemy import select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from src.core.security import hash_password
from src.models.models import User
class UsernameTakenError(Exception):
"""Username уже занят."""
async def create_user(
db: AsyncSession,
username: str,
display_name: str,
password: str,
) -> User:
user = User(
username=username,
display_name=display_name,
password_hash=hash_password(password),
)
db.add(user)
try:
await db.commit()
except IntegrityError as exc:
await db.rollback()
raise UsernameTakenError(username) from exc
await db.refresh(user)
return user
async def get_user_by_username(
db: AsyncSession,
username: str,
) -> User | None:
stmt = select(User).where(User.username == username)
result = await db.execute(stmt)
return result.scalar_one_or_none()
async def get_user_by_id(
db: AsyncSession,
user_id: uuid.UUID,
) -> User | None:
stmt = select(User).where(User.id == user_id)
result = await db.execute(stmt)
return result.scalar_one_or_none()
+56
View File
@@ -0,0 +1,56 @@
"""Test: concurrent registration of the same username must produce exactly one 201 and one 409."""
import base64
import json
import threading
import urllib.error
import urllib.request
import uuid
BASE = "http://localhost:8080"
def post_user(username: str, password: str):
body = json.dumps({
"username": username,
"display_name": "Race Test",
"password": password,
}).encode()
req = urllib.request.Request(
BASE + "/api/v1/users",
data=body,
headers={"Content-Type": "application/json"},
method="POST",
)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
return resp.status, resp.read().decode()
except urllib.error.HTTPError as e:
return e.code, e.read().decode()
def main():
username = "race_" + uuid.uuid4().hex[:8]
password = "RaceTestPassword123"
results = []
lock = threading.Lock()
def worker():
status, body = post_user(username, password)
with lock:
results.append((status, body))
threads = [threading.Thread(target=worker) for _ in range(2)]
for t in threads:
t.start()
for t in threads:
t.join()
statuses = [s for s, _ in results]
print("Statuses:", statuses)
assert sorted(statuses) == [201, 409], f"expected [201, 409], got {statuses}"
print("PASS: race registration — one 201, one 409")
if __name__ == "__main__":
main()
+65
View File
@@ -0,0 +1,65 @@
"""Test: when Redis is down, protected endpoints return 503, not 500."""
import subprocess
import time
import urllib.error
import urllib.request
import uuid
BASE = "http://localhost:8080"
def call(method, path, headers=None):
h = {"Accept": "application/json"}
h.update(headers or {})
req = urllib.request.Request(BASE + path, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
return resp.status, resp.read().decode()
except urllib.error.HTTPError as e:
return e.code, e.read().decode()
def stop_redis():
subprocess.run(["docker", "compose", "stop", "redis"], check=True, capture_output=True)
def start_redis():
subprocess.run(["docker", "compose", "start", "redis"], check=True, capture_output=True)
# Ждём, пока Redis станет healthy
for _ in range(30):
p = subprocess.run(
["docker", "inspect", "--format={{.State.Health.Status}}", "mtusi2026lab2-redis-1"],
capture_output=True, text=True,
)
if p.stdout.strip() == "healthy":
return
time.sleep(1)
raise RuntimeError("redis did not become healthy")
def main():
# Проверяем, что без токена всё ещё 401 (не 500)
try:
stop_redis()
time.sleep(2)
# 1. Аноним не должен пройти (401, не 503 — токена нет)
status, body = call("GET", "/api/v1/users/me")
assert status == 401, f"anonymous request without token should be 401, got {status} {body}"
print("Anonymous without token: 401 (correct)")
# 2. С фиктивным токеном — 503 (Redis недоступен), не 500
status, body = call("GET", "/api/v1/users/me", headers={
"Authorization": "Bearer faketoken12345",
})
assert status == 503, f"with fake token and Redis down should be 503, got {status} {body}"
print("With token, Redis down: 503 (correct)")
print("PASS: Redis unavailability handled correctly")
finally:
start_redis()
print("Redis restarted")
if __name__ == "__main__":
main()
+69
View File
@@ -0,0 +1,69 @@
"""Test: session expires after SESSION_TTL_SECONDS."""
import base64
import json
import time
import urllib.error
import urllib.request
import uuid
BASE = "http://localhost:8080"
EXPECTED_TTL = 2 # секунды
def call(method, path, body=None, headers=None):
h = {"Accept": "application/json"}
h.update(headers or {})
data = None
if body is not None:
data = json.dumps(body).encode()
h["Content-Type"] = "application/json"
req = urllib.request.Request(BASE + path, data=data, headers=h, method=method)
try:
with urllib.request.urlopen(req, timeout=10) as resp:
return resp.status, json.loads(resp.read().decode() or "{}")
except urllib.error.HTTPError as e:
return e.code, json.loads(e.read().decode() or "{}")
def main():
# 1. Регистрируем пользователя
username = "exp_" + uuid.uuid4().hex[:8]
password = "ExpiryTestPass123"
status, user = call("POST", "/api/v1/users", {
"username": username,
"display_name": "Expiry Test",
"password": password,
})
assert status == 201, f"register failed: {status} {user}"
# 2. Логинимся
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
status, session = call("POST", "/api/v1/auth/sessions", headers={
"Authorization": "Basic " + cred,
})
assert status == 201, f"login failed: {status} {session}"
token = session["token"]
print(f"Got token; waiting {EXPECTED_TTL + 2}s for expiry...")
# 3. Проверяем, что токен сразу работает
status, _ = call("GET", "/api/v1/users/me", headers={
"Authorization": "Bearer " + token,
})
assert status == 200, f"token should work immediately, got {status}"
print("Token works immediately: OK")
# 4. Ждём больше TTL
time.sleep(EXPECTED_TTL + 2)
# 5. Проверяем, что токен больше не работает
status, body = call("GET", "/api/v1/users/me", headers={
"Authorization": "Bearer " + token,
})
assert status == 401, f"expired token should give 401, got {status} {body}"
print("Token rejected after TTL: OK")
print("PASS: session expiry works")
if __name__ == "__main__":
main()