feat: implement S3 attachments and presigned uploads
This commit is contained in:
@@ -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
|
||||
@@ -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`; приложен вывод.
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
.env
|
||||
.env.*
|
||||
!.env.example
|
||||
!.env.compose.example
|
||||
secrets/
|
||||
certs/private/
|
||||
*.key
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 и включает механизмы проверки и обработки ошибок при работе с двумя независимыми хранилищами.
|
||||
@@ -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
@@ -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:
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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
@@ -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
@@ -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
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
|
||||
@@ -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
@@ -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.
@@ -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
|
||||
@@ -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
|
||||
|
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.
@@ -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
|
||||
@@ -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.
@@ -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
|
||||
|
@@ -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")
|
||||
@@ -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
|
||||
|
||||
@@ -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__")
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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
@@ -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
|
||||
|
||||
Vendored
BIN
Binary file not shown.
|
After Width: | Height: | Size: 5.5 MiB |
+15
-5
@@ -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()
|
||||
|
||||
Reference in New Issue
Block a user