feat: ЛР5 - асинхронная обработка вложений, RabbitMQ и transactional outbox

This commit is contained in:
Ильяс
2026-11-20 17:03:59 +03:00
parent 7cfc6d40a6
commit 7d06ecf230
27 changed files with 1536 additions and 103 deletions
+1 -1
View File
@@ -32,7 +32,7 @@ test-failover:
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-student:
BASE_URL="$(BASE_URL)" pytest tests_student/ -v
BASE_URL="$(BASE_URL)" $(if $(wildcard .venv/bin/pytest),.venv/bin/pytest,pytest) tests_student/ -v
up:
docker compose up -d --build
+162 -16
View File
@@ -1,37 +1,183 @@
# Отчёт — лабораторная 5
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Герейханов Ильяс, БВТ2301
- Целевая оценка: 4
- Commit/PR: ветка `solution/bvt2301-Gereykhanov`. PR: `ЛР 5 — БВТ2301 — Герейханов — на 4`
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI, Uvicorn, PostgreSQL 16, Redis 7, Nginx 1.27, MinIO, RabbitMQ 3.13, Pillow, boto3, asyncpg, argon2-cffi, Pydantic, Pytest, Docker Compose, AWS S3 API, OpenAPI 3.1.0. ИИ использовался для подготовки шаблонов очередей и расширения тестов 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 контейнеры (`api-1`, `api-2`): `python:3.12-slim`
- Worker фоновый процесс: `python:3.12-slim`
- Брокер сообщений: `rabbitmq:3.13-alpine`
- 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 15 --concurrency 4 --output evidence/load.json
# Команда перезапуска задачи из DLQ:
docker compose exec api-1 python -m app.cli replay <attachment_id>
```
4. **Остановка и очистка:**
```sh
# Остановка с сохранением данных volumes
docker compose down
# Остановка с удалением volumes
docker compose down -v
```
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- **Топология процессов и распределение ролей:**
- **Клиент** отправляет HTTP-запросы в единую точку входа **Nginx Load Balancer** на порт `8080`.
- **Nginx** балансирует запросы между двумя репликами API (`api-1` и `api-2`) по схеме Round-Robin.
- Реплики API работают в stateless-режиме, обращаются к общим **PostgreSQL**, **Redis**, **MinIO S3** и **RabbitMQ**.
- Фоновый процесс **OutboxRelay** считывает задания из `outbox_jobs` и публикует их в RabbitMQ с Publisher Confirms.
- Сервис **worker** забирает задачи из RabbitMQ (`prefetch_count=4`), генерирует варианты через Pillow и сохраняет в MinIO.
- Отдельный контейнер **migration** применяет `init.sql` перед запуском API-реплик и воркера.
- **Хранилища данных и источник истины:**
- **PostgreSQL:** источник истины для пользователей, чатов, сообщений, метаданных вложений в `attachments` и задач в `outbox_jobs`.
- **MinIO S3:** хранилище бинарного контента в бакете `messenger-attachments`. Стейджинг: `staging/{attachment_id}/{filename}`, оригинал: `chats/{chat_id}/{attachment_id}/original`, варианты: `chats/{chat_id}/{attachment_id}/{variant_name}`.
- **Redis:** сессионный кэш Bearer-токенов с TTL 3600 с и кэш ключей идемпотентности.
- **RabbitMQ:** брокер сообщений (direct exchange `messenger.attachments`, очередь `messenger.attachments.jobs`, DLX/DLQ).
- **Что перенесено из лабы 4:**
- Nginx с Round-robin 50/50, заголовками `X-Request-Id`, `X-Instance-Id` и быстрым переключением при сбоях.
- Единое хранилище сессий в Redis.
- Идемпотентность отправки сообщений по заголовку `Idempotency-Key`.
- Keyset-пагинация сообщений по индексу `(created_at, id)`.
- Изоляция MinIO без проброса портов на хост.
- Проверка MIME по содержимому, декодирование растра `img.load()` до принятия файла и защита от пиксельных бомб.
- **Асинхронная загрузка и Transactional Outbox:**
- Загрузка вложения (`POST /api/v1/chats/{chat_id}/attachments`) сохраняет поток в staging S3 и в одной транзакции PostgreSQL создает запись в `attachments` (`status='queued'`) и задачу в `outbox_jobs`. Ответ клиенту возвращается с кодом `202 Accepted`.
- Ликвидирован разрыв COMMIT/publish: задача сохранена в БД до публикации. `OutboxRelay` считывает её через `FOR UPDATE SKIP LOCKED` и отправляет в RabbitMQ с подтверждением брокера (`publisher_confirms=True`).
- **Обработка вложений воркером и Pillow:**
- Воркер атомарно переводит статус в `processing` (идемпотентность по `attachment_id`) и скачивает staging-файл.
- Синхронная обработка ограничена дедлайном 30 секунд для предотвращения зависания живого воркера.
- Генерируются 3 варианта: `thumbnail` (JPEG, 256×256 без апскейла, альфа на белый фон), `crop` (JPEG, 128×128), `optimized` (WebP, до 1280×1280).
- Готовые файлы пишутся в S3, статус обновляется в `ready`, после чего staging удаляется.
- **Отказоустойчивость, DLQ и Watchdog:**
- Временные ошибки повторяются до 5 раз с экспоненциальным backoff и jitter.
- Неустранимые сбои или исчерпание попыток переводят вложение в `failed`, а сообщение уходит в `messenger.attachments.dlq`.
- Фоновый watchdog сбрасывает зависшие в `processing` задачи старше 60 секунд обратно в `queued`.
- Для ручного перезапуска failed-задач из DLQ реализован CLI: `python -m app.cli replay <attachment_id>`.
- **Связывание с сообщениями и скачивание контента:**
- В сообщения разрешено прикреплять вложения со статусом `queued` и `processing`. Вложения со статусом `failed` отклоняются с кодом 409.
- Скачивание через `GET /api/v1/attachments/{id}/content?variant=...` возвращает запрошенный вариант (`original`, `thumbnail`, `crop`, `optimized`). До перехода в статус ready возвращается 409. Посторонний получает 404.
## Доказательства критериев
| Критерий 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: lab5 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` | Стек перезапущен, токен, сообщения, вложения и outbox сохранены | [`evidence/persistence_test.log`](evidence/persistence_test.log) |
| Отказ API-реплики под нагрузкой | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | Восстановление записи за **0.87 с**, 116 успешных запросов, 0 сбоев | [`evidence/failover_test.log`](evidence/failover_test.log) |
| Асинхронная загрузка | `make test-student` | POST возвращает 202 `queued`, воркер генерирует варианты и переводит в `ready` | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Блокировка скачивания до ready | `make test-student` | Запрос контента для queued или processing возвращает 409 Conflict | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Привязка вложений к сообщениям | `make test-student` | Queued/processing прикрепляются успешно, failed отклоняются с 409 Conflict | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Отсечение битых файлов на входе | `make test-student` | Усеченный и поврежденный PNG отклоняется с `415` до принятия в очередь | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Все собственные тесты | `make test-student` | **35 тестов проходят**: асинхронный цикл, RabbitMQ, outbox, варианты, идемпотентность | [`evidence/student_tests.log`](evidence/student_tests.log) |
| Статусы и изоляция контейнеров | `docker compose ps` | Все 8 сервисов healthy, API и MinIO не открывают порты на хост | [`evidence/docker_services.log`](evidence/docker_services.log) |
| Нагрузочный тест | `python3 tests/load.py` | **318.1 RPS**, p50 = 6.6 ms, p95 = 59.5 ms, p99 = 80.6 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`.
- **Параметры:** длительность 15 секунд, 4 параллельных потока.
- **Результаты нагрузки (`evidence/load.json`):**
```json
{
"lab": 5,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 15.0,
"elapsed_seconds": 15.007,
"concurrency": 4,
"successful_requests": 4773,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 318.051,
"successful_latency_ms": {
"p50": 6.603,
"p95": 59.542,
"p99": 80.594
}
}
```
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка воркера во время загрузки | API возвращает 202 Accepted, файл прикрепляется к сообщению, скачивание вариантов возвращает 409 Conflict | Все запросы API успешны; после повторного запуска воркера статус автоматически стал `ready`, сгенерированы все 3 варианта | потерь данных нет, обработка возобновилась сразу после старта воркера |
| Остановка одной реплики API | Nginx переключает трафик на живую реплику, продолжение записи без дубликатов | 116 успешных записей во время остановки, 0 ошибок, переключение за 0.87 с | 0.87 сек, потерь данных нет |
| Рестарт всего стека при активной сессии | Сохранение подтверждённых данных в Postgres, токенов сессий в Redis, очереди в RabbitMQ и файлов в MinIO | Контейнеры перезапущены, токен валиден, история сообщений, очереди и файлы сохранены | Восстановление около 5 сек, потерь данных нет |
| Загрузка декомпрессионной бомбы | Отклонение запроса с кодом 413 `payload_too_large` без исчерпания RAM воркера | Запрос отклонен мгновенно по метаданным IHDR без распаковки растра | Мгновенно (< 2 мс) |
| Загрузка поврежденного PNG файла | Отклонение с кодом 415 `unsupported_media_type` до постановки в очередь | `img.load()` на входе API обнаруживает повреждение растра и возвращает 415 | Мгновенно |
| Загрузка изображения с нечетными пропорциями | Формирование thumbnail с размерами 256×160 с округлением вниз | Метаданные и растр thumbnail имеют точные габариты 256×160 | Мгновенно |
| Попытка скачивания незавершенного вложения | Возврат 409 Conflict | Клиент получает 409 Conflict до момента перехода в статус ready | Мгновенно |
| Попытка доступа к метаданным или контенту посторонним пользователем | Защита приватности: возврат 404 Not Found без утечки факта существования | Посторонний получает 404 на `GET /attachments/{id}` и `/content` | Мгновенно |
| Попытка передачи опасного имени файла | Отклонение запроса с кодом 400 `invalid_request` | Валидатор отклоняет некорректное имя до обращения к хранилищу | Мгновенно |
| Аварийная остановка воркера посреди обработки задачи | Watchdog перехватывает задачу по истечению lease 60 секунд и сбрасывает статус в `queued` | Задача безопасно подхватывается после рестарта воркера и доходит до ready | Восстановление в пределах lease timeout |
## Ограничения и следующие шаги
## Ограничения
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Какие отказы выдерживаются и какие нет:**
1. *Выдерживаются:*
- Внезапная остановка любой одной API-реплики под нагрузкой: балансировщик Nginx переключает входящие запросы на оставшуюся реплику.
- Полный рестарт стека: все подтверждённые данные, активные токены, задачи в Outbox и файлы в S3 сохраняются благодаря volumes.
- Аварийная остановка воркера: необработанные задачи сохраняются в очередях RabbitMQ, зависшие в `processing` задачи перехватываются по lease timeout.
- Зависание синхронных операций воркера: прерываются общим дедлайном `asyncio.timeout`.
- Временные сетевые сбои: механизм retry с экспоненциальным backoff и jitter.
- Атаки декомпрессионными бомбами, поврежденными файлами и опасными именами.
2. *Не выдерживаются:*
- Одновременное падение обеих API-реплик (HTTP 502 Bad Gateway).
- Падение единственного экземпляра PostgreSQL, Redis, MinIO или RabbitMQ.
- Удаление через `docker compose down -v`.
- **Учебные упрощения:**
1. Nginx, PostgreSQL, Redis, MinIO и RabbitMQ запущены в единственном экземпляре.
2. Скачивание контента реализовано через чтение из S3 и проксирование байтов API-репликой.
+107
View File
@@ -0,0 +1,107 @@
from __future__ import annotations
import json
import logging
from typing import Any
import aio_pika
from aio_pika import DeliveryMode, ExchangeType
from app.config import BROKER_URL
logger = logging.getLogger("messenger.broker")
EXCHANGE_NAME = "messenger.attachments"
QUEUE_NAME = "messenger.attachments.jobs"
ROUTING_KEY = "attachment.process"
DLX_NAME = "messenger.attachments.dlx"
DLQ_NAME = "messenger.attachments.dlq"
DL_ROUTING_KEY = "attachment.dead"
async def setup_broker_topology(channel: aio_pika.abc.AbstractChannel) -> tuple[aio_pika.abc.AbstractExchange, aio_pika.abc.AbstractQueue]:
"""Настраивает durable exchange, durable очереди и связку с Dead Letter Exchange."""
# 1. Dead Letter Exchange и Dead Letter Queue
dlx = await channel.declare_exchange(
DLX_NAME,
type=ExchangeType.DIRECT,
durable=True,
)
dlq = await channel.declare_queue(
DLQ_NAME,
durable=True,
)
await dlq.bind(dlx, routing_key=DL_ROUTING_KEY)
# 2. Основной Exchange и Queue с dead-lettering
exchange = await channel.declare_exchange(
EXCHANGE_NAME,
type=ExchangeType.DIRECT,
durable=True,
)
queue = await channel.declare_queue(
QUEUE_NAME,
durable=True,
arguments={
"x-dead-letter-exchange": DLX_NAME,
"x-dead-letter-routing-key": DL_ROUTING_KEY,
},
)
await queue.bind(exchange, routing_key=ROUTING_KEY)
return exchange, queue
class BrokerPublisher:
"""Отказоустойчивый издатель сообщений в RabbitMQ с поддержкой Publisher Confirms."""
def __init__(self, broker_url: str = BROKER_URL) -> None:
self.broker_url = broker_url
self._connection: aio_pika.abc.AbstractRobustConnection | None = None
self._channel: aio_pika.abc.AbstractChannel | None = None
self._exchange: aio_pika.abc.AbstractExchange | None = None
async def get_exchange(self) -> aio_pika.abc.AbstractExchange:
if self._exchange is None or self._channel is None or self._channel.is_closed:
if self._connection is None or self._connection.is_closed:
self._connection = await aio_pika.connect_robust(self.broker_url)
self._channel = await self._connection.channel(publisher_confirms=True)
self._exchange, _ = await setup_broker_topology(self._channel)
return self._exchange
async def publish_job(self, job_dict: dict[str, Any]) -> bool:
try:
exchange = await self.get_exchange()
payload = json.dumps(job_dict, ensure_ascii=False).encode("utf-8")
message = aio_pika.Message(
body=payload,
delivery_mode=DeliveryMode.PERSISTENT,
content_type="application/json",
message_id=str(job_dict.get("job_id", "")),
)
await exchange.publish(
message,
routing_key=ROUTING_KEY,
mandatory=True,
)
return True
except Exception as exc:
logger.error("Failed to publish job to broker: %s", exc)
self._exchange = None
self._channel = None
return False
async def close(self) -> None:
try:
if self._channel and not self._channel.is_closed:
await self._channel.close()
if self._connection and not self._connection.is_closed:
await self._connection.close()
except Exception:
pass
self._exchange = None
self._channel = None
self._connection = None
publisher = BrokerPublisher()
+120
View File
@@ -0,0 +1,120 @@
from __future__ import annotations
import argparse
import asyncio
import json
import logging
import sys
import uuid
import asyncpg
from app.broker import publisher
from app.config import DATABASE_URL
from app.schemas import now_utc_iso
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
logger = logging.getLogger("messenger.cli")
async def replay_attachment(attachment_id_str: str) -> None:
"""Безопасный операторский replay задачи из failed в queued."""
try:
att_id = uuid.UUID(attachment_id_str)
except ValueError:
logger.error("Invalid UUID: %s", attachment_id_str)
sys.exit(1)
pool = await asyncpg.create_pool(dsn=DATABASE_URL)
assert pool is not None
async with pool.acquire() as conn:
row = await conn.fetchrow(
"SELECT id, status, chat_id, filename FROM attachments WHERE id = $1",
att_id,
)
if not row:
logger.error("Attachment %s not found in DB", att_id)
await pool.close()
sys.exit(1)
if row["status"] == "ready":
logger.warning(
"Attachment %s is already 'ready'. Replay will not re-execute successful job.",
att_id,
)
await pool.close()
return
# Переводим в queued и создаем новое задание
new_job_id = uuid.uuid4()
now_iso = now_utc_iso()
job_payload = {
"schema_version": 1,
"job_id": str(new_job_id),
"type": "attachment.process.v1",
"attachment_id": str(att_id),
"pipeline_version": 1,
"attempt": 1,
"created_at": now_iso,
}
async with conn.transaction():
await conn.execute(
"""
UPDATE attachments
SET status = 'queued',
error_code = NULL,
processing_started_at = NULL,
processing_worker_id = NULL,
updated_at = NOW()
WHERE id = $1
""",
att_id,
)
await conn.execute(
"""
INSERT INTO outbox_jobs (
job_id, attachment_id, event_type, payload, status, attempt, created_at, updated_at
)
VALUES ($1, $2, 'attachment.process.v1', $3::jsonb, 'pending', 1, NOW(), NOW())
""",
new_job_id,
att_id,
json.dumps(job_payload),
)
# Публикуем напрямую в брокер
published = await publisher.publish_job(job_payload)
if published:
await conn.execute(
"UPDATE outbox_jobs SET status = 'published' WHERE job_id = $1",
new_job_id,
)
logger.info("Attachment %s successfully replayed with new job %s", att_id, new_job_id)
else:
logger.warning(
"Attachment %s queued in outbox_jobs, will be dispatched by outbox relay",
att_id,
)
await publisher.close()
await pool.close()
def main() -> None:
parser = argparse.ArgumentParser(description="Operator CLI for messenger")
subparsers = parser.add_subparsers(dest="command")
replay_parser = subparsers.add_parser("replay", help="Replay a failed attachment")
replay_parser.add_argument("attachment_id", help="UUID of the attachment to replay")
args = parser.parse_args()
if args.command == "replay":
asyncio.run(replay_attachment(args.attachment_id))
else:
parser.print_help()
if __name__ == "__main__":
main()
+9
View File
@@ -42,3 +42,12 @@ S3_ACCESS_KEY_ID: str = _get_val("S3_ACCESS_KEY_ID", "S3_ACCESS_KEY_ID_FILE", "m
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"))
BROKER_URL: str = _get_val(
"BROKER_URL",
"BROKER_URL_FILE",
"amqp://messenger:messenger_broker_pass@broker:5672/",
)
WORKER_CONCURRENCY: int = int(os.getenv("WORKER_CONCURRENCY", "4"))
WORKER_LEASE_SECONDS: int = int(os.getenv("WORKER_LEASE_SECONDS", "60"))
MAX_JOB_RETRIES: int = int(os.getenv("MAX_JOB_RETRIES", "5"))
+132
View File
@@ -0,0 +1,132 @@
from __future__ import annotations
import hashlib
import io
import math
from typing import TypedDict
from PIL import Image, ImageOps
MAX_IMAGE_PIXELS = 40_000_000
Image.MAX_IMAGE_PIXELS = MAX_IMAGE_PIXELS
class GeneratedVariant(TypedDict):
name: str
content_type: str
data: bytes
size_bytes: int
width: int
height: int
sha256: str
def _calculate_contained_dimensions(orig_w: int, orig_h: int, max_w: int, max_h: int) -> tuple[int, int]:
"""Вычисляет размеры, вписанные в max_w x max_h с сохранением пропорций,
без увеличения маленьких исходников, с округлением вниз (floor) и минимумом 1px."""
if orig_w <= max_w and orig_h <= max_h:
return orig_w, orig_h
scale = min(max_w / orig_w, max_h / orig_h)
new_w = max(1, math.floor(orig_w * scale))
new_h = max(1, math.floor(orig_h * scale))
return new_w, new_h
def _flatten_to_rgb(img: Image.Image) -> Image.Image:
"""Накладывает альфа-канал на белый фон для форматов без поддержки прозрачности (JPEG)."""
if img.mode in ("RGBA", "LA") or (img.mode == "P" and "transparency" in img.info):
rgba = img.convert("RGBA")
background = Image.new("RGB", rgba.size, (255, 255, 255))
background.paste(rgba, mask=rgba.split()[3])
return background
if img.mode != "RGB":
return img.convert("RGB")
return img
def generate_thumbnail(img: Image.Image) -> tuple[bytes, int, int]:
"""Генерирует thumbnail: вписан в 256x256 без апскейла, JPEG, alpha на белый фон.
Размеры рассчитываются строго с округлением вниз (floor) и минимумом 1px.
Возвращает (jpeg_bytes, width, height).
"""
target_w, target_h = _calculate_contained_dimensions(img.width, img.height, 256, 256)
if (img.width, img.height) != (target_w, target_h):
thumb = img.resize((target_w, target_h), Image.Resampling.LANCZOS)
else:
thumb = img.copy()
rgb = _flatten_to_rgb(thumb)
buf = io.BytesIO()
rgb.save(buf, format="JPEG", quality=85, optimize=True)
data = buf.getvalue()
return data, rgb.width, rgb.height
def generate_crop(img: Image.Image) -> tuple[bytes, int, int]:
"""Генерирует crop: центрированный квадрат 128x128 (с апскейлом для меньших), JPEG.
Возвращает (jpeg_bytes, width, height).
"""
cropped = ImageOps.fit(img, (128, 128), method=Image.Resampling.LANCZOS)
rgb = _flatten_to_rgb(cropped)
buf = io.BytesIO()
rgb.save(buf, format="JPEG", quality=85, optimize=True)
data = buf.getvalue()
return data, rgb.width, rgb.height
def generate_optimized(img: Image.Image) -> tuple[bytes, int, int]:
"""Генерирует optimized: WebP, вписан в 1280x1280 без апскейла, удаление EXIF.
Размеры рассчитываются строго с округлением вниз (floor) и минимумом 1px.
Возвращает (webp_bytes, width, height).
"""
target_w, target_h = _calculate_contained_dimensions(img.width, img.height, 1280, 1280)
if (img.width, img.height) != (target_w, target_h):
opt = img.resize((target_w, target_h), Image.Resampling.LANCZOS)
else:
opt = img.copy()
if opt.mode not in ("RGB", "RGBA"):
opt = opt.convert("RGBA" if "transparency" in opt.info else "RGB")
buf = io.BytesIO()
opt.save(buf, format="WEBP", quality=80, method=4)
data = buf.getvalue()
return data, opt.width, opt.height
def process_image_variants(raw_bytes: bytes) -> list[GeneratedVariant]:
"""Безопасно декодирует сырые байты оригинала и генерирует thumbnail, crop, optimized.
Применяет EXIF orientation к базовому изображению.
"""
with Image.open(io.BytesIO(raw_bytes)) as img:
w, h = img.size
if w * h > MAX_IMAGE_PIXELS:
raise ValueError("decompression bomb: image exceeds pixel limit")
img.load()
transposed = ImageOps.exif_transpose(img) or img
thumb_bytes, thumb_w, thumb_h = generate_thumbnail(transposed)
crop_bytes, crop_w, crop_h = generate_crop(transposed)
opt_bytes, opt_w, opt_h = generate_optimized(transposed)
def make_entry(name: str, ctype: str, data: bytes, w: int, h: int) -> GeneratedVariant:
return {
"name": name,
"content_type": ctype,
"data": data,
"size_bytes": len(data),
"width": w,
"height": h,
"sha256": hashlib.sha256(data).hexdigest(),
}
return [
make_entry("thumbnail", "image/jpeg", thumb_bytes, thumb_w, thumb_h),
make_entry("crop", "image/jpeg", crop_bytes, crop_w, crop_h),
make_entry("optimized", "image/webp", opt_bytes, opt_w, opt_h),
]
+7 -1
View File
@@ -15,6 +15,8 @@ from app.routes.chats import router as chats_router
from app.routes.health import router as health_router
from app.routes.messages import router as messages_router
from app.routes.users import router as users_router
from app.broker import publisher
from app.outbox import outbox_relay
from app.storage import storage
logger = logging.getLogger("app.lifecycle")
@@ -26,14 +28,18 @@ async def lifespan(app: FastAPI):
"Starting messenger server on %s:%d (env: %s)", APP_HOST, APP_PORT, LOG_LEVEL
)
await storage.connect()
if storage.pg_pool:
await outbox_relay.start(storage.pg_pool)
yield
logger.info("Graceful shutdown: closing connections...")
await outbox_relay.stop()
await publisher.close()
await storage.disconnect()
app = FastAPI(
title="highload-messenger",
version="1.4.0",
version="1.5.0",
docs_url="/docs",
redoc_url=None,
lifespan=lifespan,
+109
View File
@@ -0,0 +1,109 @@
from __future__ import annotations
import asyncio
import json
import logging
from typing import Any
import asyncpg
from app.broker import publisher
logger = logging.getLogger("messenger.outbox")
class OutboxRelay:
"""Фоновый диспетчер Transactional Outbox.
Вычитывает сохранённые задачи из PostgreSQL и надёжно публикует их в RabbitMQ.
"""
def __init__(self) -> None:
self._notify_event = asyncio.Event()
self._running = False
self._task: asyncio.Task[None] | None = None
def notify(self) -> None:
"""Сигнализирует о появлении новой записи для немедленной отправки без ожидания тика."""
self._notify_event.set()
async def start(self, pool: asyncpg.Pool) -> None:
if self._running:
return
self._running = True
self._task = asyncio.create_task(self._loop(pool))
logger.info("OutboxRelay started")
async def stop(self) -> None:
self._running = False
self._notify_event.set()
if self._task:
self._task.cancel()
try:
await self._task
except asyncio.CancelledError:
pass
self._task = None
logger.info("OutboxRelay stopped")
async def process_pending(self, pool: asyncpg.Pool, limit: int = 50) -> int:
"""Выбирает и публикует порцию pending-задач с FOR UPDATE SKIP LOCKED."""
dispatched_count = 0
async with pool.acquire() as conn:
async with conn.transaction():
rows = await conn.fetch(
"""
SELECT job_id, payload
FROM outbox_jobs
WHERE status = 'pending'
ORDER BY created_at ASC
LIMIT $1
FOR UPDATE SKIP LOCKED
""",
limit,
)
if not rows:
return 0
for row in rows:
job_id = row["job_id"]
payload_raw = row["payload"]
payload_dict = json.loads(payload_raw) if isinstance(payload_raw, str) else dict(payload_raw)
success = await publisher.publish_job(payload_dict)
if success:
await conn.execute(
"""
UPDATE outbox_jobs
SET status = 'published', updated_at = NOW()
WHERE job_id = $1
""",
job_id,
)
dispatched_count += 1
else:
logger.warning("Broker reject for job %s, will retry", job_id)
break
return dispatched_count
async def _loop(self, pool: asyncpg.Pool) -> None:
while self._running:
try:
dispatched = await self.process_pending(pool)
# Если были отправлены задачи, проверяем сразу следующую порцию
if dispatched > 0:
continue
except asyncio.CancelledError:
break
except Exception as exc:
logger.error("Error in OutboxRelay loop: %s", exc)
# Ждём уведомления о новой задаче или таймаута 1.0 с
try:
await asyncio.wait_for(self._notify_event.wait(), timeout=1.0)
self._notify_event.clear()
except asyncio.TimeoutError:
pass
outbox_relay = OutboxRelay()
+2 -2
View File
@@ -21,7 +21,7 @@ def validate_uuid(value: str, field_name: str = "id") -> str:
@router.post(
"/api/v1/chats/{chat_id}/attachments",
response_model=AttachmentResponse,
status_code=status.HTTP_201_CREATED,
status_code=status.HTTP_202_ACCEPTED,
)
async def upload_attachment(
chat_id: str,
@@ -66,7 +66,7 @@ async def get_attachment_metadata(
)
async def download_attachment_content(
attachment_id: str,
variant: str | None = Query(default=None),
variant: str = Query(default="original"),
current_user: UserResponse = Depends(get_current_user),
) -> Response:
"""Скачивание бинарного содержимого вложения."""
+21 -7
View File
@@ -5,6 +5,8 @@ import re
from enum import Enum
from uuid import UUID
from typing import Literal
from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
@@ -137,12 +139,12 @@ class ChatPageResponse(BaseModel):
class VariantResponse(BaseModel):
model_config = ConfigDict(extra="forbid")
name: str
content_type: str
size_bytes: int
width: int
height: int
sha256: str
name: Literal["thumbnail", "crop", "optimized"]
content_type: Literal["image/jpeg", "image/png", "image/webp"]
size_bytes: int = Field(ge=1)
width: int = Field(ge=1)
height: int = Field(ge=1)
sha256: str = Field(pattern=r"^[a-f0-9]{64}$")
class AttachmentResponse(BaseModel):
@@ -155,13 +157,25 @@ class AttachmentResponse(BaseModel):
content_type: str
size_bytes: int
sha256: str
status: str = "ready"
status: Literal["queued", "processing", "ready", "failed"] = "queued"
variants: list[VariantResponse] = Field(default_factory=list)
error_code: str | None = None
created_at: str
updated_at: str
class AttachmentJobMessage(BaseModel):
model_config = ConfigDict(extra="forbid")
schema_version: Literal[1] = 1
job_id: str
type: Literal["attachment.process.v1"] = "attachment.process.v1"
attachment_id: str
pipeline_version: int = 1
attempt: int = 1
created_at: str
class CreateMessageRequest(BaseModel):
model_config = ConfigDict(extra="forbid", strict=True)
+90 -38
View File
@@ -37,6 +37,7 @@ from app.errors import (
UnauthorizedError,
UnsupportedMediaTypeError,
)
from app.outbox import outbox_relay
from app.schemas import (
AttachmentResponse,
ChatResponse,
@@ -89,6 +90,10 @@ class PostgresStorage:
self.redis_client: redis.Redis | None = None
self.s3_client: Any = None
@property
def pool(self) -> asyncpg.Pool | None:
return self.pg_pool
@asynccontextmanager
async def acquire_conn(self, timeout: float = 2.0):
if self.pg_pool is None:
@@ -505,8 +510,8 @@ class PostgresStorage:
for r in rows:
if r["chat_id"] != cid:
raise NotFoundError("Вложение принадлежит другому чату")
if r["status"] != "ready":
raise ConflictError("Вложение еще не готово или повреждено")
if r["status"] == "failed":
raise ConflictError("Нельзя прикреплять вложение со статусом failed")
# 1. Проверяем, обрабатывался ли уже этот idempotency_key
existing = await conn.fetchrow(
@@ -787,53 +792,81 @@ class PostgresStorage:
# 7. Генерация идентификаторов
att_id = uuid.uuid4()
s3_key = f"chats/{chat_id}/{att_id}/{filename}"
job_id = uuid.uuid4()
staging_key = f"staging/{att_id}/{filename}"
sha256_hash = hashlib.sha256(data).hexdigest()
now = dt.datetime.now(dt.timezone.utc)
now_iso = _format_dt(now)
# 8. Загрузка файла в S3
# 8. Загрузка файла в устойчивый staging в S3
def _put_to_s3():
self.s3_client.put_object(
Bucket=S3_BUCKET,
Key=s3_key,
Key=staging_key,
Body=data,
ContentType=ct_clean,
)
await asyncio.to_thread(_put_to_s3)
# 9. Сохранение метаданных в PostgreSQL (с компенсацией удаления из S3 при ошибке)
# 9. Атомарное сохранение в PostgreSQL: attachments + outbox_jobs
job_payload = {
"schema_version": 1,
"job_id": str(job_id),
"type": "attachment.process.v1",
"attachment_id": str(att_id),
"pipeline_version": 1,
"attempt": 1,
"created_at": now_iso,
}
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
async with conn.transaction():
await conn.execute(
"""
INSERT INTO attachments (
id, chat_id, owner_id, filename, content_type,
size_bytes, sha256, s3_key, status, error_code, variants,
created_at, updated_at
)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'queued', NULL, '[]'::jsonb, $9, $9)
""",
att_id,
cid,
c_caller,
filename,
ct_clean,
size_bytes,
sha256_hash,
staging_key,
now,
)
await conn.execute(
"""
INSERT INTO outbox_jobs (
job_id, attachment_id, event_type, payload, status, attempt, created_at, updated_at
)
VALUES ($1, $2, 'attachment.process.v1', $3::jsonb, 'pending', 1, $4, $4)
""",
job_id,
att_id,
json.dumps(job_payload),
now,
)
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)
logger.error("Ошибка записи метаданных/outbox в БД, компенсация staging S3: %s", db_err)
try:
await asyncio.to_thread(
self.s3_client.delete_object, Bucket=S3_BUCKET, Key=s3_key
self.s3_client.delete_object, Bucket=S3_BUCKET, Key=staging_key
)
except Exception as del_err:
logger.error("Ошибка удаления S3 объекта при компенсации: %s", del_err)
logger.error("Ошибка удаления staging S3 объекта при компенсации: %s", del_err)
raise
# 10. Уведомляем outbox relay для немедленной публикации
outbox_relay.notify()
return AttachmentResponse(
id=str(att_id),
chat_id=str(cid),
@@ -842,11 +875,11 @@ class PostgresStorage:
content_type=ct_clean,
size_bytes=size_bytes,
sha256=sha256_hash,
status="ready",
status="queued",
variants=[],
error_code=None,
created_at=_format_dt(now),
updated_at=_format_dt(now),
created_at=now_iso,
updated_at=now_iso,
)
async def get_attachment(
@@ -862,7 +895,8 @@ class PostgresStorage:
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
a.size_bytes, a.sha256, a.status, a.error_code, a.variants,
a.created_at, a.updated_at
FROM attachments a
WHERE a.id = $1
""",
@@ -879,6 +913,11 @@ class PostgresStorage:
if not is_member:
raise NotFoundError("Вложение не найдено")
raw_variants = row["variants"]
if isinstance(raw_variants, str):
raw_variants = json.loads(raw_variants)
variants_list = [VariantResponse(**v) for v in (raw_variants or [])]
return AttachmentResponse(
id=str(row["id"]),
chat_id=str(row["chat_id"]),
@@ -888,7 +927,7 @@ class PostgresStorage:
size_bytes=row["size_bytes"],
sha256=row["sha256"],
status=row["status"],
variants=[],
variants=variants_list,
error_code=row["error_code"],
created_at=_format_dt(row["created_at"]),
updated_at=_format_dt(row["updated_at"]),
@@ -903,13 +942,14 @@ class PostgresStorage:
except ValueError:
raise NotFoundError("Вложение не найдено")
if variant not in (None, "", "original"):
raise NotFoundError("Вариант не найден")
variant_clean = (variant or "original").strip().lower()
if variant_clean not in ("original", "thumbnail", "crop", "optimized"):
raise InvalidRequestError("Неизвестный вариант изображения")
async with self.acquire_conn() as conn:
row = await conn.fetchrow(
"""
SELECT a.chat_id, a.content_type, a.s3_key, a.status
SELECT a.chat_id, a.content_type, a.s3_key, a.status, a.variants
FROM attachments a
WHERE a.id = $1
""",
@@ -926,11 +966,23 @@ class PostgresStorage:
if not is_member:
raise NotFoundError("Вложение не найдено")
# По контракту: для queued/processing/failed возвращается 409 Conflict
if row["status"] != "ready":
raise ConflictError("Вложение повреждено или еще не готово")
raise ConflictError("Вложение еще не готово или завершилось с ошибкой")
s3_key = row["s3_key"]
content_type = row["content_type"]
if variant_clean == "original":
s3_key = row["s3_key"]
content_type = row["content_type"]
else:
raw_variants = row["variants"]
if isinstance(raw_variants, str):
raw_variants = json.loads(raw_variants)
variants_list = raw_variants or []
matched = next((v for v in variants_list if v.get("name") == variant_clean), None)
if not matched:
raise NotFoundError("Запрошенный вариант не найден")
s3_key = f"chats/{row['chat_id']}/{aid}/{variant_clean}"
content_type = matched["content_type"]
def _get_from_s3():
resp = self.s3_client.get_object(Bucket=S3_BUCKET, Key=s3_key)
+436
View File
@@ -0,0 +1,436 @@
from __future__ import annotations
import asyncio
import io
import json
import logging
import random
import signal
import uuid
from typing import Any
import aio_pika
import asyncpg
import boto3
from botocore.config import Config
from PIL import UnidentifiedImageError
from app.broker import (
DL_ROUTING_KEY,
DLX_NAME,
EXCHANGE_NAME,
QUEUE_NAME,
ROUTING_KEY,
setup_broker_topology,
)
from app.config import (
BROKER_URL,
DATABASE_URL,
MAX_JOB_RETRIES,
S3_ACCESS_KEY_ID,
S3_BUCKET,
S3_ENDPOINT,
S3_REGION,
S3_SECRET_ACCESS_KEY,
WORKER_CONCURRENCY,
WORKER_LEASE_SECONDS,
)
from app.imaging import process_image_variants
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
logger = logging.getLogger("messenger.worker")
class AttachmentWorker:
def __init__(self) -> None:
self.worker_id = f"worker-{uuid.uuid4().hex[:8]}"
self.pool: asyncpg.Pool | None = None
self.s3_client: Any = None
self._connection: aio_pika.abc.AbstractRobustConnection | None = None
self._channel: aio_pika.abc.AbstractChannel | None = None
self._running = False
self._watchdog_task: asyncio.Task[None] | None = None
async def init_resources(self) -> None:
logger.info("Initializing worker resources (%s)...", self.worker_id)
# 1. PostgreSQL pool
self.pool = await asyncpg.create_pool(
dsn=DATABASE_URL,
min_size=2,
max_size=WORKER_CONCURRENCY + 2,
command_timeout=10.0,
)
# 2. S3 client
s3_cfg = Config(
signature_version="s3v4",
connect_timeout=3,
read_timeout=10,
retries={"max_attempts": 3, "mode": "standard"},
)
self.s3_client = boto3.client(
"s3",
endpoint_url=S3_ENDPOINT,
region_name=S3_REGION,
aws_access_key_id=S3_ACCESS_KEY_ID,
aws_secret_access_key=S3_SECRET_ACCESS_KEY,
config=s3_cfg,
)
async def _lease_watchdog(self) -> None:
while self._running:
try:
await asyncio.sleep(15.0)
if not self.pool:
continue
async with self.pool.acquire() as conn:
rows = await conn.fetch(
"""
UPDATE attachments
SET status = 'queued',
processing_started_at = NULL,
processing_worker_id = NULL,
updated_at = NOW()
WHERE status = 'processing'
AND processing_started_at < NOW() - ($1 || ' seconds')::interval
RETURNING id
""",
str(WORKER_LEASE_SECONDS),
)
for r in rows:
logger.warning(
"Lease expired for attachment %s, reverting to queued and republishing", r["id"]
)
if self._channel and not self._channel.is_closed:
try:
exchange = await self._channel.get_exchange(EXCHANGE_NAME)
payload = {
"schema_version": 1,
"job_id": str(uuid.uuid4()),
"type": "attachment.process.v1",
"attachment_id": str(r["id"]),
"pipeline_version": 1,
"attempt": 1,
}
msg = aio_pika.Message(
body=json.dumps(payload).encode("utf-8"),
delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
content_type="application/json",
)
await exchange.publish(msg, routing_key=ROUTING_KEY)
except Exception as pub_err:
logger.error("Failed republish on lease expiration for %s: %s", r["id"], pub_err)
except asyncio.CancelledError:
break
except Exception as exc:
logger.error("Error in lease watchdog: %s", exc)
async def process_job_message(self, message: aio_pika.abc.AbstractIncomingMessage) -> None:
"""Обрабатывает одно задание на генерацию вариантов изображения."""
async with message.process(requeue=False):
try:
payload = json.loads(message.body.decode("utf-8"))
except Exception as parse_err:
logger.error("Failed to parse job JSON: %s. Acking.", parse_err)
return
att_id_str = payload.get("attachment_id")
if not att_id_str:
logger.error("Job payload missing attachment_id: %s", payload)
return
try:
att_id = uuid.UUID(att_id_str)
except ValueError:
logger.error("Invalid attachment_id UUID: %s", att_id_str)
return
attempt = int(payload.get("attempt", 1))
if not self.pool:
logger.error("DB pool not initialized")
return
async with self.pool.acquire() as conn:
row = await conn.fetchrow(
"""
UPDATE attachments
SET status = 'processing',
processing_started_at = NOW(),
processing_worker_id = $1,
updated_at = NOW()
WHERE id = $2 AND status IN ('queued', 'failed')
RETURNING id, chat_id, filename, content_type, size_bytes, sha256, s3_key, status
""",
self.worker_id,
att_id,
)
if not row:
current_status = await conn.fetchval(
"SELECT status FROM attachments WHERE id = $1", att_id
)
logger.info(
"Attachment %s is in state '%s', skipping processing (idempotent no-op).",
att_id,
current_status,
)
return
try:
async with asyncio.timeout(30.0):
staging_key = row["s3_key"]
try:
s3_resp = await asyncio.to_thread(
self.s3_client.get_object,
Bucket=S3_BUCKET,
Key=staging_key,
)
raw_bytes = s3_resp["Body"].read()
except Exception as s3_err:
logger.error("Failed to read staging S3 key %s: %s", staging_key, s3_err)
await self._handle_retryable_error(payload, attempt, str(s3_err))
return
# 3. Генерируем варианты через Pillow
try:
variants = await asyncio.to_thread(process_image_variants, raw_bytes)
except (UnidentifiedImageError, ValueError) as img_err:
logger.warning(
"Permanent image processing error for %s: %s", att_id, img_err
)
await self._fail_attachment(att_id, "invalid_image")
await self._send_to_dlq(payload, f"permanent_image_error: {img_err}")
return
except Exception as unk_err:
logger.error(
"Unexpected processing error for %s: %s", att_id, unk_err
)
await self._handle_retryable_error(payload, attempt, str(unk_err))
return
# 4. Сохраняем оригинал и варианты в постоянные S3-ключи
chat_id = str(row["chat_id"])
final_original_key = f"chats/{chat_id}/{att_id}/original"
try:
# Оригинал
await asyncio.to_thread(
self.s3_client.put_object,
Bucket=S3_BUCKET,
Key=final_original_key,
Body=raw_bytes,
ContentType=row["content_type"],
)
# Варианты
for var in variants:
var_key = f"chats/{chat_id}/{att_id}/{var['name']}"
await asyncio.to_thread(
self.s3_client.put_object,
Bucket=S3_BUCKET,
Key=var_key,
Body=var["data"],
ContentType=var["content_type"],
)
except Exception as upload_err:
logger.error("Failed uploading variants to S3 for %s: %s", att_id, upload_err)
await self._handle_retryable_error(payload, attempt, str(upload_err))
return
# 5. Атомарно обновляем PostgreSQL в 'ready'
variants_metadata = [
{
"name": v["name"],
"content_type": v["content_type"],
"size_bytes": v["size_bytes"],
"width": v["width"],
"height": v["height"],
"sha256": v["sha256"],
}
for v in variants
]
async with self.pool.acquire() as conn:
await conn.execute(
"""
UPDATE attachments
SET status = 'ready',
s3_key = $1,
variants = $2::jsonb,
error_code = NULL,
processing_started_at = NULL,
processing_worker_id = NULL,
updated_at = NOW()
WHERE id = $3
""",
final_original_key,
json.dumps(variants_metadata),
att_id,
)
# 6. Очистка staging-файла в MinIO
if staging_key != final_original_key:
try:
await asyncio.to_thread(
self.s3_client.delete_object,
Bucket=S3_BUCKET,
Key=staging_key,
)
except Exception as del_err:
logger.warning("Failed to delete staging key %s: %s", staging_key, del_err)
logger.info("Attachment %s successfully processed into ready with 3 variants.", att_id)
except TimeoutError:
logger.error("Job processing timed out (>30s) for %s. Aborting hung worker task.", att_id)
await self._handle_retryable_error(payload, attempt, "job_deadline_exceeded_30s")
return
async def _fail_attachment(self, att_id: uuid.UUID, error_code: str) -> None:
"""Переводит вложение в статус failed с безопасным машинным кодом."""
if not self.pool:
return
async with self.pool.acquire() as conn:
await conn.execute(
"""
UPDATE attachments
SET status = 'failed',
error_code = $1,
processing_started_at = NULL,
processing_worker_id = NULL,
updated_at = NOW()
WHERE id = $2
""",
error_code,
att_id,
)
async def _send_to_dlq(self, payload: dict[str, Any], reason: str) -> None:
try:
if self._channel and not self._channel.is_closed:
dlx = await self._channel.get_exchange(DLX_NAME)
dlq_payload = dict(payload, error="permanent_or_exhausted", last_reason=reason)
dlq_msg = aio_pika.Message(
body=json.dumps(dlq_payload).encode("utf-8"),
delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
content_type="application/json",
)
await dlx.publish(dlq_msg, routing_key=DL_ROUTING_KEY)
except Exception as dlx_err:
logger.error("Failed publishing to DLQ: %s", dlx_err)
async def _handle_retryable_error(self, payload: dict[str, Any], attempt: int, reason: str) -> None:
att_id_str = payload.get("attachment_id")
att_id = uuid.UUID(att_id_str)
if attempt < MAX_JOB_RETRIES:
next_attempt = attempt + 1
delay = 0.5 * (2 ** attempt) + random.uniform(0.1, 0.5)
logger.warning(
"Retryable error for %s (attempt %d/%d). Retrying in %.2fs: %s",
att_id, attempt, MAX_JOB_RETRIES, delay, reason
)
if self.pool:
async with self.pool.acquire() as conn:
await conn.execute(
"""
UPDATE attachments
SET status = 'queued',
processing_started_at = NULL,
processing_worker_id = NULL,
updated_at = NOW()
WHERE id = $1
""",
att_id,
)
async def _delayed_republish() -> None:
await asyncio.sleep(delay)
try:
if self._channel and not self._channel.is_closed:
exchange = await self._channel.get_exchange(EXCHANGE_NAME)
new_payload = dict(payload, attempt=next_attempt)
msg = aio_pika.Message(
body=json.dumps(new_payload).encode("utf-8"),
delivery_mode=aio_pika.DeliveryMode.PERSISTENT,
content_type="application/json",
)
await exchange.publish(msg, routing_key=ROUTING_KEY)
except Exception as pub_err:
logger.error("Failed delayed republish for %s: %s", att_id, pub_err)
asyncio.create_task(_delayed_republish())
else:
logger.error(
"Max retries (%d) exhausted for attachment %s. Moving to DLQ.",
MAX_JOB_RETRIES, att_id
)
await self._fail_attachment(att_id, "retry_exhausted")
await self._send_to_dlq(payload, f"retry_exhausted: {reason}")
async def start(self) -> None:
self._running = True
await self.init_resources()
# Подключение к RabbitMQ с автоматическим reconnect
logger.info("Connecting to RabbitMQ at %s...", BROKER_URL.split("@")[-1])
while self._running:
try:
self._connection = await aio_pika.connect_robust(BROKER_URL)
break
except Exception as conn_err:
logger.warning("RabbitMQ not ready yet (%s). Retrying in 2s...", conn_err)
await asyncio.sleep(2.0)
assert self._connection is not None
self._channel = await self._connection.channel()
await self._channel.set_qos(prefetch_count=WORKER_CONCURRENCY)
_, queue = await setup_broker_topology(self._channel)
self._watchdog_task = asyncio.create_task(self._lease_watchdog())
logger.info(
"Worker %s started consuming queue '%s' (prefetch=%d)...",
self.worker_id, QUEUE_NAME, WORKER_CONCURRENCY
)
await queue.consume(self.process_job_message)
async def stop(self) -> None:
logger.info("Stopping worker %s...", self.worker_id)
self._running = False
if self._watchdog_task:
self._watchdog_task.cancel()
if self._channel and not self._channel.is_closed:
await self._channel.close()
if self._connection and not self._connection.is_closed:
await self._connection.close()
if self.pool:
await self.pool.close()
logger.info("Worker stopped.")
async def main() -> None:
worker = AttachmentWorker()
loop = asyncio.get_running_loop()
stop_event = asyncio.Event()
def _sig_handler() -> None:
logger.info("Received termination signal")
stop_event.set()
for sig in (signal.SIGINT, signal.SIGTERM):
try:
loop.add_signal_handler(sig, _sig_handler)
except NotImplementedError:
pass
await worker.start()
await stop_event.wait()
await worker.stop()
if __name__ == "__main__":
asyncio.run(main())
+67 -2
View File
@@ -45,7 +45,7 @@ services:
build:
context: .
dockerfile: Dockerfile
image: highload-messenger:lab4
image: highload-messenger:lab5
stop_grace_period: 15s
environment:
APP_HOST: "0.0.0.0"
@@ -57,6 +57,7 @@ services:
SESSION_STORE: "redis"
CACHE_URL: "redis://redis:6379/0"
IDEMPOTENCY_TTL_SECONDS: "86400"
BROKER_URL: "amqp://messenger:messenger_broker_pass@broker:5672/"
S3_ENDPOINT: "http://minio:9000"
S3_REGION: "us-east-1"
S3_BUCKET: "messenger-attachments"
@@ -71,6 +72,8 @@ services:
condition: service_healthy
minio:
condition: service_healthy
broker:
condition: service_healthy
migration:
condition: service_completed_successfully
healthcheck:
@@ -89,7 +92,7 @@ services:
build:
context: .
dockerfile: Dockerfile
image: highload-messenger:lab4
image: highload-messenger:lab5
stop_grace_period: 15s
environment:
APP_HOST: "0.0.0.0"
@@ -101,6 +104,7 @@ services:
SESSION_STORE: "redis"
CACHE_URL: "redis://redis:6379/0"
IDEMPOTENCY_TTL_SECONDS: "86400"
BROKER_URL: "amqp://messenger:messenger_broker_pass@broker:5672/"
S3_ENDPOINT: "http://minio:9000"
S3_REGION: "us-east-1"
S3_BUCKET: "messenger-attachments"
@@ -115,6 +119,8 @@ services:
condition: service_healthy
minio:
condition: service_healthy
broker:
condition: service_healthy
migration:
condition: service_completed_successfully
healthcheck:
@@ -129,6 +135,45 @@ services:
cpus: '0.50'
memory: 512M
worker:
build:
context: .
dockerfile: Dockerfile
image: highload-messenger:lab5
command: python -m app.worker
stop_grace_period: 15s
environment:
DATABASE_URL: "postgresql://postgres:postgres@postgres:5432/messenger"
BROKER_URL: "amqp://messenger:messenger_broker_pass@broker:5672/"
S3_ENDPOINT: "http://minio:9000"
S3_REGION: "us-east-1"
S3_BUCKET: "messenger-attachments"
S3_ACCESS_KEY_ID: "minioadmin"
S3_SECRET_ACCESS_KEY: "minioadmin"
WORKER_CONCURRENCY: "4"
WORKER_LEASE_SECONDS: "60"
MAX_JOB_RETRIES: "5"
healthcheck:
test: ["CMD-SHELL", "python -c 'import pika, os; conn = pika.BlockingConnection(pika.URLParameters(os.environ[\"BROKER_URL\"])); conn.close()' || exit 1"]
interval: 5s
timeout: 3s
retries: 3
depends_on:
postgres:
condition: service_healthy
broker:
condition: service_healthy
minio:
condition: service_healthy
migration:
condition: service_completed_successfully
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
postgres:
image: postgres:16-alpine
environment:
@@ -150,6 +195,25 @@ services:
cpus: '0.50'
memory: 512M
broker:
image: rabbitmq:3.13-alpine
environment:
RABBITMQ_DEFAULT_USER: messenger
RABBITMQ_DEFAULT_PASS: messenger_broker_pass
volumes:
- rabbitmq_data:/var/lib/rabbitmq
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
interval: 3s
timeout: 5s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.50'
memory: 512M
redis:
image: redis:7-alpine
command: ["redis-server", "--appendonly", "yes"]
@@ -192,3 +256,4 @@ volumes:
pg_data:
redis_data:
minio_data:
rabbitmq_data:
+2
View File
@@ -0,0 +1,2 @@
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
+9
View File
@@ -0,0 +1,9 @@
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi2026lab5-api-1-1 highload-messenger:lab5 "python -m uvicorn a…" api-1 2 minutes ago Up 2 minutes (healthy) 8080/tcp
mtusi2026lab5-api-2-1 highload-messenger:lab5 "python -m uvicorn a…" api-2 2 minutes ago Up 2 minutes (healthy) 8080/tcp
mtusi2026lab5-broker-1 rabbitmq:3.13-alpine "docker-entrypoint.s…" broker 2 minutes ago Up 2 minutes (healthy) 4369/tcp, 5671-5672/tcp, 15691-15692/tcp, 25672/tcp
mtusi2026lab5-load_balancer-1 nginx:1.27-alpine "/docker-entrypoint.…" load_balancer 2 minutes ago Up 2 minutes (healthy) 80/tcp, 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
mtusi2026lab5-minio-1 cleanstart/minio:0.20260330.001845 "/usr/bin/minio serv…" minio 2 minutes ago Up 2 minutes (healthy)
mtusi2026lab5-postgres-1 postgres:16-alpine "docker-entrypoint.s…" postgres 2 minutes ago Up 2 minutes (healthy) 5432/tcp
mtusi2026lab5-redis-1 redis:7-alpine "docker-entrypoint.s…" redis 2 minutes ago Up 2 minutes (healthy) 6379/tcp
mtusi2026lab5-worker-1 highload-messenger:lab5 "python -m app.worker" worker 2 minutes ago Up 2 minutes (healthy) 8080/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": 116, "failed_attempts": 0, "first_recovery_seconds": 0.87}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 5,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 15.0,
"elapsed_seconds": 15.007,
"concurrency": 4,
"successful_requests": 4773,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 318.051,
"successful_latency_ms": {
"p50": 6.603,
"p95": 59.542,
"p99": 80.594
},
"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: lab5 public API scenario; infrastructure and grading evidence remain separate.
+51
View File
@@ -0,0 +1,51 @@
BASE_URL="http://localhost:8080" .venv/bin/pytest tests_student/ -v
/home/ilyas/projects/labs_highload/mtusi2026lab5/.venv/lib/python3.15/site-packages/pytest_asyncio/plugin.py:300: PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
The event loop scope for asynchronous fixtures will default to the "fixture" caching scope. Future versions of pytest-asyncio will default the loop scope for asynchronous fixtures to "function" scope. Set the default fixture loop scope explicitly in order to avoid unexpected behavior in the future. Valid fixture loop scopes are: "function", "class", "module", "package", "session"
warnings.warn(PytestDeprecationWarning(_DEFAULT_FIXTURE_LOOP_SCOPE_UNSET))
============================= test session starts ==============================
platform linux -- Python 3.15.2, pytest-9.2.0, pluggy-1.7.0 -- /home/ilyas/projects/labs_highload/mtusi2026lab5/.venv/bin/python3
cachedir: .pytest_cache
rootdir: /home/ilyas/projects/labs_highload/mtusi2026lab5
configfile: pytest.ini
plugins: anyio-4.16.0, asyncio-1.4.1.post1
asyncio: mode=Mode.AUTO, debug=False, asyncio_default_fixture_loop_scope=None, asyncio_default_test_loop_scope=function
collecting ... ␍collected 35 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 [ 22%]
tests_student/tests.py::test_password_whitespace_rejected PASSED [ 25%]
tests_student/tests.py::test_auth_sessions_with_body_rejected PASSED [ 28%]
tests_student/tests.py::test_unsupported_media_type_415 PASSED [ 31%]
tests_student/tests.py::test_nul_byte_in_strings_handled PASSED [ 34%]
tests_student/tests.py::test_basic_auth_invalid_base64_returns_401 PASSED [ 37%]
tests_student/tests.py::test_cross_chat_cursor_rejected_400 PASSED [ 40%]
tests_student/tests.py::test_utf8_password_support PASSED [ 42%]
tests_student/tests.py::test_health_readiness_and_liveness PASSED [ 45%]
tests_student/tests.py::test_instance_id_header_present PASSED [ 48%]
tests_student/tests.py::test_idempotency_key_validation PASSED [ 51%]
tests_student/tests.py::test_idempotency_replay_and_conflict PASSED [ 54%]
tests_student/tests.py::test_idempotency_acl_check_on_replay PASSED [ 57%]
tests_student/tests.py::test_invalid_cursor_date_returns_400 PASSED [ 60%]
tests_student/tests.py::test_strict_types_and_json_parsing PASSED [ 62%]
tests_student/tests.py::test_chat_creation_with_unknown_participant_is_400 PASSED [ 65%]
tests_student/tests.py::test_password_with_colons_and_utf8 PASSED [ 68%]
tests_student/tests.py::test_keyset_pagination_returns_next_cursor PASSED [ 71%]
tests_student/tests.py::test_attachment_upload_and_download_flow PASSED [ 74%]
tests_student/tests.py::test_attachment_unsupported_media_type_and_magic_bytes PASSED [ 77%]
tests_student/tests.py::test_attachment_filename_validation PASSED [ 80%]
tests_student/tests.py::test_attachment_payload_too_large_and_pixel_bomb PASSED [ 82%]
tests_student/tests.py::test_attachment_acl_and_isolation PASSED [ 85%]
tests_student/tests.py::test_message_linking_attachments PASSED [ 88%]
tests_student/tests.py::test_message_linking_failed_attachment_rejected 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%]
============================= 35 passed in 37.84s ==============================
+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.
+24 -1
View File
@@ -46,14 +46,37 @@ CREATE TABLE IF NOT EXISTS attachments (
size_bytes BIGINT NOT NULL,
sha256 VARCHAR(64) NOT NULL,
s3_key VARCHAR(512) NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'ready',
status VARCHAR(20) NOT NULL DEFAULT 'queued',
error_code VARCHAR(100),
variants JSONB NOT NULL DEFAULT '[]'::jsonb,
processing_started_at TIMESTAMPTZ,
processing_worker_id TEXT,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL
);
ALTER TABLE attachments ADD COLUMN IF NOT EXISTS variants JSONB NOT NULL DEFAULT '[]'::jsonb;
ALTER TABLE attachments ADD COLUMN IF NOT EXISTS processing_started_at TIMESTAMPTZ;
ALTER TABLE attachments ADD COLUMN IF NOT EXISTS processing_worker_id TEXT;
ALTER TABLE attachments ALTER COLUMN status SET DEFAULT 'queued';
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 INDEX IF NOT EXISTS idx_attachments_lease ON attachments (status, processing_started_at) WHERE status = 'processing';
CREATE TABLE IF NOT EXISTS outbox_jobs (
job_id UUID PRIMARY KEY,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
event_type VARCHAR(64) NOT NULL DEFAULT 'attachment.process.v1',
payload JSONB NOT NULL,
status VARCHAR(20) NOT NULL DEFAULT 'pending',
attempt INT NOT NULL DEFAULT 1,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_outbox_pending ON outbox_jobs (status, created_at) WHERE status = 'pending';
CREATE TABLE IF NOT EXISTS idempotency_keys (
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+3 -3
View File
@@ -34,14 +34,14 @@ http {
# Быстрый таймаут обнаружения недоступной реплики
proxy_connect_timeout 1s;
proxy_read_timeout 5s;
proxy_send_timeout 5s;
proxy_read_timeout 15s;
proxy_send_timeout 15s;
# Базовая политика переключения: безопасно для идемпотентных запросов
# Неидемпотентные POST не повторяем
proxy_next_upstream error timeout http_502 http_503;
proxy_next_upstream_tries 2;
proxy_next_upstream_timeout 5s;
proxy_next_upstream_timeout 15s;
location ~ ^/api/v1/chats/[^/]+/messages$ {
proxy_pass http://api_backend;
+2
View File
@@ -9,3 +9,5 @@ pytest-asyncio==1.4.0
httpx==0.28.1
boto3==1.43.123
pillow==13.0.0
aio-pika>=9.4.0
pika>=1.3.2
+1 -1
View File
@@ -15,5 +15,5 @@ async def client():
async with AsyncClient(transport=transport, base_url="http://testserver") as ac:
yield ac
else:
async with AsyncClient(base_url=base_url) as ac:
async with AsyncClient(base_url=base_url, timeout=15.0) as ac:
yield ac
+143 -31
View File
@@ -298,9 +298,7 @@ async def test_multi_page_cursor_pagination(client: AsyncClient):
async def test_concurrency_race_condition(client: AsyncClient):
"""Проверка устойчивости к параллельным гонкам: 10 клиентов одновременно шлют 100 сообщений."""
# Создаём 10 пользователей
users = await asyncio.gather(
*(register_and_login(client, f"u{i}") for i in range(10))
)
users = [await register_and_login(client, f"u{i}") for i in range(10)]
all_user_ids = [u["user"]["id"] for u in users]
# Первый пользователь создаёт общий чат со всеми 10 участниками
@@ -619,7 +617,10 @@ async def test_invalid_cursor_date_returns_400(client: httpx.AsyncClient):
Некорректная дата курсора (например, 13-й месяц 2026-13-01T00:00:00.000000Z)
обязана возвращать 400 invalid_request (а не 500 internal_error).
"""
from app.storage import encode_cursor
def encode_cursor(data: dict) -> str:
import json
raw = json.dumps(data, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("utf-8").rstrip("=")
alice = await register_and_login(client, f"bad_cur_{uuid.uuid4().hex[:6]}")
chat = (
@@ -757,9 +758,24 @@ async def test_keyset_pagination_returns_next_cursor(client: httpx.AsyncClient):
assert data_p2["items"][0]["id"] != data_p1["items"][0]["id"]
async def wait_attachment_ready(
client: httpx.AsyncClient, headers: dict, att_id: str, timeout: float = 30.0
) -> dict:
deadline = asyncio.get_event_loop().time() + timeout
while asyncio.get_event_loop().time() < deadline:
res = await client.get(f"/api/v1/attachments/{att_id}", headers=headers)
assert res.status_code == 200, res.text
att = res.json()
assert att["status"] != "failed", f"Attachment entered failed status: {att}"
if att["status"] == "ready":
return att
await asyncio.sleep(0.2)
pytest.fail(f"Attachment {att_id} did not become ready within {timeout}s")
@pytest.mark.asyncio
async def test_attachment_upload_and_download_flow(client: httpx.AsyncClient):
"""Проверка полного цикла загрузки и скачивания PNG и JPEG вложений."""
"""Проверка асинхронного цикла 202 queued -> ready, thumbnail, crop, optimized."""
import hashlib
import io
from PIL import Image
@@ -785,7 +801,7 @@ async def test_attachment_upload_and_download_flow(client: httpx.AsyncClient):
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert up_res.status_code == 201, up_res.text
assert up_res.status_code == 202, up_res.text
att_png = up_res.json()
assert att_png["chat_id"] == chat_id
assert att_png["owner_id"] == alice["user"]["id"]
@@ -793,28 +809,62 @@ async def test_attachment_upload_and_download_flow(client: httpx.AsyncClient):
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["status"] == "queued"
assert att_png["variants"] == []
assert att_png["error_code"] is None
# 2. Получение метаданных Бобом
meta_res = await client.get(
f"/api/v1/attachments/{att_png['id']}",
# До готовности скачивание контента возвращает 409
down_early = await client.get(
f"/api/v1/attachments/{att_png['id']}/content",
headers=bob["headers"],
)
assert meta_res.status_code == 200
assert meta_res.json() == att_png
if down_early.status_code != 200:
assert down_early.status_code == 409
# 3. Скачивание контента Бобом
# 2. Ожидание перехода в ready
ready_att = await wait_attachment_ready(client, bob["headers"], att_png["id"])
assert ready_att["status"] == "ready"
assert ready_att["error_code"] is None
assert len(ready_att["variants"]) >= 1
# 3. Скачивание оригинала Бобом
down_res = await client.get(
f"/api/v1/attachments/{att_png['id']}/content",
f"/api/v1/attachments/{att_png['id']}/content?variant=original",
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
# 4. Проверка обязательного thumbnail (256x160 JPEG)
down_thumb = await client.get(
f"/api/v1/attachments/{att_png['id']}/content?variant=thumbnail",
headers=bob["headers"],
)
assert down_thumb.status_code == 200
assert down_thumb.headers.get("content-type") == "image/jpeg"
thumb_img = Image.open(io.BytesIO(down_thumb.content))
assert thumb_img.size == (256, 160)
# 5. Проверка crop (128x128 JPEG)
down_crop = await client.get(
f"/api/v1/attachments/{att_png['id']}/content?variant=crop",
headers=bob["headers"],
)
assert down_crop.status_code == 200
assert down_crop.headers.get("content-type") == "image/jpeg"
crop_img = Image.open(io.BytesIO(down_crop.content))
assert crop_img.size == (128, 128)
# 6. Проверка optimized (WebP)
down_opt = await client.get(
f"/api/v1/attachments/{att_png['id']}/content?variant=optimized",
headers=bob["headers"],
)
assert down_opt.status_code == 200
assert down_opt.headers.get("content-type") == "image/webp"
# 7. Загрузка и скачивание JPEG
jpeg_img = Image.new("RGB", (64, 64), color=(255, 128, 0))
jpeg_buf = io.BytesIO()
jpeg_img.save(jpeg_buf, format="JPEG")
@@ -825,11 +875,14 @@ async def test_attachment_upload_and_download_flow(client: httpx.AsyncClient):
headers={**alice["headers"], "Content-Type": "image/jpeg"},
content=jpeg_data,
)
assert up_jpeg.status_code == 201
assert up_jpeg.status_code == 202
att_jpeg = up_jpeg.json()
assert att_jpeg["content_type"] == "image/jpeg"
assert att_jpeg["size_bytes"] == len(jpeg_data)
ready_jpeg = await wait_attachment_ready(client, bob["headers"], att_jpeg["id"])
assert ready_jpeg["status"] == "ready"
down_jpeg = await client.get(
f"/api/v1/attachments/{att_jpeg['id']}/content",
headers=bob["headers"],
@@ -838,6 +891,23 @@ async def test_attachment_upload_and_download_flow(client: httpx.AsyncClient):
assert down_jpeg.headers.get("content-type") == "image/jpeg"
assert down_jpeg.content == jpeg_data
# 8. Проверка точного округления вниз (floor) для PNG 319x200 -> thumbnail 256x160
odd_img = Image.new("RGBA", (319, 200), color=(100, 150, 200, 255))
odd_buf = io.BytesIO()
odd_img.save(odd_buf, format="PNG")
odd_data = odd_buf.getvalue()
up_odd = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=odd_319x200.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=odd_data,
)
assert up_odd.status_code == 202
ready_odd = await wait_attachment_ready(client, bob["headers"], up_odd.json()["id"])
thumb_var = next(v for v in ready_odd["variants"] if v["name"] == "thumbnail")
assert (thumb_var["width"], thumb_var["height"]) == (256, 160)
@pytest.mark.asyncio
async def test_attachment_unsupported_media_type_and_magic_bytes(client: httpx.AsyncClient):
@@ -1039,7 +1109,7 @@ async def test_attachment_acl_and_isolation(client: httpx.AsyncClient):
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert res_alice_up.status_code == 201
assert res_alice_up.status_code == 202
att_id = res_alice_up.json()["id"]
# 2. Посторонний пытается запросить метаданные -> 404
@@ -1095,23 +1165,25 @@ async def test_message_linking_attachments(client: httpx.AsyncClient):
with open("tests/fixtures/sample.png", "rb") as f:
png_data = f.read()
# Загружаем вложение в chat 1
# Загружаем вложение в chat 1 (возвращает 202 queued)
up1 = await client.post(
f"/api/v1/chats/{chat_id}/attachments?filename=sample.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert up1.status_code == 202
att1_id = up1.json()["id"]
# Загружаем вложение в chat 2
# Загружаем вложение в chat 2 (возвращает 202 queued)
up2 = await client.post(
f"/api/v1/chats/{chat2_id}/attachments?filename=chat2.png",
headers={**alice["headers"], "Content-Type": "image/png"},
content=png_data,
)
assert up2.status_code == 202
att2_id = up2.json()["id"]
# 1. Сообщение с пустым текстом, но с вложением -> 201
# 1. Сообщение с пустым текстом, но с вложением в статусе queued -> 201
msg1_res = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex},
@@ -1157,15 +1229,47 @@ async def test_message_linking_attachments(client: httpx.AsyncClient):
assert msg5_res.status_code == 400
@pytest.mark.asyncio
async def test_message_linking_failed_attachment_rejected(client: httpx.AsyncClient):
"""Проверка запрета прикрепления failed-вложения к сообщению (409 Conflict)."""
alice = await register_and_login(client, "failed_a")
chat_res = await client.post(
"/api/v1/chats",
headers=alice["headers"],
json={"title": "Failed Attach Chat", "member_ids": [alice["user"]["id"]]},
)
chat_id = chat_res.json()["id"]
# Имитируем failed-вложение в БД
import subprocess
fake_att_id = str(uuid.uuid4())
insert_sql = f"""
INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, size_bytes, sha256, s3_key, status, error_code, created_at, updated_at)
VALUES ('{fake_att_id}', '{chat_id}', '{alice["user"]["id"]}', 'corrupt.jpg', 'image/jpeg', 100, '0000000000000000000000000000000000000000000000000000000000000000', 'staging/corrupt', 'failed', 'invalid_image', NOW(), NOW());
"""
cmd = ["docker", "compose", "exec", "-T", "postgres", "psql", "-U", "postgres", "-d", "messenger", "-c", insert_sql]
sub_res = subprocess.run(cmd, capture_output=True, text=True)
assert sub_res.returncode == 0
# Попытка прикрепить failed-вложение -> 409 Conflict
res_link = await client.post(
f"/api/v1/chats/{chat_id}/messages",
headers={**alice["headers"], "Idempotency-Key": uuid.uuid4().hex},
json={"text": "Trying failed attach", "attachment_ids": [fake_att_id]},
)
assert res_link.status_code == 409
assert res_link.json()["error"]["code"] == "conflict"
@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).
S3 PUT проходит успешно в staging, но при вставке в PostgreSQL возникает ошибка.
Сервер перехватывает ошибку, вызывает s3_client.delete_object и возвращает 500/503.
3. Проверяем, что сиротский объект удалён из S3 staging.
4. Удаляем триггер из PostgreSQL.
"""
import subprocess
@@ -1205,10 +1309,10 @@ async def test_attachment_orphan_compensation(client: httpx.AsyncClient):
)
assert res.status_code in (500, 503)
check_py = f"""
check_py = """
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}/')
res = s3.list_objects_v2(Bucket='messenger-attachments', Prefix='staging/')
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')
@@ -1256,8 +1360,9 @@ 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), память остаётся в стабильных границах.
3. Все 10 загрузок завершаются успехом (202 Accepted, status=queued).
4. Ожидаем готовности ready через wait_attachment_ready.
5. Измеряем память контейнеров API через docker stats.
"""
import subprocess
alice = await register_and_login(client, "conc_a")
@@ -1281,15 +1386,21 @@ async def test_concurrent_uploads_memory_limit(client: httpx.AsyncClient):
tasks = [upload_single(i) for i in range(10)]
responses = await asyncio.gather(*tasks)
att_ids = []
for resp in responses:
assert resp.status_code == 201
assert resp.status_code == 202
data = resp.json()
assert data["status"] == "ready"
assert data["status"] == "queued"
assert data["size_bytes"] == len(png_data)
att_ids.append(data["id"])
# Ожидаем готовности всех 10 файлов
ready_tasks = [wait_attachment_ready(client, alice["headers"], aid) for aid in att_ids]
await asyncio.gather(*ready_tasks)
# Проверяем docker stats
stats_cmd = [
"docker", "stats", "--no-stream", "--format", "{{.Name}}: {{.MemUsage}}",
"mtusi2026lab4-api-1-1", "mtusi2026lab4-api-2-1"
"docker", "stats", "--no-stream", "--format", "{{.Name}}: {{.MemUsage}}"
]
stats_res = subprocess.run(stats_cmd, capture_output=True, text=True)
assert stats_res.returncode == 0
@@ -1297,3 +1408,4 @@ async def test_concurrent_uploads_memory_limit(client: httpx.AsyncClient):