feat: ЛР4 - S3 хранилище MinIO, загрузка вложений и защита от атак

This commit is contained in:
Ильяс
2026-11-06 15:59:44 +03:00
parent 9b574fa5e9
commit 4979731408
24 changed files with 1418 additions and 72 deletions
+16 -9
View File
@@ -1,20 +1,27 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
CACHE_URL_FILE=/run/secrets/cache_url
# PostgreSQL credentials and database configuration
POSTGRES_USER=postgres
POSTGRES_PASSWORD=postgres
POSTGRES_DB=messenger
DATABASE_URL=postgresql://postgres:postgres@postgres:5432/messenger
# Redis session store configuration
SESSION_STORE=redis
CACHE_URL=redis://redis:6379/0
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=http://s3:9000
# MinIO configuration
S3_ENDPOINT=http://minio:9000
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
S3_ACCESS_KEY_ID=minioadmin
S3_SECRET_ACCESS_KEY=minioadmin
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
+154 -16
View File
@@ -1,37 +1,175 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Герейханов Ильяс, БВТ2301
- Целевая оценка: 4
- Commit/PR: ветка `solution/bvt2301-Gereykhanov`. PR: `ЛР 4 — БВТ2301 — Герейханов — на 4`
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI, Uvicorn, PostgreSQL 16, Redis 7, Nginx 1.27, MinIO, boto3, Pillow, asyncpg, argon2-cffi, Pydantic, Pytest, Docker Compose; документация AWS S3 API, RFC 7231, OpenAPI 3.1.0. ИИ использовался для подготовки скриптов, отладки конфигурации nginx и расширения тестов pytest.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
1. **Версии runtime и образов:**
- Локальный runtime: Linux, Docker 29.9.1, Docker Compose v5.6.0
- Load Balancer: `nginx:1.27-alpine`
- API контейнеры: `python:3.12-slim`
- PostgreSQL: `postgres:16-alpine`
- Redis: `redis:7-alpine`
- S3-совместимое хранилище: `cleanstart/minio:0.20260330.001845`
2. **Подготовка окружения и запуск стека:**
```sh
git checkout solution/bvt2301-Gereykhanov
cp .env.example .env
# Сборка и запуск всех сервисов
make up
```
3. **Ожидание готовности и запуск проверок:**
```sh
# Проверка структуры и синтаксиса
make check
# Валидация схемы OpenAPI
make validate PYTHON=.venv/bin/python
# Проверка smoke теста
make test
# Проверка сценария сохранности данных и сессий при рестарте
make test-persistence ACTION_SCRIPT=scripts/restart.sh
# Проверка отказоустойчивости при отключении одной API-реплики
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
# Восстановление остановленной реплики после теста
docker compose up -d
# Запуск собственных тестов
make test-student
# Запуск нагрузочного теста
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load.json
```
4. **Остановка и очистка:**
```sh
# Остановка с сохранением данных volumes
docker compose down
# Остановка с удалением volumes
docker compose down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- **Топология процессов и распределение ролей:**
- **Клиент** отправляет все HTTP-запросы в единую точку входа **Nginx Load Balancer** на порт `8080`.
- **Nginx** осуществляет Round-Robin балансировку между двумя независимыми репликами API (`api-1` и `api-2`).
- Реплики API работают в stateless-режиме, не имеют открытых портов на хост и доступны только через балансировщик.
- Каждая реплика API обращается к общему **PostgreSQL**, **Redis** и **MinIO S3**.
- Отдельный одноразовый контейнер **migration** применяет `init.sql` перед стартом API-реплик.
- **Хранилища данных и источник истины:**
- **PostgreSQL:** источник истины для реляционных данных пользователей, чатов, сообщений и метаданных вложений в таблице `attachments` (`id`, `chat_id`, `owner_id`, `filename`, `content_type`, `size_bytes`, `sha256`, `s3_key`, `status`, `error_code`, `created_at`, `updated_at`).
- **MinIO S3:** хранилище бинарного контента в приватном бакете `messenger-attachments`. Ключи объектов формируются по схеме `chats/{chat_id}/{attachment_id}/{filename}`.
- **Redis:** сессионный кэш Bearer-токенов с TTL 3600 с и сохранением на volume `redis_data` через `--appendonly yes`.
- **Что перенесено из лабы 3:**
- Балансировщик Nginx с Round-robin 50/50 и `proxy_next_upstream` для быстрого переключения при сбое.
- Сквозные заголовки `X-Request-Id` и `X-Instance-Id` в ответах API.
- Единое хранилище сессий в Redis.
- Идемпотентность отправки сообщений по заголовку `Idempotency-Key` с сохранением `request_hash` в БД.
- Keyset-пагинация сообщений по индексу.
- **Интеграция S3 и изоляция сети:**
- MinIO включен во внутреннюю Docker-сеть с постоянным volume `minio_data`.
- Порты MinIO не проброшены на хост наружу, консоль закрыта от общей сети.
- При старте API выполняется автоматический идемпотентный bootstrap: проверка и создание бакета `messenger-attachments` через `boto3`.
- **Загрузка, валидация и защита от атак:**
- Эндпоинт `POST /api/v1/chats/{chat_id}/attachments?filename=...` принимает сырое бинарное тело (PNG/JPEG) до 10 MiB.
- **Проверка MIME по содержимому:** проверяются магические сигнатуры байтов. Невалидные форматы отклоняются с кодом `415`.
- **Защита от decompression bomb:** через библиотеку `Pillow` считываются размеры изображения из заголовков IHDR/SOF без декомпрессии растра в память. Превышение лимита 40 млн пикселей возвращает `413 payload_too_large`.
- **Валидация имени файла (`filename`):** длина 1–255 символов; отклоняются path-traversal последовательности, NUL-байт (`\0`) и управляющие символы с кодом `400 invalid_request`.
- **Компенсация сиротских объектов и прямой download:**
- Файл сначала сохраняется в S3 через `boto3.put_object`, после чего выполняется запись метаданных в базу. При ошибке в БД блок `except` вызывает `s3_client.delete_object`, удаляя объект из S3.
- Скачивание через `GET /api/v1/attachments/{id}/content` возвращает байты напрямую из S3 без 302/307 редиректов. Запрос от постороннего возвращает строго `404 not_found`.
- **Связывание с сообщениями и настройки Nginx:**
- В таблицу `messages` добавлено поле `attachment_ids UUID[]`.
- Разрешена отправка сообщения с пустым текстом `text=""`, если прикреплены файлы.
- В `infra/nginx.conf` задана директива `client_max_body_size 15M;` для пропуска 10 MiB загрузок.
- Все параметры согласованы с `.env.example`: `S3_ENDPOINT`, `S3_BUCKET`, `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS`.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Проверка синтаксиса и контракта | `make check` | `PASS: offline skeleton structure, local refs and Python syntax` | [`evidence/check_contract.log`](evidence/check_contract.log) |
| Полная OpenAPI 3.1 валидация | `make validate PYTHON=.venv/bin/python` | `PASS: full OpenAPI 3.1 and JSON Schema validation` | [`evidence/validate_openapi.log`](evidence/validate_openapi.log) |
| Публичный smoke тест | `make test` | `PASS: lab4 public API scenario` | [`evidence/smoke_test.log`](evidence/smoke_test.log) |
| Чередование реплик | `for i in {1..10}; do curl -sI http://localhost:8080/health/live \| grep -i x-instance-id; done` | 50 на 50 ответы `api-1` и `api-2` | [`evidence/round_robin.log`](evidence/round_robin.log) |
| Сохранение данных и сессий при рестарте | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | Стек перезапущен, токен, сообщения и вложения в S3 сохранены | [`evidence/persistence_test.log`](evidence/persistence_test.log) |
| Отказ API-реплики под нагрузкой | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | Восстановление записи за **0.778 с**, 105 успешных запросов, 0 сбоев | [`evidence/failover_test.log`](evidence/failover_test.log) |
| Защита от decompression bomb (>40M px) | `make test-student` | Запрос с 50M px изображением отклонен с `413 payload_too_large` | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Проверка MIME по магическим байтам | `make test-student` | Поддельные и поврежденные изображения отклоняются с `415` | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Компенсация сирот S3 при отказе БД | `make test-student` | При сбое PostgreSQL объект удаляется из S3, в хранилище нет сирот | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Закрытый бакет и лимит RAM (10 загрузок) | `make test-student` | Порт 9000 закрыт снаружи, 10 параллельных загрузок успешны, RAM стабильна | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Собственные тесты | `make test-student` | **34 теста проходят**: валидация вложений, компенсация S3, курсор, идемпотентность | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Статусы и изоляция контейнеров | `docker compose ps` | Все 6 сервисов healthy, API и MinIO не открывают порты на хост | [`evidence/docker_services.log`](evidence/docker_services.log) |
| Нагрузочный тест | `make load` | **309.4 RPS**, p50 = 7.9 ms, p95 = 40.8 ms, p99 = 63.0 ms, 0 ошибок | [`evidence/load.json`](evidence/load.json) |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
- **Профиль нагрузки:** скрипт `tests/load.py`, закрытый цикл параллельных POST-запросов отправки сообщений с уникальными `Idempotency-Key`.
- **Параметры:** длительность 30 секунд, 4 параллельных потока.
- **Результаты нагрузки (`evidence/load.json`):**
```json
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.015,
"concurrency": 4,
"successful_requests": 9286,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 309.375,
"successful_latency_ms": {
"p50": 7.928,
"p95": 40.768,
"p99": 62.963
}
}
```
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка одной реплики API (`scripts/stop-one.sh`) | Nginx переключает трафик на живую реплику, продолжение записи $\le 10$ с, нет дубликатов | 105 успешных записей во время остановки, 0 ошибок, переключение за 0.778 с | 0.778 сек, потерь данных нет |
| Рестарт всего стека (`scripts/restart.sh`) при активной сессии| Сохранение подтверждённых данных в Postgres, токенов сессий в Redis и файлов в MinIO | Контейнеры перезапущены, токен валиден, история сообщений и файлы сохранены | Восстановление около 5 сек, потеря подтверждённых данных: 0 |
| Загрузка декомпрессионной бомбы (изображение 10000x5000) | Отклонение запроса с кодом 413 `payload_too_large` без исчерпания RAM | Запрос отклонен мгновенно по метаданным IHDR без распаковки растра | Мгновенно (< 2 мс) |
| Загрузка файла размером более 10 MiB | Отклонение запроса с кодом 413 `payload_too_large` | Запрос отклонен до сохранения в S3 | Мгновенно |
| Попытка загрузки файла с поддельным расширением | Отклонение с кодом 415 `unsupported_media_type` | Проверка сигнатуры байтов выявляет подмену и возвращает 415 | Мгновенно |
| Попытка доступа к метаданным или контенту посторонним пользователем | Защита приватности: возврат строго 404 Not Found без утечки факта существования файла | Посторонний получает 404 на `GET /attachments/{id}` и `/content` | Мгновенно |
| Попытка передачи опасного имени файла | Отклонение запроса с кодом 400 `invalid_request` | Валидатор отклоняет некорректное имя до обращения к хранилищу | Мгновенно |
| Сбой сохранения метаданных в БД после успешного `PUT` в S3 | Автоматическое удаление объекта из S3 | В S3 не остается мусорных файлов | Мгновенно |
| Конкурентная загрузка ≥10 файлов с контролем RAM | Все файлы сохраняются в S3, память API стабильна | 10 параллельных загрузок вернули 201 ready, утечек памяти нет | Мгновенно (< 1 с) |
| Попытка прямого обращения к MinIO на порт 9000 с хоста | Соединение отклоняется (Connection Refused), консоль закрыта | Порты MinIO не проброшены наружу, прямой доступ невозможен | Мгновенно |
## Ограничения и следующие шаги
## Ограничения
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Какие отказы выдерживаются и какие нет:**
1. *Выдерживаются:*
- Внезапная остановка любой одной API-реплики под нагрузкой: балансировщик Nginx переключает входящие запросы на оставшуюся реплику.
- Полный рестарт стека: все подтверждённые данные, активные токены и файлы в S3 сохраняются благодаря volumes.
- Конкурентная отправка сообщений с одинаковым `Idempotency-Key` в разные реплики.
- Попытки атак декомпрессионными бомбами и внедрения вредоносных имен файлов.
- Сбои транзакций после записи в S3: механизм компенсации удаляет сиротские объекты.
2. *Не выдерживаются:*
- Одновременное падение обеих API-реплик (HTTP 502 Bad Gateway).
- Падение единственного экземпляра PostgreSQL, Redis или MinIO.
- Удаление через `docker compose down -v`.
- **Учебные упрощения:**
1. Nginx, PostgreSQL, Redis и MinIO запущены в единственном экземпляре без распределенной репликации.
2. Скачивание контента реализовано через проксирование байтов API-репликой.
+8
View File
@@ -34,3 +34,11 @@ CACHE_URL: str = _get_val(
"CACHE_URL_FILE",
"redis://redis:6379/0",
)
S3_ENDPOINT: str = os.getenv("S3_ENDPOINT", "http://minio:9000")
S3_REGION: str = os.getenv("S3_REGION", "us-east-1")
S3_BUCKET: str = os.getenv("S3_BUCKET", "messenger-attachments")
S3_ACCESS_KEY_ID: str = _get_val("S3_ACCESS_KEY_ID", "S3_ACCESS_KEY_ID_FILE", "minioadmin")
S3_SECRET_ACCESS_KEY: str = _get_val("S3_SECRET_ACCESS_KEY", "S3_SECRET_ACCESS_KEY_FILE", "minioadmin")
MAX_UPLOAD_BYTES: int = int(os.getenv("MAX_UPLOAD_BYTES", "10485760"))
MAX_IMAGE_PIXELS: int = int(os.getenv("MAX_IMAGE_PIXELS", "40000000"))
+37
View File
@@ -3,6 +3,7 @@ import logging
import uuid
import asyncpg
import botocore.exceptions
from fastapi import FastAPI, Request, status
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
@@ -33,6 +34,14 @@ class ConflictError(StorageError):
pass
class PayloadTooLargeError(StorageError):
pass
class UnsupportedMediaTypeError(StorageError):
pass
class UnauthorizedError(StorageError):
pass
@@ -113,6 +122,30 @@ def register_error_handlers(app: FastAPI) -> None:
status.HTTP_409_CONFLICT, ErrorCode.CONFLICT, str(exc), req_id
)
@app.exception_handler(PayloadTooLargeError)
async def payload_too_large_handler(
request: Request, exc: PayloadTooLargeError
) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
ErrorCode.PAYLOAD_TOO_LARGE,
str(exc),
req_id,
)
@app.exception_handler(UnsupportedMediaTypeError)
async def unsupported_media_type_handler(
request: Request, exc: UnsupportedMediaTypeError
) -> JSONResponse:
req_id = get_request_id(request)
return make_error_response(
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
str(exc),
req_id,
)
@app.exception_handler(RequestValidationError)
async def validation_error_handler(
request: Request, exc: RequestValidationError
@@ -185,6 +218,8 @@ def register_error_handlers(app: FastAPI) -> None:
asyncpg.PostgresError,
asyncpg.InterfaceError,
redis.exceptions.RedisError,
botocore.exceptions.BotoCoreError,
botocore.exceptions.ClientError,
TimeoutError,
asyncio.TimeoutError,
ConnectionError,
@@ -204,6 +239,8 @@ def register_error_handlers(app: FastAPI) -> None:
asyncpg.PostgresError,
asyncpg.InterfaceError,
redis.exceptions.RedisError,
botocore.exceptions.BotoCoreError,
botocore.exceptions.ClientError,
TimeoutError,
asyncio.TimeoutError,
ConnectionError,
+3 -1
View File
@@ -9,6 +9,7 @@ from fastapi import FastAPI
from app.config import APP_HOST, APP_PORT, LOG_LEVEL
from app.errors import register_error_handlers
from app.middleware import RequestIdAndLoggingMiddleware
from app.routes.attachments import router as attachments_router
from app.routes.auth import router as auth_router
from app.routes.chats import router as chats_router
from app.routes.health import router as health_router
@@ -32,7 +33,7 @@ async def lifespan(app: FastAPI):
app = FastAPI(
title="highload-messenger",
version="1.3.0",
version="1.4.0",
docs_url="/docs",
redoc_url=None,
lifespan=lifespan,
@@ -47,6 +48,7 @@ app.include_router(auth_router)
app.include_router(users_router)
app.include_router(chats_router)
app.include_router(messages_router)
app.include_router(attachments_router)
if __name__ == "__main__":
+20 -4
View File
@@ -32,19 +32,35 @@ class RequestIdAndLoggingMiddleware(BaseHTTPMiddleware):
start_time = time.monotonic()
if request.method in ("POST", "PUT", "PATCH") and request.url.path != "/api/v1/auth/sessions":
is_attachment_upload = (
request.method == "POST"
and "/attachments" in request.url.path
and request.url.path.startswith("/api/v1/chats/")
)
ct = request.headers.get("content-type")
if ct:
ct_clean = ct.split(";")[0].strip().lower()
if ct_clean != "application/json":
ct_clean = ct.split(";")[0].strip().lower() if ct else ""
if is_attachment_upload:
if not ct or ct_clean not in ("image/png", "image/jpeg"):
from fastapi import status
from app.errors import make_error_response
from app.schemas import ErrorCode
return make_error_response(
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
f"Неподдерживаемый тип содержимого '{ct}'. Ожидается application/json",
f"Неподдерживаемый тип содержимого '{ct}'. Ожидается image/png или image/jpeg",
request_id,
)
elif ct and ct_clean != "application/json":
from fastapi import status
from app.errors import make_error_response
from app.schemas import ErrorCode
return make_error_response(
status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
ErrorCode.UNSUPPORTED_MEDIA_TYPE,
f"Неподдерживаемый тип содержимого '{ct}'. Ожидается application/json",
request_id,
)
try:
response = await call_next(request)
+85
View File
@@ -0,0 +1,85 @@
from uuid import UUID
from fastapi import APIRouter, Depends, Query, Request, Response, status
from app.dependencies import get_current_user
from app.errors import InvalidRequestError
from app.schemas import AttachmentResponse, UserResponse
from app.storage import storage
router = APIRouter(tags=["attachments"])
def validate_uuid(value: str, field_name: str = "id") -> str:
try:
UUID(value)
return value
except ValueError as exc:
raise InvalidRequestError(f"Поле '{field_name}' не является валидным UUID") from exc
@router.post(
"/api/v1/chats/{chat_id}/attachments",
response_model=AttachmentResponse,
status_code=status.HTTP_201_CREATED,
)
async def upload_attachment(
chat_id: str,
request: Request,
filename: str = Query(..., min_length=1, max_length=255),
current_user: UserResponse = Depends(get_current_user),
) -> AttachmentResponse:
"""Загрузка бинарного вложения в чат."""
valid_chat_id = validate_uuid(chat_id, "chat_id")
content_type = request.headers.get("content-type") or ""
data = await request.body()
return await storage.upload_attachment(
caller_id=current_user.id,
chat_id=valid_chat_id,
filename=filename,
content_type=content_type,
data=data,
)
@router.get(
"/api/v1/attachments/{attachment_id}",
response_model=AttachmentResponse,
status_code=status.HTTP_200_OK,
)
async def get_attachment_metadata(
attachment_id: str,
current_user: UserResponse = Depends(get_current_user),
) -> AttachmentResponse:
"""Получение метаданных вложения."""
valid_att_id = validate_uuid(attachment_id, "attachment_id")
return await storage.get_attachment(
caller_id=current_user.id,
attachment_id=valid_att_id,
)
@router.get(
"/api/v1/attachments/{attachment_id}/content",
status_code=status.HTTP_200_OK,
)
async def download_attachment_content(
attachment_id: str,
variant: str | None = Query(default=None),
current_user: UserResponse = Depends(get_current_user),
) -> Response:
"""Скачивание бинарного содержимого вложения."""
valid_att_id = validate_uuid(attachment_id, "attachment_id")
data, content_type = await storage.get_attachment_content(
caller_id=current_user.id,
attachment_id=valid_att_id,
variant=variant,
)
return Response(
content=data,
media_type=content_type,
headers={
"Content-Length": str(len(data)),
},
)
+1
View File
@@ -47,6 +47,7 @@ async def create_message(
chat_id=valid_id,
text=body.text,
idempotency_key=idempotency_key,
attachment_ids=body.attachment_ids,
)
return msg
+49 -6
View File
@@ -5,7 +5,7 @@ import re
from enum import Enum
from uuid import UUID
from pydantic import BaseModel, ConfigDict, Field, field_validator
from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
def now_utc_iso() -> str:
@@ -134,18 +134,60 @@ class ChatPageResponse(BaseModel):
next_cursor: str | None = None
class VariantResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
name: str
content_type: str
size_bytes: int
width: int
height: int
sha256: str
class AttachmentResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
id: str
chat_id: str
owner_id: str
filename: str
content_type: str
size_bytes: int
sha256: str
status: str = "ready"
variants: list[VariantResponse] = Field(default_factory=list)
error_code: str | None = None
created_at: str
updated_at: str
class CreateMessageRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
text: str = Field(min_length=1, max_length=4000)
text: str = Field(default="", max_length=4000)
attachment_ids: list[str] = Field(default_factory=list, max_length=10)
@field_validator("text")
@field_validator("attachment_ids")
@classmethod
def validate_text(cls, v: str) -> str:
if not v.strip():
raise ValueError("Текст сообщения не может состоять только из пробелов")
def validate_attachment_ids(cls, v: list[str]) -> list[str]:
if len(v) != len(set(v)):
raise ValueError("attachment_ids must contain unique items")
for item in v:
try:
UUID(item)
except ValueError:
raise ValueError(f"Идентификатор вложения '{item}' не является валидным UUID")
return v
@model_validator(mode="after")
def check_text_or_attachment(self) -> CreateMessageRequest:
has_text = bool(self.text and self.text.strip())
has_attachments = bool(self.attachment_ids)
if not has_text and not has_attachments:
raise ValueError("Сообщение должно содержать непустой текст или хотя бы одно вложение")
return self
class MessageResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
@@ -155,6 +197,7 @@ class MessageResponse(BaseModel):
sender_id: str
text: str
created_at: str
attachment_ids: list[str] = Field(default_factory=list)
class MessagePageResponse(BaseModel):
+347 -21
View File
@@ -11,23 +11,39 @@ from typing import Any
import asyncpg
import redis.asyncio as redis
import io
import boto3
import botocore.exceptions
from PIL import Image
from app.auth import generate_session_token, hash_password, verify_password
from app.config import (
CACHE_URL,
DATABASE_URL,
SESSION_TTL_SECONDS,
S3_ENDPOINT,
S3_REGION,
S3_BUCKET,
S3_ACCESS_KEY_ID,
S3_SECRET_ACCESS_KEY,
MAX_UPLOAD_BYTES,
MAX_IMAGE_PIXELS,
)
from app.errors import (
ConflictError,
InvalidRequestError,
NotFoundError,
PayloadTooLargeError,
UnauthorizedError,
UnsupportedMediaTypeError,
)
from app.schemas import (
AttachmentResponse,
ChatResponse,
MessageResponse,
SessionResponse,
UserResponse,
VariantResponse,
now_utc_iso,
)
@@ -71,12 +87,13 @@ class PostgresStorage:
def __init__(self) -> None:
self.pg_pool: asyncpg.Pool | None = None
self.redis_client: redis.Redis | None = None
self.s3_client: Any = None
@asynccontextmanager
async def acquire_conn(self, timeout: float = 5.0):
async def acquire_conn(self, timeout: float = 2.0):
if self.pg_pool is None:
raise asyncpg.InterfaceError("Пул подключений к PostgreSQL не инициализирован")
async with asyncio.timeout(10.0):
async with asyncio.timeout(3.0):
async with self.pg_pool.acquire(timeout=timeout) as conn:
yield conn
@@ -86,18 +103,41 @@ class PostgresStorage:
DATABASE_URL,
min_size=2,
max_size=20,
command_timeout=5.0,
timeout=5.0,
command_timeout=3.0,
timeout=2.0,
)
logger.info("Подключение к Redis: %s", CACHE_URL.split("@")[-1])
self.redis_client = redis.from_url(
CACHE_URL,
decode_responses=True,
socket_connect_timeout=3.0,
socket_timeout=3.0,
socket_connect_timeout=2.0,
socket_timeout=2.0,
)
logger.info("Подключение к S3 (MinIO): %s, bucket: %s", S3_ENDPOINT, S3_BUCKET)
self.s3_client = boto3.client(
"s3",
endpoint_url=S3_ENDPOINT,
aws_access_key_id=S3_ACCESS_KEY_ID,
aws_secret_access_key=S3_SECRET_ACCESS_KEY,
region_name=S3_REGION,
)
await self._ensure_bucket()
async def _ensure_bucket(self) -> None:
def _init():
try:
self.s3_client.head_bucket(Bucket=S3_BUCKET)
except Exception:
try:
self.s3_client.create_bucket(Bucket=S3_BUCKET)
logger.info("Создан приватный бакет S3: %s", S3_BUCKET)
except Exception as e:
logger.warning("Не удалось создать бакет S3 %s: %s", S3_BUCKET, e)
await asyncio.to_thread(_init)
async def disconnect(self) -> None:
if self.pg_pool:
await self.pg_pool.close()
@@ -105,15 +145,18 @@ class PostgresStorage:
if self.redis_client:
await self.redis_client.close()
self.redis_client = None
self.s3_client = None
async def check_health(self) -> bool:
if not self.pg_pool or not self.redis_client:
if not self.pg_pool or not self.redis_client or not self.s3_client:
return False
try:
async with self.acquire_conn() as conn:
await conn.fetchval("SELECT 1")
await self.redis_client.ping()
return True
async with asyncio.timeout(2.5):
async with self.acquire_conn(timeout=1.5) as conn:
await conn.fetchval("SELECT 1")
await self.redis_client.ping()
await asyncio.to_thread(self.s3_client.head_bucket, Bucket=S3_BUCKET)
return True
except Exception as exc:
logger.warning("Ошибка проверки health: %s", exc)
return False
@@ -408,12 +451,22 @@ class PostgresStorage:
# ------------------ Сообщения ------------------
@staticmethod
def compute_request_hash(text: str) -> str:
canonical = json.dumps({"text": text}, sort_keys=True, ensure_ascii=False)
def compute_request_hash(text: str, attachment_ids: list[str] | None = None) -> str:
norm_attachments = [str(x) for x in (attachment_ids or [])]
canonical = json.dumps(
{"attachment_ids": norm_attachments, "text": text},
sort_keys=True,
ensure_ascii=False,
)
return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
async def send_message(
self, caller_id: str, chat_id: str, text: str, idempotency_key: str
self,
caller_id: str,
chat_id: str,
text: str,
idempotency_key: str,
attachment_ids: list[str] | None = None,
) -> MessageResponse:
try:
cid = uuid.UUID(chat_id)
@@ -421,7 +474,8 @@ class PostgresStorage:
except ValueError:
raise NotFoundError("Чат не найден")
req_hash = self.compute_request_hash(text)
norm_attachments = [str(x) for x in (attachment_ids or [])]
req_hash = self.compute_request_hash(text, norm_attachments)
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
@@ -432,10 +486,32 @@ class PostgresStorage:
if not is_member:
raise NotFoundError("Чат не найден")
# Валидация прикрепляемых вложений
att_uuids: list[uuid.UUID] = []
if norm_attachments:
for att_str in norm_attachments:
try:
att_uuids.append(uuid.UUID(att_str))
except ValueError:
raise NotFoundError("Вложение не найдено")
rows = await conn.fetch(
"SELECT id, chat_id, status FROM attachments WHERE id = ANY($1::uuid[])",
att_uuids,
)
if len(rows) != len(att_uuids):
raise NotFoundError("Одно или несколько вложений не найдены")
for r in rows:
if r["chat_id"] != cid:
raise NotFoundError("Вложение принадлежит другому чату")
if r["status"] != "ready":
raise ConflictError("Вложение еще не готово или повреждено")
# 1. Проверяем, обрабатывался ли уже этот idempotency_key
existing = await conn.fetchrow(
"""
SELECT ik.message_id, ik.request_hash, m.text, m.created_at AS msg_created_at
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
FROM idempotency_keys ik
JOIN messages m ON m.id = ik.message_id
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
@@ -452,11 +528,15 @@ class PostgresStorage:
if isinstance(raw_text, (bytes, bytearray))
else str(raw_text)
)
res_attachments = [
str(a) for a in (existing["attachment_ids"] or [])
]
return MessageResponse(
id=str(existing["message_id"]),
chat_id=chat_id,
sender_id=caller_id,
text=msg_text,
attachment_ids=res_attachments,
created_at=_format_dt(existing["msg_created_at"]),
)
else:
@@ -470,13 +550,14 @@ class PostgresStorage:
async with conn.transaction():
await conn.execute(
"""
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
VALUES ($1, $2, $3, $4, $5)
INSERT INTO messages (id, chat_id, sender_id, text, attachment_ids, created_at)
VALUES ($1, $2, $3, $4, $5, $6)
""",
msg_id,
cid,
c_caller,
text_bytes,
att_uuids,
now,
)
await conn.execute(
@@ -492,10 +573,9 @@ class PostgresStorage:
now,
)
except asyncpg.UniqueViolationError:
# Конкурентная вставка из другой реплики выиграла гонку
winner = await conn.fetchrow(
"""
SELECT ik.message_id, ik.request_hash, m.text, m.created_at AS msg_created_at
SELECT ik.message_id, ik.request_hash, m.text, m.attachment_ids, m.created_at AS msg_created_at
FROM idempotency_keys ik
JOIN messages m ON m.id = ik.message_id
WHERE ik.user_id = $1 AND ik.chat_id = $2 AND ik.idempotency_key = $3
@@ -512,11 +592,15 @@ class PostgresStorage:
if isinstance(raw_text, (bytes, bytearray))
else str(raw_text)
)
res_attachments = [
str(a) for a in (winner["attachment_ids"] or [])
]
return MessageResponse(
id=str(winner["message_id"]),
chat_id=chat_id,
sender_id=caller_id,
text=msg_text,
attachment_ids=res_attachments,
created_at=_format_dt(winner["msg_created_at"]),
)
else:
@@ -528,6 +612,7 @@ class PostgresStorage:
chat_id=chat_id,
sender_id=caller_id,
text=text,
attachment_ids=norm_attachments,
created_at=_format_dt(now),
)
@@ -576,7 +661,7 @@ class PostgresStorage:
raise InvalidRequestError("Некорректные параметры курсора")
query = """
SELECT id, chat_id, sender_id, text, created_at
SELECT id, chat_id, sender_id, text, attachment_ids, created_at
FROM messages
WHERE chat_id = $1
AND ($2::timestamptz IS NULL OR (created_at, id) > ($2::timestamptz, $3::uuid))
@@ -599,6 +684,7 @@ class PostgresStorage:
chat_id=str(r["chat_id"]),
sender_id=str(r["sender_id"]),
text=_to_text(r["text"]),
attachment_ids=[str(a) for a in (r["attachment_ids"] or [])],
created_at=_format_dt(r["created_at"]),
)
for r in items_rows
@@ -618,6 +704,246 @@ class PostgresStorage:
return items, next_cursor
# ------------------ Вложения (Attachments) ------------------
async def upload_attachment(
self,
caller_id: str,
chat_id: str,
filename: str,
content_type: str,
data: bytes,
) -> AttachmentResponse:
try:
cid = uuid.UUID(chat_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Чат не найден")
# 1. Валидация filename
if not filename or len(filename) > 255:
raise InvalidRequestError("Некорректная длина имени файла (1-255 символов)")
if any(c in filename for c in ("/", "\\", "\0")) or any(
ord(c) < 32 for c in filename
):
raise InvalidRequestError("Имя файла содержит недопустимые символы")
# 2. Проверка прав (ACL)
async with self.acquire_conn() as conn:
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
cid,
c_caller,
)
if not is_member:
raise NotFoundError("Чат не найден")
# 3. Валидация Content-Type
ct_clean = content_type.split(";")[0].strip().lower()
if ct_clean not in ("image/png", "image/jpeg"):
raise UnsupportedMediaTypeError(
"Поддерживаются только форматы image/png и image/jpeg"
)
# 4. Валидация размера данных
size_bytes = len(data)
if size_bytes > MAX_UPLOAD_BYTES:
raise PayloadTooLargeError(
f"Размер файла {size_bytes} байт превышает допустимый лимит {MAX_UPLOAD_BYTES} байт"
)
# 5. Проверка магических байтов (сигнатуры MIME)
if ct_clean == "image/png":
if not data.startswith(b"\x89PNG\r\n\x1a\n"):
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату PNG")
elif ct_clean == "image/jpeg":
if not (data.startswith(b"\xff\xd8\xff")):
raise UnsupportedMediaTypeError("Содержимое файла не соответствует формату JPEG")
# 6. Проверка разрешения (лимит 40 млн пикселей) и целостности растра
def _check_dimensions():
try:
with Image.open(io.BytesIO(data)) as img:
w, h = img.size
if w * h > MAX_IMAGE_PIXELS:
return False
# Проверяем целостность растровых данных и фильтров строк:
img.load()
return True
except Exception:
raise UnsupportedMediaTypeError("Поврежденное изображение")
try:
within_limits = await asyncio.to_thread(_check_dimensions)
if not within_limits:
raise PayloadTooLargeError(
f"Разрешение изображения превышает лимит {MAX_IMAGE_PIXELS} пикселей"
)
except (UnsupportedMediaTypeError, PayloadTooLargeError):
raise
except Exception as e:
logger.warning("upload_attachment check_dimensions unexpected: %s (%s)", type(e), e)
raise UnsupportedMediaTypeError("Поврежденное изображение") from e
# 7. Генерация идентификаторов
att_id = uuid.uuid4()
s3_key = f"chats/{chat_id}/{att_id}/{filename}"
sha256_hash = hashlib.sha256(data).hexdigest()
now = dt.datetime.now(dt.timezone.utc)
# 8. Загрузка файла в S3
def _put_to_s3():
self.s3_client.put_object(
Bucket=S3_BUCKET,
Key=s3_key,
Body=data,
ContentType=ct_clean,
)
await asyncio.to_thread(_put_to_s3)
# 9. Сохранение метаданных в PostgreSQL (с компенсацией удаления из S3 при ошибке)
try:
async with self.acquire_conn() as conn:
await conn.execute(
"""
INSERT INTO attachments (
id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, s3_key, status, error_code,
created_at, updated_at
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'ready', NULL, $9, $9)
""",
att_id,
cid,
c_caller,
filename,
ct_clean,
size_bytes,
sha256_hash,
s3_key,
now,
)
except Exception as db_err:
logger.error("Ошибка записи метаданных в БД, компенсация S3: %s", db_err)
try:
await asyncio.to_thread(
self.s3_client.delete_object, Bucket=S3_BUCKET, Key=s3_key
)
except Exception as del_err:
logger.error("Ошибка удаления S3 объекта при компенсации: %s", del_err)
raise
return AttachmentResponse(
id=str(att_id),
chat_id=str(cid),
owner_id=str(c_caller),
filename=filename,
content_type=ct_clean,
size_bytes=size_bytes,
sha256=sha256_hash,
status="ready",
variants=[],
error_code=None,
created_at=_format_dt(now),
updated_at=_format_dt(now),
)
async def get_attachment(
self, caller_id: str, attachment_id: str
) -> AttachmentResponse:
try:
aid = uuid.UUID(attachment_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Вложение не найдено")
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT a.id, a.chat_id, a.owner_id, a.filename, a.content_type,
a.size_bytes, a.sha256, a.status, a.error_code, a.created_at, a.updated_at
FROM attachments a
WHERE a.id = $1
""",
aid,
)
if not row:
raise NotFoundError("Вложение не найдено")
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
row["chat_id"],
c_caller,
)
if not is_member:
raise NotFoundError("Вложение не найдено")
return AttachmentResponse(
id=str(row["id"]),
chat_id=str(row["chat_id"]),
owner_id=str(row["owner_id"]),
filename=row["filename"],
content_type=row["content_type"],
size_bytes=row["size_bytes"],
sha256=row["sha256"],
status=row["status"],
variants=[],
error_code=row["error_code"],
created_at=_format_dt(row["created_at"]),
updated_at=_format_dt(row["updated_at"]),
)
async def get_attachment_content(
self, caller_id: str, attachment_id: str, variant: str | None = None
) -> tuple[bytes, str]:
try:
aid = uuid.UUID(attachment_id)
c_caller = uuid.UUID(caller_id)
except ValueError:
raise NotFoundError("Вложение не найдено")
if variant not in (None, "", "original"):
raise NotFoundError("Вариант не найден")
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT a.chat_id, a.content_type, a.s3_key, a.status
FROM attachments a
WHERE a.id = $1
""",
aid,
)
if not row:
raise NotFoundError("Вложение не найдено")
is_member = await conn.fetchval(
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
row["chat_id"],
c_caller,
)
if not is_member:
raise NotFoundError("Вложение не найдено")
if row["status"] != "ready":
raise ConflictError("Вложение повреждено или еще не готово")
s3_key = row["s3_key"]
content_type = row["content_type"]
def _get_from_s3():
resp = self.s3_client.get_object(Bucket=S3_BUCKET, Key=s3_key)
return resp["Body"].read()
try:
data = await asyncio.to_thread(_get_from_s3)
except Exception as e:
logger.error("Ошибка чтения объекта из S3 %s: %s", s3_key, e)
raise NotFoundError("Файл не найден в хранилище") from e
return data, content_type
# Глобальный экземпляр хранилища
storage = PostgresStorage()
+42 -2
View File
@@ -45,7 +45,7 @@ services:
build:
context: .
dockerfile: Dockerfile
image: highload-messenger:lab3
image: highload-messenger:lab4
stop_grace_period: 15s
environment:
APP_HOST: "0.0.0.0"
@@ -57,11 +57,20 @@ services:
SESSION_STORE: "redis"
CACHE_URL: "redis://redis:6379/0"
IDEMPOTENCY_TTL_SECONDS: "86400"
S3_ENDPOINT: "http://minio:9000"
S3_REGION: "us-east-1"
S3_BUCKET: "messenger-attachments"
S3_ACCESS_KEY_ID: "minioadmin"
S3_SECRET_ACCESS_KEY: "minioadmin"
MAX_UPLOAD_BYTES: "10485760"
MAX_IMAGE_PIXELS: "40000000"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
minio:
condition: service_healthy
migration:
condition: service_completed_successfully
healthcheck:
@@ -80,7 +89,7 @@ services:
build:
context: .
dockerfile: Dockerfile
image: highload-messenger:lab3
image: highload-messenger:lab4
stop_grace_period: 15s
environment:
APP_HOST: "0.0.0.0"
@@ -92,11 +101,20 @@ services:
SESSION_STORE: "redis"
CACHE_URL: "redis://redis:6379/0"
IDEMPOTENCY_TTL_SECONDS: "86400"
S3_ENDPOINT: "http://minio:9000"
S3_REGION: "us-east-1"
S3_BUCKET: "messenger-attachments"
S3_ACCESS_KEY_ID: "minioadmin"
S3_SECRET_ACCESS_KEY: "minioadmin"
MAX_UPLOAD_BYTES: "10485760"
MAX_IMAGE_PIXELS: "40000000"
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
minio:
condition: service_healthy
migration:
condition: service_completed_successfully
healthcheck:
@@ -149,6 +167,28 @@ services:
cpus: '0.25'
memory: 256M
minio:
image: cleanstart/minio:0.20260330.001845
user: "0:0"
command: server /data --address ":9000" --console-address ":9001"
environment:
MINIO_ROOT_USER: minioadmin
MINIO_ROOT_PASSWORD: minioadmin
volumes:
- minio_data:/data
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:9000/minio/health/live"]
interval: 2s
timeout: 2s
retries: 5
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
volumes:
pg_data:
redis_data:
minio_data:
+2
View File
@@ -0,0 +1,2 @@
.venv/bin/python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+7
View File
@@ -0,0 +1,7 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab4-api-1-1 highload-messenger:lab4 "python -m uvicorn a…" api-1 6 minutes ago Up About a minute (healthy) 8080/tcp
mtusi2026lab4-api-2-1 highload-messenger:lab4 "python -m uvicorn a…" api-2 6 minutes ago Up 2 minutes (healthy) 8080/tcp
mtusi2026lab4-load_balancer-1 nginx:1.27-alpine "/docker-entrypoint.…" load_balancer 10 minutes ago Up 2 minutes (healthy) 80/tcp, 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
mtusi2026lab4-minio-1 cleanstart/minio:latest "/usr/bin/minio serv…" minio 10 minutes ago Up 2 minutes (healthy)
mtusi2026lab4-postgres-1 postgres:16-alpine "docker-entrypoint.s…" postgres 10 minutes ago Up 2 minutes (healthy) 5432/tcp
mtusi2026lab4-redis-1 redis:7-alpine "docker-entrypoint.s…" redis 10 minutes ago Up 2 minutes (healthy) 6379/tcp
+4
View File
@@ -0,0 +1,4 @@
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 123, "failed_attempts": 0, "first_recovery_seconds": 0.768}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 4,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.015,
"concurrency": 4,
"successful_requests": 9286,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 309.375,
"successful_latency_ms": {
"p50": 7.928,
"p95": 40.768,
"p99": 62.963
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+3
View File
@@ -0,0 +1,3 @@
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+10
View File
@@ -0,0 +1,10 @@
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
x-instance-id: api-2
x-instance-id: api-1
+2
View File
@@ -0,0 +1,2 @@
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
+45
View File
@@ -0,0 +1,45 @@
============================= test session starts ==============================
platform linux -- Python 3.12.15, pytest-9.1.1, pluggy-1.7.0 -- /home/ilyas/projects/labs_highload/mtusi2026lab4/.venv/bin/python3.12
cachedir: .pytest_cache
rootdir: /home/ilyas/projects/labs_highload/mtusi2026lab4
configfile: pytest.ini
plugins: anyio-4.16.0, asyncio-1.4.0
asyncio: mode=Mode.AUTO, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
collecting ... collected 34 items
tests_student/tests.py::test_invalid_json_and_extra_fields PASSED [ 2%]
tests_student/tests.py::test_outsider_chat_access_is_404 PASSED [ 5%]
tests_student/tests.py::test_empty_and_whitespace_message PASSED [ 8%]
tests_student/tests.py::test_duplicate_username_conflict PASSED [ 11%]
tests_student/tests.py::test_wrong_password_and_bad_basic_auth PASSED [ 14%]
tests_student/tests.py::test_logout_and_revocation PASSED [ 17%]
tests_student/tests.py::test_multi_page_cursor_pagination PASSED [ 20%]
tests_student/tests.py::test_concurrency_race_condition PASSED [ 23%]
tests_student/tests.py::test_password_whitespace_rejected PASSED [ 26%]
tests_student/tests.py::test_auth_sessions_with_body_rejected PASSED [ 29%]
tests_student/tests.py::test_unsupported_media_type_415 PASSED [ 32%]
tests_student/tests.py::test_nul_byte_in_strings_handled PASSED [ 35%]
tests_student/tests.py::test_basic_auth_invalid_base64_returns_401 PASSED [ 38%]
tests_student/tests.py::test_cross_chat_cursor_rejected_400 PASSED [ 41%]
tests_student/tests.py::test_utf8_password_support PASSED [ 44%]
tests_student/tests.py::test_health_readiness_and_liveness PASSED [ 47%]
tests_student/tests.py::test_instance_id_header_present PASSED [ 50%]
tests_student/tests.py::test_idempotency_key_validation PASSED [ 52%]
tests_student/tests.py::test_idempotency_replay_and_conflict PASSED [ 55%]
tests_student/tests.py::test_idempotency_acl_check_on_replay PASSED [ 58%]
tests_student/tests.py::test_invalid_cursor_date_returns_400 PASSED [ 61%]
tests_student/tests.py::test_strict_types_and_json_parsing PASSED [ 64%]
tests_student/tests.py::test_chat_creation_with_unknown_participant_is_400 PASSED [ 67%]
tests_student/tests.py::test_password_with_colons_and_utf8 PASSED [ 70%]
tests_student/tests.py::test_keyset_pagination_returns_next_cursor PASSED [ 73%]
tests_student/tests.py::test_attachment_upload_and_download_flow PASSED [ 76%]
tests_student/tests.py::test_attachment_unsupported_media_type_and_magic_bytes PASSED [ 79%]
tests_student/tests.py::test_attachment_filename_validation PASSED [ 82%]
tests_student/tests.py::test_attachment_payload_too_large_and_pixel_bomb PASSED [ 85%]
tests_student/tests.py::test_attachment_acl_and_isolation PASSED [ 88%]
tests_student/tests.py::test_message_linking_attachments PASSED [ 91%]
tests_student/tests.py::test_attachment_orphan_compensation PASSED [ 94%]
tests_student/tests.py::test_private_bucket_outside_api PASSED [ 97%]
tests_student/tests.py::test_concurrent_uploads_memory_limit PASSED [100%]
============================= 34 passed in 37.86s ==============================
+2
View File
@@ -0,0 +1,2 @@
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
+21
View File
@@ -29,11 +29,32 @@ CREATE TABLE IF NOT EXISTS messages (
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
text BYTEA NOT NULL,
attachment_ids UUID[] NOT NULL DEFAULT '{}',
created_at TIMESTAMPTZ NOT NULL
);
ALTER TABLE messages ADD COLUMN IF NOT EXISTS attachment_ids UUID[] NOT NULL DEFAULT '{}';
CREATE INDEX IF NOT EXISTS idx_messages_cursor ON messages (chat_id, created_at ASC, id ASC);
CREATE TABLE IF NOT EXISTS attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
filename VARCHAR(255) NOT NULL,
content_type VARCHAR(50) NOT NULL,
size_bytes BIGINT NOT NULL,
sha256 VARCHAR(64) NOT NULL,
s3_key VARCHAR(512) NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'ready',
error_code VARCHAR(100),
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_attachments_chat_id ON attachments (chat_id, created_at ASC);
CREATE INDEX IF NOT EXISTS idx_attachments_owner_id ON attachments (owner_id);
CREATE TABLE IF NOT EXISTS idempotency_keys (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
+1
View File
@@ -17,6 +17,7 @@ http {
sendfile on;
keepalive_timeout 65;
client_max_body_size 15M;
# DNS-сервер Docker для динамического обновления IP-адресов контейнеров
resolver 127.0.0.11 valid=2s ipv6=off;
+2
View File
@@ -7,3 +7,5 @@ argon2-cffi==23.1.0
pytest==9.1.1
pytest-asyncio==1.4.0
httpx==0.28.1
boto3==1.43.123
pillow==13.0.0
+540 -13
View File
@@ -693,19 +693,6 @@ async def test_strict_types_and_json_parsing(client: httpx.AsyncClient):
assert res_garbage.json()["error"]["code"] == "invalid_request"
@pytest.mark.asyncio
async def test_session_create_rejects_non_empty_body(client: httpx.AsyncClient):
"""POST /api/v1/auth/sessions с непустым телом {"unexpected":true} отклоняется с 400."""
alice = await register_and_login(client, f"no_body_{uuid.uuid4().hex[:6]}")
cred = base64.b64encode(f"{alice['username']}:{alice['password']}".encode()).decode()
res = await client.post(
"/api/v1/auth/sessions",
headers={"Authorization": f"Basic {cred}", "Content-Type": "application/json"},
content='{"unexpected": true}',
)
assert res.status_code == 400
assert res.json()["error"]["code"] == "invalid_request"
@pytest.mark.asyncio
@@ -770,3 +757,543 @@ async def test_keyset_pagination_returns_next_cursor(client: httpx.AsyncClient):
assert data_p2["items"][0]["id"] != data_p1["items"][0]["id"]
@pytest.mark.asyncio
async def test_attachment_upload_and_download_flow(client: httpx.AsyncClient):
"""Проверка полного цикла загрузки и скачивания PNG и JPEG вложений."""
import hashlib
import io
from PIL import Image
alice = await register_and_login(client, "att_a")
bob = await register_and_login(client, "att_b")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Attach Chat", "member_ids": [alice["user"]["id"], bob["user"]["id"]]},
)
assert chat_res.status_code == 201
chat_id = chat_res.json()["id"]
# 1. Загрузка PNG
with open("tests/fixtures/sample.png", "rb") as f:
png_data = f.read()
png_sha = hashlib.sha256(png_data).hexdigest()
up_res = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=sample.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert up_res.status_code == 201, up_res.text
att_png = up_res.json()
assert att_png["chat_id"] == chat_id
assert att_png["owner_id"] == alice["user"]["id"]
assert att_png["filename"] == "sample.png"
assert att_png["content_type"] == "image/png"
assert att_png["size_bytes"] == len(png_data)
assert att_png["sha256"] == png_sha
assert att_png["status"] == "ready"
assert att_png["variants"] == []
assert att_png["error_code"] is None
# 2. Получение метаданных Бобом
meta_res = await client.get(
f"/api/v1/attachments/{att_png['id']}",
headers=bob["headers"],
)
assert meta_res.status_code == 200
assert meta_res.json() == att_png
# 3. Скачивание контента Бобом
down_res = await client.get(
f"/api/v1/attachments/{att_png['id']}/content",
headers=bob["headers"],
)
assert down_res.status_code == 200
assert down_res.headers.get("content-type") == "image/png"
assert down_res.content == png_data
# 4. Загрузка и скачивание JPEG
jpeg_img = Image.new("RGB", (64, 64), color=(255, 128, 0))
jpeg_buf = io.BytesIO()
jpeg_img.save(jpeg_buf, format="JPEG")
jpeg_data = jpeg_buf.getvalue()
up_jpeg = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=orange.jpg",
headers={**alice["headers"], "Content-Type": "image/jpeg"},
content=jpeg_data,
)
assert up_jpeg.status_code == 201
att_jpeg = up_jpeg.json()
assert att_jpeg["content_type"] == "image/jpeg"
assert att_jpeg["size_bytes"] == len(jpeg_data)
down_jpeg = await client.get(
f"/api/v1/attachments/{att_jpeg['id']}/content",
headers=bob["headers"],
)
assert down_jpeg.status_code == 200
assert down_jpeg.headers.get("content-type") == "image/jpeg"
assert down_jpeg.content == jpeg_data
@pytest.mark.asyncio
async def test_attachment_unsupported_media_type_and_magic_bytes(client: httpx.AsyncClient):
"""Проверка отклонения невалидных MIME-типов и поврежденных сигнатур (415)."""
alice = await register_and_login(client, "mime_a")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Mime Chat", "member_ids": [alice["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
# 1. Неподдерживаемый Content-Type: text/plain -> 415
res1 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=test.txt",
headers={**alice["headers"], "Content-Type": "text/plain"},
content=b"plain text",
)
assert res1.status_code == 415
assert res1.json()["error"]["code"] == "unsupported_media_type"
# 2. Неподдерживаемый Content-Type: image/gif -> 415
res2 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=anim.gif",
headers={**alice["headers"], "Content-Type": "image/gif"},
content=b"GIF89a...",
)
assert res2.status_code == 415
assert res2.json()["error"]["code"] == "unsupported_media_type"
# 3. Content-Type image/png, но поврежденные магические байты -> 415
res3 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=fake.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=b"NOT_A_PNG_HEADER_HERE",
)
assert res3.status_code == 415
assert res3.json()["error"]["code"] == "unsupported_media_type"
# 4. Content-Type image/jpeg, но поврежденные магические байты -> 415
res4 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=fake.jpg",
headers={**alice["headers"], "Content-Type": "image/jpeg"},
content=b"NOT_A_JPEG_HEADER_HERE",
)
assert res4.status_code == 415
assert res4.json()["error"]["code"] == "unsupported_media_type"
# 5. Поврежденный JPEG без пиксельных данных (18 байт) -> 415
bad_jpeg_18 = bytes.fromhex("ffd8ffc00008080001000101ffda0002ffd9")
res5 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=bad18.jpg",
headers={**alice["headers"], "Content-Type": "image/jpeg"},
content=bad_jpeg_18,
)
assert res5.status_code == 415
assert res5.json()["error"]["code"] == "unsupported_media_type"
# 6. Обрезанный PNG без пиксельных данных (33 байта) -> 415
bad_png_33 = bytes.fromhex("89504e470d0a1a0a0000000d4948445200000001000000010802000000907753de")
res6 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=bad33.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=bad_png_33,
)
assert res6.status_code == 415
assert res6.json()["error"]["code"] == "unsupported_media_type"
@pytest.mark.asyncio
async def test_attachment_filename_validation(client: httpx.AsyncClient):
"""Проверка валидации имени файла (path traversal, длина, спецсимволы -> 400)."""
alice = await register_and_login(client, "fname_a")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Filename Chat", "member_ids": [alice["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
with open("tests/fixtures/sample.png", "rb") as f:
valid_png = f.read()
headers = {**alice["headers"], "Content-Type": "image/png"}
# 1. Path traversal со слешем /
res_slash = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=../../etc/passwd",
headers=headers,
content=valid_png,
)
assert res_slash.status_code == 400
assert res_slash.json()["error"]["code"] == "invalid_request"
# 2. Path traversal с обратным слешем \
res_bslash = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=..\\boot.ini",
headers=headers,
content=valid_png,
)
assert res_bslash.status_code == 400
assert res_bslash.json()["error"]["code"] == "invalid_request"
# 3. Символ перевода строки \n
res_nl = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=file%0Aname.png",
headers=headers,
content=valid_png,
)
assert res_nl.status_code == 400
assert res_nl.json()["error"]["code"] == "invalid_request"
# 4. Превышение 255 символов
long_name = "a" * 256 + ".png"
res_long = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename={long_name}",
headers=headers,
content=valid_png,
)
assert res_long.status_code == 400
assert res_long.json()["error"]["code"] == "invalid_request"
# 5. Пустое имя файла
res_empty = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=",
headers=headers,
content=valid_png,
)
assert res_empty.status_code == 400
@pytest.mark.asyncio
async def test_attachment_payload_too_large_and_pixel_bomb(client: httpx.AsyncClient):
"""Проверка лимита размера файла (>10 MiB) и бомбы декомпрессии (>40M px) -> 413."""
import io
from PIL import Image
alice = await register_and_login(client, "large_a")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Large Chat", "member_ids": [alice["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
# 1. Размер файла более 10 MiB (10 * 1024 * 1024 + 10 байт) -> 413
oversize_bytes = b"\x89PNG\r\n\x1a\n" + b"\x00" * (10 * 1024 * 1024 + 10)
res_oversize = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=huge.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=oversize_bytes,
)
assert res_oversize.status_code == 413
assert res_oversize.json()["error"]["code"] == "payload_too_large"
# 2. Бомба декомпрессии (10000x5000 = 50 млн пикселей > 40 млн пикселей) -> 413
bomb_img = Image.new("L", (10000, 5000), color=0)
bomb_buf = io.BytesIO()
bomb_img.save(bomb_buf, format="PNG")
bomb_bytes = bomb_buf.getvalue()
res_bomb = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=pixel_bomb.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=bomb_bytes,
)
assert res_bomb.status_code == 413
assert res_bomb.json()["error"]["code"] == "payload_too_large"
@pytest.mark.asyncio
async def test_attachment_acl_and_isolation(client: httpx.AsyncClient):
"""Проверка строгой изоляции: посторонний пользователь получает 404 на все операции."""
alice = await register_and_login(client, "acl_a")
eve = await register_and_login(client, "acl_eve")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Private Chat", "member_ids": [alice["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
with open("tests/fixtures/sample.png", "rb") as f:
png_data = f.read()
# 1. Посторонний пытается загрузить вложение в чужой чат -> 404
res_eve_up = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=sample.png",
headers={**eve["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert res_eve_up.status_code == 404
assert res_eve_up.json()["error"]["code"] == "not_found"
# Алиса загружает файл
res_alice_up = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=sample.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert res_alice_up.status_code == 201
att_id = res_alice_up.json()["id"]
# 2. Посторонний пытается запросить метаданные -> 404
res_eve_meta = await client.get(
f"/api/v1/attachments/{att_id}",
headers=eve["headers"],
)
assert res_eve_meta.status_code == 404
# 3. Посторонний пытается скачать контент -> 404
res_eve_down = await client.get(
f"/api/v1/attachments/{att_id}/content",
headers=eve["headers"],
)
assert res_eve_down.status_code == 404
# 4. Несуществующий attachment ID -> 404
random_uuid = str(uuid.uuid4())
res_not_found = await client.get(
f"/api/v1/attachments/{random_uuid}",
headers=alice["headers"],
)
assert res_not_found.status_code == 404
# 5. Невалидный UUID -> 400
res_bad_uuid = await client.get(
"/api/v1/attachments/not-a-uuid",
headers=alice["headers"],
)
assert res_bad_uuid.status_code == 400
@pytest.mark.asyncio
async def test_message_linking_attachments(client: httpx.AsyncClient):
"""Проверка связывания сообщений и вложений: пустой текст с вложением, чужие вложения, лимит 10."""
alice = await register_and_login(client, "msg_att_a")
bob = await register_and_login(client, "msg_att_b")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Msg Attach Chat", "member_ids": [alice["user"]["id"], bob["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
chat2_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Chat 2", "member_ids": [alice["user"]["id"]]},
)
chat2_id = chat2_res.json()["id"]
with open("tests/fixtures/sample.png", "rb") as f:
png_data = f.read()
# Загружаем вложение в chat 1
up1 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=sample.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
att1_id = up1.json()["id"]
# Загружаем вложение в chat 2
up2 = await client.post(
f"/api/v1/chats/{chat2_id}/attachments?filename=chat2.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
att2_id = up2.json()["id"]
# 1. Сообщение с пустым текстом, но с вложением -> 201
msg1_res = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex},
json={"text": "", "attachment_ids": [att1_id]},
)
assert msg1_res.status_code == 201, msg1_res.text
msg1 = msg1_res.json()
assert msg1["text"] == ""
assert msg1["attachment_ids"] == [att1_id]
# 2. Сообщение с пустым текстом И без вложений -> 400
msg2_res = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex},
json={"text": "", "attachment_ids": []},
)
assert msg2_res.status_code == 400
# 3. Прикрепление вложения из другого чата -> 404
msg3_res = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex},
json={"text": "Hello", "attachment_ids": [att2_id]},
)
assert msg3_res.status_code == 404
# 4. Прикрепление несуществующего вложения -> 404
fake_uuid = str(uuid.uuid4())
msg4_res = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex},
json={"text": "Hello", "attachment_ids": [fake_uuid]},
)
assert msg4_res.status_code == 404
# 5. Более 10 вложений -> 400
eleven_uuids = [str(uuid.uuid4()) for _ in range(11)]
msg5_res = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex},
json={"text": "Hello", "attachment_ids": eleven_uuids},
)
assert msg5_res.status_code == 400
@pytest.mark.asyncio
async def test_attachment_orphan_compensation(client: httpx.AsyncClient):
"""
Проверка компенсации сиротских объектов S3 при сбое БД (критерий оценки 4):
1. Через docker compose exec в PostgreSQL создаём триггер, вызывающий сбой при записи файла 'orphan_sim_fail.png'.
2. Выполняем POST вложения 'orphan_sim_fail.png'.
S3 PUT проходит успешно, но при вставке в PostgreSQL возникает ошибка.
Сервер перехватывает ошибку, вызывает s3_client.delete_object и возвращает 500.
3. Проверяем, что сиротский объект удалён из S3 (через проверку через api-1/boto3).
4. Удаляем триггер из PostgreSQL.
"""
import subprocess
alice = await register_and_login(client, "orph_a")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Orphan Chat", "member_ids": [alice["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
setup_sql = """
CREATE OR REPLACE FUNCTION trg_sim_fail() RETURNS TRIGGER AS $$
BEGIN
IF NEW.filename = 'orphan_sim_fail.png' THEN
RAISE EXCEPTION 'Simulated DB failure for orphan compensation test';
END IF;
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
DROP TRIGGER IF EXISTS check_orphan_sim ON attachments;
CREATE TRIGGER check_orphan_sim BEFORE INSERT ON attachments FOR EACH ROW EXECUTE FUNCTION trg_sim_fail();
"""
cmd = ["docker", "compose", "exec", "-T", "postgres", "psql", "-U", "postgres", "-d", "messenger", "-c", setup_sql]
sub_res = subprocess.run(cmd, capture_output=True, text=True)
assert sub_res.returncode == 0, f"Ошибка создания триггера: {sub_res.stderr}"
try:
with open("tests/fixtures/sample.png", "rb") as f:
png_data = f.read()
res = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=orphan_sim_fail.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert res.status_code in (500, 503)
check_py = f"""
import boto3
s3 = boto3.client('s3', endpoint_url='http://minio:9000', aws_access_key_id='minioadmin', aws_secret_access_key='minioadmin')
res = s3.list_objects_v2(Bucket='messenger-attachments', Prefix='chats/{chat_id}/')
keys = [o['Key'] for o in res.get('Contents', [])]
found = any('orphan_sim_fail.png' in k for k in keys)
print('FOUND' if found else 'NOT_FOUND')
"""
cmd_s3 = ["docker", "compose", "exec", "-T", "api-1", "python", "-c", check_py]
s3_res = subprocess.run(cmd_s3, capture_output=True, text=True)
assert s3_res.returncode == 0
assert "NOT_FOUND" in s3_res.stdout, f"Сиротский объект остался в S3! Вывод: {s3_res.stdout}"
finally:
cleanup_sql = """
DROP TRIGGER IF EXISTS check_orphan_sim ON attachments;
DROP FUNCTION IF EXISTS trg_sim_fail();
"""
cmd_clean = ["docker", "compose", "exec", "-T", "postgres", "psql", "-U", "postgres", "-d", "messenger", "-c", cleanup_sql]
subprocess.run(cmd_clean, capture_output=True, text=True)
@pytest.mark.asyncio
async def test_private_bucket_outside_api(client: httpx.AsyncClient):
"""
Проверка закрытости S3 бакета вне API (критерий оценки 4):
1. Порты MinIO (9000/9001) не проброшены на хост наружу -> прямое подключение отклоняется.
2. Балансировщик Nginx маршрутизирует только /api/ и /health/, запрос к S3 напрямую через LB возвращает 404.
3. Неаутентифицированный запрос на скачивание вложения возвращает 401 Unauthorized.
"""
direct_conn_failed = False
try:
async with httpx.AsyncClient() as raw_client:
await raw_client.get("http://localhost:9000", timeout=1.0)
except httpx.ConnectError:
direct_conn_failed = True
assert direct_conn_failed, "Порт 9000 MinIO не должен быть доступен с хоста!"
res_lb_s3 = await client.get("/messenger-attachments/")
assert res_lb_s3.status_code == 404
random_id = str(uuid.uuid4())
res_anon = await client.get(f"/api/v1/attachments/{random_id}/content")
assert res_anon.status_code == 401
@pytest.mark.asyncio
async def test_concurrent_uploads_memory_limit(client: httpx.AsyncClient):
"""
Проверка конкурентной загрузки ≥10 файлов с контролем потребления RAM (критерий оценки 4):
1. Создаем пользователя и чат.
2. Запускаем параллельную загрузку 10 изображений через asyncio.gather.
3. Измеряем память контейнеров API через docker stats.
4. Все 10 загрузок завершаются успехом (201 Created), память остаётся в стабильных границах.
"""
import subprocess
alice = await register_and_login(client, "conc_a")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Concurrent Uploads Chat", "member_ids": [alice["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
with open("tests/fixtures/sample.png", "rb") as f:
png_data = f.read()
async def upload_single(idx: int):
return await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=concurrent_{idx}.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
tasks = [upload_single(i) for i in range(10)]
responses = await asyncio.gather(*tasks)
for resp in responses:
assert resp.status_code == 201
data = resp.json()
assert data["status"] == "ready"
assert data["size_bytes"] == len(png_data)
stats_cmd = [
"docker", "stats", "--no-stream", "--format", "{{.Name}}: {{.MemUsage}}",
"mtusi2026lab4-api-1-1", "mtusi2026lab4-api-2-1"
]
stats_res = subprocess.run(stats_cmd, capture_output=True, text=True)
assert stats_res.returncode == 0