feat: implement S3 attachments and presigned uploads

This commit is contained in:
sinveria
2026-11-10 12:08:50 +03:00
parent aaa834e412
commit d96d4a2836
50 changed files with 3138 additions and 72 deletions
+24
View File
@@ -0,0 +1,24 @@
# Local Docker Compose configuration for Lab 4.
# Copy this file to .env and replace every CHANGE_ME value locally.
# Never commit .env or share its contents.
POSTGRES_DB=messenger
POSTGRES_USER=messenger
POSTGRES_PASSWORD=CHANGE_ME_POSTGRES_PASSWORD
MINIO_ROOT_USER=CHANGE_ME_S3_ADMIN_USER
MINIO_ROOT_PASSWORD=CHANGE_ME_S3_ADMIN_PASSWORD
S3_ACCESS_KEY_ID=CHANGE_ME_APP_ACCESS_KEY
S3_SECRET_ACCESS_KEY=CHANGE_ME_APP_SECRET_KEY
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
S3_PUBLIC_ENDPOINT_URL=http://localhost:9000
SESSION_TTL_SECONDS=3600
MESSAGE_CACHE_TTL_SECONDS=60
IDEMPOTENCY_TTL_SECONDS=86400
DB_POOL_SIZE=3
DB_MAX_OVERFLOW=2
DB_POOL_TIMEOUT=10
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
ATTACHMENT_CLEANUP_INTERVAL_SECONDS=60
ATTACHMENT_CLEANUP_GRACE_SECONDS=600
ATTACHMENT_CLEANUP_BATCH_SIZE=100
+45 -15
View File
@@ -1,18 +1,48 @@
## Лабораторная 4
## Лабораторная 4 — S3-хранилище и вложения
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
**Автор / группа:** Перевалова Виктория, БПИ2302
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
**Целевая оценка:** 5
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
**Трек:** Track 1 — Presigned Upload
### Что реализовано
- Перенесена основа предыдущей лабораторной; сохранены публичные API-сценарии и контракт.
- Реализованы Proxy Upload и Presigned Upload с проверкой членства в чате, уникальными ключами, TTL, проверкой размера, SHA-256 и фактического формата изображения при complete.
- Метаданные хранятся в PostgreSQL, бинарные данные — в приватном S3-compatible bucket.
- Добавлены cleanup незавершённых presigned-загрузок, best-effort компенсация при ошибке записи метаданных, ограниченные S3 credentials и bootstrap bucket.
- Стенд включает PostgreSQL, Redis, S3-compatible storage, миграции, Traefik и две API-реплики.
### Запуск
См. [`REPORT.md`](../REPORT.md), раздел «Запуск из чистого clone». Для локального Compose используется `.env.compose.example`; после копирования в `.env` необходимо заменить демонстрационные значения.
### Проверки и доказательства
- `scripts/check_contract.py` — PASS.
- Python compileall — PASS.
- Публичный smoke — PASS: повторно выполнен после исправления маршрутизации Traefik; результат сохранён в `evidence/smoke.txt`.
- Presigned upload, completion, idempotency и download — PASS.
- Все негативные сценарии Presigned Upload — PASS (409/415/413/404 согласно проверяемому сценарию).
- Негативные сценарии, cleanup, компенсация S3/PostgreSQL, S3 unavailable/security, persistence, attachment failover и нагрузочные эксперименты описаны в `REPORT.md`; сводки находятся в `evidence/`.
- Эксперимент Track 1 подтвердил сокращение тела запроса к API до 159 байт для файла 5,5 MiB; снижение RAM не подтверждено и не заявляется.
### Ограничения и отклонения
- Между PostgreSQL и S3 нет общей распределённой транзакции; компенсация Proxy Upload best-effort. Незарегистрированные orphan-объекты требуют отдельной сверки/lifecycle policy.
- Пиковая RAM измерялась через периодический `docker stats`; короткие пики могли быть пропущены.
- В Compose используется Silo с S3 API, хотя задание буквально перечисляет MinIO, SeaweedFS или RustFS. Это отклонение явно раскрыто в `REPORT.md`; требуется согласование с преподавателем.
### Источники и использование ИИ
Использованы исходный skeleton, контракт, документация зависимостей и материалы лабораторной. ChatGPT применялся для анализа требований, диагностики, подготовки отдельных тестов и редактирования документации. Результаты проверялись локальным запуском и тестами; ИИ не заменял выполнение проверок.
### Checklist
- [x] Контракт и публичные tests не ослаблялись ради прохождения.
- [x] Сценарии отказов и безопасности уровня 4/5 воспроизведены; результаты приложены в `evidence/`.
- [x] Локальные секреты исключены из Git через `.gitignore`; `.env` не должен добавляться в PR.
- [x] Исходный README задания сохранён, инструкция конкретной реализации находится в `REPORT.md`.
- [ ] Чистый запуск из clone и повторный `make test` после последних изменений подтверждены.
- [ ] `make validate` выполнен с `requirements-dev.txt`; приложен вывод.
+1
View File
@@ -2,6 +2,7 @@
.env
.env.*
!.env.example
!.env.compose.example
secrets/
certs/private/
*.key
+4
View File
@@ -10,6 +10,10 @@ COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app ./app
COPY migrations ./migrations
COPY scripts ./scripts
COPY tests ./tests
COPY contracts ./contracts
COPY lab.json .
COPY alembic.ini .
RUN chown -R app:app /app
USER app
+475 -20
View File
@@ -1,37 +1,492 @@
# Отчёт — лабораторная 4
# Отчёт — лабораторная работа №4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- **Автор, группа:** Перевалова Виктория, БПИ2302.
- **Целевая оценка:** 5.
- **Выбранный трек:** Track 1 — Presigned Upload (прямая загрузка в S3).
- **Основная гипотеза:** прямая загрузка файлов в S3-compatible хранилище по временной подписанной ссылке позволяет уменьшить объём данных, проходящих через API, и сократить время обработки больших файлов на стороне API.
- **Commit/PR:** будет указан после итогового commit и публикации изменений в Gitea.
- **Использованные источники, библиотеки и помощь ИИ:** исходный репозиторий лабораторной работы и материалы преподавателя; Python 3, FastAPI, SQLAlchemy, Alembic, PostgreSQL, Redis, boto3, Pillow, Docker Compose, S3-compatible object storage. ChatGPT использовался для анализа требований, проектирования отдельных компонентов, подготовки тестов, диагностики ошибок и оформления отчёта. Реализация и результаты проверялись запуском приложения и тестовых сценариев.
---
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
### 1. Требования к окружению
Для запуска проекта необходимы:
- Git;
- Docker Desktop с поддержкой Docker Compose;
- Python 3.13 для локального запуска вспомогательных тестовых скриптов;
- PowerShell (для Windows) или совместимая командная оболочка;
- доступ к Gitea и возможность клонировать репозиторий.
Основные сервисы запускаются в Docker Compose:
| Компонент | Используемая версия |
|---|---|
| PostgreSQL | 16.6-bookworm |
| Redis | 7.4.2-bookworm |
| S3-compatible storage (Silo) | RELEASE.2026-10-26T00-00-00Z |
| Traefik | 3.6.2 |
| API | Docker image проекта |
### 2. Клонирование проекта
```powershell
git clone https://gitea.privcloud.tech/perevalova/mtusi2026lab4.git
cd mtusi2026lab4
```
Для перехода на ветку с реализацией:
```powershell
git checkout solution/lab4-implementation
```
### 3. Подготовка конфигурации
Создать локальный файл `.env` на основе предоставленного примера:
```powershell
Copy-Item .env.compose.example .env
```
Перед запуском необходимо проверить соответствие переменных конфигурации требованиям `compose.yaml`.
Для работы инфраструктуры необходимо задать следующие переменные:
- `POSTGRES_PASSWORD` — пароль PostgreSQL;
- `MINIO_ROOT_USER` — административный пользователь S3-хранилища;
- `MINIO_ROOT_PASSWORD` — административный пароль S3-хранилища;
- `S3_ACCESS_KEY_ID` — отдельный пользователь приложения для доступа к S3;
- `S3_SECRET_ACCESS_KEY` — секретный ключ пользователя приложения;
- `S3_REGION` — регион S3;
- `S3_BUCKET` — имя bucket.
Дополнительные параметры ограничений загрузки и фоновой очистки имеют значения по умолчанию в Compose:
- `MAX_UPLOAD_BYTES` — 10 MiB;
- `MAX_IMAGE_PIXELS` — 40 000 000;
- `ATTACHMENT_CLEANUP_INTERVAL_SECONDS` — 60 секунд;
- `ATTACHMENT_CLEANUP_GRACE_SECONDS` — 600 секунд;
- `ATTACHMENT_CLEANUP_BATCH_SIZE` — 100 записей.
Секреты должны храниться только в локальном `.env`. Файл не должен попадать в Git.
Файл `.env.compose.example` содержит имена переменных, используемые непосредственно в `compose.yaml`. После копирования необходимо заменить все демонстрационные значения `CHANGE_ME` локальными секретами. Сам `.env` не добавляется в Git.
### 4. Проверка конфигурации и сборка
```powershell
docker compose config --quiet
docker compose build
```
### 5. Запуск инфраструктуры и приложения
```powershell
docker compose up -d --build --scale api=2
```
В проекте предусмотрены следующие компоненты:
- PostgreSQL;
- Redis;
- S3-compatible storage;
- сервис первоначальной настройки S3;
- Alembic migrations;
- две реплики API;
- Traefik.
Миграции выполняются отдельным сервисом `migrate` перед запуском API.
### 6. Ожидание готовности
Проверить состояние контейнеров:
```powershell
docker compose ps
```
Проверить readiness API:
```powershell
Invoke-RestMethod http://localhost:8080/health/ready
```
Ожидаемый результат:
```json
{
"status": "ok"
}
```
### 7. Проверка приложения
Проверка структуры и контракта:
```powershell
python -X utf8 scripts/check_contract.py
python -X utf8 scripts/validate_openapi.py
```
Для полной валидации OpenAPI установите dev-зависимости: `python -m pip install -r requirements-dev.txt`. Затем выполните `python -X utf8 scripts/validate_openapi.py`.
Проверка синтаксиса:
```powershell
python -X utf8 -m compileall -q app migrations
```
Публичный smoke-тест:
```powershell
python -X utf8 tests/smoke.py --base-url http://localhost:8080
```
Дополнительные проверки:
```powershell
python -X utf8 scripts/test_presigned_upload.py
python -X utf8 scripts/test_presigned_negative.py
```
В Dockerfile вспомогательные каталоги `scripts/`, `tests/`, `contracts/` и файл `lab.json` должны копироваться в образ API. После пересборки тест очистки незавершённых загрузок выполняется внутри API-контейнера:
```powershell
docker compose exec -T api python /app/scripts/test_attachment_cleanup.py
```
Тест компенсационного удаления при отказе PostgreSQL выполняется внутри API-контейнера:
```powershell
docker compose exec -T api python /app/scripts/test_s3_db_compensation.py
```
### 8. Остановка проекта
Безопасная остановка контейнеров с сохранением данных:
```powershell
docker compose down
```
Повторный запуск:
```powershell
docker compose up -d --build --scale api=2
```
**Внимание:** намеренное удаление учебных данных выполняется отдельно:
```powershell
docker compose down -v
```
Эта команда удаляет Docker volumes, включая данные PostgreSQL, Redis и S3-хранилища. Использовать её следует только при осознанном сбросе учебного окружения.
---
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
### 1. Общая архитектура
Система состоит из нескольких взаимодействующих компонентов.
```text
Клиент
|
v
Traefik
|
----------------
| |
v v
API-1 API-2
| |
---------------------------
| | |
v v v
PostgreSQL Redis S3 Storage
(метаданные) (кэш) (файлы)
```
Дополнительно используются:
- Alembic для управления миграциями;
- отдельный bootstrap-сервис для первоначальной настройки S3;
- фоновая задача очистки незавершённых загрузок, работающая в API-репликах.
**Примечание о выборе S3-сервера.** В Compose закреплён образ `pgsty/silo:RELEASE.2026-10-26T00-00-00Z`, совместимый с S3 API. В формулировке задания прямо перечислены MinIO, SeaweedFS и RustFS; Silo в этом перечне не назван. Замена сервера не выполнялась, поскольку текущий стенд и доказательства собраны на Silo. Это потенциальное формальное отклонение, которое следует согласовать с преподавателем.
### 2. Назначение компонентов
**API (FastAPI)**
Обрабатывает запросы пользователей, проверяет авторизацию и членство в чатах, выполняет загрузку и скачивание вложений, проверяет метаданные и взаимодействует с хранилищами.
**PostgreSQL**
Является источником истины для метаданных вложений и незавершённых загрузок.
В базе хранятся:
- идентификатор вложения;
- идентификатор чата;
- идентификатор владельца;
- имя файла;
- MIME-тип;
- размер;
- SHA-256;
- ключ объекта в S3;
- статус обработки;
- даты создания и изменения.
Для presigned-загрузок дополнительно сохраняются ожидаемые размер и контрольная сумма, срок действия и состояние загрузочной сессии.
**Redis**
Используется для кэширования истории сообщений и связанных с ней операций. Не является источником истины для вложений.
**S3-compatible storage**
Хранит бинарное содержимое файлов. Bucket `messenger-attachments` настроен как приватный.
API обращается к S3 по внутреннему адресу Docker-сети. Клиент использует публичный адрес S3 для прямой загрузки по подписанной ссылке.
**Traefik**
Распределяет запросы между двумя экземплярами API.
### 3. Источник истины и транзакционные границы
PostgreSQL хранит сведения о вложениях, а S3 — бинарные данные.
Между PostgreSQL и S3 нет общей атомарной транзакции. Поэтому согласованность обеспечивается последовательностью операций и компенсационными действиями.
Для Proxy Upload:
1. API принимает и проверяет файл.
2. Загружает содержимое в S3.
3. Создаёт запись метаданных в PostgreSQL.
4. Если сохранение метаданных завершается ошибкой, API выполняет rollback и пытается удалить объект из S3.
Для Presigned Upload:
1. API проверяет пользователя и членство в чате.
2. Создаёт уникальный ключ объекта и запись `pending` в PostgreSQL.
3. Возвращает временную подписанную ссылку.
4. Клиент загружает файл непосредственно в S3.
5. Клиент вызывает endpoint завершения загрузки.
6. API получает объект из S3, проверяет размер, SHA-256 и содержимое изображения.
7. После успешной проверки создаёт запись вложения и переводит загрузку в состояние `completed`.
При ошибках проверки загрузка переводится в `failed`, а объект удаляется из S3 при успешном выполнении компенсационного действия.
Для незавершённых загрузок используется фоновая очистка с периодической проверкой просроченных записей. Для конкурентной работы нескольких API-реплик применяется блокировка PostgreSQL `FOR UPDATE SKIP LOCKED`.
### 4. Ограничения загрузки и безопасность
Поддерживаются PNG и JPEG.
Ограничения:
- максимальный размер файла — 10 MiB;
- максимальное количество пикселей — 40 000 000;
- проверяется фактический формат содержимого;
- проверяется соответствие MIME-типа;
- проверяется SHA-256;
- используется безопасное имя файла;
- тело запроса читается потоково;
- для больших файлов применяется временный файл вместо неограниченного хранения в RAM;
- скачивание доступно только авторизованным участникам соответствующего чата.
S3 bucket закрыт для анонимного доступа. Для приложения создан отдельный S3-пользователь с отдельной политикой доступа.
Административная консоль S3 не опубликована на хостовой машине.
---
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
В таблице приведены выполненные сценарии и фактические результаты.
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий | Команда / сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Проверка структуры проекта | `python -X utf8 scripts/check_contract.py` | PASS: структура, локальные ссылки и синтаксис | `evidence/check-contract.txt` (если сохранён; иначе вывод команды) |
| Валидация OpenAPI | `python -X utf8 scripts/validate_openapi.py` | PASS: OpenAPI 3.1 и JSON Schema | Вывод команды |
| Публичный smoke | `python -X utf8 tests/smoke.py --base-url http://localhost:8080` | PASS: публичный API-сценарий; повторно подтверждён после исправления маршрутизации Traefik | `evidence/smoke.txt` |
| Готовность API | `Invoke-RestMethod http://localhost:8080/health/ready` | `status: ok` | Вывод команды |
| Две API-реплики | `docker compose ps` | Обе реплики имеют статус healthy | `evidence/persistence-before.txt`, `evidence/failover-before.txt` |
| Хранение бинарных данных в S3 | Proxy Upload и проверка скачивания | Файл сохраняется и возвращается с совпадающим SHA-256 | `evidence/track1-results.csv` |
| Метаданные в PostgreSQL | Загрузка и получение вложения | Сохраняются владелец, чат, размер, MIME, SHA-256 и статус | `evidence/track1-results.csv` |
| Ограничение размера | Загрузка файла больше 10 MiB | HTTP 413 | `evidence/negative-tests-results.txt` |
| Повреждённое изображение | Загрузка некорректных байтов | HTTP 415 | `evidence/negative-tests-results.txt` |
| Несовпадение MIME | PNG с `image/jpeg` | HTTP 415 | `evidence/negative-tests-results.txt` |
| Проверка SHA-256 | Неверная ожидаемая контрольная сумма | HTTP 409 | `evidence/negative-tests-results.txt` |
| Проверка размера | Неверный ожидаемый размер | HTTP 409 | `evidence/negative-tests-results.txt` |
| Защита от чужой загрузки | Чужой пользователь вызывает complete | HTTP 404 | `evidence/negative-tests-results.txt` |
| Защита метаданных | Неучастник чата запрашивает вложение | HTTP 404 | `evidence/negative-tests-results.txt` |
| Защита скачивания | Неучастник чата скачивает вложение | HTTP 404 | `evidence/negative-tests-results.txt` |
| Запрет межчатового прикрепления | Вложение из одного чата отправляется в другой | HTTP 404 | `evidence/negative-tests-results.txt` |
| Идемпотентность завершения | Повторное завершение загрузки | Возвращается существующее вложение | Вывод `scripts/test_presigned_upload.py` |
| Прямой Presigned Upload | Создание ссылки, PUT в S3, complete | Последний повторный запуск: PASS; загрузка завершена, SHA-256 совпадает | Вывод `scripts/test_presigned_upload.py` |
| Очистка незавершённых загрузок | Ожидание фонового cleanup | Статус `expired`, объект удалён из S3 | `evidence/attachment-cleanup-results.txt` |
| Компенсация Proxy Upload | Искусственная ошибка PostgreSQL после S3 PUT | HTTP 503, объект удалён из S3 | `evidence/s3-db-compensation-results.txt` |
| Приватность bucket | `curl.exe -i http://localhost:9000/messenger-attachments/` без авторизации | HTTP 403 Forbidden (`AccessDenied`) | `evidence/s3-security-results.txt` |
| Недоступность S3 Console | `docker compose port minio 9001` | Порт 9001 не опубликован на хост | `evidence/s3-security-results.txt` |
| Сохранность данных | Перезапуск PostgreSQL, Redis, S3 и API без удаления volumes | Подтверждённые данные и существующая сессия сохранены | `evidence/persistence-results.txt` |
| Отказоустойчивость API | Остановка одной API-реплики | 108 успешных записей, 1 неуспешная попытка, первое восстановление за 2,607 с (общий сценарий сообщений) | `evidence/failover-results.txt` |
| Отказоустойчивость вложений | Остановка именно API-реплики, обслужившей Proxy Upload; скачивание через оставшуюся реплику | 2 реплики до отказа; 87 успешных записей, 4 неуспешные попытки; первое восстановление за 4,597 с; вложение скачано побайтно идентичным | `evidence/attachment-failover-results.txt` |
| Недоступность S3 | Остановка S3-сервиса | Readiness сообщил `Required storage unavailable`; после запуска S3 обе API-реплики восстановили readiness | `evidence/s3-unavailable-results.txt` |
| Эксперимент Track 1 | Сравнение Proxy и Presigned | Измерены полное время, время API и размер тела запросов | `evidence/track1-results.csv` |
| Параллельная загрузка | 10 одновременных Proxy и 10 Presigned загрузок | 10/10 успешных в обоих режимах | `evidence/concurrent-upload-results.txt`, `evidence/concurrent-upload-results.csv` |
### Подтверждение инфраструктурных hook
Для проверки сохранности данных использовался сценарий перезапуска:
```sh
docker compose restart postgres redis minio api
```
Таким образом, перезапускались:
- PostgreSQL;
- Redis;
- S3-compatible storage;
- API.
Docker volumes при этом не удалялись.
Для общего сценария отказоустойчивости API останавливался один из двух экземпляров API. Наблюдаемый результат: 108 успешных записей, 1 неуспешная попытка и первое восстановление за 2,607 секунды (`evidence/failover-results.txt`).
Отдельно проверялся отказ именно той API-реплики, которая обслужила загрузку вложения. Тест получил идентификатор обслужившей реплики из ответа API, остановил именно её, продолжил работу через оставшуюся реплику и скачал вложение. Результат: 87 успешных записей, 4 неуспешные попытки, первое восстановление за 4,597 секунды; содержимое вложения совпало побайтно (`evidence/attachment-failover-results.txt`).
---
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### Исследовательский трек 1 — Presigned Upload
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
#### Гипотеза
## Ограничения и следующие шаги
Прямая загрузка файлов из клиента в S3-compatible хранилище по временной подписанной ссылке позволяет существенно сократить объём данных, передаваемых через API. Предполагается, что это уменьшит объём передаваемых через API данных и время обработки запроса на стороне API при работе с крупными вложениями.
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
#### Методика эксперимента
Сравнивались два способа загрузки:
1. **Proxy Upload** — клиент передаёт бинарное содержимое файла API, после чего API сохраняет его в S3.
2. **Presigned Upload** — API выдаёт временную подписанную ссылку, клиент загружает файл непосредственно в S3, затем вызывает endpoint завершения загрузки.
Использовались два PNG-файла:
- `sample.png` — 111 817 байт (0,11 MiB);
- `sample_large.png` — 5 769 330 байт (5,50 MiB).
Для каждого сочетания способа загрузки и размера файла выполнено по три повтора. Всего проведено 12 измерений.
Среда эксперимента: Docker Compose, два экземпляра API, PostgreSQL 16.6, Redis 7.4.2, Silo S3-compatible storage. API-контейнеры имели ограничение памяти 512 MiB.
#### Результаты
| Способ загрузки | Размер файла | Среднее полное время | Среднее время запросов к API | Тело запросов к API |
|---|---:|---:|---:|---:|
| Proxy | 111 817 Б | 0,0786 с | 0,0785 с | 111 817 Б |
| Presigned | 111 817 Б | 0,1296 с | 0,0826 с | 158 Б |
| Proxy | 5 769 330 Б | 0,2666 с | 0,2665 с | 5 769 330 Б |
| Presigned | 5 769 330 Б | 0,2564 с | 0,1275 с | 159 Б |
При загрузке большого файла объём тела запросов клиента к API сократился примерно на 99,997%. При загрузке небольшого файла сокращение составило около 99,86%.
Полное время загрузки большого файла при Presigned Upload оказалось примерно на 3,8% меньше, чем при Proxy Upload. Суммарное время запросов к API сократилось примерно на 52,2%.
#### Параллельная загрузка
Дополнительно проведён эксперимент с десятью одновременными загрузками файла размером 5 769 330 байт.
Для каждого способа загрузки выполнялось по десять параллельных операций.
| Показатель | Proxy | Presigned |
|---|---:|---:|
| Количество загрузок | 10 | 10 |
| Успешные загрузки | 10 | 10 |
| Ошибки | 0 | 0 |
| Общее время | 3,996 с | 4,941 с |
| Пиковая суммарная RAM API | 220,2 MiB | 304,4 MiB |
| Прирост RAM относительно базового уровня | 16,1 MiB | 84,2 MiB |
Параллельный эксперимент подтвердил, что оба способа справляются с десятью одновременными загрузками без ошибок.
При этом в данном запуске Presigned Upload показал более высокий пик памяти. Поэтому утверждать, что прямая загрузка снижает потребление RAM, нельзя.
#### Потребление памяти в последовательном эксперименте
В ходе последовательного эксперимента фиксировалась память API-контейнеров с помощью `docker stats`. Измерения выполнялись с интервалом около 100 мс.
Зафиксированные максимальные значения среди API-реплик:
- Proxy, маленький файл — 103,4 MiB;
- Presigned, маленький файл — 112,7 MiB;
- Proxy, большой файл — 109,2 MiB;
- Presigned, большой файл — 128,9 MiB.
Результаты не подтверждают снижение RAM при Presigned Upload в текущем эксперименте. Измерения ограничены интервалом опроса Docker Stats и не позволяют исключить кратковременные пики между замерами.
#### Вывод
Гипотеза о сокращении объёма данных, передаваемых через API, подтверждена.
Presigned Upload позволяет передавать содержимое файла непосредственно в S3, оставляя API операции выдачи временной ссылки, проверки загрузки и сохранения метаданных.
Уменьшение времени обработки запросов API для большого файла также наблюдалось. Однако снижение общего времени загрузки небольших файлов не подтверждено, а снижение потребления RAM требует дополнительного исследования.
**Файлы с исходными измерениями:**
- `evidence/track1-results.csv`;
- `evidence/concurrent-upload-results.csv`;
- `evidence/concurrent-upload-results.txt`.
### Проверка отказов и восстановления
| Воздействие | Что ожидалось | Что наблюдалось | Время восстановления / потеря данных |
|---|---|---|---|
| Перезапуск PostgreSQL, Redis, S3 и API | Сохранение подтверждённых данных при сохранении volumes | Подтверждённые сообщения, вложения и существующая сессия сохранились | Данные не потеряны |
| Остановка одной API-реплики (общий сценарий) | Продолжение работы через оставшуюся реплику | 108 успешных записей, 1 неуспешная попытка | Первое восстановление — 2,607 с |
| Остановка реплики, обслужившей загрузку вложения | Доступность вложения через другую реплику | 87 успешных записей, 4 неуспешные попытки; вложение скачано побайтно идентичным | Первое восстановление — 4,597 с |
| Незавершённая Presigned Upload | Удаление просроченного объекта и обновление статуса | Запись получила статус `expired`, объект удалён | Ожидание фоновой очистки |
| Недоступность S3 | Остановка S3-сервиса | Readiness сообщил `Required storage unavailable`; после восстановления S3 readiness снова `ok` | Сервис восстановлен без пересоздания API |
| Ошибка PostgreSQL после загрузки в S3 через Proxy | Компенсационное удаление объекта | HTTP 503, объект отсутствует в S3 | Объект удалён |
| Ошибка проверки SHA-256 | Отклонение загрузки и удаление некорректного объекта | HTTP 409 | Ошибка обработана |
| Несовпадение размера файла | Отклонение загрузки | HTTP 409 | Ошибка обработана |
| Повреждённое изображение | Отклонение содержимого | HTTP 415 | Ошибка обработана |
| Превышение лимита размера | Отклонение загрузки до неограниченного чтения | HTTP 413 | Ошибка обработана |
| Несовпадение MIME-типа | Отклонение файла | HTTP 415 | Ошибка обработана |
| Чужой пользователь завершает загрузку | Запрет доступа | HTTP 404 | Доступ запрещён |
| Попытка прикрепить вложение из другого чата | Запрет межчатового доступа | HTTP 404 | Доступ запрещён |
### Известные ограничения
1. PostgreSQL и S3 не используют общую распределённую транзакцию. Согласованность обеспечивается компенсационными операциями и фоновой очисткой.
2. Удаление объекта из S3 является best-effort операцией. При одновременном отказе хранилища и компенсационного удаления может потребоваться повторная проверка состояния.
3. Фоновая очистка работает с зарегистрированными незавершёнными загрузками. Объекты, для которых вообще не была создана запись загрузки, требуют отдельного механизма сверки или политики жизненного цикла S3.
4. Эксперимент по памяти проводился с периодическим опросом Docker Stats. В параллельном запуске мониторинг успел получить лишь 4–5 измерений, поэтому кратковременные пики могли быть пропущены.
5. Эксперименты проведены в локальной Docker-среде, а не в распределённой производственной инфраструктуре. Результаты нельзя автоматически переносить на промышленную нагрузку.
6. Для прямой загрузки необходима доступность S3 endpoint со стороны клиента. В локальном окружении используется опубликованный адрес S3 API.
7. Фактическое снижение потребления RAM при Presigned Upload экспериментально не подтверждено.
### Итоговый вывод
В лабораторной работе реализовано S3-хранилище вложений для приложения обмена сообщениями. Бинарные данные хранятся отдельно от метаданных, которые сохраняются в PostgreSQL.
Реализованы два способа загрузки файлов: Proxy Upload и Presigned Upload. Для прямой загрузки разработан механизм выдачи временных подписанных ссылок и последующей проверки загруженного объекта.
Проведены проверки безопасности, негативные тесты, проверка очистки незавершённых загрузок, компенсации при отказе PostgreSQL, сохранности данных после перезапуска и отказоустойчивости двух API-реплик.
В исследовательском треке 1 подтверждено существенное сокращение объёма данных, передаваемых через API. Для файла размером 5,5 MiB тело запроса к API уменьшилось с 5 769 330 до 159 байт. При этом эксперимент не подтвердил снижение потребления оперативной памяти.
Таким образом, реализация демонстрирует преимущества прямой загрузки в S3, сохраняет совместимость с обязательным Proxy Upload и включает механизмы проверки и обработки ошибок при работе с двумя независимыми хранилищами.
+422
View File
@@ -0,0 +1,422 @@
import hashlib
import tempfile
import uuid
from datetime import datetime, timezone, timedelta
from urllib.parse import quote
from fastapi import APIRouter, Depends, Header, HTTPException, Query, Request, Response
from fastapi.responses import StreamingResponse
from sqlalchemy import select
from sqlalchemy.orm import Session
from botocore.exceptions import BotoCoreError, ClientError
from app.api.deps import get_db, get_current_user
from app.core.config import settings
from app.models import CreateAttachmentUpload
from app.db.models import Attachment, AttachmentUpload, User
from app.services.object_storage import client, create_presigned_upload_url
from app.services.image_validation import MAX_BYTES, validate_image_file
from app.repositories.chat_repository import ChatRepository
router = APIRouter(prefix="/api/v1", tags=["Attachments"])
def iso_utc(value):
return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
def attachment_json(item):
return {
"id": str(item.id), "chat_id": str(item.chat_id), "owner_id": str(item.owner_id),
"filename": item.filename, "content_type": item.content_type,
"size_bytes": item.size_bytes, "sha256": item.sha256, "status": item.status,
"variants": [], "error_code": item.error_code,
"created_at": iso_utc(item.created_at), "updated_at": iso_utc(item.updated_at),
}
def member_attachment(db, attachment_id, user_id):
item = db.get(Attachment, attachment_id)
if item is None or not ChatRepository(db).is_member(item.chat_id, user_id):
raise HTTPException(404, "Attachment not found")
return item
async def read_limited(request: Request):
declared = request.headers.get("content-length")
if declared and declared.isdigit() and int(declared) > MAX_BYTES:
raise HTTPException(413, "Image exceeds 10 MiB")
size = 0
# Keep at most 1 MiB in RAM; larger bodies spill to a temporary file.
spool = tempfile.SpooledTemporaryFile(max_size=1024 * 1024, mode="w+b")
try:
async for chunk in request.stream():
size += len(chunk)
if size > MAX_BYTES:
raise HTTPException(413, "Image exceeds 10 MiB")
spool.write(chunk)
spool.seek(0)
return spool, size
except Exception:
spool.close()
raise
def sha256_file(fileobj):
digest = hashlib.sha256()
fileobj.seek(0)
while True:
chunk = fileobj.read(1024 * 1024)
if not chunk: break
digest.update(chunk)
fileobj.seek(0)
return digest.hexdigest()
@router.post("/chats/{chat_id}/attachments/presigned", status_code=201)
def create_attachment_upload(
chat_id: str,
payload: CreateAttachmentUpload,
db: Session = Depends(get_db),
user: User = Depends(get_current_user),
):
try:
chat_uuid = uuid.UUID(chat_id)
except ValueError:
raise HTTPException(400, "Invalid chat UUID") from None
if not ChatRepository(db).is_member(chat_uuid, user.id):
raise HTTPException(404, "Chat not found")
if payload.size_bytes > settings.max_upload_bytes:
raise HTTPException(413, "Image exceeds configured upload limit")
upload_id = uuid.uuid4()
object_key = f"uploads/{chat_uuid}/{upload_id}"
expires_at = datetime.now(timezone.utc) + timedelta(
seconds=settings.presigned_upload_ttl_seconds
)
try:
upload_url = create_presigned_upload_url(
object_key=object_key,
content_type=payload.content_type,
)
except (BotoCoreError, ClientError):
raise HTTPException(503, "Object storage unavailable") from None
upload = AttachmentUpload(
id=upload_id,
chat_id=chat_uuid,
owner_id=user.id,
filename=payload.filename,
content_type=payload.content_type,
expected_size_bytes=payload.size_bytes,
expected_sha256=payload.sha256.lower(),
object_key=object_key,
status="pending",
expires_at=expires_at,
)
try:
db.add(upload)
db.commit()
except Exception:
db.rollback()
raise HTTPException(503, "Could not save upload metadata") from None
return {
"upload_id": str(upload_id),
"upload_url": upload_url,
"method": "PUT",
"headers": {
"Content-Type": payload.content_type,
},
"expires_in": settings.presigned_upload_ttl_seconds,
"expires_at": iso_utc(expires_at),
}
@router.post("/attachments/uploads/{upload_id}/complete", status_code=200)
def complete_attachment_upload(
upload_id: str,
db: Session = Depends(get_db),
user: User = Depends(get_current_user),
):
try:
parsed_id = uuid.UUID(upload_id)
except ValueError:
raise HTTPException(400, "Invalid upload UUID") from None
# Lock the upload row to prevent concurrent completion.
upload = db.scalar(
select(AttachmentUpload)
.where(AttachmentUpload.id == parsed_id)
.with_for_update()
)
if upload is None:
raise HTTPException(404, "Upload not found")
if (
upload.owner_id != user.id
or not ChatRepository(db).is_member(upload.chat_id, user.id)
):
raise HTTPException(404, "Upload not found")
# Idempotent completion: return the existing attachment.
if upload.status == "completed":
item = db.scalar(
select(Attachment).where(
Attachment.object_key == upload.object_key
)
)
if item is None:
raise HTTPException(409, "Completed attachment not found")
return attachment_json(item)
if upload.status != "pending":
raise HTTPException(409, "Upload is not pending")
now = datetime.now(timezone.utc)
if upload.expires_at <= now:
upload.status = "expired"
db.commit()
try:
client().delete_object(
Bucket=settings.s3_bucket,
Key=upload.object_key,
)
except Exception:
pass
raise HTTPException(409, "Upload has expired")
s3 = client()
# Read the object from S3.
try:
result = s3.get_object(
Bucket=settings.s3_bucket,
Key=upload.object_key,
)
except ClientError as exc:
code = exc.response.get("Error", {}).get("Code", "")
if code in {"NoSuchKey", "404", "NotFound"}:
raise HTTPException(409, "Uploaded object not found") from None
raise HTTPException(503, "Object storage unavailable") from None
except BotoCoreError:
raise HTTPException(503, "Object storage unavailable") from None
body = result["Body"]
spool = tempfile.SpooledTemporaryFile(
max_size=1024 * 1024,
mode="w+b",
)
def reject_upload(status_code: int, detail: str):
upload.status = "failed"
db.commit()
try:
s3.delete_object(
Bucket=settings.s3_bucket,
Key=upload.object_key,
)
except Exception:
pass
raise HTTPException(status_code=status_code, detail=detail)
try:
actual_size = result.get("ContentLength")
if actual_size != upload.expected_size_bytes:
reject_upload(409, "Uploaded file size mismatch")
if actual_size > settings.max_upload_bytes:
reject_upload(413, "Image exceeds configured upload limit")
total = 0
digest = hashlib.sha256()
try:
while True:
chunk = body.read(64 * 1024)
if not chunk:
break
total += len(chunk)
if total > settings.max_upload_bytes:
reject_upload(413, "Image exceeds configured upload limit")
if total > upload.expected_size_bytes:
reject_upload(409, "Uploaded file size mismatch")
digest.update(chunk)
spool.write(chunk)
finally:
body.close()
if total != upload.expected_size_bytes:
reject_upload(409, "Uploaded file size mismatch")
if digest.hexdigest() != upload.expected_sha256:
reject_upload(409, "Uploaded file checksum mismatch")
# Validate the actual image content, not only S3 metadata.
try:
actual_type, _, _ = validate_image_file(
spool,
upload.content_type,
)
except HTTPException as exc:
reject_upload(exc.status_code, str(exc.detail))
attachment = Attachment(
id=uuid.uuid4(),
chat_id=upload.chat_id,
owner_id=upload.owner_id,
filename=upload.filename,
content_type=actual_type,
size_bytes=total,
sha256=digest.hexdigest(),
object_key=upload.object_key,
status="ready",
error_code=None,
)
upload.status = "completed"
upload.completed_at = now
db.add(attachment)
db.commit()
db.refresh(attachment)
return attachment_json(attachment)
except HTTPException:
raise
except (BotoCoreError, ClientError):
db.rollback()
raise HTTPException(503, "Object storage unavailable") from None
except Exception:
db.rollback()
raise
finally:
spool.close()
@router.post("/chats/{chat_id}/attachments", status_code=201)
async def upload_attachment(
chat_id: str, request: Request, filename: str = Query(..., min_length=1, max_length=255),
db: Session = Depends(get_db), user: User = Depends(get_current_user),
):
try:
chat_uuid = uuid.UUID(chat_id)
except ValueError:
raise HTTPException(400, "Invalid chat UUID") from None
if not ChatRepository(db).is_member(chat_uuid, user.id):
raise HTTPException(404, "Chat not found")
if not filename.strip() or any(c in filename for c in ("/", "\\", "\x00")) or any(ord(c) < 32 or ord(c) == 127 for c in filename):
raise HTTPException(400, "Unsafe filename")
content_type = request.headers.get("content-type", "").split(";", 1)[0].strip().lower()
if content_type not in {"image/png", "image/jpeg"}:
raise HTTPException(415, "Only PNG and JPEG are supported")
spool, size = await read_limited(request)
try:
actual_type, _, _ = validate_image_file(spool, content_type)
digest = sha256_file(spool)
attachment_id = uuid.uuid4()
object_key = f"original/{chat_uuid}/{attachment_id}"
s3 = client()
try:
s3.put_object(Bucket=settings.s3_bucket, Key=object_key, Body=spool, ContentType=actual_type)
except (BotoCoreError, ClientError):
raise HTTPException(503, "Object storage unavailable") from None
item = Attachment(
id=attachment_id, chat_id=chat_uuid, owner_id=user.id, filename=filename,
content_type=actual_type, size_bytes=size, sha256=digest,
object_key=object_key, status="ready", error_code=None,
)
try:
db.add(item)
db.commit()
db.refresh(item)
except Exception:
db.rollback()
try: s3.delete_object(Bucket=settings.s3_bucket, Key=object_key)
except Exception: pass
raise HTTPException(503, "Could not save attachment metadata") from None
return attachment_json(item)
finally:
spool.close()
@router.get("/attachments/{attachment_id}")
def get_attachment(attachment_id: str, db: Session = Depends(get_db), user: User = Depends(get_current_user)):
try: parsed = uuid.UUID(attachment_id)
except ValueError: raise HTTPException(400, "Invalid attachment UUID") from None
item = member_attachment(db, parsed, user.id)
if item.status != "ready":
raise HTTPException(409, "Attachment upload is not completed")
return attachment_json(item)
@router.get("/attachments/{attachment_id}/content")
def download_attachment(attachment_id: str, variant: str = "original", db: Session = Depends(get_db), user: User = Depends(get_current_user)):
if variant != "original":
raise HTTPException(404, "Variant not found")
try: parsed = uuid.UUID(attachment_id)
except ValueError: raise HTTPException(400, "Invalid attachment UUID") from None
item = member_attachment(db, parsed, user.id)
if item.status != "ready":
raise HTTPException(409, "Attachment is not ready")
spool = tempfile.SpooledTemporaryFile(max_size=1024 * 1024, mode="w+b")
try:
result = client().get_object(Bucket=settings.s3_bucket, Key=item.object_key)
body = result["Body"]
total = 0
digest = hashlib.sha256()
try:
while True:
chunk = body.read(64 * 1024)
if not chunk:
break
total += len(chunk)
if total > MAX_BYTES:
raise HTTPException(503, "Stored object exceeds configured limit")
digest.update(chunk)
spool.write(chunk)
finally:
body.close()
if total != item.size_bytes or digest.hexdigest() != item.sha256:
raise HTTPException(503, "Stored object checksum mismatch")
spool.seek(0)
except (BotoCoreError, ClientError):
spool.close()
raise HTTPException(503, "Object storage unavailable") from None
except Exception:
spool.close()
raise
def stream_verified_file():
try:
while True:
chunk = spool.read(64 * 1024)
if not chunk:
break
yield chunk
finally:
spool.close()
return StreamingResponse(
stream_verified_file(),
media_type=item.content_type,
headers={"Content-Disposition": f"inline; filename*=UTF-8''{quote(item.filename)}"},
)
+2 -2
View File
@@ -20,7 +20,7 @@ def message_to_response(message) -> MessageResponse:
return MessageResponse(
id=str(message.id), chat_id=str(message.chat_id),
sender_id=str(message.sender_id), text=message.text,
created_at=message.created_at,
created_at=message.created_at, attachment_ids=message.attachment_ids or [],
)
@@ -44,7 +44,7 @@ def create_message(
try:
message = MessageService(db).create_message(
chat_id=parsed_id, sender_id=user.id, text=body.text,
idempotency_key=idempotency_key,
idempotency_key=idempotency_key, attachment_ids=body.attachment_ids,
)
return message_to_response(message)
except MessageNotFoundError:
+25
View File
@@ -1,4 +1,5 @@
import os
from pydantic import AliasChoices, Field
from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -15,6 +16,30 @@ class Settings(BaseSettings):
idempotency_ttl_seconds: int = 86400
instance_id: str = os.getenv("INSTANCE_ID") or os.getenv("HOSTNAME") or "api-local"
shutdown_grace_seconds: int = 20
s3_endpoint_url: str = Field(
default="http://minio:9000",
validation_alias=AliasChoices("S3_ENDPOINT_URL", "S3_ENDPOINT"),
)
s3_public_endpoint_url: str = Field(
default="http://localhost:9000",
validation_alias=AliasChoices("S3_PUBLIC_ENDPOINT_URL"),
)
presigned_upload_ttl_seconds: int = 300
attachment_cleanup_interval_seconds: int = Field(default=60, ge=5, le=3600)
attachment_cleanup_grace_seconds: int = Field(default=600, ge=0, le=86400)
attachment_cleanup_batch_size: int = Field(default=100, ge=1, le=1000)
s3_region: str = Field(default="us-east-1", validation_alias=AliasChoices("S3_REGION"))
s3_bucket: str = Field(default="messenger-attachments", validation_alias=AliasChoices("S3_BUCKET"))
s3_access_key: str = Field(
default="messenger-api",
validation_alias=AliasChoices("S3_ACCESS_KEY", "S3_ACCESS_KEY_ID"),
)
s3_secret_key: str = Field(
default="change-me-api-secret",
validation_alias=AliasChoices("S3_SECRET_KEY", "S3_SECRET_ACCESS_KEY"),
)
max_upload_bytes: int = 10 * 1024 * 1024
max_image_pixels: int = 40_000_000
model_config = SettingsConfigDict(
env_file=".env", env_file_encoding="utf-8", extra="ignore"
+83
View File
@@ -4,6 +4,7 @@ from datetime import datetime, timezone
from sqlalchemy import (
DateTime,
JSON,
ForeignKey,
Index,
String,
@@ -129,6 +130,7 @@ class Message(Base):
Text,
nullable=False,
)
attachment_ids: Mapped[list] = mapped_column(JSON, nullable=False, default=list)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=utc_now,
@@ -213,3 +215,84 @@ class IdempotencyRecord(Base):
),
Index("ix_idempotency_records_expires_at", "expires_at"),
)
class Attachment(Base):
__tablename__ = "attachments"
id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
chat_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False, index=True)
owner_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
filename: Mapped[str] = mapped_column(String(255), nullable=False)
content_type: Mapped[str] = mapped_column(String(32), nullable=False)
size_bytes: Mapped[int] = mapped_column(nullable=False)
sha256: Mapped[str] = mapped_column(String(64), nullable=False)
object_key: Mapped[str] = mapped_column(String(512), unique=True, nullable=False)
status: Mapped[str] = mapped_column(String(16), nullable=False, default="ready")
error_code: Mapped[str | None] = mapped_column(String(64), nullable=True)
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utc_now, nullable=False)
updated_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), default=utc_now, onupdate=utc_now, nullable=False)
class AttachmentUpload(Base):
__tablename__ = "attachment_uploads"
id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
)
chat_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("chats.id", ondelete="CASCADE"),
nullable=False,
)
owner_id: Mapped[uuid.UUID] = mapped_column(
UUID(as_uuid=True),
ForeignKey("users.id", ondelete="CASCADE"),
nullable=False,
)
filename: Mapped[str] = mapped_column(
String(255),
nullable=False,
)
content_type: Mapped[str] = mapped_column(
String(32),
nullable=False,
)
expected_size_bytes: Mapped[int] = mapped_column(
nullable=False,
)
expected_sha256: Mapped[str] = mapped_column(
String(64),
nullable=False,
)
object_key: Mapped[str] = mapped_column(
String(512),
unique=True,
nullable=False,
)
status: Mapped[str] = mapped_column(
String(16),
nullable=False,
default="pending",
)
expires_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
nullable=False,
)
created_at: Mapped[datetime] = mapped_column(
DateTime(timezone=True),
default=utc_now,
nullable=False,
)
completed_at: Mapped[datetime | None] = mapped_column(
DateTime(timezone=True),
nullable=True,
)
__table_args__ = (
Index("ix_attachment_uploads_chat_id", "chat_id"),
Index("ix_attachment_uploads_owner_id", "owner_id"),
Index("ix_attachment_uploads_expires_at", "expires_at"),
)
+25 -5
View File
@@ -1,6 +1,7 @@
import asyncio
import logging
import uuid
from contextlib import asynccontextmanager
from contextlib import asynccontextmanager, suppress
from fastapi import FastAPI, HTTPException, Request
from fastapi.exceptions import RequestValidationError
@@ -13,25 +14,43 @@ from app.api.auth import router as auth_router
from app.api.users import router as users_router
from app.api.chats import router as chats_router
from app.api.messages import router as messages_router
from app.api.attachments import router as attachments_router
from app.core.config import settings
from app.db.session import engine
from app.services.object_storage import client as s3_client
from app.services.attachment_cleanup import cleanup_expired_uploads
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
logger = logging.getLogger(__name__)
async def attachment_cleanup_loop():
while True:
try:
# Synchronous boto3/SQLAlchemy I/O must not block the event loop.
await asyncio.to_thread(cleanup_expired_uploads)
except Exception:
logger.exception("Attachment cleanup worker iteration failed")
await asyncio.sleep(settings.attachment_cleanup_interval_seconds)
@asynccontextmanager
async def lifespan(app: FastAPI):
logger.info("Application startup instance_id=%s", settings.instance_id)
cleanup_task = asyncio.create_task(attachment_cleanup_loop())
try:
yield
finally:
cleanup_task.cancel()
with suppress(asyncio.CancelledError):
await cleanup_task
engine.dispose()
logger.info("Application shutdown instance_id=%s", settings.instance_id)
app = FastAPI(title=settings.app_name, version="1.3.0", lifespan=lifespan)
app = FastAPI(title=settings.app_name, version="1.4.0", lifespan=lifespan)
app.include_router(users_router)
app.include_router(auth_router)
app.include_router(chats_router)
app.include_router(messages_router)
app.include_router(attachments_router)
@app.middleware("http")
async def response_headers(request: Request, call_next):
@@ -77,10 +96,11 @@ def readiness():
try:
with engine.connect() as connection:
connection.execute(text("SELECT 1"))
s3_client().head_bucket(Bucket=settings.s3_bucket)
return {"status": "ok"}
except SQLAlchemyError:
logger.exception("PostgreSQL readiness check failed")
except Exception:
logger.exception("PostgreSQL or S3 readiness check failed")
raise HTTPException(
status_code=503,
detail="Database unavailable",
detail="Required storage unavailable",
) from None
+32 -4
View File
@@ -1,6 +1,6 @@
from datetime import datetime, timezone
from typing import List, Optional
from typing import List, Optional, Literal
from pydantic import BaseModel, ConfigDict, Field, field_validator
@@ -67,14 +67,20 @@ class Chat(BaseConfig):
class CreateMessage(BaseConfig):
text: str = Field(..., min_length=1, max_length=4000)
text: str = Field(..., max_length=4000)
attachment_ids: List[str] = Field(default_factory=list, max_length=10)
@field_validator("attachment_ids")
@classmethod
def validate_attachment_ids(cls, value):
if len(value) != len(set(value)):
raise ValueError("attachment_ids must be unique")
return value
@field_validator("text")
@classmethod
def validate_text(cls, value: str) -> str:
value = value.strip()
if not value:
raise ValueError("text must not be blank")
return value
@@ -84,6 +90,7 @@ class Message(BaseConfig):
sender_id: str
text: str
created_at: datetime
attachment_ids: List[str] = Field(default_factory=list)
class Health(BaseConfig):
@@ -108,3 +115,24 @@ class ChatPage(BaseConfig):
class MessagePage(BaseConfig):
items: List[Message]
next_cursor: Optional[str] = None
class CreateAttachmentUpload(BaseConfig):
filename: str = Field(..., min_length=1, max_length=255)
content_type: Literal["image/png", "image/jpeg"]
size_bytes: int = Field(..., gt=0, le=10 * 1024 * 1024)
sha256: str = Field(..., pattern=r"^[a-fA-F0-9]{64}$")
@field_validator("filename")
@classmethod
def validate_filename(cls, value: str) -> str:
value = value.strip()
if (
not value
or any(c in value for c in ("/", "\\", "\x00"))
or any(ord(c) < 32 or ord(c) == 127 for c in value)
):
raise ValueError("Unsafe filename")
return value
+2
View File
@@ -28,11 +28,13 @@ class MessageRepository:
chat_id: uuid.UUID,
sender_id: uuid.UUID,
text: str,
attachment_ids: list[str] | None = None,
) -> Message:
message = Message(
chat_id=chat_id,
sender_id=sender_id,
text=text,
attachment_ids=attachment_ids or [],
)
self.db.add(message)
+66
View File
@@ -0,0 +1,66 @@
"""Best-effort cleanup for abandoned presigned uploads."""
import logging
from datetime import datetime, timedelta, timezone
from sqlalchemy import select
from app.core.config import settings
from app.db.models import AttachmentUpload
from app.db.session import SessionLocal
from app.services.object_storage import client
logger = logging.getLogger(__name__)
def cleanup_expired_uploads() -> int:
"""Delete old pending objects and mark their upload records expired.
A grace period protects clients completing an upload near URL expiry.
PostgreSQL SKIP LOCKED makes this safe across multiple API replicas.
"""
cutoff = datetime.now(timezone.utc) - timedelta(
seconds=settings.attachment_cleanup_grace_seconds
)
deleted_count = 0
with SessionLocal() as db:
uploads = db.scalars(
select(AttachmentUpload)
.where(
AttachmentUpload.status == "pending",
AttachmentUpload.expires_at <= cutoff,
)
.order_by(AttachmentUpload.expires_at.asc())
.limit(settings.attachment_cleanup_batch_size)
.with_for_update(skip_locked=True)
).all()
if not uploads:
return 0
s3 = client()
try:
for upload in uploads:
# DeleteObject is idempotent: a missing object is also safe.
s3.delete_object(
Bucket=settings.s3_bucket,
Key=upload.object_key,
)
upload.status = "expired"
deleted_count += 1
db.commit()
except Exception:
db.rollback()
logger.exception(
"Attachment cleanup batch failed; pending records will be retried"
)
return 0
if deleted_count:
logger.info(
"Expired abandoned attachment uploads cleaned: count=%d",
deleted_count,
)
return deleted_count
+41
View File
@@ -0,0 +1,41 @@
from io import BytesIO
from PIL import Image, UnidentifiedImageError
from fastapi import HTTPException
MAX_BYTES = 10 * 1024 * 1024
MAX_PIXELS = 40_000_000
ALLOWED = {"PNG": "image/png", "JPEG": "image/jpeg"}
def validate_image_file(fileobj, declared_type: str):
"""Validate a seekable, size-limited file without loading its full encoded bytes."""
try:
fileobj.seek(0)
with Image.open(fileobj) as image:
fmt = image.format
width, height = image.size
if fmt not in ALLOWED:
raise HTTPException(415, "Only PNG and JPEG are supported")
if width * height > MAX_PIXELS:
raise HTTPException(413, "Image exceeds 40 million pixels")
image.verify()
fileobj.seek(0)
with Image.open(fileobj) as image:
image.load()
except HTTPException:
raise
except (UnidentifiedImageError, OSError, ValueError, SyntaxError, Image.DecompressionBombError):
raise HTTPException(415, "Invalid or corrupted image") from None
actual_type = ALLOWED[fmt]
if declared_type != actual_type:
raise HTTPException(415, "Content-Type does not match image content")
fileobj.seek(0)
return actual_type, width, height
def validate_image(data: bytes, declared_type: str):
if not data:
raise HTTPException(415, "Empty image")
if len(data) > MAX_BYTES:
raise HTTPException(413, "Image exceeds 10 MiB")
return validate_image_file(BytesIO(data), declared_type)
+22 -5
View File
@@ -15,7 +15,7 @@ from sqlalchemy.dialects.postgresql import insert as pg_insert
from sqlalchemy.orm import Session
from app.core.config import settings
from app.db.models import IdempotencyRecord, Message
from app.db.models import Attachment, IdempotencyRecord, Message
from app.repositories.chat_repository import ChatRepository
from app.repositories.message_repository import MessageRepository
@@ -137,6 +137,7 @@ class MessageService:
"chat_id": str(message.chat_id),
"sender_id": str(message.sender_id),
"text": message.text,
"attachment_ids": message.attachment_ids or [],
"created_at": message.created_at.isoformat(),
}
for message in messages
@@ -154,6 +155,7 @@ class MessageService:
chat_id=uuid.UUID(item["chat_id"]),
sender_id=uuid.UUID(item["sender_id"]),
text=item["text"],
attachment_ids=item.get("attachment_ids", []),
created_at=datetime.fromisoformat(item["created_at"]),
)
for item in data["items"]
@@ -210,19 +212,34 @@ class MessageService:
sender_id: uuid.UUID,
text: str,
idempotency_key: str,
attachment_ids: list[str] | None = None,
) -> Message:
text = text.strip()
if not text or len(text) > 4000:
attachment_ids = attachment_ids or []
if (not text and not attachment_ids) or len(text) > 4000 or len(attachment_ids) > 10:
raise InvalidMessageDataError("Invalid message text")
# Access is checked for every retry, before consulting the key.
if not self.chats.is_member(chat_id, sender_id):
raise MessageNotFoundError()
if len(attachment_ids) != len(set(attachment_ids)):
raise InvalidMessageDataError("Duplicate attachment IDs")
if attachment_ids:
try:
parsed_attachment_ids = [uuid.UUID(value) for value in attachment_ids]
except (ValueError, TypeError):
raise InvalidMessageDataError("Invalid attachment UUID") from None
attachments = list(self.db.scalars(select(Attachment).where(Attachment.id.in_(parsed_attachment_ids))).all())
if len(attachments) != len(parsed_attachment_ids) or any(a.chat_id != chat_id for a in attachments):
raise MessageNotFoundError()
if any(a.status != "ready" for a in attachments):
raise InvalidMessageDataError("Attachment is not ready")
method = "POST"
path = f"/api/v1/chats/{chat_id}/messages"
request_hash = hashlib.sha256(
json.dumps({"text": text}, sort_keys=True, separators=(",", ":")).encode("utf-8")
json.dumps({"text": text, "attachment_ids": attachment_ids}, sort_keys=True, separators=(",", ":")).encode("utf-8")
).hexdigest()
now = datetime.now(timezone.utc)
expires_at = now + timedelta(seconds=max(settings.idempotency_ttl_seconds, 86400))
@@ -258,7 +275,7 @@ class MessageService:
if existing is None:
# Rare expiration race: retry once in a fresh transaction.
self.db.rollback()
return self.create_message(chat_id, sender_id, text, idempotency_key)
return self.create_message(chat_id, sender_id, text, idempotency_key, attachment_ids)
if existing.request_hash != request_hash:
self.db.rollback()
raise IdempotencyConflictError()
@@ -271,7 +288,7 @@ class MessageService:
return message
message = self.messages.create(
chat_id=chat_id, sender_id=sender_id, text=text
chat_id=chat_id, sender_id=sender_id, text=text, attachment_ids=attachment_ids
)
self.db.execute(
update(IdempotencyRecord)
+39
View File
@@ -0,0 +1,39 @@
import boto3
from botocore.config import Config
from app.core.config import settings
def client(endpoint_url=None):
return boto3.client(
"s3", endpoint_url=endpoint_url or settings.s3_endpoint_url,
aws_access_key_id=settings.s3_access_key,
aws_secret_access_key=settings.s3_secret_key,
region_name=settings.s3_region,
config=Config(signature_version="s3v4", connect_timeout=3, read_timeout=15, retries={"max_attempts": 2}, s3={"addressing_style": "path"}),
)
def ensure_bucket() -> None:
s3 = client()
try:
s3.head_bucket(Bucket=settings.s3_bucket)
except Exception:
s3.create_bucket(Bucket=settings.s3_bucket)
def presigned_client():
return client(endpoint_url=settings.s3_public_endpoint_url)
def create_presigned_upload_url(object_key: str, content_type: str) -> str:
s3 = presigned_client()
return s3.generate_presigned_url(
ClientMethod="put_object",
Params={
"Bucket": settings.s3_bucket,
"Key": object_key,
"ContentType": content_type,
},
ExpiresIn=settings.presigned_upload_ttl_seconds,
)
+183
View File
@@ -0,0 +1,183 @@
name: mtusi-lab4
services:
postgres:
image: postgres:16.6-bookworm
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB:-messenger}
POSTGRES_USER: ${POSTGRES_USER:-messenger}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U \"$$POSTGRES_USER\" -d \"$$POSTGRES_DB\""]
interval: 5s
timeout: 3s
retries: 15
start_period: 10s
networks: [backend]
redis:
image: redis:7.4.2-bookworm
restart: unless-stopped
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
volumes:
- redis_data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 3s
retries: 10
networks: [backend]
minio:
image: pgsty/silo:RELEASE.2026-10-26T00-00-00Z
command: ["server", "/data", "--address", ":9000", "--console-address", ":9001"]
restart: unless-stopped
ports:
- "127.0.0.1:9000:9000"
environment:
MINIO_ROOT_USER: ${MINIO_ROOT_USER:?Set MINIO_ROOT_USER in .env}
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:?Set MINIO_ROOT_PASSWORD in .env}
volumes:
- minio_data:/data
# MinIO is intentionally internal: neither S3 API nor admin console is published on the host.
networks: [backend]
minio-bootstrap:
image: pgsty/mc:RELEASE.2026-10-26T00-00-00Z
depends_on:
minio:
condition: service_started
entrypoint: ["/bin/sh", "-ec"]
command:
- |
mc --disable-pager alias set local http://minio:9000 "$${MINIO_ROOT_USER}" "$${MINIO_ROOT_PASSWORD}"
until mc --disable-pager ready local; do echo 'Waiting for MinIO...'; sleep 2; done
mc --disable-pager mb --ignore-existing local/messenger-attachments
mc --disable-pager anonymous set none local/messenger-attachments
if ! mc --disable-pager admin policy info local messenger-attachments-policy >/dev/null 2>&1; then
mc --disable-pager admin policy create local messenger-attachments-policy /policy.json
fi
if ! mc --disable-pager admin user info local "$${S3_ACCESS_KEY_ID}" >/dev/null 2>&1; then
mc --disable-pager admin user add local "$${S3_ACCESS_KEY_ID}" "$${S3_SECRET_ACCESS_KEY}"
fi
mc --disable-pager admin policy attach local messenger-attachments-policy --user "$${S3_ACCESS_KEY_ID}"
environment:
MINIO_ROOT_USER: ${MINIO_ROOT_USER:?Set MINIO_ROOT_USER in .env}
MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:?Set MINIO_ROOT_PASSWORD in .env}
S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:?Set S3_ACCESS_KEY_ID in .env}
S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:?Set S3_SECRET_ACCESS_KEY in .env}
volumes:
- ./infra/minio-policy.json:/policy.json:ro
restart: "no"
networks: [backend]
migrate:
build:
context: .
dockerfile: Dockerfile
command: ["alembic", "upgrade", "head"]
environment:
DATABASE_URL: postgresql+psycopg://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger}
depends_on:
postgres:
condition: service_healthy
restart: "no"
networks: [backend]
api:
build:
context: .
dockerfile: Dockerfile
restart: unless-stopped
environment:
APP_ENV: lab
DATABASE_URL: postgresql+psycopg://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger}
CACHE_URL: redis://redis:6379/0
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
MESSAGE_CACHE_TTL_SECONDS: ${MESSAGE_CACHE_TTL_SECONDS:-60}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
DB_POOL_SIZE: ${DB_POOL_SIZE:-3}
DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:-2}
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-10}
S3_ENDPOINT: http://minio:9000
S3_PUBLIC_ENDPOINT_URL: ${S3_PUBLIC_ENDPOINT_URL:-http://localhost:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:?Set S3_ACCESS_KEY_ID in .env}
S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:?Set S3_SECRET_ACCESS_KEY in .env}
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
ATTACHMENT_CLEANUP_INTERVAL_SECONDS: ${ATTACHMENT_CLEANUP_INTERVAL_SECONDS:-60}
ATTACHMENT_CLEANUP_GRACE_SECONDS: ${ATTACHMENT_CLEANUP_GRACE_SECONDS:-600}
ATTACHMENT_CLEANUP_BATCH_SIZE: ${ATTACHMENT_CLEANUP_BATCH_SIZE:-100}
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
redis:
condition: service_healthy
minio-bootstrap:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
interval: 5s
timeout: 3s
retries: 3
start_period: 20s
deploy:
replicas: 2
resources:
limits:
cpus: "1.0"
memory: 512M
labels:
- traefik.enable=true
- traefik.docker.network=mtusi-lab4-edge
- traefik.http.routers.messenger.rule=PathPrefix(`/`)
- traefik.http.routers.messenger.entrypoints=web
- traefik.http.services.messenger.loadbalancer.server.port=8080
- traefik.http.services.messenger.loadbalancer.healthcheck.path=/health/ready
- traefik.http.services.messenger.loadbalancer.healthcheck.interval=3s
- traefik.http.services.messenger.loadbalancer.healthcheck.timeout=2s
- traefik.http.services.messenger.loadbalancer.passhostheader=true
networks: [backend, edge]
traefik:
image: traefik:v3.6.2
restart: unless-stopped
command:
- --providers.docker=true
- --providers.docker.exposedbydefault=false
- --providers.docker.network=mtusi-lab4-edge
- --entrypoints.web.address=:8080
- --ping=true
- --ping.entrypoint=ping
- --entrypoints.ping.address=:8082
- --accesslog=true
- --log.level=INFO
ports:
- "8080:8080"
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
healthcheck:
test: ["CMD", "wget", "-q", "--spider", "http://127.0.0.1:8082/ping"]
interval: 10s
timeout: 3s
retries: 5
networks: [edge]
networks:
backend:
driver: bridge
edge:
name: mtusi-lab4-edge
driver: bridge
volumes:
postgres_data:
redis_data:
minio_data:
Binary file not shown.
+14
View File
@@ -0,0 +1,14 @@
ATTACHMENT FAILOVER TEST
Mode: failover
Observed API instances before failure: 2
Successful writes: 87
Failed attempts: 4
First recovery: 4.597 seconds
The API replica that handled the attachment upload was stopped.
The attachment remained accessible through the other API replica.
Downloaded content matched the original bytes.
Existing session and confirmed messages were preserved.
RESULT: PASS
+3
View File
@@ -0,0 +1,3 @@
method,concurrency,file_size_bytes,successful_uploads,failed_uploads,wall_time_s,throughput_uploads_per_s,peak_api_total_mib,baseline_api_total_mib,peak_delta_api_total_mib,api1_peak_mib,api2_peak_mib,memory_samples,memory_sampling_errors,avg_upload_time_s,max_upload_time_s,api_body_bytes_per_upload,s3_body_bytes_per_upload
proxy,10,5769330,10,0,3.9963,2.502,220.2,204.1,16.1,110.2,110.0,4,0,2.3315,2.6514,5769330,0
presigned,10,5769330,10,0,4.941,2.024,304.4,220.2,84.2,156.8,147.6,5,0,3.6495,3.9018,160,5769330
1 method concurrency file_size_bytes successful_uploads failed_uploads wall_time_s throughput_uploads_per_s peak_api_total_mib baseline_api_total_mib peak_delta_api_total_mib api1_peak_mib api2_peak_mib memory_samples memory_sampling_errors avg_upload_time_s max_upload_time_s api_body_bytes_per_upload s3_body_bytes_per_upload
2 proxy 10 5769330 10 0 3.9963 2.502 220.2 204.1 16.1 110.2 110.0 4 0 2.3315 2.6514 5769330 0
3 presigned 10 5769330 10 0 4.941 2.024 304.4 220.2 84.2 156.8 147.6 5 0 3.6495 3.9018 160 5769330
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
+15
View File
@@ -0,0 +1,15 @@
S3 SECURITY TEST
1. Admin console port:
Command: docker compose port minio 9001
Result: no port 9001/tcp published.
2. Anonymous bucket access:
Command: curl.exe -i http://localhost:9000/messenger-attachments/
Result: HTTP 403 Forbidden
S3 error: AccessDenied
3. Bucket:
messenger-attachments
RESULT: PASS
+25
View File
@@ -0,0 +1,25 @@
S3 UNAVAILABLE TEST
1. Stopped S3:
docker compose stop minio
2. Readiness response while S3 was unavailable:
HTTP 503
{
"error": {
"code": "unavailable",
"message": "Required storage unavailable"
}
}
3. Restarted S3:
docker compose start minio
4. Container status:
Both API replicas healthy.
S3 container running.
5. Readiness response after recovery:
status: ok
RESULT: PASS
Binary file not shown.
+13
View File
@@ -0,0 +1,13 @@
method,file,file_size_bytes,repeat,elapsed_total_s,elapsed_api_s,client_to_api_body_bytes,client_to_s3_upload_bytes,api_peak_rss_mib,api_peak_delta_mib
proxy,sample.png,111817,1,0.0838,0.0837,111817,0,103.4,0.0
proxy,sample.png,111817,2,0.0773,0.0772,111817,0,103.4,0.0
proxy,sample.png,111817,3,0.0746,0.0746,111817,0,103.4,0.0
presigned,sample.png,111817,1,0.1103,0.084,158,111817,103.8,1.5
presigned,sample.png,111817,2,0.1003,0.0556,158,111817,103.8,0.0
presigned,sample.png,111817,3,0.1782,0.1082,158,111817,112.7,8.9
proxy,sample_large.png,5769330,1,0.2416,0.2415,5769330,0,103.8,1.5
proxy,sample_large.png,5769330,2,0.2777,0.2776,5769330,0,105.3,1.5
proxy,sample_large.png,5769330,3,0.2806,0.2805,5769330,0,109.2,5.2
presigned,sample_large.png,5769330,1,0.3062,0.1403,159,5769330,128.9,19.7
presigned,sample_large.png,5769330,2,0.2171,0.1092,159,5769330,116.3,0.0
presigned,sample_large.png,5769330,3,0.2459,0.1329,159,5769330,116.3,0.0
1 method file file_size_bytes repeat elapsed_total_s elapsed_api_s client_to_api_body_bytes client_to_s3_upload_bytes api_peak_rss_mib api_peak_delta_mib
2 proxy sample.png 111817 1 0.0838 0.0837 111817 0 103.4 0.0
3 proxy sample.png 111817 2 0.0773 0.0772 111817 0 103.4 0.0
4 proxy sample.png 111817 3 0.0746 0.0746 111817 0 103.4 0.0
5 presigned sample.png 111817 1 0.1103 0.084 158 111817 103.8 1.5
6 presigned sample.png 111817 2 0.1003 0.0556 158 111817 103.8 0.0
7 presigned sample.png 111817 3 0.1782 0.1082 158 111817 112.7 8.9
8 proxy sample_large.png 5769330 1 0.2416 0.2415 5769330 0 103.8 1.5
9 proxy sample_large.png 5769330 2 0.2777 0.2776 5769330 0 105.3 1.5
10 proxy sample_large.png 5769330 3 0.2806 0.2805 5769330 0 109.2 5.2
11 presigned sample_large.png 5769330 1 0.3062 0.1403 159 5769330 128.9 19.7
12 presigned sample_large.png 5769330 2 0.2171 0.1092 159 5769330 116.3 0.0
13 presigned sample_large.png 5769330 3 0.2459 0.1329 159 5769330 116.3 0.0
+19
View File
@@ -0,0 +1,19 @@
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket",
"s3:GetObject",
"s3:PutObject",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::messenger-attachments",
"arn:aws:s3:::messenger-attachments/*"
]
}
]
}
@@ -0,0 +1,37 @@
"""add attachment metadata"""
from alembic import op
import sqlalchemy as sa
from typing import Sequence, Union
revision: str = "4d9a1f2c7b10"
down_revision: Union[str, None] = "8c3d9f4a21b7"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.add_column("messages", sa.Column("attachment_ids", sa.JSON(), nullable=False, server_default="[]"))
op.create_table(
"attachments",
sa.Column("id", sa.UUID(), nullable=False),
sa.Column("chat_id", sa.UUID(), nullable=False),
sa.Column("owner_id", sa.UUID(), nullable=False),
sa.Column("filename", sa.String(255), nullable=False),
sa.Column("content_type", sa.String(32), nullable=False),
sa.Column("size_bytes", sa.Integer(), nullable=False),
sa.Column("sha256", sa.String(64), nullable=False),
sa.Column("object_key", sa.String(512), nullable=False),
sa.Column("status", sa.String(16), nullable=False),
sa.Column("error_code", sa.String(64), nullable=True),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
sa.ForeignKeyConstraint(["chat_id"], ["chats.id"], ondelete="CASCADE"),
sa.ForeignKeyConstraint(["owner_id"], ["users.id"], ondelete="CASCADE"),
sa.PrimaryKeyConstraint("id"),
sa.UniqueConstraint("object_key"),
)
op.create_index("ix_attachments_chat_id", "attachments", ["chat_id"])
def downgrade() -> None:
op.drop_index("ix_attachments_chat_id", table_name="attachments")
op.drop_table("attachments")
op.drop_column("messages", "attachment_ids")
@@ -0,0 +1,78 @@
"""add attachment uploads
Revision ID: a7c2e91d5f40
Revises: 4d9a1f2c7b10
"""
from typing import Sequence, Union
from alembic import op
import sqlalchemy as sa
revision: str = "a7c2e91d5f40"
down_revision: Union[str, None] = "4d9a1f2c7b10"
branch_labels = None
depends_on = None
def upgrade() -> None:
op.create_table(
"attachment_uploads",
sa.Column("id", sa.UUID(), nullable=False),
sa.Column("chat_id", sa.UUID(), nullable=False),
sa.Column("owner_id", sa.UUID(), nullable=False),
sa.Column("filename", sa.String(length=255), nullable=False),
sa.Column("content_type", sa.String(length=32), nullable=False),
sa.Column("expected_size_bytes", sa.Integer(), nullable=False),
sa.Column("expected_sha256", sa.String(length=64), nullable=False),
sa.Column("object_key", sa.String(length=512), nullable=False),
sa.Column("status", sa.String(length=16), nullable=False),
sa.Column("expires_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
sa.Column("completed_at", sa.DateTime(timezone=True), nullable=True),
sa.ForeignKeyConstraint(
["chat_id"],
["chats.id"],
ondelete="CASCADE",
),
sa.ForeignKeyConstraint(
["owner_id"],
["users.id"],
ondelete="CASCADE",
),
sa.PrimaryKeyConstraint("id"),
sa.UniqueConstraint("object_key"),
)
op.create_index(
"ix_attachment_uploads_chat_id",
"attachment_uploads",
["chat_id"],
)
op.create_index(
"ix_attachment_uploads_owner_id",
"attachment_uploads",
["owner_id"],
)
op.create_index(
"ix_attachment_uploads_expires_at",
"attachment_uploads",
["expires_at"],
)
def downgrade() -> None:
op.drop_index(
"ix_attachment_uploads_expires_at",
table_name="attachment_uploads",
)
op.drop_index(
"ix_attachment_uploads_owner_id",
table_name="attachment_uploads",
)
op.drop_index(
"ix_attachment_uploads_chat_id",
table_name="attachment_uploads",
)
op.drop_table("attachment_uploads")
+2
View File
@@ -7,3 +7,5 @@ psycopg[binary]==3.2.3
alembic==1.14.0
redis==5.2.1
pwdlib[argon2]==0.2.1
boto3==1.35.99
Pillow==11.0.0
+30
View File
@@ -0,0 +1,30 @@
import os
import runpy
import subprocess
import sys
bash = r"C:\Program Files\Git\bin\bash.exe"
original_popen = subprocess.Popen
def compatible_popen(args, **kwargs):
if isinstance(args, (list, tuple)) and len(args) == 1:
args = [bash, args[0]]
return original_popen(args, **kwargs)
subprocess.Popen = compatible_popen
sys.path.insert(0, os.path.abspath("tests"))
mode = sys.argv[1] if len(sys.argv) > 1 else "failover"
if mode not in ("persistence", "failover"):
raise SystemExit("Mode must be persistence or failover")
sys.argv = [
"tests/resilience.py",
"--mode", mode,
"--action-script",
"scripts/restart.sh" if mode == "persistence" else "scripts/stop-one.sh",
"--base-url", "http://localhost:8080",
]
runpy.run_path("tests/resilience.py", run_name="__main__")
+304
View File
@@ -0,0 +1,304 @@
import csv
import hashlib
import json
import subprocess
import sys
import threading
import time
import urllib.request
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
BASE_URL = "http://localhost:8080"
FIXTURE = ROOT / "tests" / "fixtures" / "sample_large.png"
API_CONTAINERS = ("mtusi-lab4-api-1", "mtusi-lab4-api-2")
CONCURRENCY = 10
OUTPUT = ROOT / "evidence" / "concurrent-upload-results.csv"
def parse_mib(value):
units = {
"B": 1 / (1024 * 1024),
"KiB": 1 / 1024,
"MiB": 1,
"GiB": 1024,
"Ki": 1 / 1024,
"Mi": 1,
"Gi": 1024,
"kB": 1000 / (1024 * 1024),
"MB": 1000 * 1000 / (1024 * 1024),
"GB": 1000 * 1000 * 1000 / (1024 * 1024),
}
for unit in sorted(units, key=len, reverse=True):
if value.endswith(unit):
return float(value[:-len(unit)].strip()) * units[unit]
raise ValueError(f"Unknown Docker memory unit: {value}")
def docker_memory():
result = subprocess.run(
[
"docker", "stats", "--no-stream",
"--format", "{{.Name}}|{{.MemUsage}}",
],
capture_output=True,
text=True,
check=True,
)
values = {}
for line in result.stdout.splitlines():
if "|" not in line:
continue
name, usage = line.split("|", 1)
if name in API_CONTAINERS:
values[name] = parse_mib(usage.split("/", 1)[0].strip())
missing = set(API_CONTAINERS) - set(values)
if missing:
raise RuntimeError("Missing API containers: " + ", ".join(missing))
return values
class MemoryMonitor:
def __init__(self):
self.running = False
self.samples = []
self.thread = None
self.errors = []
def sample(self):
while self.running:
try:
values = docker_memory()
self.samples.append(values)
except Exception as exc:
self.errors.append(type(exc).__name__)
time.sleep(0.1)
def __enter__(self):
self.baseline = docker_memory()
self.samples = [dict(self.baseline)]
self.running = True
self.thread = threading.Thread(target=self.sample, daemon=True)
self.thread.start()
return self
def __exit__(self, exc_type, exc_value, traceback):
self.running = False
self.thread.join(timeout=5)
try:
self.samples.append(docker_memory())
except Exception as exc:
self.errors.append(type(exc).__name__)
def summary(self):
peak_by_container = {
name: max(sample[name] for sample in self.samples)
for name in API_CONTAINERS
}
total_samples = [
sum(sample[name] for name in API_CONTAINERS)
for sample in self.samples
]
baseline_total = sum(self.baseline.values())
peak_total = max(total_samples)
return {
"baseline_total_mib": round(baseline_total, 2),
"peak_total_mib": round(peak_total, 2),
"peak_delta_total_mib": round(peak_total - baseline_total, 2),
"api1_peak_mib": round(peak_by_container[API_CONTAINERS[0]], 2),
"api2_peak_mib": round(peak_by_container[API_CONTAINERS[1]], 2),
"samples": len(self.samples),
"sampling_errors": len(self.errors),
}
def response_json(response):
return json.loads(response["bytes"].decode("utf-8"))
def upload_one(index, method, actor, chat, content, digest, barrier):
client = Client(BASE_URL)
barrier.wait(timeout=30)
started = time.monotonic()
if method == "proxy":
response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments"
f"?filename=parallel-{index}.png",
201,
actor=actor,
raw=content,
headers={"Content-Type": "image/png"},
)
attachment = response_json(response)
api_elapsed = response["elapsed"]
api_body_bytes = len(content)
s3_body_bytes = 0
else:
body = {
"filename": f"parallel-{index}.png",
"content_type": "image/png",
"size_bytes": len(content),
"sha256": digest,
}
create_response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments/presigned",
201,
actor=actor,
body=body,
)
created = response_json(create_response)
request = urllib.request.Request(
created["upload_url"],
data=content,
headers=created["headers"],
method="PUT",
)
with urllib.request.urlopen(request, timeout=90) as response:
check(response.status in (200, 201, 204), "S3 PUT failed")
complete_response = client.call(
"POST",
f"/api/v1/attachments/uploads/{created['upload_id']}/complete",
200,
actor=actor,
)
attachment = response_json(complete_response)
api_elapsed = create_response["elapsed"] + complete_response["elapsed"]
api_body_bytes = len(json.dumps(body).encode("utf-8"))
s3_body_bytes = len(content)
elapsed = time.monotonic() - started
check(attachment["status"] == "ready", "attachment is not ready")
check(attachment["size_bytes"] == len(content), "wrong attachment size")
check(attachment["sha256"] == digest, "wrong attachment checksum")
return {
"worker": index,
"elapsed_total_s": round(elapsed, 4),
"elapsed_api_s": round(api_elapsed, 4),
"client_to_api_body_bytes": api_body_bytes,
"client_to_s3_upload_bytes": s3_body_bytes,
"attachment_id": attachment["id"],
}
def run_method(method, actor, chat, content, digest):
print(f"\nStarting {CONCURRENCY} simultaneous {method} uploads...")
barrier = threading.Barrier(CONCURRENCY)
results = []
errors = []
with MemoryMonitor() as memory:
started = time.monotonic()
with ThreadPoolExecutor(max_workers=CONCURRENCY) as executor:
futures = [
executor.submit(
upload_one, index, method, actor, chat,
content, digest, barrier,
)
for index in range(1, CONCURRENCY + 1)
]
for future in as_completed(futures):
try:
results.append(future.result())
except Exception as exc:
errors.append(f"{type(exc).__name__}: {exc}")
wall_time = time.monotonic() - started
mem = memory.summary()
successful = len(results)
print(
f"{method}: success={successful}/{CONCURRENCY}, "
f"errors={len(errors)}, wall={wall_time:.3f}s, "
f"peak API RAM={mem['peak_total_mib']} MiB, "
f"delta={mem['peak_delta_total_mib']} MiB, "
f"samples={mem['samples']}"
)
for error in errors:
print("ERROR:", error)
return {
"method": method,
"concurrency": CONCURRENCY,
"file_size_bytes": len(content),
"successful_uploads": successful,
"failed_uploads": len(errors),
"wall_time_s": round(wall_time, 4),
"throughput_uploads_per_s": round(successful / wall_time, 3),
"peak_api_total_mib": mem["peak_total_mib"],
"baseline_api_total_mib": mem["baseline_total_mib"],
"peak_delta_api_total_mib": mem["peak_delta_total_mib"],
"api1_peak_mib": mem["api1_peak_mib"],
"api2_peak_mib": mem["api2_peak_mib"],
"memory_samples": mem["samples"],
"memory_sampling_errors": mem["sampling_errors"],
"avg_upload_time_s": round(
sum(item["elapsed_total_s"] for item in results) / successful, 4
) if successful else None,
"max_upload_time_s": max(
(item["elapsed_total_s"] for item in results), default=None
),
"api_body_bytes_per_upload": (
results[0]["client_to_api_body_bytes"] if results else None
),
"s3_body_bytes_per_upload": (
results[0]["client_to_s3_upload_bytes"] if results else None
),
}
def main():
if not FIXTURE.exists():
raise FileNotFoundError(FIXTURE)
content = FIXTURE.read_bytes()
if len(content) > 10 * 1024 * 1024:
raise RuntimeError("Fixture exceeds 10 MiB")
digest = hashlib.sha256(content).hexdigest()
with urllib.request.urlopen(BASE_URL + "/health/ready", timeout=10) as response:
check(response.status == 200, "API is not ready")
# Prepare identities and chat before measuring concurrent uploads.
setup = Client(BASE_URL)
alice, _, _, chat = setup.bootstrap()
rows = []
for method in ("proxy", "presigned"):
rows.append(run_method(method, alice, chat, content, digest))
OUTPUT.parent.mkdir(parents=True, exist_ok=True)
with OUTPUT.open("w", newline="", encoding="utf-8-sig") as file:
writer = csv.DictWriter(file, fieldnames=list(rows[0].keys()))
writer.writeheader()
writer.writerows(rows)
print("\nResults:", OUTPUT)
print("Fixture:", FIXTURE.name)
print("File size:", len(content), "bytes")
print("SHA-256:", digest)
if any(row["successful_uploads"] != CONCURRENCY for row in rows):
raise SystemExit("FAIL: at least one concurrent upload failed")
print("PASS: 10 concurrent uploads completed for both methods")
if __name__ == "__main__":
main()
+375
View File
@@ -0,0 +1,375 @@
import csv
import json
import subprocess
import sys
import threading
import time
import urllib.request
import hashlib
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
BASE_URL = "http://localhost:8080"
FIXTURES = [
ROOT / "tests" / "fixtures" / "sample.png",
ROOT / "tests" / "fixtures" / "sample_large.png",
]
API_CONTAINERS = [
"mtusi-lab4-api-1",
"mtusi-lab4-api-2",
]
REPEATS = 3
OUTPUT = ROOT / "evidence" / "track1-results.csv"
def docker_memory():
"""Return current memory usage in MiB for both API containers."""
result = subprocess.run(
[
"docker",
"stats",
"--no-stream",
"--format",
"{{.Name}}|{{.MemUsage}}",
],
capture_output=True,
text=True,
check=True,
)
values = {}
for line in result.stdout.splitlines():
if "|" not in line:
continue
name, usage = line.split("|", 1)
if name not in API_CONTAINERS:
continue
memory_value = usage.split("/", 1)[0].strip()
values[name] = parse_memory_mib(memory_value)
missing = set(API_CONTAINERS) - set(values)
if missing:
raise RuntimeError(
"Could not read memory for containers: "
+ ", ".join(sorted(missing))
)
return values
def parse_memory_mib(value):
"""Convert Docker memory values to MiB."""
value = value.strip()
units = {
"B": 1 / (1024 * 1024),
"KiB": 1 / 1024,
"MiB": 1,
"GiB": 1024,
"kB": 1000 / (1024 * 1024),
"MB": 1000 * 1000 / (1024 * 1024),
"GB": 1000 * 1000 * 1000 / (1024 * 1024),
"Ki": 1 / 1024,
"Mi": 1,
"Gi": 1024,
}
for unit in sorted(units, key=len, reverse=True):
if value.endswith(unit):
number = value[:-len(unit)].strip()
return float(number) * units[unit]
raise ValueError(f"Unknown Docker memory unit: {value}")
class MemoryMonitor:
"""Sample API container memory while one upload is running."""
def __init__(self):
self.baseline = {}
self.peak = {}
self.running = False
self.thread = None
def _sample(self):
while self.running:
try:
current = docker_memory()
for name, value in current.items():
self.peak[name] = max(
self.peak.get(name, value),
value,
)
except Exception as exc:
print(
"WARNING: memory sampling failed:",
type(exc).__name__,
)
time.sleep(0.1)
def __enter__(self):
self.baseline = docker_memory()
self.peak = dict(self.baseline)
self.running = True
self.thread = threading.Thread(
target=self._sample,
daemon=True,
)
self.thread.start()
return self
def __exit__(self, exc_type, exc_value, traceback):
self.running = False
if self.thread:
self.thread.join(timeout=3)
try:
current = docker_memory()
for name, value in current.items():
self.peak[name] = max(
self.peak.get(name, value),
value,
)
except Exception:
pass
@property
def peak_rss_mib(self):
return max(self.peak.values())
@property
def peak_delta_mib(self):
return max(
self.peak[name] - self.baseline[name]
for name in API_CONTAINERS
)
def response_json(response):
return json.loads(response["bytes"].decode("utf-8"))
def proxy_upload(client, actor, chat, content):
"""Upload a file through the API proxy endpoint."""
started = time.monotonic()
response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=benchmark.png",
201,
actor=actor,
raw=content,
headers={"Content-Type": "image/png"},
)
elapsed = time.monotonic() - started
attachment = response_json(response)
check(attachment["status"] == "ready", "proxy attachment is not ready")
check(
attachment["size_bytes"] == len(content),
"proxy attachment size mismatch",
)
check(
attachment["sha256"] == hashlib.sha256(content).hexdigest(),
"proxy attachment checksum mismatch",
)
return {
"elapsed_total_s": elapsed,
"elapsed_api_s": response["elapsed"],
"api_request_body_bytes": len(content),
"s3_upload_bytes": 0,
}
def presigned_upload(client, actor, chat, content):
"""Upload a file directly to S3 using a presigned URL."""
digest = hashlib.sha256(content).hexdigest()
create_body = {
"filename": "benchmark.png",
"content_type": "image/png",
"size_bytes": len(content),
"sha256": digest,
}
create_body_bytes = len(
json.dumps(create_body, ensure_ascii=False).encode("utf-8")
)
started = time.monotonic()
create_response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments/presigned",
201,
actor=actor,
body=create_body,
)
created = response_json(create_response)
check(created["method"] == "PUT", "unexpected upload method")
s3_request = urllib.request.Request(
created["upload_url"],
data=content,
headers=created["headers"],
method="PUT",
)
with urllib.request.urlopen(s3_request, timeout=60) as response:
check(
response.status in (200, 201, 204),
"direct S3 upload failed",
)
complete_response = client.call(
"POST",
f"/api/v1/attachments/uploads/{created['upload_id']}/complete",
200,
actor=actor,
)
attachment = response_json(complete_response)
elapsed = time.monotonic() - started
check(attachment["status"] == "ready", "presigned attachment is not ready")
check(
attachment["size_bytes"] == len(content),
"presigned attachment size mismatch",
)
check(
attachment["sha256"] == digest,
"presigned attachment checksum mismatch",
)
return {
"elapsed_total_s": elapsed,
"elapsed_api_s": (
create_response["elapsed"] + complete_response["elapsed"]
),
"api_request_body_bytes": create_body_bytes,
"s3_upload_bytes": len(content),
}
def main():
OUTPUT.parent.mkdir(parents=True, exist_ok=True)
for path in FIXTURES:
if not path.exists():
raise FileNotFoundError(path)
if path.stat().st_size > 10 * 1024 * 1024:
raise RuntimeError(f"Fixture exceeds 10 MiB: {path.name}")
print("Checking API readiness...")
with urllib.request.urlopen(
BASE_URL + "/health/ready",
timeout=10,
) as response:
check(response.status == 200, "API is not ready")
client = Client(BASE_URL)
alice, bob, eve, chat = client.bootstrap()
rows = []
for fixture in FIXTURES:
content = fixture.read_bytes()
size_bytes = len(content)
for method in ("proxy", "presigned"):
for repeat in range(1, REPEATS + 1):
print(
f"Running {method}: {fixture.name}, "
f"repeat {repeat}/{REPEATS}"
)
with MemoryMonitor() as memory:
if method == "proxy":
metrics = proxy_upload(
client,
alice,
chat,
content,
)
else:
metrics = presigned_upload(
client,
alice,
chat,
content,
)
row = {
"method": method,
"file": fixture.name,
"file_size_bytes": size_bytes,
"repeat": repeat,
"elapsed_total_s": round(
metrics["elapsed_total_s"], 4
),
"elapsed_api_s": round(
metrics["elapsed_api_s"], 4
),
"client_to_api_body_bytes": (
metrics["api_request_body_bytes"]
),
"client_to_s3_upload_bytes": (
metrics["s3_upload_bytes"]
),
"api_peak_rss_mib": round(
memory.peak_rss_mib, 2
),
"api_peak_delta_mib": round(
memory.peak_delta_mib, 2
),
}
rows.append(row)
print(
f" total={row['elapsed_total_s']}s, "
f"API={row['elapsed_api_s']}s, "
f"API body={row['client_to_api_body_bytes']} bytes, "
f"peak RAM={row['api_peak_rss_mib']} MiB, "
f"RAM delta={row['api_peak_delta_mib']} MiB"
)
fieldnames = list(rows[0].keys())
with OUTPUT.open("w", newline="", encoding="utf-8-sig") as file:
writer = csv.DictWriter(file, fieldnames=fieldnames)
writer.writeheader()
writer.writerows(rows)
print()
print("PASS: Track 1 benchmark completed")
print(f"Results: {OUTPUT}")
print(f"Measurements: {len(rows)}")
if __name__ == "__main__":
main()
+45
View File
@@ -0,0 +1,45 @@
import os
from pathlib import Path
from PIL import Image
ROOT = Path(__file__).resolve().parents[1]
FIXTURES = ROOT / "tests" / "fixtures"
WIDTH = 1600
HEIGHT = 1200
def main():
FIXTURES.mkdir(parents=True, exist_ok=True)
source = FIXTURES / "sample.png"
large = FIXTURES / "sample_large.png"
if not source.exists():
raise FileNotFoundError(
f"Small fixture not found: {source}"
)
pixels = os.urandom(WIDTH * HEIGHT * 3)
image = Image.frombytes(
"RGB",
(WIDTH, HEIGHT),
pixels,
)
image.save(large, format="PNG", optimize=False)
for path in (source, large):
size = path.stat().st_size
print(f"{path.name}: {size} bytes ({size / 1024 / 1024:.2f} MiB)")
if large.stat().st_size > 10 * 1024 * 1024:
raise RuntimeError("Large fixture exceeds the 10 MiB upload limit")
print("PASS: Track 1 fixtures prepared")
if __name__ == "__main__":
main()
Regular → Executable
+2 -2
View File
@@ -1,4 +1,4 @@
#!/bin/sh
set -eu
# Restart all stateful dependencies and all API replicas without touching volumes.
docker compose restart postgres redis api
docker compose restart postgres redis minio api
Regular → Executable
+14 -8
View File
@@ -1,17 +1,23 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}"
project="${COMPOSE_PROJECT_NAME:-mtusi-lab3}"
project="${COMPOSE_PROJECT_NAME:-mtusi-lab4}"
found=""
for id in $(docker ps -q --filter "label=com.docker.compose.project=${project}" --filter "label=com.docker.compose.service=api"); do
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id")
if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then
found="$id"
break
fi
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$id")
if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then
found="$id"
break
fi
done
if [ -z "$found" ]; then
echo "No running API container matches TARGET_INSTANCE_ID" >&2
exit 1
echo "No running API container matches TARGET_INSTANCE_ID" >&2
exit 1
fi
docker stop --time 3 "$found" >/dev/null
+101
View File
@@ -0,0 +1,101 @@
import hashlib
import sys
import time
import uuid
from datetime import datetime, timedelta, timezone
from pathlib import Path
from botocore.exceptions import ClientError
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "tests"))
from client import Client
from app.core.config import settings
from app.db.models import AttachmentUpload
from app.db.session import SessionLocal
from app.services.object_storage import client as s3_client
BASE_URL = "http://localhost:8080"
FIXTURE = ROOT / "tests" / "fixtures" / "sample.png"
def main():
content = FIXTURE.read_bytes()
digest = hashlib.sha256(content).hexdigest()
api = Client(BASE_URL)
alice, _, _, chat = api.bootstrap()
upload_id = uuid.uuid4()
object_key = f"cleanup-test/{chat['id']}/{upload_id}"
# Host-side test uses the published S3 endpoint.
s3 = s3_client()
s3.put_object(
Bucket=settings.s3_bucket,
Key=object_key,
Body=content,
ContentType="image/png",
)
with SessionLocal() as db:
upload = AttachmentUpload(
id=upload_id,
chat_id=uuid.UUID(chat["id"]),
owner_id=uuid.UUID(alice["id"]),
filename="cleanup-test.png",
content_type="image/png",
expected_size_bytes=len(content),
expected_sha256=digest,
object_key=object_key,
status="pending",
# Older than expiry + 10-minute grace period.
expires_at=datetime.now(timezone.utc) - timedelta(minutes=11),
)
db.add(upload)
db.commit()
print(f"Created synthetic pending upload: {upload_id}")
print("Waiting for background cleanup (up to 90 seconds)...")
deadline = time.monotonic() + 90
final_status = None
while time.monotonic() < deadline:
with SessionLocal() as db:
row = db.get(AttachmentUpload, upload_id)
final_status = row.status if row else None
if final_status == "expired":
break
time.sleep(2)
if final_status != "expired":
raise SystemExit(
f"FAIL: expected status expired, got {final_status!r}"
)
try:
s3.head_object(Bucket=settings.s3_bucket, Key=object_key)
except ClientError as exc:
code = exc.response.get("Error", {}).get("Code", "")
status = exc.response.get("ResponseMetadata", {}).get("HTTPStatusCode")
if code not in ("404", "NoSuchKey", "NotFound") and status != 404:
raise
else:
raise SystemExit("FAIL: S3 object still exists")
print("PASS: abandoned upload marked expired")
print("PASS: corresponding S3 object deleted")
print(f"Upload ID: {upload_id}")
print(f"Object size: {len(content)} bytes")
print(f"SHA-256: {digest}")
if __name__ == "__main__":
main()
+285
View File
@@ -0,0 +1,285 @@
import uuid
import hashlib
import json
import sys
import urllib.request
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
BASE_URL = "http://localhost:8080"
IMAGE = ROOT / "tests" / "fixtures" / "sample.png"
def response_json(response):
return json.loads(response["bytes"].decode("utf-8"))
def create_upload(client, actor, chat, content, filename="sample.png"):
"""Create a presigned upload and return its metadata."""
response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments/presigned",
201,
actor=actor,
body={
"filename": filename,
"content_type": "image/png",
"size_bytes": len(content),
"sha256": hashlib.sha256(content).hexdigest(),
},
)
return response_json(response)
def create_upload_with_metadata(
client,
actor,
chat,
content,
expected_size=None,
expected_sha256=None,
):
"""Create an upload with deliberately supplied expected metadata."""
response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments/presigned",
201,
actor=actor,
body={
"filename": "sample.png",
"content_type": "image/png",
"size_bytes": (
len(content) if expected_size is None else expected_size
),
"sha256": (
hashlib.sha256(content).hexdigest()
if expected_sha256 is None
else expected_sha256
),
},
)
return response_json(response)
def put_to_s3(upload, content):
"""Upload bytes directly to S3 using the presigned URL."""
request = urllib.request.Request(
upload["upload_url"],
data=content,
headers=upload["headers"],
method="PUT",
)
with urllib.request.urlopen(request, timeout=30) as response:
check(
response.status in (200, 201, 204),
"S3 upload failed",
)
def complete_upload(client, actor, upload_id, expected_status=200):
return client.call(
"POST",
f"/api/v1/attachments/uploads/{upload_id}/complete",
expected_status,
actor=actor,
)
def main():
content = IMAGE.read_bytes()
digest = hashlib.sha256(content).hexdigest()
client = Client(BASE_URL)
alice, bob, eve, chat = client.bootstrap()
# 1. Incorrect SHA-256 must be rejected.
wrong_digest = "0" * 64
check(wrong_digest != digest, "test checksum unexpectedly matches")
upload = create_upload_with_metadata(
client,
alice,
chat,
content,
expected_sha256=wrong_digest,
)
put_to_s3(upload, content)
complete_upload(
client,
alice,
upload["upload_id"],
expected_status=409,
)
print("PASS: incorrect SHA-256 rejected with HTTP 409")
# 2. Incorrect expected size must be rejected.
upload = create_upload_with_metadata(
client,
alice,
chat,
content,
expected_size=len(content) + 1,
)
put_to_s3(upload, content)
complete_upload(
client,
alice,
upload["upload_id"],
expected_status=409,
)
print("PASS: incorrect file size rejected with HTTP 409")
# 3. Corrupted image must be rejected.
corrupt_content = b"This is not a valid PNG image"
upload = create_upload(
client,
alice,
chat,
corrupt_content,
)
put_to_s3(upload, corrupt_content)
complete_upload(
client,
alice,
upload["upload_id"],
expected_status=415,
)
print("PASS: corrupted image rejected with HTTP 415")
# 4. Another user must not complete Alice's upload.
upload = create_upload(
client,
alice,
chat,
content,
)
put_to_s3(upload, content)
complete_upload(
client,
eve,
upload["upload_id"],
expected_status=404,
)
print("PASS: foreign user cannot complete another user's upload")
# The legitimate owner must still be able to complete it.
owner_response = complete_upload(
client,
alice,
upload["upload_id"],
expected_status=200,
)
attachment = response_json(owner_response)
check(
attachment["status"] == "ready",
"owner's attachment is not ready",
)
check(
attachment["owner_id"] == alice["id"],
"attachment owner does not match",
)
check(
attachment["sha256"] == digest,
"attachment checksum mismatch",
)
print("PASS: legitimate owner can complete the upload")
# 5. Proxy upload must reject files larger than 10 MiB.
oversized_content = b"\x00" * (10 * 1024 * 1024 + 1)
client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=oversized.png",
expected=413,
actor=alice,
raw=oversized_content,
headers={"Content-Type": "image/png"},
)
print("PASS: oversized proxy upload rejected with HTTP 413")
# 6. PNG content must not be accepted as JPEG.
client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments?filename=mismatch.jpg",
expected=415,
actor=alice,
raw=content,
headers={"Content-Type": "image/jpeg"},
)
print("PASS: MIME mismatch rejected with HTTP 415")
# 7. Create a ready attachment in Alice and Bob's chat.
attachment, _ = client.attachment(alice, chat)
attachment_id = attachment["id"]
# Eve is not a member of Alice and Bob's chat.
client.call(
"GET",
f"/api/v1/attachments/{attachment_id}",
expected=404,
actor=eve,
)
print("PASS: non-member cannot access attachment metadata")
# 8. A non-member must not download the attachment.
client.call(
"GET",
f"/api/v1/attachments/{attachment_id}/content",
expected=404,
actor=eve,
)
print("PASS: non-member cannot download attachment")
# 9. Create another chat where Alice and Eve are members.
second_chat = client.call(
"POST",
"/api/v1/chats",
201,
actor=alice,
body={
"title": "Cross-chat attachment test",
"member_ids": [alice["id"], eve["id"]],
},
schema="Chat",
)["json"]
# Try to attach a file from the first chat to a message in the second.
client.call(
"POST",
f"/api/v1/chats/{second_chat['id']}/messages",
expected=404,
actor=alice,
body={
"text": "Cross-chat attachment test",
"attachment_ids": [attachment_id],
},
headers={"Idempotency-Key": uuid.uuid4().hex},
)
print("PASS: attachment from another chat rejected with HTTP 404")
print()
print("PASS: all presigned negative scenarios")
if __name__ == "__main__":
main()
+123
View File
@@ -0,0 +1,123 @@
import hashlib
import json
import sys
import urllib.request
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
BASE_URL = "http://localhost:8080"
IMAGE = ROOT / "tests" / "fixtures" / "sample.png"
def response_json(response):
"""Decode JSON from the raw response bytes."""
return json.loads(response["bytes"].decode("utf-8"))
def main():
content = IMAGE.read_bytes()
digest = hashlib.sha256(content).hexdigest()
client = Client(BASE_URL)
alice, bob, eve, chat = client.bootstrap()
# 1. Request a short-lived upload URL.
create_response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments/presigned",
201,
actor=alice,
body={
"filename": "sample.png",
"content_type": "image/png",
"size_bytes": len(content),
"sha256": digest,
},
)
created = response_json(create_response)
check(created["method"] == "PUT", "unexpected upload method")
check(bool(created["upload_id"]), "missing upload_id")
check(created["expires_in"] > 0, "invalid upload expiration")
# 2. Upload directly to S3, without sending the file through the API.
request = urllib.request.Request(
created["upload_url"],
data=content,
headers=created["headers"],
method="PUT",
)
with urllib.request.urlopen(request, timeout=30) as response:
check(
response.status in (200, 201, 204),
"S3 upload failed",
)
# 3. Complete the upload.
complete_path = (
f"/api/v1/attachments/uploads/{created['upload_id']}/complete"
)
complete_response = client.call(
"POST",
complete_path,
200,
actor=alice,
)
attachment = response_json(complete_response)
check(attachment["status"] == "ready", "attachment is not ready")
check(attachment["chat_id"] == chat["id"], "wrong attachment chat")
check(attachment["owner_id"] == alice["id"], "wrong attachment owner")
check(attachment["sha256"] == digest, "attachment checksum mismatch")
check(
attachment["size_bytes"] == len(content),
"attachment size mismatch",
)
# 4. Complete again: must return the same attachment.
repeated_response = client.call(
"POST",
complete_path,
200,
actor=alice,
)
repeated = response_json(repeated_response)
check(
repeated["id"] == attachment["id"],
"repeated completion created a duplicate",
)
# 5. Download through the authorized API endpoint.
downloaded = client.call(
"GET",
f"/api/v1/attachments/{attachment['id']}/content",
200,
actor=alice,
)["bytes"]
check(downloaded == content, "downloaded bytes differ from original")
check(
hashlib.sha256(downloaded).hexdigest() == digest,
"downloaded checksum mismatch",
)
print("PASS: presigned upload, completion, idempotency and download")
print(f"Upload ID: {created['upload_id']}")
print(f"Attachment ID: {attachment['id']}")
print(f"File size: {len(content)} bytes")
print(f"SHA-256: {digest}")
if __name__ == "__main__":
main()
+127
View File
@@ -0,0 +1,127 @@
import sys
from pathlib import Path
from sqlalchemy import text
ROOT = Path("/app")
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, check
from app.core.config import settings
from app.db.models import Attachment
from app.db.session import SessionLocal
from app.services.object_storage import client as s3_client
TRIGGER_NAME = "lab4_force_attachment_insert_failure"
FUNCTION_NAME = "lab4_fail_attachment_insert"
TEST_FILENAME = "lab4-forced-db-failure.png"
def install_failure_trigger():
table = Attachment.__table__
schema = table.schema or "public"
qualified_table = f'"{schema}"."{table.name}"'
with SessionLocal() as db:
db.execute(text(f"""
CREATE OR REPLACE FUNCTION public.{FUNCTION_NAME}()
RETURNS trigger
LANGUAGE plpgsql
AS $$
BEGIN
IF NEW.filename = '{TEST_FILENAME}' THEN
RAISE EXCEPTION 'Lab 4 controlled metadata failure'
USING ERRCODE = 'P0001';
END IF;
RETURN NEW;
END;
$$;
"""))
db.execute(text(
f'DROP TRIGGER IF EXISTS {TRIGGER_NAME} ON {qualified_table}'
))
db.execute(text(
f'CREATE TRIGGER {TRIGGER_NAME} '
f'BEFORE INSERT ON {qualified_table} '
f'FOR EACH ROW EXECUTE FUNCTION public.{FUNCTION_NAME}()'
))
db.commit()
def remove_failure_trigger():
table = Attachment.__table__
schema = table.schema or "public"
qualified_table = f'"{schema}"."{table.name}"'
with SessionLocal() as db:
db.execute(text(
f'DROP TRIGGER IF EXISTS {TRIGGER_NAME} ON {qualified_table}'
))
db.execute(text(
f'DROP FUNCTION IF EXISTS public.{FUNCTION_NAME}()'
))
db.commit()
def object_keys(s3, prefix):
result = s3.list_objects_v2(
Bucket=settings.s3_bucket,
Prefix=prefix,
)
return {
item["Key"]
for item in result.get("Contents", [])
}
def main():
client = Client("http://127.0.0.1:8080")
alice, bob, eve, chat = client.bootstrap()
content = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
prefix = f"original/{chat['id']}/"
s3 = s3_client()
before = object_keys(s3, prefix)
install_failure_trigger()
print("Temporary PostgreSQL failure trigger installed.")
try:
response = client.call(
"POST",
f"/api/v1/chats/{chat['id']}/attachments"
f"?filename={TEST_FILENAME}",
expected=503,
actor=alice,
raw=content,
headers={"Content-Type": "image/png"},
)
check(
response["status"] == 503,
"Expected HTTP 503 after forced metadata failure",
)
print("PASS: S3 upload succeeded, PostgreSQL metadata insert failed")
after = object_keys(s3, prefix)
unexpected_objects = after - before
check(
not unexpected_objects,
"Compensation failed: unexpected S3 objects remain",
)
print("PASS: uploaded S3 object was deleted after DB failure")
print()
print("PASS: S3/PostgreSQL compensation scenario")
finally:
remove_failure_trigger()
print("Temporary PostgreSQL trigger removed.")
if __name__ == "__main__":
main()
+20 -6
View File
@@ -182,13 +182,27 @@ class Client:
headers = {'Idempotency-Key':key or uuid.uuid4().hex} if LAB>=3 else {}
return self.call('POST','/api/v1/chats/'+chat['id']+'/messages',201,actor=actor,body=body,headers=headers,schema='Message')
def attachment(self, actor, chat):
def attachment(self, actor, chat, include_instance=False):
content = (ROOT / 'tests/fixtures/sample.png').read_bytes()
att = self.call('POST','/api/v1/chats/'+chat['id']+'/attachments?filename=sample.png',201 if LAB==4 else 202,actor=actor,raw=content,headers={'Content-Type':'image/png'},schema='Attachment')['json']
check(att['status']==('ready' if LAB==4 else 'queued'),'incorrect upload status')
check(att['chat_id']==chat['id'] and att['owner_id']==actor['id'],'attachment ownership mismatch')
check(att['sha256']==hashlib.sha256(content).hexdigest() and att['size_bytes']==len(content),'original checksum/size mismatch')
return att,content
response = self.call(
'POST',
'/api/v1/chats/' + chat['id'] + '/attachments?filename=sample.png',
201 if LAB == 4 else 202,
actor=actor,
raw=content,
headers={'Content-Type': 'image/png'},
schema='Attachment'
)
att = response['json']
check(att['status'] == ('ready' if LAB == 4 else 'queued'), 'incorrect upload status')
check(att['chat_id'] == chat['id'] and att['owner_id'] == actor['id'], 'attachment ownership mismatch')
check(
att['sha256'] == hashlib.sha256(content).hexdigest()
and att['size_bytes'] == len(content),
'original checksum/size mismatch'
)
instance_id = response['headers'].get('X-Instance-Id', '')
return (att, content, instance_id) if include_instance else (att, content)
def wait_ready(self, actor, att, wait_seconds=60):
deadline = time.monotonic()+wait_seconds
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 5.5 MiB

+15 -5
View File
@@ -40,12 +40,22 @@ def main():
alice,bob,eve,chat = c.bootstrap()
sent = c.message(alice,chat,'Сохранить при отказе')
original = sent['json']
target = sent['headers'].get('X-Instance-Id','')
target = sent['headers'].get('X-Instance-Id', '')
attachment = content = None
if LAB>=4:
attachment,content = c.attachment(alice,chat)
if LAB>=5:
attachment = c.wait_ready(alice,attachment)
if LAB >= 4:
attachment, content, upload_instance = c.attachment(alice, chat, include_instance=True)
if args.mode == 'failover':
check(bool(upload_instance), 'attachment upload response has no X-Instance-Id')
target = upload_instance
if LAB >= 5:
attachment = c.wait_ready(alice, attachment)
if args.mode == 'failover':
check(bool(target), 'target API instance ID is empty')
env = dict(os.environ)
env['TARGET_INSTANCE_ID'] = target
observed = set()