feat: Саватеев А трек 4
This commit is contained in:
@@ -44,3 +44,19 @@ S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
|
||||
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
# Только путь к файлам; сами ключи — в secrets/ (scripts/init-secrets.sh)
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE=/run/secrets/s3_admin_access_key_id
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_admin_secret_access_key
|
||||
S3_POOL_MAX_SIZE=20
|
||||
S3_CONNECT_TIMEOUT_SEC=2
|
||||
S3_READ_TIMEOUT_SEC=10
|
||||
S3_MAX_ATTEMPTS=2
|
||||
S3_STARTUP_TIMEOUT_SEC=60
|
||||
# Байт загрузки в RAM; остальное — во временном файле запроса (удаляется сразу)
|
||||
UPLOAD_SPOOL_MEMORY_BYTES=1048576
|
||||
# Одновременных проверок изображений на реплику: худший случай ~250 МБ на одну
|
||||
IMAGE_INSPECT_WORKERS=1
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC=30
|
||||
# Janitor очищает незавершённые загрузки не моложе grace period
|
||||
ATTACHMENT_PENDING_GRACE_SEC=900
|
||||
JANITOR_INTERVAL_SEC=60
|
||||
|
||||
@@ -6,14 +6,17 @@ TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
|
||||
export BUILDX_NO_DEFAULT_ATTESTATIONS := 1
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover install up down restart restore instances rolling-update ps logs wait-ready destroy-data student-test concurrency-test test-expiry test-failures test-migrations explain sigterm-check experiment-failover experiment-rolling
|
||||
.PHONY: help check validate test load test-persistence test-failover install init up down restart restore instances rolling-update ps logs wait-ready destroy-data student-test concurrency-test test-expiry test-failures test-migrations explain sigterm-check experiment-failover experiment-rolling test-storage test-s3-failure janitor-dry-run janitor-once experiment-uploads s3-ui
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "up/down/restart/ps/logs: compose stack; destroy-data: DELETE volumes intentionally"
|
||||
@echo "instances: API containers <-> X-Instance-Id; restore: start replicas stopped by stop-one.sh; rolling-update: replace replicas one by one"
|
||||
@echo "experiment-failover / experiment-rolling: load + stop each replica / rolling update, metrics to evidence/"
|
||||
@echo "student-test: own tests; test-migrations: from empty volume; test-expiry: short SESSION_TTL; test-failures: stop Valkey/PostgreSQL; explain: EXPLAIN history"
|
||||
@echo "student-test: own tests; test-migrations: from empty volume; test-expiry: short SESSION_TTL; test-failures: stop Valkey/PostgreSQL/S3; explain: EXPLAIN history"
|
||||
@echo "init: .env + local S3 secrets; test-storage: private bucket/credentials/consistency; janitor-dry-run / janitor-once: S3/DB reconcile"
|
||||
@echo "experiment-uploads: >=10 concurrent uploads, peak API memory to evidence/"
|
||||
@echo "s3-ui: temporary read-only SeaweedFS Filer UI on 127.0.0.1:8888 (Ctrl+C to close)"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -38,6 +41,9 @@ test-failover:
|
||||
install:
|
||||
poetry install --no-root
|
||||
|
||||
init:
|
||||
./scripts/init-secrets.sh
|
||||
|
||||
up:
|
||||
docker compose up -d --build --wait
|
||||
|
||||
@@ -78,12 +84,31 @@ student-test:
|
||||
concurrency-test:
|
||||
BASE_URL="$(BASE_URL)" poetry run pytest student-tests/test_concurrency.py -s
|
||||
|
||||
test-expiry:
|
||||
docker compose --profile expiry up -d --build --wait api-short-ttl
|
||||
EXPIRY_BASE_URL=http://localhost:8081 poetry run pytest student-tests/test_expiry.py -s; \
|
||||
status=$$?; docker compose --profile expiry stop api-short-ttl; exit $$status
|
||||
|
||||
test-failures:
|
||||
BASE_URL="$(BASE_URL)" RUN_FAILURE_TESTS=1 poetry run pytest student-tests/test_dependency_failures.py -s
|
||||
BASE_URL="$(BASE_URL)" RUN_FAILURE_TESTS=1 poetry run pytest student-tests/test_dependency_failures.py student-tests/test_storage_failures.py student-tests/test_attachment_failover.py -s
|
||||
|
||||
test-s3-failure:
|
||||
BASE_URL="$(BASE_URL)" RUN_FAILURE_TESTS=1 poetry run pytest student-tests/test_storage_failures.py -s
|
||||
|
||||
test-storage:
|
||||
BASE_URL="$(BASE_URL)" RUN_STORAGE_TESTS=1 poetry run pytest student-tests/test_storage_security.py student-tests/test_storage_consistency.py -s
|
||||
|
||||
janitor-dry-run:
|
||||
docker compose exec -T janitor python src/janitor.py --once --dry-run
|
||||
|
||||
janitor-once:
|
||||
docker compose exec -T janitor python src/janitor.py --once
|
||||
|
||||
s3-ui:
|
||||
$(PYTHON) scripts/s3_ui.py
|
||||
|
||||
experiment-uploads:
|
||||
poetry run python scripts/upload_experiment.py --base-url "$(BASE_URL)" --output evidence/experiment-uploads.json
|
||||
|
||||
test-migrations:
|
||||
./scripts/check_migrations.sh
|
||||
|
||||
@@ -1,37 +1,138 @@
|
||||
# Отчёт — лабораторная 4
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Саватеев Артём, группа TODO
|
||||
- Целевая оценка: **4**; трек 5 не заявлен
|
||||
- Commit/PR: TODO после публикации (ветка `feature/lab4-core-logic`)
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI, asyncpg, redis-py, aiobotocore 3.9.1 (S3-клиент), Pillow 12.3.0 (проверка изображений), SeaweedFS 4.48 (S3-сервер); документация S3 API и SeaweedFS (identities, `-s3.config`)
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Prerequisites: Docker Engine 29 / Compose v2.40, Python 3.12 + Poetry 2.2 (для собственных тестов), Python 3.9+ (публичные тесты)
|
||||
|
||||
| Компонент | Образ / версия |
|
||||
| --- | --- |
|
||||
| API, migrate, s3-bootstrap, janitor | `mtusi-messenger:lab4` из `Dockerfile` (python:3.12.12-slim-bookworm) |
|
||||
| PostgreSQL | `postgres:18.2-alpine3.22` |
|
||||
| Valkey | `valkey/valkey:8.1.4-alpine3.22` |
|
||||
| S3 | `chrislusf/seaweedfs:4.48` |
|
||||
| LB | `nginx:1.28.0-alpine3.21` |
|
||||
|
||||
```sh
|
||||
make init # .env из .env.example + секреты в secrets/ (повторный запуск ничего не меняет)
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait
|
||||
# порядок: postgres, valkey, s3 → migrate (миграции) и s3-bootstrap (bucket)
|
||||
# → api ×2, janitor → nginx; --wait ждёт healthy всех сервисов
|
||||
make test # публичный smoke
|
||||
make install && make student-test # собственные unit + black-box тесты
|
||||
make test-storage # приватность bucket, права ключей, сверка janitor
|
||||
make test-failures # отказы PostgreSQL/Valkey/S3 и реплики, принявшей файл
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && ./scripts/restore.sh
|
||||
make experiment-uploads # ≥10 одновременных загрузок, пик памяти → evidence/
|
||||
make test-migrations # миграции с пустого volume (отдельный compose-проект)
|
||||
```
|
||||
|
||||
Безопасная остановка: `make down` (volumes сохраняются). Намеренное удаление учебных данных: `make destroy-data` (`down -v`: PostgreSQL и S3). Секреты: `scripts/init-secrets.sh` создаёт `secrets/` (в `.gitignore`), значения не печатает и не перезаписывает — иначе объекты bucket станут недоступны. Оператору больше ничего делать не нужно: bucket создаётся сервисом `s3-bootstrap` автоматически.
|
||||
|
||||
Если порт 8080 занят другим стендом (например, lab3), задайте `LB_PORT` в `.env` и `BASE_URL=http://localhost:<порт>` для тестов.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
клиент → nginx (edge) → api ×2 ─┬─ backend: PostgreSQL (метаданные, источник истины), Valkey (кэш сессий)
|
||||
└─ storage: SeaweedFS S3 (байты оригиналов, приватный bucket)
|
||||
janitor (backend + storage): сверка S3/БД
|
||||
migrate, s3-bootstrap: одноразовые, до старта API
|
||||
```
|
||||
|
||||
**Перенесено из lab3 без изменений:** пользователи, сессии (PostgreSQL + Valkey), чаты, история, Idempotency-Key, 2 реплики за nginx, graceful shutdown, `X-Instance-Id`, скрипты отказов. **Изменено:** сообщение получило `attachment_ids` (пустой текст разрешён только с вложениями); hash идемпотентности считается без полей по умолчанию, поэтому для текстовых сообщений он совпадает с lab3. Попутно исправлен Makefile lab3: потерянная строка цели `test-expiry`.
|
||||
|
||||
**Слои** (как в lab3): `domain` (схемы, ошибки) → `interfaces` (абстракции `AttachmentRepository`, `ObjectStorage`) → `infrastructure` (PostgreSQL/S3 реализации, `AttachmentService`, `StorageReconciler`, `ImageInspector`) → `application` (FastAPI endpoints). Сервисы зависят только от интерфейсов, поэтому отказы S3/БД проверяются unit-тестами на фейках.
|
||||
|
||||
**Хранилище.** MinIO не выбран: образы `minio/minio` и `minio/mc` больше не скачиваются из Docker Hub/quay, стенд не собрался бы из чистого clone. SeaweedFS 4.48 запускается одним контейнером `weed server`:
|
||||
- master/volume/filer и их веб-интерфейсы слушают только `127.0.0.1` внутри контейнера; в сеть `storage` открыт лишь S3 API `:9000`. Порты наружу не публикуются, сеть `storage` — `internal`, в неё входят только api, janitor, s3-bootstrap.
|
||||
- Identities (`secrets/s3_identities.json`): `bootstrap` (Admin) — только у `s3-bootstrap`; `messenger-api` — `Read/Write/List` **только своего bucket** — у API и janitor. Identity `anonymous` нет, поэтому любой неподписанный запрос получает 403.
|
||||
- `s3-bootstrap` идемпотентен: `CreateBucket` с обработкой `BucketAlreadyOwnedByYou`, затем проверяет, что анонимный запрос получает 403. Иначе завершается ошибкой, и API не стартует.
|
||||
|
||||
**Модель данных** (`migrations/0003_attachments.sql`): `attachments` (метаданные + `object_key` + `status` pending/ready/deleting), `message_attachments` (порядок вложений). Составные FK гарантируют на уровне БД, что владелец — участник чата, а вложение и сообщение принадлежат одному чату. Используемое вложение удалить нельзя (FK без CASCADE). Ключ объекта `originals/<128 бит random>` назначает сервер; `filename` — только отображение.
|
||||
|
||||
**Загрузка** `POST /chats/{id}/attachments` (сырые байты):
|
||||
1. Аутентификация → членство в чате (404) → filename (400) → Content-Type (415) → Content-Length > 10 MiB (413). Всё это до чтения тела.
|
||||
2. Тело читается потоком: первые 1 MiB в RAM, остальное во временный файл запроса, который удаляется сразу. Чтение обрывается на байте 10 MiB+1 (413). SHA-256 считается по ходу.
|
||||
3. `ImageInspector` в пуле из `IMAGE_INSPECT_WORKERS` потоков: формат по сигнатуре (подмена MIME → 415); размеры из заголовка до распаковки (> 40 Мпикс → 413); целостность: PNG — CRC всех chunk и IEND, JPEG — декодирование libjpeg в draft-режиме 1/8 (повреждено → 415).
|
||||
4. Запись: строка `pending` (COMMIT) → один `PUT` в S3 с `x-amz-checksum-sha256` (S3 сверяет байты) → `pending → ready` → **201**. 201 возвращается только когда оригинал в S3 и метаданные подтверждены. PUT + подтверждение ограничены `ATTACHMENT_STORE_TIMEOUT_SEC=30`.
|
||||
|
||||
**Скачивание** — только через API, без redirect: проверка участника (чужое/неизвестное/незавершённое — одинаковый 404), затем поток из S3 по 64 KiB с истинным `Content-Type`, `Content-Length`, `X-Content-Type-Options: nosniff`, `Content-Disposition` (RFC 5987). Случайный ключ и приватный bucket не заменяют ACL: ключ мог бы утечь через логи или бэкап, а доступ к файлу определяется членством в чате, которое знает только приложение.
|
||||
|
||||
**Согласованность S3 ↔ PostgreSQL (уровень 4).** Инвариант: *у каждого объекта под `originals/` есть строка*. Строка коммитится до PUT, а удаляется только после удаления объекта.
|
||||
- Сбой после записи строки (S3 PUT упал или неизвестен, COMMIT `ready` не прошёл, таймаут, отмена задачи при остановке реплики) компенсируется сразу: `pending → deleting` → `DeleteObject` → `DELETE` строки. Строку сначала *забирают*: если UPDATE в `ready` на самом деле прошёл, claim не сработает, и объект готового вложения уцелеет.
|
||||
- Если компенсация не удалась (S3/БД недоступны, процесс убит), остаётся строка `pending` или `deleting`. Её дочищает **janitor** (`src/janitor.py`, отдельный сервис, раз в 60 с): `pending` старше `ATTACHMENT_PENDING_GRACE_SEC=900` атомарно переводится в `deleting` (`FOR UPDATE SKIP LOCKED`), затем удаляется объект (идемпотентно), затем строка. Прерванная очистка `deleting` повторяется при следующем проходе.
|
||||
- **Безопасность grace period:** API подтверждает только строку моложе grace (`created_at > now() - grace` по часам БД), janitor забирает только старше grace. Граничную гонку сериализует блокировка строки. Загрузка длится ≤ 30 с + проверка, что на порядки меньше 900 с.
|
||||
- Второй проход janitor — сверка bucket: объекты без строки старше grace удаляются. При соблюдении инварианта их нет; проход проверяет инвариант и страхует, например, от восстановления БД из старой копии. Свежие объекты и любые `ready` не трогаются. `--dry-run` только отчитывается.
|
||||
- **«S3 PUT прошёл, COMMIT нет»:** объект учтён строкой `pending`. Клиент получил 503 и id не знает. Компенсация удалит объект сразу, а если не сможет — janitor через ≤ grace + интервал.
|
||||
|
||||
**Readiness** = PostgreSQL + S3 (`head_bucket` с таймаутом 2 с): с lab4 вложения входят в обязательный синхронный путь. Valkey не критичен, как и раньше. При падении S3 реплика честно отвечает 503 на `/health/ready`. nginx не исключает реплики по readiness, поэтому сообщения, сессии и метаданные продолжают работать, а загрузка и скачивание отвечают быстрым 503.
|
||||
|
||||
**Лимиты памяти по всей цепочке:** nginx (`proxy_request_buffering off` на upload, `client_max_body_size 11m`: тело 10 MiB+1 отклоняет сама реплика с 413 по контракту), API (spool 1 MiB RAM на загрузку, проверка изображений в 1 потоке на реплику, лимит контейнера 512M), SeaweedFS (`-s3.concurrentUploadLimitMB=128`, `GOMEMLIMIT=384MiB`, лимит 512M). Последние два пункта — исправления по итогам эксперимента (см. ниже).
|
||||
|
||||
**Переменные `.env.example` → конфигурация:** `S3_ENDPOINT/REGION/BUCKET` → клиент aiobotocore (path-style); `S3_ACCESS_KEY_ID_FILE`/`S3_SECRET_ACCESS_KEY_FILE` → compose secrets `/run/secrets/*` у api и janitor; `S3_ADMIN_*_FILE` → только у s3-bootstrap; `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` → лимиты контракта; `UPLOAD_SPOOL_MEMORY_BYTES`, `IMAGE_INSPECT_WORKERS` → память на загрузку; `S3_CONNECT/READ_TIMEOUT_SEC`, `S3_MAX_ATTEMPTS`, `ATTACHMENT_STORE_TIMEOUT_SEC` → ограниченное время ответа; `ATTACHMENT_PENDING_GRACE_SEC`, `JANITOR_INTERVAL_SEC` → janitor.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `make test` | PASS: lab4 public API scenario | `evidence/tests.txt` |
|
||||
| Lab3 сохранена | `make student-test` | 187 passed, 16 skipped (явные отказы и expiry запускаются своими целями) | `evidence/tests.txt` |
|
||||
| S3 в стенде, метаданные в PG, байты в приватном bucket | `compose.yaml`, `test_storage_security.py`, `test_attachments.py::test_public_api_does_not_expose_storage_details` | Объекты только в SeaweedFS (volume `s3_data`), на API нет volume. Ответ API не раскрывает ключ, bucket и адрес | `evidence/tests.txt` |
|
||||
| 201 ready, побайтный download, checksum, посторонний 404 | `test_attachments.py` (PNG fixture, JPEG baseline/progressive) | SHA-256 и байты совпадают у второго участника; посторонний и неизвестный id — одинаковый 404 | `evidence/tests.txt` |
|
||||
| Сообщение с `attachment_ids` | `test_message_attachments.py` | Читается участником, порядок сохранён, `text=""` с вложением → 201 | `evidence/tests.txt` |
|
||||
| PNG/JPEG ≤ 10 MiB, ≤ 40 Мпикс, MIME по содержимому, опасные имена | `test_attachments.py` | Ровно 10 485 760 байт → 201, +1 → 413 от API; 8000×5000 → 201, 8000×5001 → 413 (файл < 1 MiB, лимит до распаковки); 13 опасных filename → 400 | `evidence/tests.txt` |
|
||||
| Failover upload → download | `test_attachment_failover.py`, `make test-failover` ×2 | `UPLOADED BY 5a67…, DOWNLOADED FROM [da68…]`; публичный: 0 ошибок, восстановление записи 2.06 с и 1.62 с | `evidence/failures.txt`, `evidence/failover.txt` |
|
||||
| Restart с volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; uptime всех 7 контейнеров сброшен | `evidence/persistence.txt` |
|
||||
| **4:** слишком большой файл, повреждённое, подмена MIME, чужое id, файл другого чата, без 500 | `test_attachments.py`, `test_message_attachments.py` | 413 / 415 (6 видов повреждений, 9 видов подмены) / 404 / 404, сообщение не создаётся; каждый ответ проверен `assert_not_server_error` | `evidence/tests.txt` |
|
||||
| **4:** обрыв загрузки и отказ между S3/БД | `student-tests/unit/test_unit_attachment_service.py` (8 сценариев отказа на фейках), `test_storage_consistency.py` (стенд), `test_storage_failures.py` | Во всех сценариях итог — ни объектов, ни строк. На стенде janitor удалил 2 «упавшие» загрузки и 1 сироту, свежие и `ready` сохранены. Обрыв тела прямо в реплике — 0 строк | `evidence/tests.txt`, `evidence/failures.txt` |
|
||||
| **4:** RAM ограничена, ≥ 10 одновременных загрузок | `make experiment-uploads` | см. раздел «Эксперименты» | `evidence/experiment-uploads.json` |
|
||||
| **4:** идемпотентный bootstrap, отдельные ограниченные ключи, консоль закрыта, private bucket вне API | `make test-storage` (`test_storage_security.py`) | 2 запуска bootstrap: «уже существует», «приватен»; API-ключ: put/get/delete своего bucket — да, `CreateBucket/DeleteBucket/PutBucketPolicy/PutBucketAcl` — AccessDenied; у API нет админ-ключей; порты 9333/8888/8080/19333/18888/18080/8181/9101 закрыты; анонимный GET объекта, списка и сервиса — 403; nginx не видит S3 | `evidence/tests.txt` |
|
||||
| Миграции с нуля | `make test-migrations` | 0001–0003 применяются; 3 повторных запуска идемпотентны; API без migrate не стартует | вывод команды |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
**Гипотеза:** память API на загрузку ограничена (spool 1 MiB, потоковый PUT/GET, 1 поток декодирования на реплику), поэтому пик RSS не растёт как N × размер файла.
|
||||
|
||||
**Методика** (`scripts/upload_experiment.py`): 2 API-реплики (1 CPU / 512M каждая), Docker Desktop VM 10 CPU / 7.7 GiB, macOS arm64. Перед каждым раундом реплики перезапускаются, затем прогрев. N загрузок стартуют по одному барьеру через nginx. Память опрашивается внутри контейнеров каждые 0.2 с (VmRSS процесса, cgroup `memory.current`), плюс VmHWM. После раунда один файл скачивается и сверяется по SHA-256. Профили: PNG 9.19 MB из шума (приём тела, spool, S3) и progressive JPEG 8000×5000 = 40 Мпикс, 4.98 MB (худший случай декодера). Один прогон на точку, 2026-10-20.
|
||||
|
||||
| Профиль | N | 201 | p50 / p95 / max, с | RSS до → пик, МиБ (реплика 1 / 2) | cgroup пик, МиБ |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| PNG 9.19 MB | 10 | 10/10 | 2.01 / 2.09 / 2.09 | 99 → 122 / 126 | 153 / 166 |
|
||||
| PNG 9.19 MB | 20 | 20/20 | 3.46 / 3.88 / 3.89 | 99 → 124 / 126 | 215 / 216 |
|
||||
| PNG 9.19 MB | 30 | 30/30 | 4.62 / 4.98 / 7.21 | 99 → 127 / 142 | 255 / 280 |
|
||||
| JPEG 40 Мпикс | 10 | 10/10 | 0.96 / 1.42 / 1.42 | 99 → 334 / 333 | 338 / 338 |
|
||||
| JPEG 40 Мпикс | 20 | 20/20 | 1.77 / 2.59 / 2.74 | 94 → 336 / 336 | 362 / 362 |
|
||||
| JPEG 40 Мпикс | 30 | 30/30 | 2.98 / 6.64 / 6.64 | 99 → 338 / 340 | 391 / 393 |
|
||||
|
||||
**Выводы.** При 15 одновременных PNG на реплику (135 МиБ данных) RSS вырос лишь на 28–43 МиБ. Пик для худшего JPEG (~335 МиБ, буфер коэффициентов libjpeg, ~6 Б/пиксель) не зависит от N: декодирование сериализовано одним потоком, остальные загрузки ждут в очереди, растёт только задержка. Рост cgroup сверх RSS — page cache временных файлов spool, он вытесняемый. Ни одного OOM.
|
||||
|
||||
**Что эксперимент нашёл и что исправлено:**
|
||||
1. Первый прогон: при N = 10 PNG соединения обрывались. В `memory.events` nginx `oom_kill 4`: с `proxy_request_buffering on` nginx складывал тела во временные файлы, и грязный page cache выходил за лимит 64M. Исправлено отключением буферизации на upload-location: тело идёт потоком в API, где память на загрузку ограничена.
|
||||
2. Затем при N = 20 все ответы 503. dmesg: `Killed process (weed) anon-rss:459380kB`, SeaweedFS держал тела в Go-куче. Исправлено `-s3.concurrentUploadLimitMB=128`, `-volume.concurrentUploadLimitMB=128`, `GOMEMLIMIT=384MiB`. Сверх лимита запросы ждут. После исправлений: N = 10/20/30 — 100 % успешно.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Остановка реплики, принявшей файл | Download через другую, тот же SHA-256 | 10/10 скачиваний с другой реплики, байты совпадают | Без перерыва / нет |
|
||||
| `stop-one.sh` под записью сообщений (×2) | Восстановление ≤ 10 с, без дублей | 0 ошибок, 130 и 129 записей, 2.06 с и 1.62 с | ≤ 2.1 с / нет |
|
||||
| Restart всего стенда с volumes | Данные, файл и прежний токен целы | PASS | ≈ 30 с (SeaweedFS останавливается ~25 с) / нет |
|
||||
| Остановка S3 | Upload/download 503 < 6 с, сообщения и метаданные работают, ready 503 | Так и есть. Компенсация не смогла удалить объект → строка `deleting` → janitor дочистил | Сразу после старта S3 / нет |
|
||||
| Падение API между PUT и COMMIT (внедрено в БД/S3) | janitor удаляет после grace, свежие и `ready` не трогает | `unfinished 2, orphans 1` удалены; свежие пережили первый проход и удалены вторым | grace + интервал / нет |
|
||||
| Обрыв тела загрузки прямо в реплике | Ни строк, ни объектов | 0 строк; API журналирует 400 «Загрузка прервана клиентом» | Мгновенно / нет |
|
||||
| PostgreSQL / Valkey (из lab3) | 503 ограниченно по времени / обход кэша | 4 passed | — |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Не выдерживается:** потеря Docker-host. Единственные экземпляры PostgreSQL, SeaweedFS (один volume-сервер без репликации) и nginx — точки отказа. HA хранилищ не заявляется.
|
||||
- PNG проверяется по структуре и CRC без распаковки IDAT: файл с корректными CRC, но испорченным zlib-потоком будет принят. Полное декодирование появится в lab5 у worker (статус `failed`). JPEG декодируется в draft-режиме, это проверяет весь поток данных.
|
||||
- Худший случай памяти на реплику ≈ 100 МиБ база + ~240 МиБ (один progressive JPEG 40 Мпикс) + 1 МиБ × число загрузок. `IMAGE_INSPECT_WORKERS > 1` требует соразмерно поднять лимит контейнера.
|
||||
- Slow-client: после отключения буферизации nginx медленная загрузка держит в API корутину (не поток) до `client_body_timeout` nginx (10 с между чтениями). Отдельного глобального лимита одновременных загрузок на реплику нет: их ограничивают пул SeaweedFS и таймауты.
|
||||
- Grace period 15 мин означает, что объект упавшей загрузки может занимать место до ~16 мин. Это осознанный компромисс в пользу безопасности.
|
||||
- Эксперимент — по одному прогону на точку на ноутбуке. Числа задержек не переносятся на другую машину, переносимы выводы о форме роста памяти.
|
||||
- **Перед сдачей:** повторить `make test-failures` и `make test-persistence` на финальной конфигурации. Последний повтор (12:32–12:33) недействителен: стенд lab4 был остановлен извне, и порт 8080 занял стенд lab3. Подробности в `evidence/*.txt`.
|
||||
|
||||
+133
-6
@@ -1,11 +1,10 @@
|
||||
name: messenger-lab3
|
||||
name: messenger-lab4
|
||||
|
||||
# Один образ приложения для api, migrate, s3-bootstrap и janitor. Собирает его
|
||||
# только api: параллельная сборка одного тега несколькими сервисами конфликтует.
|
||||
x-app: &app
|
||||
build:
|
||||
context: .
|
||||
args:
|
||||
APP_REVISION: ${APP_REVISION:-dev}
|
||||
image: mtusi-messenger:lab3
|
||||
image: mtusi-messenger:lab4
|
||||
pull_policy: never
|
||||
env_file:
|
||||
- .env
|
||||
environment: &app-network
|
||||
@@ -13,6 +12,7 @@ x-app: &app
|
||||
DB_PORT: "5432"
|
||||
VALKEY_HOST: valkey
|
||||
VALKEY_PORT: "6379"
|
||||
S3_ENDPOINT: http://s3:9000
|
||||
|
||||
x-api-resources: &api-resources
|
||||
resources:
|
||||
@@ -29,13 +29,20 @@ x-api: &api
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
s3-bootstrap:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
valkey:
|
||||
condition: service_started
|
||||
# Только ограниченные ключи своего bucket; административных у API нет
|
||||
secrets:
|
||||
- s3_access_key_id
|
||||
- s3_secret_access_key
|
||||
networks:
|
||||
- edge
|
||||
- backend
|
||||
- storage
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "src/healthcheck.py"]
|
||||
interval: 5s
|
||||
@@ -74,6 +81,10 @@ services:
|
||||
|
||||
api:
|
||||
<<: *api
|
||||
build:
|
||||
context: .
|
||||
args:
|
||||
APP_REVISION: ${APP_REVISION:-dev}
|
||||
deploy:
|
||||
<<: *api-resources
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
@@ -149,6 +160,105 @@ services:
|
||||
cpus: "0.25"
|
||||
memory: 96M
|
||||
|
||||
# SeaweedFS всё-в-одном. master, volume, filer и их веб-интерфейсы слушают
|
||||
# только loopback контейнера; в сеть storage открыт лишь S3 API (9000).
|
||||
# Порты наружу не публикуются: bucket доступен только через API.
|
||||
s3:
|
||||
image: chrislusf/seaweedfs:4.48
|
||||
restart: unless-stopped
|
||||
command:
|
||||
- server
|
||||
- -dir=/data
|
||||
- -ip=127.0.0.1
|
||||
- -ip.bind=127.0.0.1
|
||||
- -master.volumeSizeLimitMB=1024
|
||||
- -volume.max=0
|
||||
- -s3
|
||||
- -s3.port=9000
|
||||
- -s3.ip.bind=0.0.0.0
|
||||
- -s3.config=/run/secrets/s3_identities
|
||||
- -s3.port.iceberg=0
|
||||
- -s3.port.lance=0
|
||||
# Тела загрузок SeaweedFS держит в памяти: без лимита 20 одновременных
|
||||
# PUT по 9 MiB вызывали OOM kill weed (evidence/experiment-uploads.json).
|
||||
# Сверх лимита запросы ждут своей очереди.
|
||||
- -s3.concurrentUploadLimitMB=128
|
||||
- -volume.concurrentUploadLimitMB=128
|
||||
environment:
|
||||
# Мягкий предел кучи Go ниже лимита контейнера: GC срабатывает раньше OOM
|
||||
GOMEMLIMIT: 384MiB
|
||||
secrets:
|
||||
- s3_identities
|
||||
volumes:
|
||||
- s3_data:/data
|
||||
networks:
|
||||
- storage
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:9000/healthz"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 30
|
||||
start_period: 10s
|
||||
stop_grace_period: 30s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.0"
|
||||
memory: 512M
|
||||
|
||||
# Идемпотентное создание приватного bucket административными ключами
|
||||
s3-bootstrap:
|
||||
<<: *app
|
||||
command: ["python", "src/s3_bootstrap.py"]
|
||||
restart: "no"
|
||||
depends_on:
|
||||
s3:
|
||||
condition: service_healthy
|
||||
secrets:
|
||||
- s3_admin_access_key_id
|
||||
- s3_admin_secret_access_key
|
||||
networks:
|
||||
- storage
|
||||
healthcheck:
|
||||
disable: true
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.5"
|
||||
memory: 256M
|
||||
|
||||
# Сверка S3/БД: незавершённые загрузки старше grace period и сироты
|
||||
janitor:
|
||||
<<: *app
|
||||
command: ["python", "src/janitor.py"]
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
s3-bootstrap:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
secrets:
|
||||
- s3_access_key_id
|
||||
- s3_secret_access_key
|
||||
networks:
|
||||
- backend
|
||||
- storage
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "src/healthcheck.py", "janitor"]
|
||||
interval: 30s
|
||||
timeout: 5s
|
||||
retries: 3
|
||||
start_period: 30s
|
||||
start_interval: 1s
|
||||
stop_grace_period: 10s
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.25"
|
||||
memory: 192M
|
||||
|
||||
api-short-ttl:
|
||||
<<: *api
|
||||
profiles:
|
||||
@@ -164,6 +274,23 @@ networks:
|
||||
edge: {}
|
||||
backend:
|
||||
internal: true
|
||||
# API, janitor и bootstrap ↔ S3; PostgreSQL и Valkey сюда не входят
|
||||
storage:
|
||||
internal: true
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
s3_data:
|
||||
|
||||
# Создаются scripts/init-secrets.sh; в git не попадают
|
||||
secrets:
|
||||
s3_access_key_id:
|
||||
file: ./secrets/s3_access_key_id
|
||||
s3_secret_access_key:
|
||||
file: ./secrets/s3_secret_access_key
|
||||
s3_admin_access_key_id:
|
||||
file: ./secrets/s3_admin_access_key_id
|
||||
s3_admin_secret_access_key:
|
||||
file: ./secrets/s3_admin_secret_access_key
|
||||
s3_identities:
|
||||
file: ./secrets/s3_identities.json
|
||||
|
||||
@@ -0,0 +1,254 @@
|
||||
{
|
||||
"environment": {
|
||||
"host": "Darwin arm64",
|
||||
"docker": "29.0.1",
|
||||
"docker_vm_cpus": 10,
|
||||
"docker_vm_memory_gib": 7.7,
|
||||
"api_limits": "cpus 1.0, memory 512M per replica (compose.yaml)",
|
||||
"s3": "chrislusf/seaweedfs:4.48",
|
||||
"settings": {
|
||||
"API_REPLICAS": "2",
|
||||
"MAX_UPLOAD_BYTES": "10485760",
|
||||
"MAX_IMAGE_PIXELS": "40000000",
|
||||
"S3_POOL_MAX_SIZE": "20",
|
||||
"UPLOAD_SPOOL_MEMORY_BYTES": "1048576",
|
||||
"IMAGE_INSPECT_WORKERS": "1"
|
||||
}
|
||||
},
|
||||
"rounds": [
|
||||
{
|
||||
"profile": "png",
|
||||
"file_bytes": 9192108,
|
||||
"concurrency": 10,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 10
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"d5c1cf9c56c0": 5,
|
||||
"c194122992eb": 5
|
||||
},
|
||||
"wall_seconds": 2.09,
|
||||
"latency_seconds": {
|
||||
"p50": 2.01,
|
||||
"p95": 2.09,
|
||||
"max": 2.09
|
||||
},
|
||||
"throughput_mib_per_second": 41.9,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.1,
|
||||
"rss_peak_process_vmhwm_mib": 156.5,
|
||||
"rss_peak_sampled_mib": 121.5,
|
||||
"cgroup_peak_sampled_mib": 152.6,
|
||||
"samples": 20
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 156.5,
|
||||
"rss_peak_sampled_mib": 125.7,
|
||||
"cgroup_peak_sampled_mib": 165.6,
|
||||
"samples": 20
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "png",
|
||||
"file_bytes": 9192108,
|
||||
"concurrency": 20,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 20
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"f6aa4c07652a": 10,
|
||||
"3b495b150936": 10
|
||||
},
|
||||
"wall_seconds": 3.89,
|
||||
"latency_seconds": {
|
||||
"p50": 3.456,
|
||||
"p95": 3.881,
|
||||
"max": 3.888
|
||||
},
|
||||
"throughput_mib_per_second": 45.1,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 156.6,
|
||||
"rss_peak_sampled_mib": 123.6,
|
||||
"cgroup_peak_sampled_mib": 214.6,
|
||||
"samples": 29
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 156.4,
|
||||
"rss_peak_sampled_mib": 126.1,
|
||||
"cgroup_peak_sampled_mib": 216.3,
|
||||
"samples": 29
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "png",
|
||||
"file_bytes": 9192108,
|
||||
"concurrency": 30,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 30
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"5d4554045abd": 15,
|
||||
"51a1d5ba826c": 15
|
||||
},
|
||||
"wall_seconds": 7.21,
|
||||
"latency_seconds": {
|
||||
"p50": 4.62,
|
||||
"p95": 4.979,
|
||||
"max": 7.206
|
||||
},
|
||||
"throughput_mib_per_second": 36.5,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.1,
|
||||
"rss_peak_process_vmhwm_mib": 156.6,
|
||||
"rss_peak_sampled_mib": 127.1,
|
||||
"cgroup_peak_sampled_mib": 254.8,
|
||||
"samples": 45
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.1,
|
||||
"rss_peak_process_vmhwm_mib": 156.6,
|
||||
"rss_peak_sampled_mib": 142.0,
|
||||
"cgroup_peak_sampled_mib": 279.8,
|
||||
"samples": 46
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "jpeg",
|
||||
"file_bytes": 4980814,
|
||||
"concurrency": 10,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 10
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"68c5e652faea": 5,
|
||||
"647da7ba9c11": 5
|
||||
},
|
||||
"wall_seconds": 1.42,
|
||||
"latency_seconds": {
|
||||
"p50": 0.958,
|
||||
"p95": 1.416,
|
||||
"max": 1.416
|
||||
},
|
||||
"throughput_mib_per_second": 33.5,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 333.4,
|
||||
"rss_peak_sampled_mib": 334.0,
|
||||
"cgroup_peak_sampled_mib": 338.4,
|
||||
"samples": 17
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 5,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 332.6,
|
||||
"rss_peak_sampled_mib": 333.4,
|
||||
"cgroup_peak_sampled_mib": 337.7,
|
||||
"samples": 17
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "jpeg",
|
||||
"file_bytes": 4980814,
|
||||
"concurrency": 20,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 20
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"a54206764ef9": 10,
|
||||
"b85fe6e9cbd7": 10
|
||||
},
|
||||
"wall_seconds": 2.74,
|
||||
"latency_seconds": {
|
||||
"p50": 1.768,
|
||||
"p95": 2.593,
|
||||
"max": 2.738
|
||||
},
|
||||
"throughput_mib_per_second": 34.6,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 93.5,
|
||||
"rss_peak_process_vmhwm_mib": 335.0,
|
||||
"rss_peak_sampled_mib": 336.0,
|
||||
"cgroup_peak_sampled_mib": 362.0,
|
||||
"samples": 24
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 10,
|
||||
"rss_before_mib": 93.5,
|
||||
"rss_peak_process_vmhwm_mib": 337.4,
|
||||
"rss_peak_sampled_mib": 336.0,
|
||||
"cgroup_peak_sampled_mib": 362.4,
|
||||
"samples": 24
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"profile": "jpeg",
|
||||
"file_bytes": 4980814,
|
||||
"concurrency": 30,
|
||||
"replicas_restarted_before": true,
|
||||
"status_counts": {
|
||||
"201": 30
|
||||
},
|
||||
"uploads_by_instance": {
|
||||
"da06b29a8834": 15,
|
||||
"0ff93f8a6fd8": 15
|
||||
},
|
||||
"wall_seconds": 6.64,
|
||||
"latency_seconds": {
|
||||
"p50": 2.981,
|
||||
"p95": 6.635,
|
||||
"max": 6.635
|
||||
},
|
||||
"throughput_mib_per_second": 21.5,
|
||||
"download_sha256_matches": true,
|
||||
"replicas": {
|
||||
"messenger-lab4-api-1": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 337.4,
|
||||
"rss_peak_sampled_mib": 337.9,
|
||||
"cgroup_peak_sampled_mib": 390.6,
|
||||
"samples": 43
|
||||
},
|
||||
"messenger-lab4-api-2": {
|
||||
"uploads_served": 15,
|
||||
"rss_before_mib": 99.2,
|
||||
"rss_peak_process_vmhwm_mib": 339.1,
|
||||
"rss_peak_sampled_mib": 339.7,
|
||||
"cgroup_peak_sampled_mib": 393.1,
|
||||
"samples": 43
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
## instances before
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 running/healthy 0fd6b920cefc 2735 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
## make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
{"observed_instances_before": 2, "successful_writes": 130, "failed_attempts": 0, "first_recovery_seconds": 2.058}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
## instances after (stopped replica stays stopped)
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 exited/unhealthy - 0 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
|
||||
## second run after scripts/restore.sh
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 running/healthy 04c6c919ec65 5688 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
{"observed_instances_before": 2, "successful_writes": 129, "failed_attempts": 0, "first_recovery_seconds": 1.618}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
CONTAINER STATE INSTANCE PID REVISION
|
||||
messenger-lab4-api-1 exited/unhealthy - 0 dev
|
||||
messenger-lab4-api-2 running/healthy 5a67f0c47be1 2687 dev
|
||||
@@ -0,0 +1,19 @@
|
||||
# make test-failures (PostgreSQL, Valkey, S3, остановка реплики, принявшей файл)
|
||||
#
|
||||
# 2026-10-20 ~12:05 MSK — 6 passed (до включения S3 в readiness, отключения
|
||||
# буферизации nginx и лимитов SeaweedFS).
|
||||
student-tests/test_dependency_failures.py::test_valkey_down_cache_is_bypassed PASSED
|
||||
student-tests/test_dependency_failures.py::test_logout_during_valkey_outage_is_not_resurrected PASSED
|
||||
student-tests/test_dependency_failures.py::test_postgres_down_returns_bounded_503_and_no_anonymous_access PASSED
|
||||
student-tests/test_dependency_failures.py::test_session_survives_postgres_restart PASSED
|
||||
student-tests/test_storage_failures.py::test_s3_outage_is_isolated_and_leaves_no_garbage PASSED
|
||||
student-tests/test_attachment_failover.py::test_download_survives_stop_of_uploading_replica
|
||||
UPLOADED BY 5a67f0c47be1, DOWNLOADED FROM ['da68a0e82155']
|
||||
PASSED
|
||||
========================= 6 passed in 70.80s (0:01:10) =========================
|
||||
|
||||
# 2026-10-20 12:32 MSK — повторный прогон НЕДЕЙСТВИТЕЛЕН (5 passed, 1 failed):
|
||||
# во время прогона стенд lab4 был остановлен извне и порт 8080 занял стенд lab3.
|
||||
# test_attachment_failover отдельно на lab4 после этого: 1 passed
|
||||
# (UPLOADED BY 67c813dd874b, DOWNLOADED FROM ['82dc3cadef5c']).
|
||||
# Повторить make test-failures на финальной конфигурации перед сдачей.
|
||||
@@ -0,0 +1,27 @@
|
||||
# make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
#
|
||||
# 2026-10-20 ~12:17 MSK — PASS (readiness с проверкой S3, до отключения
|
||||
# буферизации nginx и лимитов SeaweedFS; эти изменения не касаются сохранности).
|
||||
## containers before
|
||||
api messenger-lab4-api-1 Up 10 seconds (healthy)
|
||||
api messenger-lab4-api-2 Up 10 seconds (healthy)
|
||||
janitor messenger-lab4-janitor-1 Up 10 seconds (healthy)
|
||||
nginx messenger-lab4-nginx-1 Up About a minute (healthy)
|
||||
postgres messenger-lab4-postgres-1 Up About a minute (healthy)
|
||||
s3 messenger-lab4-s3-1 Up About a minute (healthy)
|
||||
valkey messenger-lab4-valkey-1 Up About a minute (healthy)
|
||||
## make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
## containers after (uptime сброшен у всех: реально перезапущены PostgreSQL, Valkey, S3, API, janitor, nginx)
|
||||
api messenger-lab4-api-1 Up 15 seconds (healthy)
|
||||
api messenger-lab4-api-2 Up 15 seconds (health: starting)
|
||||
janitor messenger-lab4-janitor-1 Up 16 seconds (healthy)
|
||||
nginx messenger-lab4-nginx-1 Up 15 seconds (healthy)
|
||||
postgres messenger-lab4-postgres-1 Up 42 seconds (healthy)
|
||||
s3 messenger-lab4-s3-1 Up 17 seconds (health: starting)
|
||||
valkey messenger-lab4-valkey-1 Up 42 seconds (healthy)
|
||||
|
||||
# 2026-10-20 12:33 MSK — повторный прогон НЕДЕЙСТВИТЕЛЕН: во время прогона стенд
|
||||
# lab4 был остановлен извне, на 127.0.0.1:8080 работал стенд lab3 (его ответы
|
||||
# без attachment_ids). Повторить на финальной конфигурации перед сдачей.
|
||||
@@ -0,0 +1,9 @@
|
||||
## make check
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
## make test
|
||||
PASS: lab4 public API scenario; infrastructure and grading evidence remain separate.
|
||||
## make student-test (unit + black-box)
|
||||
======================= 187 passed, 16 skipped in 23.48s =======================
|
||||
## make test-storage
|
||||
JANITOR REPORT: {"dry_run": false, "unfinished_claimed": 2, "unfinished_objects_deleted": 2, "unfinished_rows_deleted": 2, "objects_scanned": 381, "orphan_objects_found": 1, "orphan_objects_deleted": 1}
|
||||
======================== 8 passed in 114.70s (0:01:54) =========================
|
||||
@@ -66,6 +66,23 @@ http {
|
||||
proxy_pass http://api;
|
||||
}
|
||||
|
||||
# Загрузка вложения. Лимит LB чуть больше лимита API (10 MiB): тело
|
||||
# 10 MiB + 1 отклоняет сама реплика ответом 413 по контракту, а LB
|
||||
# отсекает только заведомо огромные тела.
|
||||
# Тело НЕ буферизуется в nginx, а идёт потоком в API (там память
|
||||
# на загрузку ограничена spool 1 MiB). С буферизацией 10 одновременных
|
||||
# тел по 9 MiB во временных файлах nginx давали грязный page cache
|
||||
# сверх лимита контейнера 64M и OOM kill воркеров (эксперимент
|
||||
# evidence/experiment-uploads.json). Медленный клиент занимает в API
|
||||
# только корутину; client_body_timeout обрывает зависшую передачу.
|
||||
# read timeout больше ATTACHMENT_STORE_TIMEOUT_SEC (30 с) + проверки.
|
||||
location ~ ^/api/v1/chats/[^/]+/attachments$ {
|
||||
client_max_body_size 11m;
|
||||
proxy_request_buffering off;
|
||||
proxy_read_timeout 45s;
|
||||
proxy_pass http://api;
|
||||
}
|
||||
|
||||
error_page 502 503 504 = @unavailable;
|
||||
error_page 413 = @too_large;
|
||||
|
||||
|
||||
@@ -0,0 +1,69 @@
|
||||
-- Вложения (lab4): метаданные в PostgreSQL, байты — в приватном bucket S3.
|
||||
-- Только расширение схемы (expand): API lab3 продолжает работать на новой схеме.
|
||||
|
||||
-- Строка создаётся ДО записи объекта в S3 (status = pending) и удаляется только
|
||||
-- ПОСЛЕ удаления объекта (через deleting). Поэтому у каждого объекта S3 есть
|
||||
-- строка, и janitor находит незавершённые загрузки по БД, а не обходом bucket.
|
||||
CREATE TABLE attachments (
|
||||
id uuid PRIMARY KEY DEFAULT uuidv7(),
|
||||
chat_id uuid NOT NULL,
|
||||
owner_id uuid NOT NULL,
|
||||
filename text NOT NULL,
|
||||
content_type text NOT NULL,
|
||||
size_bytes integer NOT NULL,
|
||||
sha256 bytea NOT NULL,
|
||||
-- назначает сервер (originals/<random>); filename в ключ не входит
|
||||
object_key text NOT NULL,
|
||||
status text NOT NULL DEFAULT 'pending',
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
CONSTRAINT attachments_object_key_key UNIQUE (object_key),
|
||||
-- цель составного FK из message_attachments: вложение того же чата
|
||||
CONSTRAINT attachments_id_chat_id_key UNIQUE (id, chat_id),
|
||||
-- загружать может только участник чата; без CASCADE: молча удалённая
|
||||
-- строка оставила бы объект S3 неучтённым
|
||||
CONSTRAINT attachments_owner_member_fkey FOREIGN KEY (chat_id, owner_id)
|
||||
REFERENCES chat_members (chat_id, user_id),
|
||||
CONSTRAINT attachments_status_check
|
||||
CHECK (status IN ('pending', 'ready', 'deleting')),
|
||||
CONSTRAINT attachments_content_type_check
|
||||
CHECK (content_type IN ('image/png', 'image/jpeg')),
|
||||
CONSTRAINT attachments_size_bytes_range CHECK (size_bytes BETWEEN 1 AND 10485760),
|
||||
CONSTRAINT attachments_sha256_len CHECK (octet_length(sha256) = 32),
|
||||
CONSTRAINT attachments_filename_len CHECK (char_length(filename) BETWEEN 1 AND 255)
|
||||
);
|
||||
|
||||
-- janitor: WHERE status <> 'ready' AND created_at < now() - grace;
|
||||
-- готовых строк подавляющее большинство, в индекс они не попадают
|
||||
CREATE INDEX attachments_unfinished_created_at_idx
|
||||
ON attachments (created_at)
|
||||
WHERE status <> 'ready';
|
||||
|
||||
-- Пустой текст допустим, если у сообщения есть вложения (проверяет API:
|
||||
-- условие охватывает две таблицы). Ограничение только ослабляется.
|
||||
ALTER TABLE messages DROP CONSTRAINT messages_text_len;
|
||||
ALTER TABLE messages
|
||||
ADD CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 0 AND 4000);
|
||||
|
||||
-- цель составного FK из message_attachments: сообщение того же чата
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_id_chat_id_key UNIQUE (id, chat_id);
|
||||
|
||||
-- position сохраняет порядок attachment_ids из запроса
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL,
|
||||
chat_id uuid NOT NULL,
|
||||
attachment_id uuid NOT NULL,
|
||||
position smallint NOT NULL,
|
||||
PRIMARY KEY (message_id, position),
|
||||
CONSTRAINT message_attachments_attachment_key UNIQUE (message_id, attachment_id),
|
||||
CONSTRAINT message_attachments_message_fkey FOREIGN KEY (message_id, chat_id)
|
||||
REFERENCES messages (id, chat_id) ON DELETE CASCADE,
|
||||
-- вложение принадлежит чату сообщения; используемое вложение не удалить
|
||||
CONSTRAINT message_attachments_attachment_fkey FOREIGN KEY (attachment_id, chat_id)
|
||||
REFERENCES attachments (id, chat_id),
|
||||
CONSTRAINT message_attachments_position_range CHECK (position BETWEEN 0 AND 9)
|
||||
);
|
||||
|
||||
-- Проверка FK при удалении вложения: без индекса — полный проход таблицы
|
||||
CREATE INDEX message_attachments_attachment_id_idx
|
||||
ON message_attachments (attachment_id);
|
||||
Generated
+1180
-1
File diff suppressed because it is too large
Load Diff
@@ -15,6 +15,8 @@ loguru = "0.7.3"
|
||||
asyncpg = "0.31.0"
|
||||
redis = "6.4.0"
|
||||
argon2-cffi = "25.1.0"
|
||||
aiobotocore = "3.9.1"
|
||||
pillow = "12.3.0"
|
||||
|
||||
[tool.poetry.group.dev.dependencies]
|
||||
pytest = "9.1.1"
|
||||
|
||||
@@ -4,7 +4,7 @@ set -eu
|
||||
# compose-проект с собственным пустым volume. Рабочий стенд и его данные
|
||||
# не затрагиваются; временный volume этого проекта удаляется в конце.
|
||||
cd "$(dirname "$0")/.."
|
||||
PROJECT=messenger-lab3-migrations-check
|
||||
PROJECT=messenger-lab4-migrations-check
|
||||
# Публикуется только порт LB: свои порты, чтобы не конфликтовать с основным стендом
|
||||
export LB_PORT="${MIGRATIONS_CHECK_LB_PORT:-58080}"
|
||||
export LB_EXPIRY_PORT="${MIGRATIONS_CHECK_LB_EXPIRY_PORT:-58081}"
|
||||
|
||||
Executable
+73
@@ -0,0 +1,73 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Локальные синтетические секреты стенда в secrets/ (каталог в .gitignore)
|
||||
# и .env из .env.example, если их ещё нет. Повторный запуск ничего не меняет:
|
||||
# существующие ключи не перезаписываются, иначе данные bucket станут недоступны.
|
||||
#
|
||||
# s3_admin_* — ключи s3-bootstrap: создание bucket (действие Admin)
|
||||
# s3_access_* — ключи API и janitor: Read/Write/List только своего bucket
|
||||
# s3_identities — конфигурация identities SeaweedFS из этих ключей
|
||||
#
|
||||
# Значения не печатаются. Файлы 0644 внутри каталога 0700: процесс API в
|
||||
# контейнере работает не от root и должен прочитать смонтированный секрет.
|
||||
cd "$(dirname "$0")/.."
|
||||
umask 077
|
||||
|
||||
if [ ! -f .env ]; then
|
||||
cp .env.example .env
|
||||
echo "created .env from .env.example"
|
||||
fi
|
||||
|
||||
BUCKET=$(sed -n 's/^S3_BUCKET=//p' .env)
|
||||
: "${BUCKET:?S3_BUCKET is not set in .env}"
|
||||
|
||||
mkdir -p secrets
|
||||
chmod 700 secrets
|
||||
|
||||
random() {
|
||||
LC_ALL=C tr -dc 'A-Za-z0-9' </dev/urandom | head -c "$1"
|
||||
}
|
||||
|
||||
secret() {
|
||||
file="secrets/$1"
|
||||
if [ ! -s "$file" ]; then
|
||||
random "$2" >"$file"
|
||||
echo "created $file"
|
||||
fi
|
||||
chmod 644 "$file"
|
||||
}
|
||||
|
||||
secret s3_admin_access_key_id 20
|
||||
secret s3_admin_secret_access_key 40
|
||||
secret s3_access_key_id 20
|
||||
secret s3_secret_access_key 40
|
||||
|
||||
# Без identity "anonymous" SeaweedFS отклоняет любой неподписанный запрос
|
||||
cat >secrets/s3_identities.json <<EOF
|
||||
{
|
||||
"identities": [
|
||||
{
|
||||
"name": "bootstrap",
|
||||
"credentials": [
|
||||
{
|
||||
"accessKey": "$(cat secrets/s3_admin_access_key_id)",
|
||||
"secretKey": "$(cat secrets/s3_admin_secret_access_key)"
|
||||
}
|
||||
],
|
||||
"actions": ["Admin"]
|
||||
},
|
||||
{
|
||||
"name": "messenger-api",
|
||||
"credentials": [
|
||||
{
|
||||
"accessKey": "$(cat secrets/s3_access_key_id)",
|
||||
"secretKey": "$(cat secrets/s3_secret_access_key)"
|
||||
}
|
||||
],
|
||||
"actions": ["Read:$BUCKET", "Write:$BUCKET", "List:$BUCKET"]
|
||||
}
|
||||
]
|
||||
}
|
||||
EOF
|
||||
chmod 644 secrets/s3_identities.json
|
||||
echo "secrets ready in secrets/ (values are not printed)"
|
||||
+6
-5
@@ -1,11 +1,12 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Перезапуск всего стенда с сохранением volumes: хранилища (PostgreSQL, Valkey),
|
||||
# затем все API-реплики и балансировщик. Никаких down -v, flush или повторного
|
||||
# seed; migrate не запускается — схема уже в volume. Готовность ждёт тест.
|
||||
# Перезапуск всего стенда с сохранением volumes: хранилища (PostgreSQL, Valkey,
|
||||
# S3), затем все API-реплики, janitor и балансировщик. Никаких down -v, flush
|
||||
# или повторного seed; migrate и s3-bootstrap не запускаются — схема и bucket
|
||||
# уже в volumes. Готовность ждёт тест.
|
||||
cd "$(dirname "$0")/.."
|
||||
ENV_FILE="${ENV_FILE:-.env}"
|
||||
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps postgres valkey
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps api
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps postgres valkey s3
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps api janitor
|
||||
docker compose --env-file "$ENV_FILE" restart --no-deps nginx
|
||||
|
||||
Executable
+114
@@ -0,0 +1,114 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Временный read-only доступ к Filer UI SeaweedFS (просмотр бакетов) с хоста.
|
||||
|
||||
Filer UI слушает только 127.0.0.1 внутри контейнера s3 и в сеть не открыт
|
||||
(требование: административная консоль не доступна в общей сети). Этот скрипт
|
||||
— операторский инструмент на время демонстрации:
|
||||
|
||||
* слушает только 127.0.0.1 хоста и живёт, пока запущен (Ctrl+C — закрыть);
|
||||
* пропускает только GET/HEAD: удаление/загрузка через UI (POST/PUT/DELETE)
|
||||
отклоняются 405, данные bucket через него не изменить;
|
||||
* каждый запрос выполняется в контейнере s3 (docker exec … curl) к
|
||||
127.0.0.1:8888 — порты контейнера и сети стенда не меняются.
|
||||
|
||||
make s3-ui # http://127.0.0.1:8888/buckets/
|
||||
python3 scripts/s3_ui.py --port 18888
|
||||
|
||||
Python 3.9+, стандартная библиотека.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import subprocess
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
FILER_URL = "http://127.0.0.1:8888"
|
||||
CURL_TIMEOUT_SEC = 30
|
||||
# Заголовки клиента, передаваемые filer: от Accept зависит HTML или JSON
|
||||
FORWARDED_HEADERS = ("Accept", "Range")
|
||||
# Ответ пересобирается целиком: длина и кодирование задаются заново
|
||||
DROPPED_HEADERS = {"transfer-encoding", "connection", "content-length", "keep-alive"}
|
||||
|
||||
|
||||
def s3_container() -> str:
|
||||
container = subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", "ps", "-q", "s3"],
|
||||
cwd=ROOT,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=True,
|
||||
).stdout.strip()
|
||||
if not container:
|
||||
raise SystemExit("контейнер s3 не запущен: сначала make up")
|
||||
return container
|
||||
|
||||
|
||||
class ReadOnlyFilerProxy(BaseHTTPRequestHandler):
|
||||
container = ""
|
||||
|
||||
def do_GET(self) -> None:
|
||||
self._proxy(head=False)
|
||||
|
||||
def do_HEAD(self) -> None:
|
||||
self._proxy(head=True)
|
||||
|
||||
def _reject(self) -> None:
|
||||
self.send_error(405, "Read-only: изменение bucket через UI запрещено")
|
||||
|
||||
do_POST = do_PUT = do_DELETE = do_PATCH = _reject
|
||||
|
||||
def _proxy(self, head: bool) -> None:
|
||||
command = ["docker", "exec", self.container, "curl", "-s", "-i"]
|
||||
if head:
|
||||
command.append("-I")
|
||||
for name in FORWARDED_HEADERS:
|
||||
if self.headers.get(name):
|
||||
command += ["-H", f"{name}: {self.headers[name]}"]
|
||||
command.append(FILER_URL + self.path)
|
||||
try:
|
||||
raw = subprocess.run(
|
||||
command, capture_output=True, timeout=CURL_TIMEOUT_SEC, check=True
|
||||
).stdout
|
||||
except (subprocess.SubprocessError, OSError):
|
||||
self.send_error(502, "Filer недоступен")
|
||||
return
|
||||
head_part, _, body = raw.partition(b"\r\n\r\n")
|
||||
lines = head_part.decode("latin-1").split("\r\n")
|
||||
status = int(lines[0].split()[1])
|
||||
self.send_response(status)
|
||||
for line in lines[1:]:
|
||||
name, _, value = line.partition(":")
|
||||
if name.strip().lower() not in DROPPED_HEADERS:
|
||||
self.send_header(name.strip(), value.strip())
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.send_header("Connection", "close")
|
||||
self.end_headers()
|
||||
if not head:
|
||||
self.wfile.write(body)
|
||||
|
||||
def log_message(self, format: str, *args: object) -> None:
|
||||
print(f"{self.command} {self.path.split('?')[0]} -> {args[1] if len(args) > 1 else ''}")
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
parser.add_argument("--port", type=int, default=8888)
|
||||
args = parser.parse_args()
|
||||
|
||||
ReadOnlyFilerProxy.container = s3_container()
|
||||
server = ThreadingHTTPServer(("127.0.0.1", args.port), ReadOnlyFilerProxy)
|
||||
print(f"Filer UI (read-only): http://127.0.0.1:{args.port}/buckets/ — Ctrl+C, чтобы закрыть")
|
||||
try:
|
||||
server.serve_forever()
|
||||
except KeyboardInterrupt:
|
||||
pass
|
||||
finally:
|
||||
server.server_close()
|
||||
print("проброс закрыт")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,317 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Эксперимент: N одновременных загрузок вложений и пик памяти API-реплик.
|
||||
|
||||
Гипотеза: память реплики на загрузку ограничена (spool ≤ 1 MiB RAM, потоковый
|
||||
PUT в S3, проверка изображения в пуле из IMAGE_INSPECT_WORKERS потоков),
|
||||
поэтому пик RSS растёт не пропорционально N × размер файла.
|
||||
|
||||
Профили:
|
||||
png — PNG ~9 MiB из шума (почти не сжимается): нагрузка на приём тела,
|
||||
spool, SHA-256 и PUT в S3. Генерируется стандартной библиотекой.
|
||||
jpeg — progressive JPEG 8000×5000 = 40 Мпикс (предел): худший случай
|
||||
декодера libjpeg. Нужен Pillow (poetry run python ...).
|
||||
|
||||
Перед каждым прогоном API-реплики перезапускаются: VmHWM (пиковый RSS
|
||||
процесса) начинается заново. Память опрашивается внутри контейнеров каждые
|
||||
0.2 с (cgroup memory.current и VmRSS процесса). Все N запросов стартуют по
|
||||
одному барьеру. Tokens не печатаются и не сохраняются.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import platform
|
||||
import statistics
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import zlib
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
|
||||
from client import Client # noqa: E402
|
||||
|
||||
REQUEST_TIMEOUT_SEC = 120
|
||||
READY_TIMEOUT_SEC = 90
|
||||
SAMPLE_INTERVAL_SEC = 0.2
|
||||
COMPOSE = ["docker", "compose", "--env-file", ".env"]
|
||||
SAMPLER = (
|
||||
"while :; do "
|
||||
"echo $(cat /sys/fs/cgroup/memory.current) "
|
||||
"$(awk '/VmRSS/ {print $2}' /proc/1/status); "
|
||||
f"sleep {SAMPLE_INTERVAL_SEC}; done"
|
||||
)
|
||||
|
||||
|
||||
def png_noise(width: int, height: int) -> bytes:
|
||||
"""Настоящий RGB PNG из случайных байт: размер ≈ width × height × 3"""
|
||||
|
||||
def chunk(kind: bytes, data: bytes) -> bytes:
|
||||
return (
|
||||
struct.pack(">I", len(data))
|
||||
+ kind
|
||||
+ data
|
||||
+ struct.pack(">I", zlib.crc32(kind + data))
|
||||
)
|
||||
|
||||
raw = b"".join(b"\x00" + os.urandom(width * 3) for _ in range(height))
|
||||
header = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
||||
return (
|
||||
b"\x89PNG\r\n\x1a\n"
|
||||
+ chunk(b"IHDR", header)
|
||||
+ chunk(b"IDAT", zlib.compress(raw, 1))
|
||||
+ chunk(b"IEND", b"")
|
||||
)
|
||||
|
||||
|
||||
def jpeg_worst_case() -> bytes:
|
||||
from PIL import Image
|
||||
|
||||
Image.MAX_IMAGE_PIXELS = None
|
||||
image = Image.effect_noise((8000, 5000), 64).convert("RGB")
|
||||
buffer = io.BytesIO()
|
||||
image.save(buffer, "JPEG", quality=10, progressive=True, subsampling=0)
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def compose(*args: str) -> str:
|
||||
return subprocess.run(
|
||||
[*COMPOSE, *args], cwd=ROOT, capture_output=True, text=True, check=True
|
||||
).stdout
|
||||
|
||||
|
||||
def api_containers() -> list[str]:
|
||||
return compose("ps", "-q", "api").split()
|
||||
|
||||
|
||||
def container_name(container: str) -> str:
|
||||
return subprocess.run(
|
||||
["docker", "inspect", "-f", "{{.Name}}", container],
|
||||
capture_output=True, text=True, check=True,
|
||||
).stdout.strip().lstrip("/")
|
||||
|
||||
|
||||
def process_status(container: str) -> dict:
|
||||
"""VmRSS/VmHWM процесса API (PID 1), байты, и его X-Instance-Id"""
|
||||
output = subprocess.run(
|
||||
["docker", "exec", container, "sh", "-c",
|
||||
"grep -E 'VmRSS|VmHWM' /proc/1/status; cat /tmp/instance-id"],
|
||||
capture_output=True, text=True, check=True,
|
||||
).stdout.split("\n")
|
||||
values: dict = {line.split(":")[0]: int(line.split()[1]) * 1024 for line in output[:2]}
|
||||
values["instance"] = output[2].strip()
|
||||
return values
|
||||
|
||||
|
||||
def restart_api(base_url: str) -> None:
|
||||
compose("restart", "api")
|
||||
deadline = time.monotonic() + READY_TIMEOUT_SEC
|
||||
while time.monotonic() < deadline:
|
||||
states = [
|
||||
subprocess.run(
|
||||
["docker", "inspect", "-f", "{{.State.Health.Status}}", c],
|
||||
capture_output=True, text=True,
|
||||
).stdout.strip()
|
||||
for c in api_containers()
|
||||
]
|
||||
if states and all(state == "healthy" for state in states):
|
||||
return
|
||||
time.sleep(1)
|
||||
raise SystemExit("API replicas are not healthy after restart")
|
||||
|
||||
|
||||
class Sampler(threading.Thread):
|
||||
"""Опрос памяти одного контейнера изнутри одним долгим docker exec"""
|
||||
|
||||
def __init__(self, container: str) -> None:
|
||||
super().__init__(daemon=True)
|
||||
self.container = container
|
||||
self.cgroup_max = 0
|
||||
self.rss_max = 0
|
||||
self.samples = 0
|
||||
self._process = subprocess.Popen(
|
||||
["docker", "exec", container, "sh", "-c", SAMPLER],
|
||||
stdout=subprocess.PIPE, text=True,
|
||||
)
|
||||
|
||||
def run(self) -> None:
|
||||
assert self._process.stdout is not None
|
||||
for line in self._process.stdout:
|
||||
parts = line.split()
|
||||
if len(parts) == 2:
|
||||
self.cgroup_max = max(self.cgroup_max, int(parts[0]))
|
||||
self.rss_max = max(self.rss_max, int(parts[1]) * 1024)
|
||||
self.samples += 1
|
||||
|
||||
def stop(self) -> None:
|
||||
self._process.terminate()
|
||||
self._process.wait()
|
||||
|
||||
|
||||
def upload_once(base: str, token: str, chat_id: str, content: bytes, content_type: str) -> dict:
|
||||
request = urllib.request.Request(
|
||||
f"{base}/api/v1/chats/{chat_id}/attachments?filename=experiment",
|
||||
data=content,
|
||||
method="POST",
|
||||
headers={"Authorization": "Bearer " + token, "Content-Type": content_type},
|
||||
)
|
||||
started = time.monotonic()
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=REQUEST_TIMEOUT_SEC) as response:
|
||||
body, status, instance = response.read(), response.status, response.headers.get("X-Instance-Id")
|
||||
except urllib.error.HTTPError as error:
|
||||
body, status, instance = error.read(), error.code, error.headers.get("X-Instance-Id")
|
||||
except OSError as error:
|
||||
return {"status": None, "error": type(error).__name__, "seconds": time.monotonic() - started}
|
||||
result = {"status": status, "instance": instance, "seconds": time.monotonic() - started}
|
||||
if status == 201:
|
||||
result["id"] = json.loads(body)["id"]
|
||||
return result
|
||||
|
||||
|
||||
def percentile(values: list[float], share: float) -> float:
|
||||
ordered = sorted(values)
|
||||
return ordered[min(len(ordered) - 1, round(share * (len(ordered) - 1)))]
|
||||
|
||||
|
||||
def run_round(client: Client, actor: dict, chat: dict, profile: str, content: bytes,
|
||||
content_type: str, concurrency: int, restart: bool) -> dict:
|
||||
if restart:
|
||||
restart_api(client.base)
|
||||
containers = api_containers()
|
||||
# Прогрев: первый запрос каждой реплики открывает пулы БД/S3
|
||||
warmup = png_noise(4, 4)
|
||||
for _ in range(2 * len(containers)):
|
||||
upload_once(client.base, actor["token"], chat["id"], warmup, "image/png")
|
||||
before = {container_name(c): process_status(c) for c in containers}
|
||||
samplers = [Sampler(c) for c in containers]
|
||||
for sampler in samplers:
|
||||
sampler.start()
|
||||
time.sleep(1)
|
||||
|
||||
barrier = threading.Barrier(concurrency)
|
||||
results: list[dict] = [{} for _ in range(concurrency)]
|
||||
|
||||
def worker(index: int) -> None:
|
||||
barrier.wait()
|
||||
results[index] = upload_once(client.base, actor["token"], chat["id"], content, content_type)
|
||||
|
||||
started = time.monotonic()
|
||||
threads = [threading.Thread(target=worker, args=(i,)) for i in range(concurrency)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
wall = time.monotonic() - started
|
||||
time.sleep(1)
|
||||
for sampler in samplers:
|
||||
sampler.stop()
|
||||
after = {container_name(c): process_status(c) for c in containers}
|
||||
|
||||
ok = [r for r in results if r.get("status") == 201]
|
||||
sample = ok[0]["id"] if ok else None
|
||||
checksum_ok = None
|
||||
if sample:
|
||||
downloaded = client.call("GET", f"/api/v1/attachments/{sample}/content", actor=actor)["bytes"]
|
||||
checksum_ok = hashlib.sha256(downloaded).digest() == hashlib.sha256(content).digest()
|
||||
seconds = [r["seconds"] for r in ok]
|
||||
mib = 1024 * 1024
|
||||
replicas = {}
|
||||
for sampler in samplers:
|
||||
name = container_name(sampler.container)
|
||||
replicas[name] = {
|
||||
"uploads_served": sum(1 for r in ok if r.get("instance") == after[name].get("instance")),
|
||||
"rss_before_mib": round(before[name]["VmRSS"] / mib, 1),
|
||||
"rss_peak_process_vmhwm_mib": round(after[name]["VmHWM"] / mib, 1),
|
||||
"rss_peak_sampled_mib": round(sampler.rss_max / mib, 1),
|
||||
"cgroup_peak_sampled_mib": round(sampler.cgroup_max / mib, 1),
|
||||
"samples": sampler.samples,
|
||||
}
|
||||
by_instance: dict[str, int] = {}
|
||||
for r in ok:
|
||||
by_instance[r["instance"]] = by_instance.get(r["instance"], 0) + 1
|
||||
return {
|
||||
"profile": profile,
|
||||
"file_bytes": len(content),
|
||||
"concurrency": concurrency,
|
||||
"replicas_restarted_before": restart,
|
||||
"status_counts": {str(s): sum(1 for r in results if r.get("status") == s)
|
||||
for s in sorted({r.get("status") for r in results}, key=str)},
|
||||
"uploads_by_instance": by_instance,
|
||||
"wall_seconds": round(wall, 2),
|
||||
"latency_seconds": {
|
||||
"p50": round(percentile(seconds, 0.5), 3),
|
||||
"p95": round(percentile(seconds, 0.95), 3),
|
||||
"max": round(max(seconds), 3),
|
||||
} if seconds else None,
|
||||
"throughput_mib_per_second": round(len(ok) * len(content) / mib / wall, 1),
|
||||
"download_sha256_matches": checksum_ok,
|
||||
"replicas": replicas,
|
||||
}
|
||||
|
||||
|
||||
def environment() -> dict:
|
||||
info = json.loads(subprocess.run(
|
||||
["docker", "info", "--format", "{{json .}}"], capture_output=True, text=True, check=True
|
||||
).stdout)
|
||||
settings = {}
|
||||
for line in (ROOT / ".env").read_text().splitlines():
|
||||
key = line.split("=", 1)[0]
|
||||
if key in {"IMAGE_INSPECT_WORKERS", "UPLOAD_SPOOL_MEMORY_BYTES", "MAX_UPLOAD_BYTES",
|
||||
"MAX_IMAGE_PIXELS", "API_REPLICAS", "S3_POOL_MAX_SIZE"}:
|
||||
settings[key] = line.split("=", 1)[1]
|
||||
return {
|
||||
"host": f"{platform.system()} {platform.machine()}",
|
||||
"docker": info.get("ServerVersion"),
|
||||
"docker_vm_cpus": info.get("NCPU"),
|
||||
"docker_vm_memory_gib": round(info.get("MemTotal", 0) / 2**30, 1),
|
||||
"api_limits": "cpus 1.0, memory 512M per replica (compose.yaml)",
|
||||
"s3": "chrislusf/seaweedfs:4.48",
|
||||
"settings": settings,
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
|
||||
parser.add_argument("--base-url", default=None)
|
||||
parser.add_argument("--output", default="evidence/experiment-uploads.json")
|
||||
parser.add_argument("--concurrency", default="10,20")
|
||||
parser.add_argument("--profiles", default="png,jpeg")
|
||||
parser.add_argument("--no-restart", action="store_true")
|
||||
args = parser.parse_args()
|
||||
|
||||
client = Client(args.base_url)
|
||||
alice, _, _, chat = client.bootstrap()
|
||||
payloads = {}
|
||||
if "png" in args.profiles:
|
||||
payloads["png"] = (png_noise(1750, 1750), "image/png")
|
||||
if "jpeg" in args.profiles:
|
||||
try:
|
||||
payloads["jpeg"] = (jpeg_worst_case(), "image/jpeg")
|
||||
except ImportError:
|
||||
print("jpeg profile skipped: Pillow is not installed (use poetry run)")
|
||||
report = {"environment": environment(), "rounds": []}
|
||||
for profile, (content, content_type) in payloads.items():
|
||||
for concurrency in (int(x) for x in args.concurrency.split(",")):
|
||||
result = run_round(client, alice, chat, profile, content, content_type,
|
||||
concurrency, not args.no_restart)
|
||||
report["rounds"].append(result)
|
||||
print(json.dumps(result, ensure_ascii=False))
|
||||
output = ROOT / args.output
|
||||
output.parent.mkdir(parents=True, exist_ok=True)
|
||||
output.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
|
||||
print("saved:", args.output)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -2,7 +2,12 @@ from fastapi import APIRouter, Depends, Request, status
|
||||
|
||||
from domain import HealthSchema
|
||||
from domain.errors import UnavailableError
|
||||
from infrastructure.dependencies import DatabasePoolManager, get_database
|
||||
from infrastructure.dependencies import (
|
||||
DatabasePoolManager,
|
||||
ObjectStorageManager,
|
||||
get_database,
|
||||
get_storage,
|
||||
)
|
||||
|
||||
health_router = APIRouter(prefix="/health", tags=["Health"])
|
||||
|
||||
@@ -23,14 +28,22 @@ async def liveness() -> HealthSchema:
|
||||
response_model=HealthSchema,
|
||||
)
|
||||
async def readiness(
|
||||
request: Request, database: DatabasePoolManager = Depends(get_database)
|
||||
request: Request,
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
storage: ObjectStorageManager = Depends(get_storage),
|
||||
) -> HealthSchema:
|
||||
"""
|
||||
Приложение не завершается и PostgreSQL отвечает. Valkey не критичен:
|
||||
без него сессии читаются из PostgreSQL, поэтому он не влияет на готовность.
|
||||
Приложение не завершается, PostgreSQL и S3 отвечают: с lab4 загрузка
|
||||
и скачивание вложений входят в обязательный синхронный путь.
|
||||
|
||||
Valkey не критичен: без него сессии читаются из PostgreSQL. Без S3
|
||||
недоступны только вложения — nginx не исключает реплику по readiness,
|
||||
поэтому сообщения продолжают работать, а реплика честно сообщает 503.
|
||||
"""
|
||||
if not getattr(request.app.state, "is_ready", False):
|
||||
raise UnavailableError()
|
||||
if not await database.check():
|
||||
raise UnavailableError("бд недоступна")
|
||||
if not await storage.check():
|
||||
raise UnavailableError("хранилище файлов недоступно")
|
||||
return HealthSchema()
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
from fastapi import APIRouter
|
||||
|
||||
from .attachments import attachments_router
|
||||
from .auth import auth_router
|
||||
from .chats import chats_router
|
||||
from .messages import messages_router
|
||||
@@ -11,5 +12,6 @@ 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)
|
||||
|
||||
__all__ = ["app"]
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
from .endpoints import attachments_router
|
||||
|
||||
__all__ = ["attachments_router"]
|
||||
@@ -0,0 +1,100 @@
|
||||
from typing import Annotated
|
||||
from uuid import UUID
|
||||
|
||||
from fastapi import APIRouter, Depends, Header, Query, Request, status
|
||||
from fastapi.responses import StreamingResponse
|
||||
from starlette.background import BackgroundTask
|
||||
|
||||
from application.api.dependencies import get_current_user
|
||||
from application.api.utils import content_disposition, request_chunks
|
||||
from domain import (
|
||||
AttachmentContentType,
|
||||
AttachmentFilename,
|
||||
AttachmentSchema,
|
||||
AttachmentVariant,
|
||||
UserSchema,
|
||||
)
|
||||
from infrastructure.dependencies import ServiceCreator
|
||||
from infrastructure.services import AttachmentService
|
||||
|
||||
attachments_router = APIRouter(tags=["Attachments"])
|
||||
|
||||
IMAGE_BODY = {
|
||||
content_type: {"schema": {"type": "string", "format": "binary"}}
|
||||
for content_type in AttachmentContentType
|
||||
}
|
||||
|
||||
|
||||
@attachments_router.post(
|
||||
"/chats/{chat_id}/attachments",
|
||||
status_code=status.HTTP_201_CREATED,
|
||||
response_model=AttachmentSchema,
|
||||
openapi_extra={"requestBody": {"required": True, "content": IMAGE_BODY}},
|
||||
)
|
||||
async def upload_attachment(
|
||||
chat_id: UUID,
|
||||
filename: Annotated[AttachmentFilename, Query()],
|
||||
request: Request,
|
||||
content_type: Annotated[str | None, Header()] = None,
|
||||
content_length: Annotated[int | None, Header(ge=0)] = None,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: AttachmentService = Depends(ServiceCreator.get_attachment_service),
|
||||
) -> AttachmentSchema:
|
||||
"""
|
||||
Сырые байты одного PNG/JPEG, не multipart. 201 ready — только после
|
||||
сохранения оригинала в S3 и метаданных в PostgreSQL.
|
||||
"""
|
||||
return await service.upload(
|
||||
current_user,
|
||||
chat_id,
|
||||
filename,
|
||||
content_type,
|
||||
content_length,
|
||||
request_chunks(request),
|
||||
)
|
||||
|
||||
|
||||
@attachments_router.get(
|
||||
"/attachments/{attachment_id}",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_model=AttachmentSchema,
|
||||
)
|
||||
async def get_attachment(
|
||||
attachment_id: UUID,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: AttachmentService = Depends(ServiceCreator.get_attachment_service),
|
||||
) -> AttachmentSchema:
|
||||
"""Метаданные доступны только участникам чата вложения; остальным — 404"""
|
||||
return await service.get_attachment(current_user, attachment_id)
|
||||
|
||||
|
||||
@attachments_router.get(
|
||||
"/attachments/{attachment_id}/content",
|
||||
status_code=status.HTTP_200_OK,
|
||||
response_class=StreamingResponse,
|
||||
responses={200: {"content": IMAGE_BODY}},
|
||||
)
|
||||
async def download_attachment(
|
||||
attachment_id: UUID,
|
||||
variant: Annotated[AttachmentVariant, Query()] = AttachmentVariant.ORIGINAL,
|
||||
current_user: UserSchema = Depends(get_current_user),
|
||||
service: AttachmentService = Depends(ServiceCreator.get_attachment_service),
|
||||
) -> StreamingResponse:
|
||||
"""
|
||||
Байты через API, без redirect на S3: доступ проверяет приложение.
|
||||
Ответ идёт потоком из S3, файл целиком в памяти реплики не собирается.
|
||||
"""
|
||||
attachment, content = await service.open_content(
|
||||
current_user, attachment_id, variant
|
||||
)
|
||||
return StreamingResponse(
|
||||
content.iter_chunks(),
|
||||
media_type=attachment.content_type,
|
||||
headers={
|
||||
"Content-Length": str(content.content_length),
|
||||
"Content-Disposition": content_disposition(attachment.filename),
|
||||
"X-Content-Type-Options": "nosniff",
|
||||
"Cache-Control": "private, no-store",
|
||||
},
|
||||
background=BackgroundTask(content.close),
|
||||
)
|
||||
@@ -4,10 +4,13 @@ from .errors import (
|
||||
error_response,
|
||||
get_request_id,
|
||||
)
|
||||
from .streams import content_disposition, request_chunks
|
||||
|
||||
__all__ = [
|
||||
"REQUEST_ID_HEADER",
|
||||
"INSTANCE_ID_HEADER",
|
||||
"error_response",
|
||||
"get_request_id",
|
||||
"request_chunks",
|
||||
"content_disposition",
|
||||
]
|
||||
|
||||
@@ -0,0 +1,28 @@
|
||||
from collections.abc import AsyncIterator
|
||||
from urllib.parse import quote
|
||||
|
||||
from fastapi import Request
|
||||
from starlette.requests import ClientDisconnect
|
||||
|
||||
from domain.errors import InvalidRequestError
|
||||
|
||||
|
||||
async def request_chunks(request: Request) -> AsyncIterator[bytes]:
|
||||
"""
|
||||
Тело запроса потоком, без буферизации целиком. Обрыв соединения клиентом
|
||||
— доменная ошибка, а не необработанное исключение (500 в журнале).
|
||||
"""
|
||||
try:
|
||||
async for chunk in request.stream():
|
||||
if chunk:
|
||||
yield chunk
|
||||
except ClientDisconnect:
|
||||
raise InvalidRequestError("Загрузка прервана клиентом") from None
|
||||
|
||||
|
||||
def content_disposition(filename: str) -> str:
|
||||
"""
|
||||
inline с именем по RFC 6266/5987: имя целиком percent-encoded, поэтому
|
||||
кавычки, ; и переводы строк не могут разорвать заголовок.
|
||||
"""
|
||||
return f"inline; filename*=UTF-8''{quote(filename, safe='')}"
|
||||
@@ -5,6 +5,8 @@ from .settings import (
|
||||
APP_KEEPALIVE_TIMEOUT_SEC,
|
||||
APP_PORT,
|
||||
APP_REVISION,
|
||||
ATTACHMENT_PENDING_GRACE_SEC,
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC,
|
||||
DB_COMMAND_TIMEOUT_SEC,
|
||||
DB_CONNECT_TIMEOUT_SEC,
|
||||
DB_HOST,
|
||||
@@ -16,14 +18,32 @@ from .settings import (
|
||||
DB_STARTUP_TIMEOUT_SEC,
|
||||
DB_USER,
|
||||
IDEMPOTENCY_TTL_SECONDS,
|
||||
IMAGE_INSPECT_WORKERS,
|
||||
INSTANCE_ID,
|
||||
INSTANCE_ID_FILE,
|
||||
JANITOR_HEARTBEAT_FILE,
|
||||
JANITOR_INTERVAL_SEC,
|
||||
LOG_LEVEL,
|
||||
MAX_IMAGE_PIXELS,
|
||||
MAX_UPLOAD_BYTES,
|
||||
PASSWORD_HASH_WORKERS,
|
||||
S3_ACCESS_KEY_ID_FILE,
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE,
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE,
|
||||
S3_BUCKET,
|
||||
S3_CONNECT_TIMEOUT_SEC,
|
||||
S3_ENDPOINT,
|
||||
S3_MAX_ATTEMPTS,
|
||||
S3_POOL_MAX_SIZE,
|
||||
S3_READ_TIMEOUT_SEC,
|
||||
S3_REGION,
|
||||
S3_SECRET_ACCESS_KEY_FILE,
|
||||
S3_STARTUP_TIMEOUT_SEC,
|
||||
SESSION_CACHE_TTL_SECONDS,
|
||||
SESSION_TTL_SECONDS,
|
||||
SHUTDOWN_DRAIN_SEC,
|
||||
SHUTDOWN_TIMEOUT_SEC,
|
||||
UPLOAD_SPOOL_MEMORY_BYTES,
|
||||
VALKEY_HOST,
|
||||
VALKEY_PASS,
|
||||
VALKEY_POOL_MAX_SIZE,
|
||||
@@ -62,6 +82,26 @@ __all__ = [
|
||||
"SESSION_CACHE_TTL_SECONDS",
|
||||
"PASSWORD_HASH_WORKERS",
|
||||
"IDEMPOTENCY_TTL_SECONDS",
|
||||
"S3_ENDPOINT",
|
||||
"S3_REGION",
|
||||
"S3_BUCKET",
|
||||
"S3_ACCESS_KEY_ID_FILE",
|
||||
"S3_SECRET_ACCESS_KEY_FILE",
|
||||
"S3_ADMIN_ACCESS_KEY_ID_FILE",
|
||||
"S3_ADMIN_SECRET_ACCESS_KEY_FILE",
|
||||
"S3_POOL_MAX_SIZE",
|
||||
"S3_CONNECT_TIMEOUT_SEC",
|
||||
"S3_READ_TIMEOUT_SEC",
|
||||
"S3_MAX_ATTEMPTS",
|
||||
"S3_STARTUP_TIMEOUT_SEC",
|
||||
"MAX_UPLOAD_BYTES",
|
||||
"MAX_IMAGE_PIXELS",
|
||||
"UPLOAD_SPOOL_MEMORY_BYTES",
|
||||
"IMAGE_INSPECT_WORKERS",
|
||||
"ATTACHMENT_STORE_TIMEOUT_SEC",
|
||||
"ATTACHMENT_PENDING_GRACE_SEC",
|
||||
"JANITOR_INTERVAL_SEC",
|
||||
"INSTANCE_ID",
|
||||
"INSTANCE_ID_FILE",
|
||||
"JANITOR_HEARTBEAT_FILE",
|
||||
]
|
||||
|
||||
@@ -45,5 +45,32 @@ SESSION_CACHE_TTL_SECONDS = env.int("SESSION_CACHE_TTL_SECONDS")
|
||||
PASSWORD_HASH_WORKERS = env.int("PASSWORD_HASH_WORKERS")
|
||||
IDEMPOTENCY_TTL_SECONDS = env.int("IDEMPOTENCY_TTL_SECONDS")
|
||||
|
||||
# S3: ключи читаются из файлов-секретов при старте, в env только пути к ним
|
||||
S3_ENDPOINT = env.str("S3_ENDPOINT")
|
||||
S3_REGION = env.str("S3_REGION")
|
||||
S3_BUCKET = env.str("S3_BUCKET")
|
||||
S3_ACCESS_KEY_ID_FILE = Path(env.str("S3_ACCESS_KEY_ID_FILE"))
|
||||
S3_SECRET_ACCESS_KEY_FILE = Path(env.str("S3_SECRET_ACCESS_KEY_FILE"))
|
||||
# Административные ключи нужны только одноразовому s3-bootstrap, не API
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE = Path(env.str("S3_ADMIN_ACCESS_KEY_ID_FILE"))
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE = Path(env.str("S3_ADMIN_SECRET_ACCESS_KEY_FILE"))
|
||||
S3_POOL_MAX_SIZE = env.int("S3_POOL_MAX_SIZE")
|
||||
S3_CONNECT_TIMEOUT_SEC = env.float("S3_CONNECT_TIMEOUT_SEC")
|
||||
S3_READ_TIMEOUT_SEC = env.float("S3_READ_TIMEOUT_SEC")
|
||||
S3_MAX_ATTEMPTS = env.int("S3_MAX_ATTEMPTS")
|
||||
S3_STARTUP_TIMEOUT_SEC = env.float("S3_STARTUP_TIMEOUT_SEC")
|
||||
|
||||
MAX_UPLOAD_BYTES = env.int("MAX_UPLOAD_BYTES")
|
||||
MAX_IMAGE_PIXELS = env.int("MAX_IMAGE_PIXELS")
|
||||
# Сколько байт загрузки держится в RAM, остальное — во временном файле запроса
|
||||
UPLOAD_SPOOL_MEMORY_BYTES = env.int("UPLOAD_SPOOL_MEMORY_BYTES")
|
||||
IMAGE_INSPECT_WORKERS = env.int("IMAGE_INSPECT_WORKERS")
|
||||
# Жёсткий срок PUT в S3 + подтверждения в БД; много меньше grace period janitor
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC = env.float("ATTACHMENT_STORE_TIMEOUT_SEC")
|
||||
ATTACHMENT_PENDING_GRACE_SEC = env.int("ATTACHMENT_PENDING_GRACE_SEC")
|
||||
JANITOR_INTERVAL_SEC = env.float("JANITOR_INTERVAL_SEC")
|
||||
|
||||
INSTANCE_ID = secrets.token_hex(6)
|
||||
INSTANCE_ID_FILE = Path(tempfile.gettempdir()) / "instance-id"
|
||||
# Время последней успешной сверки janitor — для healthcheck его контейнера
|
||||
JANITOR_HEARTBEAT_FILE = Path(tempfile.gettempdir()) / "janitor-heartbeat"
|
||||
|
||||
@@ -1,9 +1,23 @@
|
||||
from .attachments import (
|
||||
ORIGINAL_OBJECT_PREFIX,
|
||||
AttachmentContentType,
|
||||
AttachmentFilename,
|
||||
AttachmentSchema,
|
||||
AttachmentStatus,
|
||||
AttachmentVariant,
|
||||
InspectedImageSchema,
|
||||
NewAttachmentSchema,
|
||||
ReconcileReportSchema,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
)
|
||||
from .auth import ActiveSessionSchema, BasicCredentialsSchema, SessionSchema
|
||||
from .chats import ChatPageSchema, ChatSchema, CreateChatSchema
|
||||
from .health import HealthSchema
|
||||
from .messages import (
|
||||
IDEMPOTENCY_KEY_MAX_LENGTH,
|
||||
IDEMPOTENCY_KEY_PATTERN,
|
||||
MESSAGE_ATTACHMENTS_MAX,
|
||||
CreateMessageSchema,
|
||||
IdempotencyKeySchema,
|
||||
MessagePageSchema,
|
||||
@@ -26,9 +40,21 @@ __all__ = [
|
||||
"IdempotencyKeySchema",
|
||||
"IDEMPOTENCY_KEY_PATTERN",
|
||||
"IDEMPOTENCY_KEY_MAX_LENGTH",
|
||||
"MESSAGE_ATTACHMENTS_MAX",
|
||||
"MessageSchema",
|
||||
"MessagePageSchema",
|
||||
"HealthSchema",
|
||||
"PageKey",
|
||||
"PageCursorSchema",
|
||||
"ORIGINAL_OBJECT_PREFIX",
|
||||
"AttachmentContentType",
|
||||
"AttachmentFilename",
|
||||
"AttachmentStatus",
|
||||
"AttachmentVariant",
|
||||
"AttachmentSchema",
|
||||
"NewAttachmentSchema",
|
||||
"StoredAttachmentSchema",
|
||||
"UnfinishedUploadSchema",
|
||||
"InspectedImageSchema",
|
||||
"ReconcileReportSchema",
|
||||
]
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
from .schemas import (
|
||||
FILENAME_MAX_LENGTH,
|
||||
ORIGINAL_OBJECT_PREFIX,
|
||||
AttachmentContentType,
|
||||
AttachmentFilename,
|
||||
AttachmentSchema,
|
||||
AttachmentStatus,
|
||||
AttachmentVariant,
|
||||
AttachmentVariantSchema,
|
||||
InspectedImageSchema,
|
||||
NewAttachmentSchema,
|
||||
ReconcileReportSchema,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
ensure_safe_filename,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"FILENAME_MAX_LENGTH",
|
||||
"ORIGINAL_OBJECT_PREFIX",
|
||||
"AttachmentContentType",
|
||||
"AttachmentFilename",
|
||||
"AttachmentStatus",
|
||||
"AttachmentVariant",
|
||||
"AttachmentVariantSchema",
|
||||
"AttachmentSchema",
|
||||
"NewAttachmentSchema",
|
||||
"StoredAttachmentSchema",
|
||||
"UnfinishedUploadSchema",
|
||||
"InspectedImageSchema",
|
||||
"ReconcileReportSchema",
|
||||
"ensure_safe_filename",
|
||||
]
|
||||
@@ -0,0 +1,161 @@
|
||||
import unicodedata
|
||||
from enum import StrEnum
|
||||
from typing import Annotated, Literal
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import AfterValidator, BaseModel, ConfigDict, Field
|
||||
|
||||
from domain.utils import NotBlankStr, UtcDateTime
|
||||
|
||||
FILENAME_MAX_LENGTH = 255
|
||||
|
||||
# Объекты оригиналов в bucket: ключ назначает сервер, filename в него не входит
|
||||
ORIGINAL_OBJECT_PREFIX = "originals/"
|
||||
|
||||
# Невидимое управление направлением текста: «photognp.exe» отображается
|
||||
# как «photoexe.png»
|
||||
BIDI_CONTROL_CHARACTERS = frozenset(
|
||||
""
|
||||
)
|
||||
|
||||
|
||||
def ensure_safe_filename(value: str) -> str:
|
||||
"""
|
||||
Отображаемое имя файла — не путь и не ключ S3. Запрещены разделители путей,
|
||||
управляющие символы (включая NUL), bidi-управление и имена из одних точек.
|
||||
"""
|
||||
if "/" in value or "\\" in value:
|
||||
raise ValueError("Имя файла не может содержать / или \\")
|
||||
if any(
|
||||
unicodedata.category(char) == "Cc" or char in BIDI_CONTROL_CHARACTERS
|
||||
for char in value
|
||||
):
|
||||
raise ValueError("Имя файла не может содержать управляющие символы")
|
||||
if not value.strip("."):
|
||||
raise ValueError("Имя файла не может состоять из точек")
|
||||
return value
|
||||
|
||||
|
||||
AttachmentFilename = Annotated[
|
||||
NotBlankStr,
|
||||
Field(min_length=1, max_length=FILENAME_MAX_LENGTH),
|
||||
AfterValidator(ensure_safe_filename),
|
||||
]
|
||||
|
||||
|
||||
class AttachmentContentType(StrEnum):
|
||||
"""Допустимые форматы оригинала; определяются по содержимому"""
|
||||
|
||||
PNG = "image/png"
|
||||
JPEG = "image/jpeg"
|
||||
|
||||
|
||||
class AttachmentStatus(StrEnum):
|
||||
"""
|
||||
Состояние строки вложения в БД.
|
||||
|
||||
pending — строка записана до PUT в S3; объект мог не дойти до S3
|
||||
или остаться без подтверждения (сбой между S3 и БД)
|
||||
ready — оригинал в S3 и метаданные подтверждены; только его видит API
|
||||
deleting — незавершённая загрузка забрана на очистку: сначала удаляется
|
||||
объект S3, затем строка
|
||||
"""
|
||||
|
||||
PENDING = "pending"
|
||||
READY = "ready"
|
||||
DELETING = "deleting"
|
||||
|
||||
|
||||
class AttachmentVariant(StrEnum):
|
||||
"""Имена вариантов из контракта; в lab4 существует только original"""
|
||||
|
||||
ORIGINAL = "original"
|
||||
THUMBNAIL = "thumbnail"
|
||||
CROP = "crop"
|
||||
OPTIMIZED = "optimized"
|
||||
|
||||
|
||||
class AttachmentVariantSchema(BaseModel):
|
||||
"""Производный вариант изображения; появляется с lab5"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
name: AttachmentVariant
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
width: int
|
||||
height: int
|
||||
sha256: str
|
||||
|
||||
|
||||
class AttachmentSchema(BaseModel):
|
||||
"""Метаданные вложения; size_bytes, sha256 и content_type описывают оригинал"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
id: UUID
|
||||
chat_id: UUID
|
||||
owner_id: UUID
|
||||
filename: str
|
||||
content_type: AttachmentContentType
|
||||
size_bytes: int
|
||||
sha256: str
|
||||
status: Literal["ready"] = "ready"
|
||||
variants: list[AttachmentVariantSchema] = Field(default_factory=list)
|
||||
error_code: str | None = None
|
||||
created_at: UtcDateTime
|
||||
updated_at: UtcDateTime
|
||||
|
||||
|
||||
class NewAttachmentSchema(BaseModel):
|
||||
"""Проверенная загрузка: метаданные и назначенный сервером ключ объекта S3"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
chat_id: UUID
|
||||
owner_id: UUID
|
||||
filename: str
|
||||
content_type: AttachmentContentType
|
||||
size_bytes: int
|
||||
sha256: bytes
|
||||
object_key: str
|
||||
|
||||
|
||||
class StoredAttachmentSchema(BaseModel):
|
||||
"""Вложение вместе с ключом объекта — только внутри приложения"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
attachment: AttachmentSchema
|
||||
object_key: str
|
||||
|
||||
|
||||
class UnfinishedUploadSchema(BaseModel):
|
||||
"""Строка pending/deleting, забранная на очистку, и её объект S3"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
id: UUID
|
||||
object_key: str
|
||||
|
||||
|
||||
class InspectedImageSchema(BaseModel):
|
||||
"""Результат проверки содержимого: истинный формат и размеры"""
|
||||
|
||||
model_config = ConfigDict(frozen=True)
|
||||
|
||||
content_type: AttachmentContentType
|
||||
width: int
|
||||
height: int
|
||||
|
||||
|
||||
class ReconcileReportSchema(BaseModel):
|
||||
"""Итог одного прохода сверки S3 и БД"""
|
||||
|
||||
dry_run: bool
|
||||
unfinished_claimed: int = 0
|
||||
unfinished_objects_deleted: int = 0
|
||||
unfinished_rows_deleted: int = 0
|
||||
objects_scanned: int = 0
|
||||
orphan_objects_found: int = 0
|
||||
orphan_objects_deleted: int = 0
|
||||
@@ -5,8 +5,10 @@ from .exceptions import (
|
||||
InvalidCredentialsError,
|
||||
InvalidRequestError,
|
||||
NotFoundError,
|
||||
PayloadTooLargeError,
|
||||
UnauthorizedError,
|
||||
UnavailableError,
|
||||
UnsupportedMediaTypeError,
|
||||
)
|
||||
from .schemas import ErrorBodySchema, ErrorSchema
|
||||
|
||||
@@ -18,6 +20,8 @@ __all__ = [
|
||||
"InvalidCredentialsError",
|
||||
"NotFoundError",
|
||||
"ConflictError",
|
||||
"PayloadTooLargeError",
|
||||
"UnsupportedMediaTypeError",
|
||||
"UnavailableError",
|
||||
"ErrorBodySchema",
|
||||
"ErrorSchema",
|
||||
|
||||
@@ -56,6 +56,22 @@ class ConflictError(AppError):
|
||||
default_message = "Конфликт состояния"
|
||||
|
||||
|
||||
class PayloadTooLargeError(AppError):
|
||||
"""Тело больше лимита байт или изображение больше лимита пикселей"""
|
||||
|
||||
status_code = HTTPStatus.REQUEST_ENTITY_TOO_LARGE
|
||||
code = ErrorCode.PAYLOAD_TOO_LARGE
|
||||
default_message = "Слишком большой файл"
|
||||
|
||||
|
||||
class UnsupportedMediaTypeError(AppError):
|
||||
"""Содержимое не PNG/JPEG, повреждено или не совпадает с Content-Type"""
|
||||
|
||||
status_code = HTTPStatus.UNSUPPORTED_MEDIA_TYPE
|
||||
code = ErrorCode.UNSUPPORTED_MEDIA_TYPE
|
||||
default_message = "Поддерживаются только изображения PNG и JPEG"
|
||||
|
||||
|
||||
class UnavailableError(AppError):
|
||||
"""Приложение не готово обслуживать запросы"""
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
from .schemas import (
|
||||
IDEMPOTENCY_KEY_MAX_LENGTH,
|
||||
IDEMPOTENCY_KEY_PATTERN,
|
||||
MESSAGE_ATTACHMENTS_MAX,
|
||||
CreateMessageSchema,
|
||||
IdempotencyKeySchema,
|
||||
MessagePageSchema,
|
||||
@@ -10,6 +11,7 @@ from .schemas import (
|
||||
__all__ = [
|
||||
"IDEMPOTENCY_KEY_PATTERN",
|
||||
"IDEMPOTENCY_KEY_MAX_LENGTH",
|
||||
"MESSAGE_ATTACHMENTS_MAX",
|
||||
"CreateMessageSchema",
|
||||
"IdempotencyKeySchema",
|
||||
"MessageSchema",
|
||||
|
||||
@@ -1,22 +1,53 @@
|
||||
from typing import Annotated
|
||||
from typing import Annotated, Self
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
from pydantic import (
|
||||
AfterValidator,
|
||||
BaseModel,
|
||||
ConfigDict,
|
||||
Field,
|
||||
StrictStr,
|
||||
field_validator,
|
||||
model_validator,
|
||||
)
|
||||
|
||||
from domain.utils import NotBlankStr, UtcDateTime
|
||||
from domain.utils import UtcDateTime, ensure_not_blank, ensure_storable
|
||||
|
||||
MessageText = Annotated[NotBlankStr, Field(min_length=1, max_length=4000)]
|
||||
MessageText = Annotated[
|
||||
StrictStr, Field(max_length=4000), AfterValidator(ensure_storable)
|
||||
]
|
||||
|
||||
MESSAGE_ATTACHMENTS_MAX = 10
|
||||
|
||||
IDEMPOTENCY_KEY_PATTERN = r"^[A-Za-z0-9._:-]{1,128}$"
|
||||
IDEMPOTENCY_KEY_MAX_LENGTH = 128
|
||||
|
||||
|
||||
class CreateMessageSchema(BaseModel):
|
||||
"""Запрос отправки сообщения: отправитель берётся из текущей сессии"""
|
||||
"""
|
||||
Запрос отправки сообщения: отправитель берётся из текущей сессии.
|
||||
Пустой или пробельный текст допустим только вместе с вложениями.
|
||||
"""
|
||||
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
|
||||
text: MessageText
|
||||
attachment_ids: list[UUID] = Field(
|
||||
default_factory=list, max_length=MESSAGE_ATTACHMENTS_MAX
|
||||
)
|
||||
|
||||
@field_validator("attachment_ids")
|
||||
@classmethod
|
||||
def validate_unique_attachments(cls, value: list[UUID]) -> list[UUID]:
|
||||
if len(set(value)) != len(value):
|
||||
raise ValueError("attachment_ids не должен содержать дубликаты")
|
||||
return value
|
||||
|
||||
@model_validator(mode="after")
|
||||
def validate_not_empty(self) -> Self:
|
||||
if not self.attachment_ids:
|
||||
ensure_not_blank(self.text)
|
||||
return self
|
||||
|
||||
|
||||
class MessageSchema(BaseModel):
|
||||
@@ -29,6 +60,7 @@ class MessageSchema(BaseModel):
|
||||
sender_id: UUID
|
||||
text: str
|
||||
created_at: UtcDateTime
|
||||
attachment_ids: list[UUID]
|
||||
|
||||
|
||||
class MessagePageSchema(BaseModel):
|
||||
|
||||
+23
-2
@@ -16,15 +16,23 @@ from config import (
|
||||
APP_PORT,
|
||||
APP_REVISION,
|
||||
DB_STARTUP_TIMEOUT_SEC,
|
||||
IMAGE_INSPECT_WORKERS,
|
||||
INSTANCE_ID,
|
||||
INSTANCE_ID_FILE,
|
||||
LOGGER,
|
||||
MAX_IMAGE_PIXELS,
|
||||
PASSWORD_HASH_WORKERS,
|
||||
SESSION_TTL_SECONDS,
|
||||
SHUTDOWN_DRAIN_SEC,
|
||||
SHUTDOWN_TIMEOUT_SEC,
|
||||
)
|
||||
from infrastructure import PasswordHasher, cache_manager, database_pool_manager
|
||||
from infrastructure import (
|
||||
ImageInspector,
|
||||
PasswordHasher,
|
||||
cache_manager,
|
||||
database_pool_manager,
|
||||
storage_manager,
|
||||
)
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
@@ -32,14 +40,25 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
|
||||
"""
|
||||
uvicorn открывает порт только после startup: реплика без БД или со старой
|
||||
схемой не принимает соединений, и LB отправляет запросы другим репликам.
|
||||
|
||||
S3 на старт не влияет: реплика стартует и обслуживает сообщения,
|
||||
а readiness остаётся 503, пока bucket недоступен.
|
||||
"""
|
||||
await database_pool_manager.create_pool(DB_STARTUP_TIMEOUT_SEC)
|
||||
await database_pool_manager.check_migrations()
|
||||
cache_manager.create_client()
|
||||
await storage_manager.create_client()
|
||||
if await storage_manager.check():
|
||||
LOGGER.info("Bucket S3 доступен")
|
||||
else:
|
||||
LOGGER.warning("Bucket S3 недоступен: вложения отвечают 503")
|
||||
password_hasher = PasswordHasher(PASSWORD_HASH_WORKERS)
|
||||
image_inspector = ImageInspector(IMAGE_INSPECT_WORKERS, MAX_IMAGE_PIXELS)
|
||||
app.state.database = database_pool_manager
|
||||
app.state.cache = cache_manager
|
||||
app.state.storage = storage_manager
|
||||
app.state.password_hasher = password_hasher
|
||||
app.state.image_inspector = image_inspector
|
||||
INSTANCE_ID_FILE.write_text(INSTANCE_ID)
|
||||
app.state.is_ready = True
|
||||
LOGGER.info(
|
||||
@@ -49,15 +68,17 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
|
||||
yield
|
||||
app.state.is_ready = False
|
||||
await cache_manager.close()
|
||||
await storage_manager.close()
|
||||
await database_pool_manager.close()
|
||||
password_hasher.close()
|
||||
image_inspector.close()
|
||||
LOGGER.info(f"Application stopped, instance={INSTANCE_ID}, connections closed")
|
||||
|
||||
|
||||
app = FastAPI(
|
||||
title="mtuci-labs-messanger",
|
||||
description="мессенджер-конкурент-максу",
|
||||
version="1.3.0",
|
||||
version="1.4.0",
|
||||
lifespan=lifespan,
|
||||
)
|
||||
|
||||
|
||||
+16
-3
@@ -1,14 +1,18 @@
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
from config import APP_PORT
|
||||
from config import APP_PORT, JANITOR_HEARTBEAT_FILE, JANITOR_INTERVAL_SEC
|
||||
|
||||
READY_URL = f"http://127.0.0.1:{APP_PORT}/health/ready"
|
||||
|
||||
REQUEST_TIMEOUT_SEC = 2
|
||||
|
||||
# janitor считается зависшим, если пропустил несколько проходов подряд
|
||||
JANITOR_MAX_SILENCE_SEC = 3 * JANITOR_INTERVAL_SEC
|
||||
|
||||
def main() -> int:
|
||||
|
||||
def api() -> int:
|
||||
try:
|
||||
with urllib.request.urlopen(READY_URL, timeout=REQUEST_TIMEOUT_SEC) as response:
|
||||
return 0 if response.status == 200 else 1
|
||||
@@ -16,5 +20,14 @@ def main() -> int:
|
||||
return 1
|
||||
|
||||
|
||||
def janitor() -> int:
|
||||
"""Последняя успешная сверка была недавно"""
|
||||
try:
|
||||
age = time.time() - JANITOR_HEARTBEAT_FILE.stat().st_mtime
|
||||
except OSError:
|
||||
return 1
|
||||
return 0 if age < JANITOR_MAX_SILENCE_SEC else 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
sys.exit(janitor() if sys.argv[1:] == ["janitor"] else api())
|
||||
|
||||
@@ -1,4 +1,11 @@
|
||||
from .dependencies import cache_manager, database_pool_manager
|
||||
from .dependencies import cache_manager, database_pool_manager, storage_manager
|
||||
from .media import ImageInspector
|
||||
from .security import PasswordHasher
|
||||
|
||||
__all__ = ["database_pool_manager", "cache_manager", "PasswordHasher"]
|
||||
__all__ = [
|
||||
"database_pool_manager",
|
||||
"cache_manager",
|
||||
"storage_manager",
|
||||
"PasswordHasher",
|
||||
"ImageInspector",
|
||||
]
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
from .cache import CacheManager, cache_manager, get_cache
|
||||
from .database import DatabasePoolManager, database_pool_manager, get_database
|
||||
from .service_creator import ServiceCreator
|
||||
from .storage import ObjectStorageManager, get_storage, storage_manager
|
||||
|
||||
__all__ = [
|
||||
"ServiceCreator",
|
||||
@@ -10,4 +11,7 @@ __all__ = [
|
||||
"CacheManager",
|
||||
"cache_manager",
|
||||
"get_cache",
|
||||
"ObjectStorageManager",
|
||||
"storage_manager",
|
||||
"get_storage",
|
||||
]
|
||||
|
||||
@@ -1,29 +1,40 @@
|
||||
from fastapi import Depends
|
||||
|
||||
from config import (
|
||||
ATTACHMENT_PENDING_GRACE_SEC,
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC,
|
||||
IDEMPOTENCY_TTL_SECONDS,
|
||||
MAX_UPLOAD_BYTES,
|
||||
SESSION_CACHE_TTL_SECONDS,
|
||||
SESSION_TTL_SECONDS,
|
||||
UPLOAD_SPOOL_MEMORY_BYTES,
|
||||
)
|
||||
from infrastructure.dependencies.cache import CacheManager, get_cache
|
||||
from infrastructure.dependencies.database import DatabasePoolManager, get_database
|
||||
from infrastructure.dependencies.storage import ObjectStorageManager, get_storage
|
||||
from infrastructure.media import ImageInspector, get_image_inspector
|
||||
from infrastructure.repositories import (
|
||||
PostgresAttachmentRepository,
|
||||
PostgresChatRepository,
|
||||
PostgresMessageRepository,
|
||||
PostgresSessionRepository,
|
||||
PostgresUserRepository,
|
||||
S3ObjectStorage,
|
||||
ValkeySessionCache,
|
||||
)
|
||||
from infrastructure.security import PasswordHasher, get_password_hasher
|
||||
from infrastructure.services import (
|
||||
AttachmentService,
|
||||
AuthService,
|
||||
ChatService,
|
||||
MessageService,
|
||||
UserService,
|
||||
)
|
||||
from interfaces import (
|
||||
AttachmentRepository,
|
||||
ChatRepository,
|
||||
MessageRepository,
|
||||
ObjectStorage,
|
||||
SessionCache,
|
||||
SessionRepository,
|
||||
UserRepository,
|
||||
@@ -55,6 +66,18 @@ class ServiceCreator:
|
||||
) -> SessionRepository:
|
||||
return PostgresSessionRepository(database)
|
||||
|
||||
@staticmethod
|
||||
def _get_attachment_repository(
|
||||
database: DatabasePoolManager = Depends(get_database),
|
||||
) -> AttachmentRepository:
|
||||
return PostgresAttachmentRepository(database)
|
||||
|
||||
@staticmethod
|
||||
def _get_object_storage(
|
||||
storage: ObjectStorageManager = Depends(get_storage),
|
||||
) -> ObjectStorage:
|
||||
return S3ObjectStorage(storage)
|
||||
|
||||
@staticmethod
|
||||
def _get_session_cache(
|
||||
cache: CacheManager = Depends(get_cache),
|
||||
@@ -97,3 +120,23 @@ class ServiceCreator:
|
||||
return MessageService(
|
||||
chat_repository, message_repository, IDEMPOTENCY_TTL_SECONDS
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def get_attachment_service(
|
||||
chat_repository: ChatRepository = Depends(_get_chat_repository),
|
||||
attachment_repository: AttachmentRepository = Depends(
|
||||
_get_attachment_repository
|
||||
),
|
||||
storage: ObjectStorage = Depends(_get_object_storage),
|
||||
inspector: ImageInspector = Depends(get_image_inspector),
|
||||
) -> AttachmentService:
|
||||
return AttachmentService(
|
||||
chat_repository,
|
||||
attachment_repository,
|
||||
storage,
|
||||
inspector,
|
||||
MAX_UPLOAD_BYTES,
|
||||
UPLOAD_SPOOL_MEMORY_BYTES,
|
||||
ATTACHMENT_STORE_TIMEOUT_SEC,
|
||||
ATTACHMENT_PENDING_GRACE_SEC,
|
||||
)
|
||||
|
||||
@@ -0,0 +1,187 @@
|
||||
import asyncio
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from contextlib import AsyncExitStack
|
||||
from pathlib import Path
|
||||
|
||||
from aiobotocore.client import AioBaseClient
|
||||
from aiobotocore.config import AioConfig
|
||||
from aiobotocore.session import get_session
|
||||
from botocore.exceptions import ClientError
|
||||
from starlette.requests import HTTPConnection
|
||||
|
||||
from config import (
|
||||
LOGGER,
|
||||
S3_ACCESS_KEY_ID_FILE,
|
||||
S3_BUCKET,
|
||||
S3_CONNECT_TIMEOUT_SEC,
|
||||
S3_ENDPOINT,
|
||||
S3_MAX_ATTEMPTS,
|
||||
S3_POOL_MAX_SIZE,
|
||||
S3_READ_TIMEOUT_SEC,
|
||||
S3_REGION,
|
||||
S3_SECRET_ACCESS_KEY_FILE,
|
||||
)
|
||||
from infrastructure.security import read_secret
|
||||
from infrastructure.utils import STORAGE_UNAVAILABLE_ERRORS, storage_error_code
|
||||
|
||||
STARTUP_RETRY_INTERVAL_SEC = 1
|
||||
|
||||
ANONYMOUS_CHECK_TIMEOUT_SEC = 3
|
||||
|
||||
# Ответ S3 на уже существующий bucket: повторный bootstrap — не ошибка
|
||||
BUCKET_EXISTS_CODES = frozenset({"BucketAlreadyOwnedByYou", "BucketAlreadyExists"})
|
||||
|
||||
|
||||
class ObjectStorageManager:
|
||||
"""
|
||||
Клиент S3 (aiobotocore): ограниченный пул соединений, короткие таймауты
|
||||
и ограниченное число попыток. Ключи доступа читаются из файлов-секретов
|
||||
при создании клиента и нигде не логируются.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
endpoint: str,
|
||||
region: str,
|
||||
bucket: str,
|
||||
access_key_file: Path,
|
||||
secret_key_file: Path,
|
||||
max_pool_size: int,
|
||||
connect_timeout: float,
|
||||
read_timeout: float,
|
||||
max_attempts: int,
|
||||
) -> None:
|
||||
self._endpoint = endpoint
|
||||
self._region = region
|
||||
self.bucket = bucket
|
||||
self._access_key_file = access_key_file
|
||||
self._secret_key_file = secret_key_file
|
||||
self.max_pool_size = max_pool_size
|
||||
self.connect_timeout = connect_timeout
|
||||
self.read_timeout = read_timeout
|
||||
self.max_attempts = max_attempts
|
||||
self.client: AioBaseClient | None = None
|
||||
self._exit_stack = AsyncExitStack()
|
||||
|
||||
async def create_client(self) -> AioBaseClient:
|
||||
"""
|
||||
Создание клиента; соединения открываются лениво при первом запросе.
|
||||
|
||||
Path-style адресация: имя bucket в пути, а не в DNS-имени хоста.
|
||||
Контрольные суммы botocore по умолчанию выключены (when_required):
|
||||
целостность PUT обеспечивает собственный SHA-256 (x-amz-checksum-sha256).
|
||||
"""
|
||||
if self.client is None:
|
||||
config = AioConfig(
|
||||
s3={"addressing_style": "path"},
|
||||
connect_timeout=self.connect_timeout,
|
||||
read_timeout=self.read_timeout,
|
||||
retries={"max_attempts": self.max_attempts, "mode": "standard"},
|
||||
max_pool_connections=self.max_pool_size,
|
||||
request_checksum_calculation="when_required",
|
||||
response_checksum_validation="when_required",
|
||||
)
|
||||
client = get_session().create_client(
|
||||
"s3",
|
||||
endpoint_url=self._endpoint,
|
||||
region_name=self._region,
|
||||
aws_access_key_id=read_secret(self._access_key_file),
|
||||
aws_secret_access_key=read_secret(self._secret_key_file),
|
||||
config=config,
|
||||
)
|
||||
self.client = await self._exit_stack.enter_async_context(client)
|
||||
LOGGER.info(
|
||||
f"Клиент S3 создан: {self._endpoint}, bucket: {self.bucket}, "
|
||||
f"pool: {self.max_pool_size}, timeout: {self.connect_timeout}/"
|
||||
f"{self.read_timeout} с, попыток: {self.max_attempts}"
|
||||
)
|
||||
return self.client
|
||||
|
||||
async def check(self) -> bool:
|
||||
"""
|
||||
Bucket доступен с текущими ключами — для readiness. Срок ограничен
|
||||
connect_timeout: healthcheck не ждёт всех попыток клиента.
|
||||
Не журналирует: readiness опрашивается каждые несколько секунд.
|
||||
"""
|
||||
assert self.client is not None
|
||||
try:
|
||||
async with asyncio.timeout(self.connect_timeout):
|
||||
await self.client.head_bucket(Bucket=self.bucket)
|
||||
except STORAGE_UNAVAILABLE_ERRORS:
|
||||
return False
|
||||
return True
|
||||
|
||||
async def wait_ready(self, startup_timeout: float) -> None:
|
||||
"""Ожидание S3 при старте стенда: сервер поднимается не мгновенно"""
|
||||
assert self.client is not None
|
||||
deadline = time.monotonic() + startup_timeout
|
||||
while True:
|
||||
try:
|
||||
await self.client.list_buckets()
|
||||
return
|
||||
except STORAGE_UNAVAILABLE_ERRORS as error:
|
||||
if time.monotonic() >= deadline:
|
||||
LOGGER.error(
|
||||
f"S3 недоступен за {startup_timeout} с: "
|
||||
f"{storage_error_code(error)}"
|
||||
)
|
||||
raise
|
||||
LOGGER.warning(f"S3 ещё недоступен: {storage_error_code(error)}, повтор")
|
||||
await asyncio.sleep(STARTUP_RETRY_INTERVAL_SEC)
|
||||
|
||||
async def ensure_bucket(self) -> None:
|
||||
"""
|
||||
Идемпотентное создание bucket административными ключами (s3-bootstrap).
|
||||
Повторный запуск ничего не меняет.
|
||||
"""
|
||||
assert self.client is not None
|
||||
try:
|
||||
await self.client.create_bucket(Bucket=self.bucket)
|
||||
LOGGER.info(f"Bucket {self.bucket} создан")
|
||||
except ClientError as error:
|
||||
if storage_error_code(error) not in BUCKET_EXISTS_CODES:
|
||||
raise
|
||||
LOGGER.info(f"Bucket {self.bucket} уже существует")
|
||||
|
||||
def check_anonymous_denied(self) -> None:
|
||||
"""
|
||||
Bucket приватен: анонимный (неподписанный) запрос списка объектов
|
||||
получает 403. Иначе bootstrap завершается ошибкой и API не стартует.
|
||||
"""
|
||||
url = f"{self._endpoint.rstrip('/')}/{self.bucket}"
|
||||
try:
|
||||
with urllib.request.urlopen(url, timeout=ANONYMOUS_CHECK_TIMEOUT_SEC):
|
||||
pass
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code == 403:
|
||||
LOGGER.info(f"Bucket {self.bucket} приватен: анонимный доступ — 403")
|
||||
return
|
||||
raise RuntimeError(
|
||||
f"Неожиданный ответ на анонимный запрос к bucket: {error.code}"
|
||||
) from None
|
||||
raise RuntimeError(f"Bucket {self.bucket} доступен анонимно")
|
||||
|
||||
async def close(self) -> None:
|
||||
await self._exit_stack.aclose()
|
||||
self.client = None
|
||||
|
||||
|
||||
def get_storage(connection: HTTPConnection) -> ObjectStorageManager:
|
||||
"""Получение менеджера S3-клиента, созданного в lifespan."""
|
||||
storage: ObjectStorageManager = connection.app.state.storage
|
||||
return storage
|
||||
|
||||
|
||||
storage_manager = ObjectStorageManager(
|
||||
endpoint=S3_ENDPOINT,
|
||||
region=S3_REGION,
|
||||
bucket=S3_BUCKET,
|
||||
access_key_file=S3_ACCESS_KEY_ID_FILE,
|
||||
secret_key_file=S3_SECRET_ACCESS_KEY_FILE,
|
||||
max_pool_size=S3_POOL_MAX_SIZE,
|
||||
connect_timeout=S3_CONNECT_TIMEOUT_SEC,
|
||||
read_timeout=S3_READ_TIMEOUT_SEC,
|
||||
max_attempts=S3_MAX_ATTEMPTS,
|
||||
)
|
||||
@@ -0,0 +1,4 @@
|
||||
from .image_inspector import ImageInspector, get_image_inspector
|
||||
from .upload_spool import SpooledUpload, spool_upload
|
||||
|
||||
__all__ = ["ImageInspector", "get_image_inspector", "SpooledUpload", "spool_upload"]
|
||||
@@ -0,0 +1,127 @@
|
||||
import asyncio
|
||||
import struct
|
||||
import warnings
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from typing import IO
|
||||
|
||||
from PIL import Image, UnidentifiedImageError
|
||||
from starlette.requests import HTTPConnection
|
||||
|
||||
from domain import AttachmentContentType, InspectedImageSchema
|
||||
from domain.errors import PayloadTooLargeError, UnsupportedMediaTypeError
|
||||
|
||||
PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
|
||||
JPEG_SIGNATURE = b"\xff\xd8\xff"
|
||||
|
||||
PILLOW_FORMATS = {
|
||||
AttachmentContentType.PNG: "PNG",
|
||||
AttachmentContentType.JPEG: "JPEG",
|
||||
}
|
||||
|
||||
# Как Pillow сообщает о повреждённом или чужом содержимом
|
||||
DECODE_ERRORS: tuple[type[Exception], ...] = (
|
||||
UnidentifiedImageError,
|
||||
OSError,
|
||||
SyntaxError,
|
||||
ValueError,
|
||||
EOFError,
|
||||
struct.error,
|
||||
)
|
||||
|
||||
|
||||
class ImageInspector:
|
||||
"""
|
||||
Проверка PNG/JPEG по содержимому, а не по Content-Type клиента.
|
||||
|
||||
1. Формат — по сигнатуре; несовпадение с заявленным Content-Type — 415.
|
||||
2. Ширина и высота читаются из заголовка, лимит пикселей проверяется до
|
||||
распаковки: 413 без выделения памяти под изображение.
|
||||
3. Целостность: PNG — CRC каждого chunk и наличие IEND (verify, без
|
||||
распаковки); JPEG — декодирование в draft-режиме libjpeg (масштаб 1/8).
|
||||
|
||||
Проверка идёт в отдельном пуле потоков: event loop не блокируется, а число
|
||||
одновременных декодирований и их память ограничены workers. Худший случай —
|
||||
progressive JPEG на пределе пикселей: libjpeg держит коэффициенты всего
|
||||
изображения (до ~6 байт на пиксель) даже в draft-режиме.
|
||||
"""
|
||||
|
||||
def __init__(self, workers: int, max_pixels: int) -> None:
|
||||
self._max_pixels = max_pixels
|
||||
# Вторая линия защиты Pillow: Image.open отказывает выше 2 * max_pixels.
|
||||
# Предупреждение в диапазоне (max, 2 * max] не нужно: такой файл
|
||||
# отклоняется явной проверкой ниже.
|
||||
Image.MAX_IMAGE_PIXELS = max_pixels
|
||||
warnings.simplefilter("ignore", Image.DecompressionBombWarning)
|
||||
self._executor = ThreadPoolExecutor(
|
||||
max_workers=workers, thread_name_prefix="image-inspect"
|
||||
)
|
||||
|
||||
async def inspect(
|
||||
self, file: IO[bytes], declared: AttachmentContentType
|
||||
) -> InspectedImageSchema:
|
||||
"""
|
||||
Raises:
|
||||
UnsupportedMediaTypeError: не PNG/JPEG, повреждено или подмена MIME
|
||||
PayloadTooLargeError: пикселей больше лимита
|
||||
"""
|
||||
loop = asyncio.get_running_loop()
|
||||
return await loop.run_in_executor(
|
||||
self._executor, self._inspect, file, declared
|
||||
)
|
||||
|
||||
def close(self) -> None:
|
||||
self._executor.shutdown(wait=False, cancel_futures=True)
|
||||
|
||||
def _inspect(
|
||||
self, file: IO[bytes], declared: AttachmentContentType
|
||||
) -> InspectedImageSchema:
|
||||
file.seek(0)
|
||||
actual = self._sniff(file.read(len(PNG_SIGNATURE)))
|
||||
if actual is None:
|
||||
raise UnsupportedMediaTypeError(
|
||||
"Содержимое не является изображением PNG или JPEG"
|
||||
)
|
||||
if actual is not declared:
|
||||
raise UnsupportedMediaTypeError(
|
||||
"Content-Type не соответствует содержимому файла"
|
||||
)
|
||||
file.seek(0)
|
||||
try:
|
||||
with Image.open(file, formats=[PILLOW_FORMATS[actual]]) as image:
|
||||
width, height = image.size
|
||||
if width * height > self._max_pixels:
|
||||
raise PayloadTooLargeError(
|
||||
f"Изображение больше {self._max_pixels} пикселей"
|
||||
)
|
||||
self._verify(image, actual)
|
||||
except Image.DecompressionBombError:
|
||||
raise PayloadTooLargeError(
|
||||
f"Изображение больше {self._max_pixels} пикселей"
|
||||
) from None
|
||||
except DECODE_ERRORS:
|
||||
raise UnsupportedMediaTypeError("Изображение повреждено") from None
|
||||
return InspectedImageSchema(content_type=actual, width=width, height=height)
|
||||
|
||||
@staticmethod
|
||||
def _sniff(header: bytes) -> AttachmentContentType | None:
|
||||
if header.startswith(PNG_SIGNATURE):
|
||||
return AttachmentContentType.PNG
|
||||
if header.startswith(JPEG_SIGNATURE):
|
||||
return AttachmentContentType.JPEG
|
||||
return None
|
||||
|
||||
@staticmethod
|
||||
def _verify(image: Image.Image, content_type: AttachmentContentType) -> None:
|
||||
if content_type is AttachmentContentType.PNG:
|
||||
image.verify()
|
||||
return
|
||||
# draft выбирает наименьший масштаб libjpeg (1/8): весь поток данных
|
||||
# разбирается, но выходной буфер в 64 раза меньше полного
|
||||
image.draft(image.mode, (1, 1))
|
||||
image.load()
|
||||
|
||||
|
||||
def get_image_inspector(connection: HTTPConnection) -> ImageInspector:
|
||||
"""Получение проверки изображений, созданной в lifespan."""
|
||||
inspector: ImageInspector = connection.app.state.image_inspector
|
||||
return inspector
|
||||
@@ -0,0 +1,49 @@
|
||||
import hashlib
|
||||
import tempfile
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import dataclass
|
||||
from typing import IO
|
||||
|
||||
from domain.errors import InvalidRequestError, PayloadTooLargeError
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class SpooledUpload:
|
||||
"""Принятое тело загрузки: файл запроса, размер и SHA-256 байт"""
|
||||
|
||||
file: IO[bytes]
|
||||
size: int
|
||||
sha256: bytes
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def spool_upload(
|
||||
chunks: AsyncIterator[bytes], max_bytes: int, memory_bytes: int
|
||||
) -> AsyncIterator[SpooledUpload]:
|
||||
"""
|
||||
Приём тела потоком: первые memory_bytes держатся в RAM, остальное —
|
||||
во временном файле запроса, который удаляется при выходе из контекста
|
||||
(в том числе при обрыве загрузки). Это не хранилище: оригинал живёт в S3.
|
||||
|
||||
Чтение прекращается на первом байте сверх max_bytes, поэтому одна загрузка
|
||||
занимает не больше memory_bytes RAM и max_bytes диска. SHA-256 и размер
|
||||
считаются по ходу чтения, без второго прохода.
|
||||
|
||||
Raises:
|
||||
PayloadTooLargeError: тело больше max_bytes
|
||||
InvalidRequestError: пустое тело
|
||||
"""
|
||||
with tempfile.SpooledTemporaryFile(max_size=memory_bytes) as file:
|
||||
digest = hashlib.sha256()
|
||||
size = 0
|
||||
async for chunk in chunks:
|
||||
size += len(chunk)
|
||||
if size > max_bytes:
|
||||
raise PayloadTooLargeError(f"Файл больше {max_bytes} байт")
|
||||
digest.update(chunk)
|
||||
file.write(chunk)
|
||||
if size == 0:
|
||||
raise InvalidRequestError("Пустое тело: ожидаются байты PNG или JPEG")
|
||||
file.seek(0)
|
||||
yield SpooledUpload(file=file, size=size, sha256=digest.digest())
|
||||
@@ -1,5 +1,7 @@
|
||||
from .attachment_repository import PostgresAttachmentRepository
|
||||
from .chat_repository import PostgresChatRepository
|
||||
from .message_repository import PostgresMessageRepository
|
||||
from .object_storage import S3ObjectStorage
|
||||
from .session_cache import ValkeySessionCache
|
||||
from .session_repository import PostgresSessionRepository
|
||||
from .user_repository import PostgresUserRepository
|
||||
@@ -9,5 +11,7 @@ __all__ = [
|
||||
"PostgresChatRepository",
|
||||
"PostgresMessageRepository",
|
||||
"PostgresSessionRepository",
|
||||
"PostgresAttachmentRepository",
|
||||
"ValkeySessionCache",
|
||||
"S3ObjectStorage",
|
||||
]
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
from .postgres import PostgresAttachmentRepository
|
||||
|
||||
__all__ = ["PostgresAttachmentRepository"]
|
||||
@@ -0,0 +1,281 @@
|
||||
from uuid import UUID
|
||||
|
||||
import asyncpg
|
||||
|
||||
from domain import (
|
||||
AttachmentSchema,
|
||||
AttachmentStatus,
|
||||
NewAttachmentSchema,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
)
|
||||
from domain.errors import NotFoundError
|
||||
from infrastructure.utils import Pool, repository_logs
|
||||
from interfaces import AttachmentRepository
|
||||
|
||||
|
||||
class PostgresAttachmentRepository(AttachmentRepository):
|
||||
def __init__(self, pool: Pool) -> None:
|
||||
self._pool = pool
|
||||
|
||||
@repository_logs
|
||||
async def create_pending(self, attachment: NewAttachmentSchema) -> UUID:
|
||||
"""
|
||||
Строка коммитится до PUT в S3. Владелец обязан быть участником чата —
|
||||
это проверяет FK на chat_members.
|
||||
"""
|
||||
query = """
|
||||
INSERT INTO attachments
|
||||
(
|
||||
chat_id,
|
||||
owner_id,
|
||||
filename,
|
||||
content_type,
|
||||
size_bytes,
|
||||
sha256,
|
||||
object_key,
|
||||
status
|
||||
)
|
||||
VALUES
|
||||
(
|
||||
$1,
|
||||
$2,
|
||||
$3,
|
||||
$4,
|
||||
$5,
|
||||
$6,
|
||||
$7,
|
||||
$8
|
||||
)
|
||||
RETURNING id;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
try:
|
||||
attachment_id: UUID = await conn.fetchval(
|
||||
query,
|
||||
attachment.chat_id,
|
||||
attachment.owner_id,
|
||||
attachment.filename,
|
||||
attachment.content_type,
|
||||
attachment.size_bytes,
|
||||
attachment.sha256,
|
||||
attachment.object_key,
|
||||
AttachmentStatus.PENDING,
|
||||
)
|
||||
except asyncpg.ForeignKeyViolationError:
|
||||
raise NotFoundError() from None
|
||||
return attachment_id
|
||||
|
||||
@repository_logs
|
||||
async def mark_ready(
|
||||
self, attachment_id: UUID, grace_seconds: int
|
||||
) -> AttachmentSchema | None:
|
||||
"""
|
||||
Условие по возрасту на часах БД — тех же, по которым janitor отбирает
|
||||
строки: загрузка, которую janitor уже может очищать, не подтверждается.
|
||||
Одновременный claim janitor и это UPDATE сериализует блокировка строки.
|
||||
"""
|
||||
query = """
|
||||
UPDATE attachments
|
||||
SET
|
||||
status = $2,
|
||||
updated_at = clock_timestamp()
|
||||
WHERE
|
||||
id = $1
|
||||
AND status = $3
|
||||
AND created_at > clock_timestamp() - make_interval(secs => $4::integer)
|
||||
RETURNING
|
||||
id,
|
||||
chat_id,
|
||||
owner_id,
|
||||
filename,
|
||||
content_type,
|
||||
size_bytes,
|
||||
sha256,
|
||||
created_at,
|
||||
updated_at;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
query,
|
||||
attachment_id,
|
||||
AttachmentStatus.READY,
|
||||
AttachmentStatus.PENDING,
|
||||
grace_seconds,
|
||||
)
|
||||
return self._row_to_attachment(row) if row is not None else None
|
||||
|
||||
@repository_logs
|
||||
async def claim_pending(self, attachment_id: UUID) -> UnfinishedUploadSchema | None:
|
||||
query = """
|
||||
UPDATE attachments
|
||||
SET
|
||||
status = $2,
|
||||
updated_at = clock_timestamp()
|
||||
WHERE
|
||||
id = $1
|
||||
AND status = $3
|
||||
RETURNING id, object_key;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
query,
|
||||
attachment_id,
|
||||
AttachmentStatus.DELETING,
|
||||
AttachmentStatus.PENDING,
|
||||
)
|
||||
return self._row_to_unfinished(row) if row is not None else None
|
||||
|
||||
@repository_logs
|
||||
async def claim_unfinished(
|
||||
self, grace_seconds: int, limit: int
|
||||
) -> list[UnfinishedUploadSchema]:
|
||||
"""
|
||||
Перевод pending → deleting атомарен: после него mark_ready этой строки
|
||||
невозможен. SKIP LOCKED — строку, которую сейчас подтверждает API,
|
||||
janitor не ждёт и не забирает. deleting-строки возвращаются независимо
|
||||
от возраста: их очистка прервалась и повторяется.
|
||||
"""
|
||||
query = """
|
||||
WITH stale AS
|
||||
(
|
||||
SELECT id
|
||||
FROM attachments
|
||||
WHERE
|
||||
status IN ($2, $3)
|
||||
AND
|
||||
(
|
||||
status = $3
|
||||
OR created_at < clock_timestamp() - make_interval(secs => $1::integer)
|
||||
)
|
||||
ORDER BY created_at
|
||||
LIMIT $4
|
||||
FOR UPDATE SKIP LOCKED
|
||||
)
|
||||
UPDATE attachments attachment
|
||||
SET
|
||||
status = $3,
|
||||
updated_at = clock_timestamp()
|
||||
FROM stale
|
||||
WHERE attachment.id = stale.id
|
||||
RETURNING attachment.id, attachment.object_key;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
rows = await conn.fetch(
|
||||
query,
|
||||
grace_seconds,
|
||||
AttachmentStatus.PENDING,
|
||||
AttachmentStatus.DELETING,
|
||||
limit,
|
||||
)
|
||||
return [self._row_to_unfinished(row) for row in rows]
|
||||
|
||||
@repository_logs
|
||||
async def list_unfinished(
|
||||
self, grace_seconds: int, limit: int
|
||||
) -> list[UnfinishedUploadSchema]:
|
||||
query = """
|
||||
SELECT
|
||||
id,
|
||||
object_key
|
||||
FROM attachments
|
||||
WHERE
|
||||
status IN ($2, $3)
|
||||
AND
|
||||
(
|
||||
status = $3
|
||||
OR created_at < clock_timestamp() - make_interval(secs => $1::integer)
|
||||
)
|
||||
ORDER BY created_at
|
||||
LIMIT $4;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
rows = await conn.fetch(
|
||||
query,
|
||||
grace_seconds,
|
||||
AttachmentStatus.PENDING,
|
||||
AttachmentStatus.DELETING,
|
||||
limit,
|
||||
)
|
||||
return [self._row_to_unfinished(row) for row in rows]
|
||||
|
||||
@repository_logs
|
||||
async def delete_claimed(self, attachment_ids: list[UUID]) -> int:
|
||||
query = """
|
||||
DELETE FROM attachments
|
||||
WHERE
|
||||
id = ANY($1::uuid[])
|
||||
AND status = $2;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
status = await conn.execute(
|
||||
query, attachment_ids, AttachmentStatus.DELETING
|
||||
)
|
||||
return int(status.split()[-1])
|
||||
|
||||
@repository_logs
|
||||
async def get_for_member(
|
||||
self, attachment_id: UUID, member_id: UUID
|
||||
) -> StoredAttachmentSchema | None:
|
||||
query = """
|
||||
SELECT
|
||||
attachment.id,
|
||||
attachment.chat_id,
|
||||
attachment.owner_id,
|
||||
attachment.filename,
|
||||
attachment.content_type,
|
||||
attachment.size_bytes,
|
||||
attachment.sha256,
|
||||
attachment.object_key,
|
||||
attachment.created_at,
|
||||
attachment.updated_at
|
||||
FROM attachments attachment
|
||||
WHERE
|
||||
attachment.id = $1
|
||||
AND attachment.status = $3
|
||||
AND EXISTS
|
||||
(
|
||||
SELECT 1
|
||||
FROM chat_members caller
|
||||
WHERE caller.chat_id = attachment.chat_id AND caller.user_id = $2
|
||||
);
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
query, attachment_id, member_id, AttachmentStatus.READY
|
||||
)
|
||||
if row is None:
|
||||
return None
|
||||
return StoredAttachmentSchema(
|
||||
attachment=self._row_to_attachment(row), object_key=row["object_key"]
|
||||
)
|
||||
|
||||
@repository_logs
|
||||
async def find_known_keys(self, object_keys: list[str]) -> set[str]:
|
||||
"""Поиск по уникальному индексу object_key"""
|
||||
query = """
|
||||
SELECT object_key
|
||||
FROM attachments
|
||||
WHERE object_key = ANY($1::text[]);
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
rows = await conn.fetch(query, object_keys)
|
||||
return {row["object_key"] for row in rows}
|
||||
|
||||
@staticmethod
|
||||
def _row_to_attachment(row: asyncpg.Record) -> AttachmentSchema:
|
||||
return AttachmentSchema(
|
||||
id=row["id"],
|
||||
chat_id=row["chat_id"],
|
||||
owner_id=row["owner_id"],
|
||||
filename=row["filename"],
|
||||
content_type=row["content_type"],
|
||||
size_bytes=row["size_bytes"],
|
||||
sha256=row["sha256"].hex(),
|
||||
created_at=row["created_at"],
|
||||
updated_at=row["updated_at"],
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _row_to_unfinished(row: asyncpg.Record) -> UnfinishedUploadSchema:
|
||||
return UnfinishedUploadSchema(id=row["id"], object_key=row["object_key"])
|
||||
@@ -3,13 +3,23 @@ from uuid import UUID
|
||||
import asyncpg
|
||||
|
||||
from domain import IdempotencyKeySchema, MessageSchema, PageKey
|
||||
from domain.errors import ConflictError
|
||||
from domain.errors import ConflictError, NotFoundError
|
||||
from infrastructure.utils import Pool, repository_logs, transaction
|
||||
from interfaces import MessageRepository
|
||||
|
||||
# Пространство ключей advisory lock: (namespace, hashtext(chat_id))
|
||||
CHAT_LOCK_NAMESPACE = 2
|
||||
|
||||
# Вложения сообщения в порядке attachment_ids запроса
|
||||
MESSAGE_ATTACHMENT_IDS = """
|
||||
ARRAY(
|
||||
SELECT link.attachment_id
|
||||
FROM message_attachments link
|
||||
WHERE link.message_id = message.id
|
||||
ORDER BY link.position
|
||||
) AS attachment_ids
|
||||
"""
|
||||
|
||||
|
||||
class PostgresMessageRepository(MessageRepository):
|
||||
def __init__(self, pool: Pool) -> None:
|
||||
@@ -21,6 +31,7 @@ class PostgresMessageRepository(MessageRepository):
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
attachment_ids: list[UUID],
|
||||
idempotency: IdempotencyKeySchema,
|
||||
) -> tuple[MessageSchema, bool]:
|
||||
"""
|
||||
@@ -36,18 +47,24 @@ class PostgresMessageRepository(MessageRepository):
|
||||
порядок коммитов совпадает с порядком (created_at, id), и читатель
|
||||
с cursor не пропустит сообщение. MAX берётся из индекса
|
||||
(chat_id, created_at, id) — Index Only Scan Backward, а не проход по истории.
|
||||
|
||||
Вложения связываются одним INSERT ... SELECT только с готовыми
|
||||
вложениями этого чата; если связано меньше, чем передано, — 404
|
||||
и откат всей транзакции, сообщение не появляется. Составной FK
|
||||
(attachment_id, chat_id) дублирует проверку чата на уровне БД.
|
||||
"""
|
||||
lock_query = """
|
||||
SELECT pg_advisory_xact_lock($1, hashtext($2::uuid::text));
|
||||
"""
|
||||
find_key_query = """
|
||||
find_key_query = f"""
|
||||
SELECT
|
||||
idem.request_hash,
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at
|
||||
message.created_at,
|
||||
{MESSAGE_ATTACHMENT_IDS}
|
||||
FROM message_idempotency_keys idem
|
||||
JOIN messages message ON message.id = idem.message_id
|
||||
WHERE
|
||||
@@ -73,6 +90,25 @@ class PostgresMessageRepository(MessageRepository):
|
||||
WHERE chat_id = $1
|
||||
RETURNING id, chat_id, sender_id, text, created_at;
|
||||
"""
|
||||
attachments_query = """
|
||||
INSERT INTO message_attachments
|
||||
(
|
||||
message_id,
|
||||
chat_id,
|
||||
attachment_id,
|
||||
position
|
||||
)
|
||||
SELECT
|
||||
$1,
|
||||
$2,
|
||||
attachment.id,
|
||||
item.ordinality - 1
|
||||
FROM unnest($3::uuid[]) WITH ORDINALITY AS item(attachment_id, ordinality)
|
||||
JOIN attachments attachment
|
||||
ON attachment.id = item.attachment_id
|
||||
AND attachment.chat_id = $2
|
||||
AND attachment.status = 'ready';
|
||||
"""
|
||||
|
||||
save_key_query = """
|
||||
INSERT INTO message_idempotency_keys
|
||||
@@ -113,6 +149,12 @@ class PostgresMessageRepository(MessageRepository):
|
||||
return self._row_to_message(stored), False
|
||||
row = await conn.fetchrow(insert_query, chat_id, sender_id, text)
|
||||
assert row is not None
|
||||
if attachment_ids:
|
||||
status = await conn.execute(
|
||||
attachments_query, row["id"], chat_id, attachment_ids
|
||||
)
|
||||
if int(status.split()[-1]) != len(attachment_ids):
|
||||
raise NotFoundError("Вложение не найдено")
|
||||
await conn.execute(
|
||||
save_key_query,
|
||||
sender_id,
|
||||
@@ -122,7 +164,7 @@ class PostgresMessageRepository(MessageRepository):
|
||||
row["id"],
|
||||
idempotency.ttl_seconds,
|
||||
)
|
||||
return self._row_to_message(row), True
|
||||
return self._row_to_message(row, attachment_ids), True
|
||||
|
||||
@repository_logs
|
||||
async def list_for_chat(
|
||||
@@ -133,30 +175,32 @@ class PostgresMessageRepository(MessageRepository):
|
||||
(chat_id, created_at, id) начинает чтение сразу после cursor
|
||||
и останавливается после LIMIT строк.
|
||||
"""
|
||||
first_page_query = """
|
||||
first_page_query = f"""
|
||||
SELECT
|
||||
id,
|
||||
chat_id,
|
||||
sender_id,
|
||||
text,
|
||||
created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at, id
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at,
|
||||
{MESSAGE_ATTACHMENT_IDS}
|
||||
FROM messages message
|
||||
WHERE message.chat_id = $1
|
||||
ORDER BY message.created_at, message.id
|
||||
LIMIT $2;
|
||||
"""
|
||||
next_page_query = """
|
||||
next_page_query = f"""
|
||||
SELECT
|
||||
id,
|
||||
chat_id,
|
||||
sender_id,
|
||||
text,
|
||||
created_at
|
||||
FROM messages
|
||||
message.id,
|
||||
message.chat_id,
|
||||
message.sender_id,
|
||||
message.text,
|
||||
message.created_at,
|
||||
{MESSAGE_ATTACHMENT_IDS}
|
||||
FROM messages message
|
||||
WHERE
|
||||
chat_id = $1
|
||||
AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at, id
|
||||
message.chat_id = $1
|
||||
AND (message.created_at, message.id) > ($2, $3)
|
||||
ORDER BY message.created_at, message.id
|
||||
LIMIT $4;
|
||||
"""
|
||||
async with self._pool.acquire() as conn:
|
||||
@@ -169,11 +213,17 @@ class PostgresMessageRepository(MessageRepository):
|
||||
return [self._row_to_message(row) for row in rows]
|
||||
|
||||
@staticmethod
|
||||
def _row_to_message(row: asyncpg.Record) -> MessageSchema:
|
||||
def _row_to_message(
|
||||
row: asyncpg.Record, attachment_ids: list[UUID] | None = None
|
||||
) -> MessageSchema:
|
||||
"""attachment_ids — из запроса для только что вставленного сообщения"""
|
||||
return MessageSchema(
|
||||
id=row["id"],
|
||||
chat_id=row["chat_id"],
|
||||
sender_id=row["sender_id"],
|
||||
text=row["text"],
|
||||
created_at=row["created_at"],
|
||||
attachment_ids=(
|
||||
attachment_ids if attachment_ids is not None else row["attachment_ids"]
|
||||
),
|
||||
)
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
from .s3 import S3ObjectStorage, S3StoredObject
|
||||
|
||||
__all__ = ["S3ObjectStorage", "S3StoredObject"]
|
||||
@@ -0,0 +1,118 @@
|
||||
import base64
|
||||
from collections.abc import AsyncIterator
|
||||
from datetime import datetime
|
||||
from typing import TYPE_CHECKING, Any, BinaryIO
|
||||
|
||||
from aiobotocore.client import AioBaseClient
|
||||
from botocore.exceptions import ClientError
|
||||
|
||||
from config import LOGGER
|
||||
from domain.errors import UnavailableError
|
||||
from infrastructure.utils import (
|
||||
STORAGE_UNAVAILABLE_ERRORS,
|
||||
storage_error_code,
|
||||
storage_logs,
|
||||
)
|
||||
from interfaces import ObjectStorage, StoredObject
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from infrastructure.dependencies.storage import ObjectStorageManager
|
||||
|
||||
DOWNLOAD_CHUNK_SIZE = 64 * 1024
|
||||
|
||||
MISSING_OBJECT_CODES = frozenset({"NoSuchKey", "404"})
|
||||
|
||||
|
||||
class S3StoredObject(StoredObject):
|
||||
"""Тело GET-ответа S3, читаемое частями по DOWNLOAD_CHUNK_SIZE"""
|
||||
|
||||
def __init__(self, body: Any, content_length: int) -> None:
|
||||
self._body = body
|
||||
self.content_length = content_length
|
||||
self._closed = False
|
||||
|
||||
async def iter_chunks(self) -> AsyncIterator[bytes]:
|
||||
"""
|
||||
Обрыв S3 посреди передачи: заголовки клиенту уже отправлены, поэтому
|
||||
ответ обрывается, а клиент видит несовпадение с Content-Length.
|
||||
"""
|
||||
try:
|
||||
async for chunk in self._body.iter_chunks(DOWNLOAD_CHUNK_SIZE):
|
||||
yield chunk
|
||||
except STORAGE_UNAVAILABLE_ERRORS as error:
|
||||
LOGGER.warning(
|
||||
f"Чтение объекта S3 прервано: {storage_error_code(error)}"
|
||||
)
|
||||
raise
|
||||
finally:
|
||||
await self.close()
|
||||
|
||||
async def close(self) -> None:
|
||||
if not self._closed:
|
||||
self._closed = True
|
||||
await self._body.aclose()
|
||||
|
||||
|
||||
class S3ObjectStorage(ObjectStorage):
|
||||
"""
|
||||
Объекты вложений в приватном bucket. Ключи API имеют права только на
|
||||
чтение, запись и список объектов этого bucket.
|
||||
"""
|
||||
|
||||
def __init__(self, storage: "ObjectStorageManager") -> None:
|
||||
self._storage = storage
|
||||
|
||||
@property
|
||||
def _client(self) -> AioBaseClient:
|
||||
assert self._storage.client is not None
|
||||
return self._storage.client
|
||||
|
||||
@storage_logs
|
||||
async def put(
|
||||
self,
|
||||
key: str,
|
||||
body: BinaryIO,
|
||||
size: int,
|
||||
content_type: str,
|
||||
sha256: bytes,
|
||||
) -> None:
|
||||
"""
|
||||
Один PUT (до 10 MiB multipart не нужен): объект появляется в S3 целиком
|
||||
или не появляется вовсе, незавершённых частей не остаётся.
|
||||
"""
|
||||
await self._client.put_object(
|
||||
Bucket=self._storage.bucket,
|
||||
Key=key,
|
||||
Body=body,
|
||||
ContentLength=size,
|
||||
ContentType=content_type,
|
||||
ChecksumSHA256=base64.b64encode(sha256).decode(),
|
||||
)
|
||||
|
||||
@storage_logs
|
||||
async def open(self, key: str) -> StoredObject | None:
|
||||
try:
|
||||
response = await self._client.get_object(
|
||||
Bucket=self._storage.bucket, Key=key
|
||||
)
|
||||
except ClientError as error:
|
||||
if storage_error_code(error) in MISSING_OBJECT_CODES:
|
||||
return None
|
||||
raise
|
||||
return S3StoredObject(response["Body"], response["ContentLength"])
|
||||
|
||||
@storage_logs
|
||||
async def delete(self, key: str) -> None:
|
||||
await self._client.delete_object(Bucket=self._storage.bucket, Key=key)
|
||||
|
||||
async def list_objects(self, prefix: str) -> AsyncIterator[tuple[str, datetime]]:
|
||||
paginator = self._client.get_paginator("list_objects_v2")
|
||||
try:
|
||||
async for page in paginator.paginate(
|
||||
Bucket=self._storage.bucket, Prefix=prefix
|
||||
):
|
||||
for item in page.get("Contents", []):
|
||||
yield item["Key"], item["LastModified"]
|
||||
except STORAGE_UNAVAILABLE_ERRORS as error:
|
||||
LOGGER.warning(f"Список объектов S3 не получен: {storage_error_code(error)}")
|
||||
raise UnavailableError("Хранилище файлов временно недоступно") from None
|
||||
@@ -1,4 +1,11 @@
|
||||
from .password_hasher import PasswordHasher, get_password_hasher
|
||||
from .secrets import read_secret
|
||||
from .tokens import generate_token, hash_token
|
||||
|
||||
__all__ = ["PasswordHasher", "get_password_hasher", "generate_token", "hash_token"]
|
||||
__all__ = [
|
||||
"PasswordHasher",
|
||||
"get_password_hasher",
|
||||
"generate_token",
|
||||
"hash_token",
|
||||
"read_secret",
|
||||
]
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def read_secret(path: Path) -> str:
|
||||
"""
|
||||
Секрет из файла (Docker/Compose secret в /run/secrets). Значение не
|
||||
логируется и не попадает в текст ошибки — только путь.
|
||||
"""
|
||||
try:
|
||||
value = path.read_text(encoding="utf-8").strip()
|
||||
except OSError as error:
|
||||
raise RuntimeError(
|
||||
f"Не удалось прочитать секрет {path}: {type(error).__name__}"
|
||||
) from None
|
||||
if not value:
|
||||
raise RuntimeError(f"Секрет {path} пуст")
|
||||
return value
|
||||
@@ -1,6 +1,15 @@
|
||||
from .attachment_service import AttachmentService
|
||||
from .auth_service import AuthService
|
||||
from .chat_service import ChatService
|
||||
from .message_service import MessageService
|
||||
from .storage_reconciler import StorageReconciler
|
||||
from .user_service import UserService
|
||||
|
||||
__all__ = ["UserService", "AuthService", "ChatService", "MessageService"]
|
||||
__all__ = [
|
||||
"UserService",
|
||||
"AuthService",
|
||||
"ChatService",
|
||||
"MessageService",
|
||||
"AttachmentService",
|
||||
"StorageReconciler",
|
||||
]
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
from .attachment_service import AttachmentService
|
||||
|
||||
__all__ = ["AttachmentService"]
|
||||
@@ -0,0 +1,222 @@
|
||||
import asyncio
|
||||
import secrets
|
||||
from collections.abc import AsyncIterator
|
||||
from typing import IO
|
||||
from uuid import UUID
|
||||
|
||||
from config import LOGGER
|
||||
from domain import (
|
||||
ORIGINAL_OBJECT_PREFIX,
|
||||
AttachmentContentType,
|
||||
AttachmentSchema,
|
||||
AttachmentVariant,
|
||||
NewAttachmentSchema,
|
||||
StoredAttachmentSchema,
|
||||
UserSchema,
|
||||
)
|
||||
from domain.errors import (
|
||||
AppError,
|
||||
NotFoundError,
|
||||
PayloadTooLargeError,
|
||||
UnavailableError,
|
||||
UnsupportedMediaTypeError,
|
||||
)
|
||||
from infrastructure.media import ImageInspector, spool_upload
|
||||
from interfaces import AttachmentRepository, ChatRepository, ObjectStorage, StoredObject
|
||||
|
||||
# 128 бит случайности: ключ не угадывается и не связан с filename
|
||||
OBJECT_KEY_RANDOM_BYTES = 16
|
||||
|
||||
|
||||
class AttachmentService:
|
||||
"""
|
||||
Вложения: оригинал в приватном S3, метаданные в PostgreSQL.
|
||||
|
||||
Порядок записи: строка pending → PUT в S3 → pending → ready → 201.
|
||||
201 возвращается только после того, как и объект, и подтверждённые
|
||||
метаданные сохранены. Сбой после записи строки компенсируется сразу:
|
||||
строка забирается в deleting, объект удаляется, затем строка. Если
|
||||
компенсация сама не удалась (S3/БД недоступны, процесс упал), строку
|
||||
pending дочищает janitor после grace period.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
chat_repository: ChatRepository,
|
||||
attachment_repository: AttachmentRepository,
|
||||
storage: ObjectStorage,
|
||||
inspector: ImageInspector,
|
||||
max_upload_bytes: int,
|
||||
spool_memory_bytes: int,
|
||||
store_timeout_seconds: float,
|
||||
pending_grace_seconds: int,
|
||||
) -> None:
|
||||
self._chats = chat_repository
|
||||
self._attachments = attachment_repository
|
||||
self._storage = storage
|
||||
self._inspector = inspector
|
||||
self._max_upload_bytes = max_upload_bytes
|
||||
self._spool_memory_bytes = spool_memory_bytes
|
||||
self._store_timeout = store_timeout_seconds
|
||||
self._pending_grace = pending_grace_seconds
|
||||
|
||||
async def upload(
|
||||
self,
|
||||
current_user: UserSchema,
|
||||
chat_id: UUID,
|
||||
filename: str,
|
||||
content_type: str | None,
|
||||
content_length: int | None,
|
||||
chunks: AsyncIterator[bytes],
|
||||
) -> AttachmentSchema:
|
||||
"""
|
||||
Синхронная загрузка оригинала. Дешёвые проверки (доступ, Content-Type,
|
||||
Content-Length) выполняются до чтения тела; тело читается потоком
|
||||
с лимитом байт, изображение проверяется до записи в S3.
|
||||
|
||||
Raises:
|
||||
NotFoundError: чата нет или пользователь не участник
|
||||
UnsupportedMediaTypeError: не PNG/JPEG, повреждено, подмена MIME
|
||||
PayloadTooLargeError: больше лимита байт или пикселей
|
||||
UnavailableError: S3 или БД недоступны; ничего не сохранено
|
||||
"""
|
||||
await self._ensure_member(current_user, chat_id)
|
||||
declared = self._parse_content_type(content_type)
|
||||
if content_length is not None and content_length > self._max_upload_bytes:
|
||||
raise PayloadTooLargeError(f"Файл больше {self._max_upload_bytes} байт")
|
||||
async with spool_upload(
|
||||
chunks, self._max_upload_bytes, self._spool_memory_bytes
|
||||
) as upload:
|
||||
image = await self._inspector.inspect(upload.file, declared)
|
||||
new = NewAttachmentSchema(
|
||||
chat_id=chat_id,
|
||||
owner_id=current_user.id,
|
||||
filename=filename,
|
||||
content_type=image.content_type,
|
||||
size_bytes=upload.size,
|
||||
sha256=upload.sha256,
|
||||
object_key=self._new_object_key(),
|
||||
)
|
||||
attachment = await self._store(new, upload.file)
|
||||
LOGGER.info(
|
||||
f"Загружено вложение {attachment.id} в чат {chat_id} пользователем "
|
||||
f"{current_user.id}: {attachment.content_type}, "
|
||||
f"{attachment.size_bytes} байт, {image.width}x{image.height}"
|
||||
)
|
||||
return attachment
|
||||
|
||||
async def get_attachment(
|
||||
self, current_user: UserSchema, attachment_id: UUID
|
||||
) -> AttachmentSchema:
|
||||
stored = await self._get_stored(current_user, attachment_id)
|
||||
return stored.attachment
|
||||
|
||||
async def open_content(
|
||||
self,
|
||||
current_user: UserSchema,
|
||||
attachment_id: UUID,
|
||||
variant: AttachmentVariant,
|
||||
) -> tuple[AttachmentSchema, StoredObject]:
|
||||
"""
|
||||
Объект открывается до ответа: недоступность S3 — 503 в общем формате
|
||||
ошибки, а не оборванный 200.
|
||||
|
||||
Raises:
|
||||
NotFoundError: вложения нет, оно чужое или варианта нет
|
||||
UnavailableError: S3 недоступен
|
||||
"""
|
||||
stored = await self._get_stored(current_user, attachment_id)
|
||||
if variant is not AttachmentVariant.ORIGINAL:
|
||||
raise NotFoundError("Вариант изображения не найден")
|
||||
content = await self._storage.open(stored.object_key)
|
||||
if content is None:
|
||||
LOGGER.error(
|
||||
f"Нарушена согласованность: объект готового вложения "
|
||||
f"{attachment_id} отсутствует в S3"
|
||||
)
|
||||
raise AppError()
|
||||
return stored.attachment, content
|
||||
|
||||
async def _store(self, new: NewAttachmentSchema, body: IO[bytes]) -> AttachmentSchema:
|
||||
"""
|
||||
Запись объекта и подтверждение метаданных с жёстким сроком
|
||||
store_timeout ≪ grace period: janitor не может забрать загрузку,
|
||||
которая ещё идёт.
|
||||
"""
|
||||
attachment_id = await self._attachments.create_pending(new)
|
||||
try:
|
||||
async with asyncio.timeout(self._store_timeout):
|
||||
body.seek(0)
|
||||
await self._storage.put(
|
||||
new.object_key,
|
||||
body,
|
||||
new.size_bytes,
|
||||
new.content_type,
|
||||
new.sha256,
|
||||
)
|
||||
attachment = await self._attachments.mark_ready(
|
||||
attachment_id, self._pending_grace
|
||||
)
|
||||
except BaseException as error:
|
||||
LOGGER.warning(
|
||||
f"Загрузка {attachment_id} не завершена ({type(error).__name__}), "
|
||||
"компенсация"
|
||||
)
|
||||
await self._compensate(attachment_id)
|
||||
if isinstance(error, TimeoutError):
|
||||
raise UnavailableError("Хранилище файлов не ответило вовремя") from None
|
||||
raise
|
||||
if attachment is None:
|
||||
LOGGER.warning(f"Загрузка {attachment_id} уже забрана на очистку")
|
||||
await self._compensate(attachment_id)
|
||||
raise UnavailableError("Загрузка не подтверждена, повторите запрос")
|
||||
return attachment
|
||||
|
||||
async def _compensate(self, attachment_id: UUID) -> None:
|
||||
"""
|
||||
Best effort: pending → deleting → удалить объект → удалить строку.
|
||||
Строку сначала забирают: если в неизвестном исходе UPDATE в ready
|
||||
всё же прошёл, claim не сработает, и объект готового вложения цел.
|
||||
Любой сбой здесь только журналируется: остаток дочистит janitor.
|
||||
"""
|
||||
try:
|
||||
claimed = await self._attachments.claim_pending(attachment_id)
|
||||
if claimed is None:
|
||||
return
|
||||
await self._storage.delete(claimed.object_key)
|
||||
await self._attachments.delete_claimed([claimed.id])
|
||||
except AppError as error:
|
||||
LOGGER.warning(
|
||||
f"Компенсация загрузки {attachment_id} не удалась "
|
||||
f"({type(error).__name__}): строку дочистит janitor"
|
||||
)
|
||||
|
||||
async def _get_stored(
|
||||
self, current_user: UserSchema, attachment_id: UUID
|
||||
) -> StoredAttachmentSchema:
|
||||
"""Чужое, неизвестное и незавершённое вложение неразличимы: 404"""
|
||||
stored = await self._attachments.get_for_member(attachment_id, current_user.id)
|
||||
if stored is None:
|
||||
raise NotFoundError()
|
||||
return stored
|
||||
|
||||
async def _ensure_member(self, current_user: UserSchema, chat_id: UUID) -> None:
|
||||
"""Посторонний получает 404: существование чужого чата не раскрывается"""
|
||||
if await self._chats.get_for_member(chat_id, current_user.id) is None:
|
||||
raise NotFoundError()
|
||||
|
||||
@staticmethod
|
||||
def _parse_content_type(raw: str | None) -> AttachmentContentType:
|
||||
"""Заявленный тип без параметров; содержимое сверяется с ним позже"""
|
||||
media_type = (raw or "").split(";", 1)[0].strip().lower()
|
||||
try:
|
||||
return AttachmentContentType(media_type)
|
||||
except ValueError:
|
||||
raise UnsupportedMediaTypeError(
|
||||
"Content-Type должен быть image/png или image/jpeg"
|
||||
) from None
|
||||
|
||||
@staticmethod
|
||||
def _new_object_key() -> str:
|
||||
"""Ключ назначает сервер; имя файла пользователя в него не входит"""
|
||||
return ORIGINAL_OBJECT_PREFIX + secrets.token_hex(OBJECT_KEY_RANDOM_BYTES)
|
||||
@@ -37,6 +37,9 @@ class MessageService:
|
||||
|
||||
Повтор с тем же Idempotency-Key заново проверяет доступ к чату
|
||||
и возвращает исходное сообщение.
|
||||
|
||||
Raises:
|
||||
NotFoundError: чат чужой или вложение не готово / из другого чата
|
||||
"""
|
||||
await self._ensure_member(current_user, chat_id)
|
||||
idempotency = IdempotencyKeySchema(
|
||||
@@ -45,12 +48,13 @@ class MessageService:
|
||||
ttl_seconds=self._idempotency_ttl,
|
||||
)
|
||||
message, created = await self._messages.create(
|
||||
chat_id, current_user.id, data.text, idempotency
|
||||
chat_id, current_user.id, data.text, data.attachment_ids, idempotency
|
||||
)
|
||||
if created:
|
||||
LOGGER.info(
|
||||
f"Сообщение {message.id} отправлено в чат {chat_id} "
|
||||
f"пользователем {current_user.id}"
|
||||
f"пользователем {current_user.id}, "
|
||||
f"вложений: {len(message.attachment_ids)}"
|
||||
)
|
||||
else:
|
||||
LOGGER.info(
|
||||
@@ -79,5 +83,9 @@ class MessageService:
|
||||
"""
|
||||
SHA-256 канонического тела. Порядок полей задаёт схема, а не клиент,
|
||||
поэтому JSON с другим порядком ключей считается тем же запросом.
|
||||
Значения по умолчанию не входят в hash: отсутствующий attachment_ids
|
||||
равен [], а hash текстового сообщения совпадает с hash lab3.
|
||||
"""
|
||||
return hashlib.sha256(data.model_dump_json().encode()).digest()
|
||||
return hashlib.sha256(
|
||||
data.model_dump_json(exclude_defaults=True).encode()
|
||||
).digest()
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
from .storage_reconciler import StorageReconciler
|
||||
|
||||
__all__ = ["StorageReconciler"]
|
||||
@@ -0,0 +1,106 @@
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
from config import LOGGER
|
||||
from domain import ORIGINAL_OBJECT_PREFIX, ReconcileReportSchema, UnfinishedUploadSchema
|
||||
from interfaces import AttachmentRepository, ObjectStorage
|
||||
|
||||
# Строк незавершённых загрузок за один запрос к БД
|
||||
UNFINISHED_BATCH_SIZE = 100
|
||||
|
||||
# Ключей S3 на одну проверку в БД (WHERE object_key = ANY(...))
|
||||
ORPHAN_SCAN_BATCH_SIZE = 500
|
||||
|
||||
|
||||
class StorageReconciler:
|
||||
"""
|
||||
Сверка S3 и PostgreSQL (janitor). Один проход:
|
||||
|
||||
1. Незавершённые загрузки. pending старше grace period переводятся
|
||||
в deleting (после этого API уже не подтвердит их), объект удаляется
|
||||
(идемпотентно — его могло и не быть), затем строка. deleting прошлых
|
||||
проходов повторяются: очистку можно прервать в любой точке.
|
||||
2. Сироты. Объекты под originals/ без строки в БД и старше grace period
|
||||
удаляются. Пока соблюдается инвариант «строка раньше объекта», их нет;
|
||||
проход проверяет инвариант и страхует от внешних нарушений (например,
|
||||
восстановления БД из старой копии).
|
||||
|
||||
Не удаляются: готовые вложения (ready) и всё, что моложе grace period.
|
||||
dry_run — только отчёт, без изменений.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
attachment_repository: AttachmentRepository,
|
||||
storage: ObjectStorage,
|
||||
grace_seconds: int,
|
||||
) -> None:
|
||||
self._attachments = attachment_repository
|
||||
self._storage = storage
|
||||
self._grace_seconds = grace_seconds
|
||||
|
||||
async def run_once(self, dry_run: bool = False) -> ReconcileReportSchema:
|
||||
"""
|
||||
Raises:
|
||||
UnavailableError: S3 или БД недоступны; следующий проход повторит
|
||||
"""
|
||||
report = ReconcileReportSchema(dry_run=dry_run)
|
||||
await self._clean_unfinished(report)
|
||||
await self._clean_orphans(report)
|
||||
LOGGER.info(f"Сверка S3/БД завершена: {report.model_dump_json()}")
|
||||
return report
|
||||
|
||||
async def _clean_unfinished(self, report: ReconcileReportSchema) -> None:
|
||||
if report.dry_run:
|
||||
found = await self._attachments.list_unfinished(
|
||||
self._grace_seconds, UNFINISHED_BATCH_SIZE
|
||||
)
|
||||
report.unfinished_claimed = len(found)
|
||||
return
|
||||
while True:
|
||||
claimed = await self._attachments.claim_unfinished(
|
||||
self._grace_seconds, UNFINISHED_BATCH_SIZE
|
||||
)
|
||||
if not claimed:
|
||||
return
|
||||
report.unfinished_claimed += len(claimed)
|
||||
await self._delete_objects(claimed)
|
||||
report.unfinished_objects_deleted += len(claimed)
|
||||
report.unfinished_rows_deleted += await self._attachments.delete_claimed(
|
||||
[upload.id for upload in claimed]
|
||||
)
|
||||
for upload in claimed:
|
||||
LOGGER.info(f"Незавершённая загрузка {upload.id} очищена")
|
||||
|
||||
async def _clean_orphans(self, report: ReconcileReportSchema) -> None:
|
||||
threshold = datetime.now(UTC) - timedelta(seconds=self._grace_seconds)
|
||||
batch: list[tuple[str, datetime]] = []
|
||||
async for key, modified_at in self._storage.list_objects(
|
||||
ORIGINAL_OBJECT_PREFIX
|
||||
):
|
||||
report.objects_scanned += 1
|
||||
batch.append((key, modified_at))
|
||||
if len(batch) >= ORPHAN_SCAN_BATCH_SIZE:
|
||||
await self._clean_orphan_batch(batch, threshold, report)
|
||||
batch = []
|
||||
if batch:
|
||||
await self._clean_orphan_batch(batch, threshold, report)
|
||||
|
||||
async def _clean_orphan_batch(
|
||||
self,
|
||||
batch: list[tuple[str, datetime]],
|
||||
threshold: datetime,
|
||||
report: ReconcileReportSchema,
|
||||
) -> None:
|
||||
known = await self._attachments.find_known_keys([key for key, _ in batch])
|
||||
for key, modified_at in batch:
|
||||
if key in known or modified_at >= threshold:
|
||||
continue
|
||||
report.orphan_objects_found += 1
|
||||
LOGGER.warning(f"Объект S3 без строки в БД: {key}")
|
||||
if not report.dry_run:
|
||||
await self._storage.delete(key)
|
||||
report.orphan_objects_deleted += 1
|
||||
|
||||
async def _delete_objects(self, uploads: list[UnfinishedUploadSchema]) -> None:
|
||||
for upload in uploads:
|
||||
await self._storage.delete(upload.object_key)
|
||||
@@ -1,5 +1,10 @@
|
||||
from .pagination import build_page, decode_cursor, encode_cursor, page_key
|
||||
from .repository_utils import DATABASE_UNAVAILABLE_ERRORS, repository_logs
|
||||
from .storage_utils import (
|
||||
STORAGE_UNAVAILABLE_ERRORS,
|
||||
storage_error_code,
|
||||
storage_logs,
|
||||
)
|
||||
from .transaction import ConnectionPool, Pool, transaction
|
||||
|
||||
__all__ = [
|
||||
@@ -9,6 +14,9 @@ __all__ = [
|
||||
"build_page",
|
||||
"repository_logs",
|
||||
"DATABASE_UNAVAILABLE_ERRORS",
|
||||
"storage_logs",
|
||||
"storage_error_code",
|
||||
"STORAGE_UNAVAILABLE_ERRORS",
|
||||
"ConnectionPool",
|
||||
"Pool",
|
||||
"transaction",
|
||||
|
||||
@@ -0,0 +1,48 @@
|
||||
from collections.abc import Callable
|
||||
from functools import wraps
|
||||
from typing import Any
|
||||
|
||||
import aiohttp
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
from config import LOGGER
|
||||
from domain.errors import UnavailableError
|
||||
|
||||
# Сеть, таймауты и ответы S3 с ошибкой (5xx, AccessDenied, BadDigest):
|
||||
# для клиента — 503, подробности только в журнале
|
||||
STORAGE_UNAVAILABLE_ERRORS: tuple[type[Exception], ...] = (
|
||||
BotoCoreError,
|
||||
ClientError,
|
||||
aiohttp.ClientError,
|
||||
OSError,
|
||||
TimeoutError,
|
||||
)
|
||||
|
||||
|
||||
def storage_error_code(error: Exception) -> str:
|
||||
"""Код ошибки S3 (NoSuchKey, AccessDenied...) или имя класса исключения"""
|
||||
if isinstance(error, ClientError):
|
||||
return str(error.response.get("Error", {}).get("Code", "ClientError"))
|
||||
return type(error).__name__
|
||||
|
||||
|
||||
def storage_logs(func: Callable) -> Callable:
|
||||
"""
|
||||
Decorator for logging object storage requests.
|
||||
"""
|
||||
|
||||
@wraps(func)
|
||||
async def wrapper(*args: Any, **kwargs: Any) -> Any:
|
||||
log_text = (
|
||||
f"Request to S3 || Object: {args[0].__class__.__name__} "
|
||||
f"|| Function: {func.__name__} || "
|
||||
)
|
||||
try:
|
||||
result = await func(*args, **kwargs)
|
||||
except STORAGE_UNAVAILABLE_ERRORS as error:
|
||||
LOGGER.warning(log_text + f"failed || Error: {storage_error_code(error)}")
|
||||
raise UnavailableError("Хранилище файлов временно недоступно") from None
|
||||
LOGGER.debug(log_text + "completed")
|
||||
return result
|
||||
|
||||
return wrapper
|
||||
@@ -1,5 +1,7 @@
|
||||
from .attachment_repository import AttachmentRepository
|
||||
from .chat_repository import ChatRepository
|
||||
from .message_repository import MessageRepository
|
||||
from .object_storage import ObjectStorage, StoredObject
|
||||
from .session_cache import SessionCache
|
||||
from .session_repository import SessionRepository
|
||||
from .user_repository import UserRepository
|
||||
@@ -10,4 +12,7 @@ __all__ = [
|
||||
"MessageRepository",
|
||||
"SessionRepository",
|
||||
"SessionCache",
|
||||
"AttachmentRepository",
|
||||
"ObjectStorage",
|
||||
"StoredObject",
|
||||
]
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
from abc import ABC, abstractmethod
|
||||
from uuid import UUID
|
||||
|
||||
from domain import (
|
||||
AttachmentSchema,
|
||||
NewAttachmentSchema,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
)
|
||||
|
||||
|
||||
class AttachmentRepository(ABC):
|
||||
"""
|
||||
Слой абстракции метаданных вложений — источника истины о том, какие
|
||||
объекты S3 принадлежат приложению.
|
||||
|
||||
Инвариант: у каждого объекта под ORIGINAL_OBJECT_PREFIX есть строка
|
||||
(pending, ready или deleting). Строка записывается до PUT в S3,
|
||||
а удаляется только после удаления объекта.
|
||||
"""
|
||||
|
||||
@abstractmethod
|
||||
async def create_pending(self, attachment: NewAttachmentSchema) -> UUID:
|
||||
"""
|
||||
Намерение загрузки фиксируется до записи в S3: если процесс упадёт
|
||||
после PUT, объект не останется неучтённым.
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def mark_ready(
|
||||
self, attachment_id: UUID, grace_seconds: int
|
||||
) -> AttachmentSchema | None:
|
||||
"""
|
||||
Подтверждение загрузки: pending → ready.
|
||||
|
||||
None, если строка уже не pending или старше grace period: janitor
|
||||
мог забрать её на очистку, такая загрузка подтверждаться не должна.
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def claim_pending(self, attachment_id: UUID) -> UnfinishedUploadSchema | None:
|
||||
"""
|
||||
Компенсация неудачной загрузки: pending → deleting.
|
||||
None, если строка уже не pending (подтверждена или забрана janitor).
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def claim_unfinished(
|
||||
self, grace_seconds: int, limit: int
|
||||
) -> list[UnfinishedUploadSchema]:
|
||||
"""
|
||||
Сверка: pending старше grace period переводятся в deleting; вместе
|
||||
с ними возвращаются ранее забранные deleting — их очистку повторяют.
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def list_unfinished(
|
||||
self, grace_seconds: int, limit: int
|
||||
) -> list[UnfinishedUploadSchema]:
|
||||
"""То же, что claim_unfinished, но без изменения строк (dry-run)"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def delete_claimed(self, attachment_ids: list[UUID]) -> int:
|
||||
"""Удаление строк deleting, чьи объекты уже удалены из S3"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def get_for_member(
|
||||
self, attachment_id: UUID, member_id: UUID
|
||||
) -> StoredAttachmentSchema | None:
|
||||
"""
|
||||
Готовое вложение, только если пользователь — участник его чата.
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def find_known_keys(self, object_keys: list[str]) -> set[str]:
|
||||
"""Ключи из списка, у которых есть строка в любом состоянии"""
|
||||
pass
|
||||
@@ -13,6 +13,7 @@ class MessageRepository(ABC):
|
||||
chat_id: UUID,
|
||||
sender_id: UUID,
|
||||
text: str,
|
||||
attachment_ids: list[UUID],
|
||||
idempotency: IdempotencyKeySchema,
|
||||
) -> tuple[MessageSchema, bool]:
|
||||
"""
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
from abc import ABC, abstractmethod
|
||||
from collections.abc import AsyncIterator
|
||||
from datetime import datetime
|
||||
from typing import BinaryIO
|
||||
|
||||
|
||||
class StoredObject(ABC):
|
||||
"""
|
||||
Открытый на чтение объект: ответ хранилища уже получен (ошибки доступа
|
||||
известны до отправки заголовков клиенту), тело читается потоком.
|
||||
"""
|
||||
|
||||
content_length: int
|
||||
|
||||
@abstractmethod
|
||||
def iter_chunks(self) -> AsyncIterator[bytes]:
|
||||
"""Тело объекта частями; по завершении соединение возвращается в пул"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def close(self) -> None:
|
||||
"""Освобождение соединения, если тело не дочитано; повторный вызов безопасен"""
|
||||
pass
|
||||
|
||||
|
||||
class ObjectStorage(ABC):
|
||||
"""
|
||||
Слой абстракции объектного хранилища (S3) для байтов вложений.
|
||||
Недоступность хранилища — UnavailableError.
|
||||
"""
|
||||
|
||||
@abstractmethod
|
||||
async def put(
|
||||
self,
|
||||
key: str,
|
||||
body: BinaryIO,
|
||||
size: int,
|
||||
content_type: str,
|
||||
sha256: bytes,
|
||||
) -> None:
|
||||
"""
|
||||
Запись объекта потоком из файла. Хранилище сверяет SHA-256 полученных
|
||||
байт с переданным: объект с другим содержимым не сохраняется.
|
||||
"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def open(self, key: str) -> StoredObject | None:
|
||||
"""Объект на чтение; None, если объекта нет"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def delete(self, key: str) -> None:
|
||||
"""Удаление объекта; отсутствующий объект — не ошибка"""
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
def list_objects(self, prefix: str) -> AsyncIterator[tuple[str, datetime]]:
|
||||
"""Ключи и время последнего изменения объектов под prefix, постранично"""
|
||||
pass
|
||||
@@ -0,0 +1,95 @@
|
||||
"""
|
||||
Janitor: периодическая сверка S3 и PostgreSQL (сервис janitor).
|
||||
|
||||
Дочищает незавершённые загрузки старше grace period и объекты S3 без строки
|
||||
в БД; готовые и свежие вложения не трогает. Работает с теми же ограниченными
|
||||
S3-ключами, что и API. Несколько одновременных janitor безопасны: строки
|
||||
забираются через FOR UPDATE SKIP LOCKED, удаление объекта идемпотентно.
|
||||
|
||||
python src/janitor.py # цикл раз в JANITOR_INTERVAL_SEC
|
||||
python src/janitor.py --once --dry-run # один проход, только отчёт
|
||||
|
||||
После каждого успешного прохода цикла обновляется JANITOR_HEARTBEAT_FILE:
|
||||
по его возрасту healthcheck контейнера (src/healthcheck.py janitor) видит,
|
||||
что janitor не завис и его зависимости доступны.
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import signal
|
||||
import sys
|
||||
import time
|
||||
|
||||
from config import (
|
||||
ATTACHMENT_PENDING_GRACE_SEC,
|
||||
DB_STARTUP_TIMEOUT_SEC,
|
||||
JANITOR_HEARTBEAT_FILE,
|
||||
JANITOR_INTERVAL_SEC,
|
||||
LOGGER,
|
||||
)
|
||||
from domain.errors import UnavailableError
|
||||
from infrastructure import database_pool_manager, storage_manager
|
||||
from infrastructure.repositories import PostgresAttachmentRepository, S3ObjectStorage
|
||||
from infrastructure.services import StorageReconciler
|
||||
|
||||
|
||||
def parse_args() -> argparse.Namespace:
|
||||
parser = argparse.ArgumentParser(description="Сверка S3 и PostgreSQL")
|
||||
parser.add_argument("--once", action="store_true", help="один проход и выход")
|
||||
parser.add_argument("--dry-run", action="store_true", help="только отчёт")
|
||||
parser.add_argument(
|
||||
"--grace-seconds",
|
||||
type=int,
|
||||
default=ATTACHMENT_PENDING_GRACE_SEC,
|
||||
help="возраст, после которого незавершённое удаляется",
|
||||
)
|
||||
return parser.parse_args()
|
||||
|
||||
|
||||
async def main(args: argparse.Namespace) -> int:
|
||||
stop = asyncio.Event()
|
||||
loop = asyncio.get_running_loop()
|
||||
for signum in (signal.SIGTERM, signal.SIGINT):
|
||||
loop.add_signal_handler(signum, stop.set)
|
||||
|
||||
await database_pool_manager.create_pool(DB_STARTUP_TIMEOUT_SEC)
|
||||
await database_pool_manager.check_migrations()
|
||||
await storage_manager.create_client()
|
||||
reconciler = StorageReconciler(
|
||||
PostgresAttachmentRepository(database_pool_manager),
|
||||
S3ObjectStorage(storage_manager),
|
||||
args.grace_seconds,
|
||||
)
|
||||
LOGGER.info(
|
||||
f"Janitor запущен: grace {args.grace_seconds} с, "
|
||||
f"интервал {JANITOR_INTERVAL_SEC} с, dry-run: {args.dry_run}"
|
||||
)
|
||||
exit_code = 0
|
||||
try:
|
||||
while not stop.is_set():
|
||||
try:
|
||||
report = await reconciler.run_once(args.dry_run)
|
||||
exit_code = 0
|
||||
if not args.once:
|
||||
JANITOR_HEARTBEAT_FILE.write_text(str(time.time()))
|
||||
if args.once:
|
||||
# Отчёт отдельной строкой stdout: его разбирают тесты
|
||||
print(report.model_dump_json(), flush=True)
|
||||
except UnavailableError:
|
||||
exit_code = 1
|
||||
LOGGER.warning("Сверка не выполнена: S3 или БД недоступны, повтор")
|
||||
if args.once:
|
||||
break
|
||||
try:
|
||||
await asyncio.wait_for(stop.wait(), JANITOR_INTERVAL_SEC)
|
||||
except TimeoutError:
|
||||
pass
|
||||
finally:
|
||||
await storage_manager.close()
|
||||
await database_pool_manager.close()
|
||||
LOGGER.info("Janitor остановлен")
|
||||
return exit_code
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(asyncio.run(main(parse_args())))
|
||||
@@ -0,0 +1,51 @@
|
||||
"""
|
||||
Однократная подготовка bucket до запуска API-реплик (сервис s3-bootstrap).
|
||||
|
||||
Работает с административными ключами, которых у API нет. Идемпотентен:
|
||||
повторный запуск находит bucket и ничего не меняет. Завершается ошибкой,
|
||||
если bucket доступен анонимно, — тогда API-реплики не стартуют.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
|
||||
from config import (
|
||||
LOGGER,
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE,
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE,
|
||||
S3_BUCKET,
|
||||
S3_CONNECT_TIMEOUT_SEC,
|
||||
S3_ENDPOINT,
|
||||
S3_MAX_ATTEMPTS,
|
||||
S3_READ_TIMEOUT_SEC,
|
||||
S3_REGION,
|
||||
S3_STARTUP_TIMEOUT_SEC,
|
||||
)
|
||||
from infrastructure.dependencies import ObjectStorageManager
|
||||
|
||||
ADMIN_POOL_SIZE = 1
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
admin = ObjectStorageManager(
|
||||
endpoint=S3_ENDPOINT,
|
||||
region=S3_REGION,
|
||||
bucket=S3_BUCKET,
|
||||
access_key_file=S3_ADMIN_ACCESS_KEY_ID_FILE,
|
||||
secret_key_file=S3_ADMIN_SECRET_ACCESS_KEY_FILE,
|
||||
max_pool_size=ADMIN_POOL_SIZE,
|
||||
connect_timeout=S3_CONNECT_TIMEOUT_SEC,
|
||||
read_timeout=S3_READ_TIMEOUT_SEC,
|
||||
max_attempts=S3_MAX_ATTEMPTS,
|
||||
)
|
||||
await admin.create_client()
|
||||
try:
|
||||
await admin.wait_ready(S3_STARTUP_TIMEOUT_SEC)
|
||||
await admin.ensure_bucket()
|
||||
admin.check_anonymous_denied()
|
||||
finally:
|
||||
await admin.close()
|
||||
LOGGER.info("Bucket готов, s3-bootstrap завершается")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -5,7 +5,15 @@ from pathlib import Path
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from helpers import auth, basic, message_headers, unique_password, unique_username
|
||||
from helpers import (
|
||||
auth,
|
||||
basic,
|
||||
message_headers,
|
||||
png_bytes,
|
||||
unique_password,
|
||||
unique_username,
|
||||
upload_raw,
|
||||
)
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
DEFAULT_BASE_URL = json.loads((ROOT / "lab.json").read_text())["default_base_url"]
|
||||
@@ -74,3 +82,43 @@ def send_message(api: httpx.Client) -> Callable[..., dict]:
|
||||
return response.json()
|
||||
|
||||
return send
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def upload(api: httpx.Client) -> Callable[..., dict]:
|
||||
"""Успешная загрузка вложения: 201 и Attachment"""
|
||||
|
||||
def create(
|
||||
user: dict,
|
||||
chat: dict,
|
||||
content: bytes | None = None,
|
||||
content_type: str = "image/png",
|
||||
filename: str = "image.png",
|
||||
) -> dict:
|
||||
response = upload_raw(
|
||||
api, user, chat["id"], content or png_bytes(), content_type, filename
|
||||
)
|
||||
assert response.status_code == 201, response.text
|
||||
return response.json()
|
||||
|
||||
return create
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def send_attachments(api: httpx.Client) -> Callable[..., httpx.Response]:
|
||||
"""POST сообщения с attachment_ids; ответ не проверяется"""
|
||||
|
||||
def send(
|
||||
user: dict,
|
||||
chat: dict,
|
||||
attachment_ids: list[str],
|
||||
text: str = "",
|
||||
key: str | None = None,
|
||||
) -> httpx.Response:
|
||||
return api.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages",
|
||||
json={"text": text, "attachment_ids": attachment_ids},
|
||||
headers=message_headers(user, key),
|
||||
)
|
||||
|
||||
return send
|
||||
|
||||
@@ -1,11 +1,16 @@
|
||||
"""Общие проверки для собственных black-box тестов"""
|
||||
|
||||
import base64
|
||||
import json
|
||||
import io
|
||||
import struct
|
||||
import subprocess
|
||||
import uuid
|
||||
import zlib
|
||||
from pathlib import Path
|
||||
|
||||
import httpx
|
||||
from PIL import Image
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
|
||||
@@ -101,3 +106,111 @@ def psql(sql: str) -> str:
|
||||
'psql -X -q -tA -v ON_ERROR_STOP=1 -U "$POSTGRES_USER" -d "$POSTGRES_DB"',
|
||||
stdin=sql,
|
||||
).strip()
|
||||
|
||||
|
||||
# --- Изображения и вложения (lab4) ---
|
||||
|
||||
MAX_UPLOAD_BYTES = 10 * 1024 * 1024
|
||||
MAX_IMAGE_PIXELS = 40_000_000
|
||||
FIXTURE_PNG = ROOT / "tests/fixtures/sample.png"
|
||||
|
||||
|
||||
def png_bytes(width: int = 32, height: int = 20, noise: bool = False) -> bytes:
|
||||
"""Настоящий PNG; noise — плохо сжимаемое содержимое"""
|
||||
image = (
|
||||
Image.effect_noise((width, height), 64).convert("RGB")
|
||||
if noise
|
||||
else Image.new("RGB", (width, height), (200, 30, 90))
|
||||
)
|
||||
buffer = io.BytesIO()
|
||||
image.save(buffer, "PNG")
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def jpeg_bytes(width: int = 32, height: int = 20, progressive: bool = False) -> bytes:
|
||||
image = Image.effect_noise((width, height), 64).convert("RGB")
|
||||
buffer = io.BytesIO()
|
||||
image.save(buffer, "JPEG", quality=85, progressive=progressive)
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def bilevel_png(width: int, height: int) -> bytes:
|
||||
"""Огромное по пикселям, но крошечное по байтам изображение (1 бит, нули)"""
|
||||
buffer = io.BytesIO()
|
||||
Image.new("1", (width, height)).save(buffer, "PNG")
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def png_chunk(chunk_type: bytes, data: bytes) -> bytes:
|
||||
return (
|
||||
struct.pack(">I", len(data))
|
||||
+ chunk_type
|
||||
+ data
|
||||
+ struct.pack(">I", zlib.crc32(chunk_type + data))
|
||||
)
|
||||
|
||||
|
||||
def png_of_size(size: int) -> bytes:
|
||||
"""
|
||||
Валидный PNG ровно size байт: перед IEND вставляется chunk tEXt
|
||||
с корректным CRC нужной длины.
|
||||
"""
|
||||
base = png_bytes()
|
||||
iend = base[-12:]
|
||||
padding = size - len(base) - 12
|
||||
keyword = b"Comment\x00"
|
||||
text = png_chunk(b"tEXt", keyword + b"a" * (padding - len(keyword)))
|
||||
result = base[:-12] + text + iend
|
||||
assert len(result) == size
|
||||
return result
|
||||
|
||||
|
||||
def upload_headers(user: dict, content_type: str = "image/png") -> dict[str, str]:
|
||||
return {**auth(user), "Content-Type": content_type}
|
||||
|
||||
|
||||
def upload_raw(
|
||||
api: httpx.Client,
|
||||
user: dict,
|
||||
chat_id: str,
|
||||
content: bytes,
|
||||
content_type: str | None = "image/png",
|
||||
filename: str = "image.png",
|
||||
) -> httpx.Response:
|
||||
"""POST сырых байт; content_type=None — без заголовка Content-Type"""
|
||||
headers = auth(user) if content_type is None else upload_headers(user, content_type)
|
||||
return api.post(
|
||||
f"/api/v1/chats/{chat_id}/attachments",
|
||||
params={"filename": filename},
|
||||
content=content,
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
def assert_not_server_error(response: httpx.Response) -> None:
|
||||
"""Ошибка пользователя не превращается в 5xx и имеет формат контракта"""
|
||||
assert response.status_code < 500, response.text
|
||||
assert response.headers["X-Instance-Id"]
|
||||
|
||||
|
||||
def last_json_line(output: str) -> dict:
|
||||
"""Результат скрипта — последняя JSON-строка stdout; выше — журнал loguru"""
|
||||
return json.loads(
|
||||
next(line for line in reversed(output.splitlines()) if line.startswith("{"))
|
||||
)
|
||||
|
||||
|
||||
def container_json(service: str, script: str) -> dict:
|
||||
"""
|
||||
Python-скрипт внутри контейнера стенда: его сети, секреты и код из src.
|
||||
Скрипт печатает результат одной JSON-строкой.
|
||||
"""
|
||||
prelude = "import sys\nsys.path.insert(0, 'src')\n"
|
||||
output = compose("exec", "-T", service, "python", "-", stdin=prelude + script)
|
||||
return last_json_line(output)
|
||||
|
||||
|
||||
def run_janitor(*args: str) -> dict:
|
||||
"""Один проход janitor внутри его контейнера; отчёт сверки"""
|
||||
output = compose("exec", "-T", "janitor", "python", "src/janitor.py", "--once", *args)
|
||||
return last_json_line(output)
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
"""
|
||||
Upload → остановка именно той API-реплики, что приняла файл → download через
|
||||
другую реплику возвращает тот же файл. На репликах нет локальной копии
|
||||
оригинала: байты лежат в общем S3.
|
||||
|
||||
Останавливает контейнер (scripts/stop-one.sh) и возвращает его
|
||||
(scripts/restore.sh), поэтому запускается явно: make test-failures.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from helpers import ROOT, auth, png_bytes, upload_raw
|
||||
|
||||
pytestmark = pytest.mark.skipif(
|
||||
os.environ.get("RUN_FAILURE_TESTS") != "1",
|
||||
reason="останавливает API-реплику: запускайте через make test-failures",
|
||||
)
|
||||
|
||||
DOWNLOADS_AFTER_STOP = 10
|
||||
HOOK_TIMEOUT_SEC = 90
|
||||
|
||||
|
||||
def run_script(name: str, **env: str) -> None:
|
||||
subprocess.run(
|
||||
[str(ROOT / "scripts" / name)],
|
||||
cwd=ROOT,
|
||||
env={**os.environ, **env},
|
||||
capture_output=True,
|
||||
timeout=HOOK_TIMEOUT_SEC,
|
||||
check=True,
|
||||
)
|
||||
|
||||
|
||||
def test_download_survives_stop_of_uploading_replica(
|
||||
api: httpx.Client, make_user, make_chat
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
bob = make_user("bob")
|
||||
chat = make_chat(alice, [alice, bob])
|
||||
content = png_bytes(800, 600, noise=True)
|
||||
|
||||
uploaded = upload_raw(api, alice, chat["id"], content)
|
||||
assert uploaded.status_code == 201, uploaded.text
|
||||
attachment = uploaded.json()
|
||||
uploader = uploaded.headers["X-Instance-Id"]
|
||||
|
||||
run_script("stop-one.sh", TARGET_INSTANCE_ID=uploader)
|
||||
try:
|
||||
served_by = set()
|
||||
for _ in range(DOWNLOADS_AFTER_STOP):
|
||||
response = api.get(
|
||||
f"/api/v1/attachments/{attachment['id']}/content", headers=auth(bob)
|
||||
)
|
||||
assert response.status_code == 200, response.text
|
||||
assert hashlib.sha256(response.content).hexdigest() == attachment["sha256"]
|
||||
assert response.content == content
|
||||
served_by.add(response.headers["X-Instance-Id"])
|
||||
print(f"\nUPLOADED BY {uploader}, DOWNLOADED FROM {sorted(served_by)}")
|
||||
assert uploader not in served_by
|
||||
finally:
|
||||
run_script("restore.sh")
|
||||
@@ -0,0 +1,384 @@
|
||||
"""
|
||||
Вложения: загрузка, побайтное скачивание, доступ, лимиты и проверка содержимого.
|
||||
Любая ошибка пользователя — 4xx в формате контракта, никогда не 5xx.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import uuid
|
||||
from urllib.parse import unquote
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from helpers import (
|
||||
FIXTURE_PNG,
|
||||
MAX_IMAGE_PIXELS,
|
||||
MAX_UPLOAD_BYTES,
|
||||
assert_error,
|
||||
assert_not_server_error,
|
||||
auth,
|
||||
bilevel_png,
|
||||
jpeg_bytes,
|
||||
png_bytes,
|
||||
png_of_size,
|
||||
upload_raw,
|
||||
)
|
||||
|
||||
ATTACHMENT_FIELDS = {
|
||||
"id",
|
||||
"chat_id",
|
||||
"owner_id",
|
||||
"filename",
|
||||
"content_type",
|
||||
"size_bytes",
|
||||
"sha256",
|
||||
"status",
|
||||
"variants",
|
||||
"error_code",
|
||||
"created_at",
|
||||
"updated_at",
|
||||
}
|
||||
|
||||
|
||||
def download(api: httpx.Client, user: dict, attachment_id: str) -> httpx.Response:
|
||||
return api.get(f"/api/v1/attachments/{attachment_id}/content", headers=auth(user))
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("content", "content_type"),
|
||||
[
|
||||
(FIXTURE_PNG.read_bytes(), "image/png"),
|
||||
(jpeg_bytes(640, 480), "image/jpeg"),
|
||||
(jpeg_bytes(640, 480, progressive=True), "image/jpeg"),
|
||||
],
|
||||
ids=["png-fixture", "jpeg-baseline", "jpeg-progressive"],
|
||||
)
|
||||
def test_upload_and_download_byte_exact(
|
||||
api: httpx.Client, make_user, make_chat, upload, content: bytes, content_type: str
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
bob = make_user("bob")
|
||||
chat = make_chat(alice, [alice, bob])
|
||||
|
||||
attachment = upload(alice, chat, content, content_type, "photo")
|
||||
|
||||
assert set(attachment) == ATTACHMENT_FIELDS
|
||||
assert attachment["status"] == "ready"
|
||||
assert attachment["variants"] == [] and attachment["error_code"] is None
|
||||
assert attachment["chat_id"] == chat["id"] and attachment["owner_id"] == alice["id"]
|
||||
assert attachment["content_type"] == content_type
|
||||
assert attachment["size_bytes"] == len(content)
|
||||
assert attachment["sha256"] == hashlib.sha256(content).hexdigest()
|
||||
assert attachment["created_at"].endswith("Z")
|
||||
|
||||
metadata = api.get(f"/api/v1/attachments/{attachment['id']}", headers=auth(bob))
|
||||
assert metadata.status_code == 200 and metadata.json() == attachment
|
||||
|
||||
response = download(api, bob, attachment["id"])
|
||||
assert response.status_code == 200
|
||||
assert response.content == content
|
||||
assert response.headers["content-type"] == content_type
|
||||
assert response.headers["content-length"] == str(len(content))
|
||||
assert response.headers["x-content-type-options"] == "nosniff"
|
||||
assert response.headers["X-Instance-Id"]
|
||||
|
||||
|
||||
def test_public_api_does_not_expose_storage_details(
|
||||
api: httpx.Client, make_user, make_chat, upload
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
attachment = upload(alice, chat)
|
||||
response = download(api, alice, attachment["id"])
|
||||
exposed = (str(attachment) + str(dict(response.headers))).lower()
|
||||
for marker in ("originals/", "s3:9000", "messenger-attachments", "amz"):
|
||||
assert marker not in exposed
|
||||
assert response.status_code == 200
|
||||
assert not response.history, "download must not redirect to storage"
|
||||
|
||||
|
||||
def test_unicode_filename_is_preserved(
|
||||
api: httpx.Client, make_user, make_chat, upload
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
name = "Фото отпуска 😀 «море» — 1.png"
|
||||
attachment = upload(alice, chat, filename=name)
|
||||
assert attachment["filename"] == name
|
||||
disposition = download(api, alice, attachment["id"]).headers["content-disposition"]
|
||||
assert disposition.startswith("inline; filename*=UTF-8''")
|
||||
assert unquote(disposition.split("''", 1)[1]) == name
|
||||
|
||||
|
||||
def test_outsider_and_unknown_get_indistinguishable_404(
|
||||
api: httpx.Client, make_user, make_chat, upload
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
eve = make_user("eve")
|
||||
chat = make_chat(alice, [alice])
|
||||
attachment = upload(alice, chat)
|
||||
|
||||
for suffix in ("", "/content"):
|
||||
foreign = api.get(f"/api/v1/attachments/{attachment['id']}{suffix}", headers=auth(eve))
|
||||
missing = api.get(f"/api/v1/attachments/{uuid.uuid4()}{suffix}", headers=auth(eve))
|
||||
assert_error(foreign, 404, "not_found")
|
||||
assert_error(missing, 404, "not_found")
|
||||
assert foreign.json()["error"]["message"] == missing.json()["error"]["message"]
|
||||
|
||||
|
||||
def test_outsider_cannot_upload_into_foreign_chat(
|
||||
api: httpx.Client, make_user, make_chat
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
eve = make_user("eve")
|
||||
chat = make_chat(alice, [alice])
|
||||
assert_error(upload_raw(api, eve, chat["id"], png_bytes()), 404, "not_found")
|
||||
assert_error(upload_raw(api, eve, str(uuid.uuid4()), png_bytes()), 404, "not_found")
|
||||
|
||||
|
||||
def test_authentication_is_required(api: httpx.Client, make_user, make_chat, upload) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
attachment = upload(alice, chat)
|
||||
anonymous = {"token": "x" * 43}
|
||||
for response in (
|
||||
api.post(
|
||||
f"/api/v1/chats/{chat['id']}/attachments",
|
||||
params={"filename": "a.png"},
|
||||
content=png_bytes(),
|
||||
headers={"Content-Type": "image/png"},
|
||||
),
|
||||
api.get(f"/api/v1/attachments/{attachment['id']}"),
|
||||
download(api, anonymous, attachment["id"]),
|
||||
):
|
||||
assert_error(response, 401, "unauthorized")
|
||||
|
||||
|
||||
def test_variants_and_malformed_ids(api: httpx.Client, make_user, make_chat, upload) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
attachment = upload(alice, chat)
|
||||
path = f"/api/v1/attachments/{attachment['id']}/content"
|
||||
|
||||
original = api.get(path, params={"variant": "original"}, headers=auth(alice))
|
||||
assert original.status_code == 200
|
||||
# Вариант из контракта, но в lab4 его нет у ready-вложения
|
||||
missing = api.get(path, params={"variant": "thumbnail"}, headers=auth(alice))
|
||||
assert_error(missing, 404, "not_found")
|
||||
unknown = api.get(path, params={"variant": "../../etc"}, headers=auth(alice))
|
||||
assert_error(unknown, 400, "invalid_request")
|
||||
malformed = api.get("/api/v1/attachments/not-a-uuid", headers=auth(alice))
|
||||
assert_error(malformed, 400, "invalid_request")
|
||||
|
||||
|
||||
# --- Размер ---
|
||||
|
||||
|
||||
def test_exactly_max_bytes_is_accepted(api: httpx.Client, make_user, make_chat, upload) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
content = png_of_size(MAX_UPLOAD_BYTES)
|
||||
attachment = upload(alice, chat, content)
|
||||
assert attachment["size_bytes"] == MAX_UPLOAD_BYTES
|
||||
assert download(api, alice, attachment["id"]).content == content
|
||||
|
||||
|
||||
def test_too_large_file_is_rejected_by_api(api: httpx.Client, make_user, make_chat) -> None:
|
||||
"""10 MiB + 1 байт отклоняет реплика (X-Instance-Id), а не только LB"""
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = upload_raw(api, alice, chat["id"], png_of_size(MAX_UPLOAD_BYTES + 1))
|
||||
assert_error(response, 413, "payload_too_large")
|
||||
assert response.headers["X-Instance-Id"]
|
||||
|
||||
|
||||
def test_huge_body_is_rejected_by_balancer(api: httpx.Client, make_user, make_chat) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = upload_raw(api, alice, chat["id"], b"\x00" * (12 * 1024 * 1024))
|
||||
assert_error(response, 413, "payload_too_large")
|
||||
|
||||
|
||||
def test_empty_body_is_rejected(api: httpx.Client, make_user, make_chat) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
assert_error(upload_raw(api, alice, chat["id"], b""), 400, "invalid_request")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("width", "height", "status"),
|
||||
[
|
||||
(8000, 5000, 201),
|
||||
(8000, 5001, 413),
|
||||
(20000, 20000, 413),
|
||||
],
|
||||
)
|
||||
def test_pixel_limit_applies_before_decoding(
|
||||
api: httpx.Client, make_user, make_chat, width: int, height: int, status: int
|
||||
) -> None:
|
||||
"""Файл крошечный по байтам: лимит считается по заголовку, а не по размеру"""
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
content = bilevel_png(width, height)
|
||||
assert len(content) < 1024 * 1024
|
||||
response = upload_raw(api, alice, chat["id"], content)
|
||||
if status == 201:
|
||||
assert width * height == MAX_IMAGE_PIXELS
|
||||
assert response.status_code == 201, response.text
|
||||
else:
|
||||
assert_error(response, 413, "payload_too_large")
|
||||
|
||||
|
||||
# --- Содержимое и MIME ---
|
||||
|
||||
|
||||
def corrupted_payloads() -> list[tuple[str, bytes, str]]:
|
||||
png = png_bytes(300, 200, noise=True)
|
||||
jpeg = jpeg_bytes(300, 200)
|
||||
flipped = bytearray(png)
|
||||
flipped[len(png) // 2] ^= 0xFF
|
||||
return [
|
||||
("png-truncated", png[: len(png) // 2], "image/png"),
|
||||
("png-bit-flip-crc", bytes(flipped), "image/png"),
|
||||
("png-signature-garbage", png[:8] + b"\x00garbage" * 64, "image/png"),
|
||||
("png-without-iend", png[:-12], "image/png"),
|
||||
("jpeg-truncated", jpeg[: len(jpeg) // 2], "image/jpeg"),
|
||||
("jpeg-signature-garbage", b"\xff\xd8\xff" + b"garbage" * 64, "image/jpeg"),
|
||||
]
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("name", "content", "content_type"),
|
||||
corrupted_payloads(),
|
||||
ids=[item[0] for item in corrupted_payloads()],
|
||||
)
|
||||
def test_corrupted_image_is_rejected(
|
||||
api: httpx.Client, make_user, make_chat, name: str, content: bytes, content_type: str
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = upload_raw(api, alice, chat["id"], content, content_type)
|
||||
assert_not_server_error(response)
|
||||
assert_error(response, 415, "unsupported_media_type")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("content", "content_type"),
|
||||
[
|
||||
(png_bytes(), "image/jpeg"),
|
||||
(jpeg_bytes(), "image/png"),
|
||||
(b"GIF89a\x01\x00\x01\x00\x00\x00\x00;", "image/png"),
|
||||
(b"<svg xmlns='http://www.w3.org/2000/svg'/>", "image/png"),
|
||||
(b"%PDF-1.7\n", "image/jpeg"),
|
||||
(png_bytes(), "application/octet-stream"),
|
||||
(png_bytes(), "image/gif"),
|
||||
(png_bytes(), "text/html"),
|
||||
(png_bytes(), None),
|
||||
],
|
||||
ids=[
|
||||
"png-as-jpeg",
|
||||
"jpeg-as-png",
|
||||
"gif-as-png",
|
||||
"svg-as-png",
|
||||
"pdf-as-jpeg",
|
||||
"octet-stream",
|
||||
"image-gif",
|
||||
"text-html",
|
||||
"no-content-type",
|
||||
],
|
||||
)
|
||||
def test_mime_spoofing_is_rejected(
|
||||
api: httpx.Client, make_user, make_chat, content: bytes, content_type: str | None
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = upload_raw(api, alice, chat["id"], content, content_type)
|
||||
assert_not_server_error(response)
|
||||
assert_error(response, 415, "unsupported_media_type")
|
||||
|
||||
|
||||
def test_content_type_parameters_are_ignored(
|
||||
api: httpx.Client, make_user, make_chat
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = upload_raw(api, alice, chat["id"], png_bytes(), "Image/PNG; foo=bar")
|
||||
assert response.status_code == 201, response.text
|
||||
assert response.json()["content_type"] == "image/png"
|
||||
|
||||
|
||||
# --- Имя файла ---
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"filename",
|
||||
[
|
||||
"../../etc/passwd",
|
||||
"dir/photo.png",
|
||||
"C:\\photo.png",
|
||||
"a\x00b.png",
|
||||
"line\nbreak.png",
|
||||
"tab\t.png",
|
||||
"bell\x07.png",
|
||||
"photo\u202egnp.exe",
|
||||
"",
|
||||
" ",
|
||||
".",
|
||||
"..",
|
||||
"x" * 256,
|
||||
],
|
||||
ids=[
|
||||
"traversal",
|
||||
"slash",
|
||||
"backslash",
|
||||
"nul",
|
||||
"newline",
|
||||
"tab",
|
||||
"control",
|
||||
"bidi-override",
|
||||
"empty",
|
||||
"blank",
|
||||
"dot",
|
||||
"dotdot",
|
||||
"too-long",
|
||||
],
|
||||
)
|
||||
def test_dangerous_filename_is_rejected(
|
||||
api: httpx.Client, make_user, make_chat, filename: str
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = upload_raw(api, alice, chat["id"], png_bytes(), filename=filename)
|
||||
assert_not_server_error(response)
|
||||
assert_error(response, 400, "invalid_request")
|
||||
|
||||
|
||||
def test_missing_filename_is_rejected(api: httpx.Client, make_user, make_chat) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = api.post(
|
||||
f"/api/v1/chats/{chat['id']}/attachments",
|
||||
content=png_bytes(),
|
||||
headers={**auth(alice), "Content-Type": "image/png"},
|
||||
)
|
||||
assert_error(response, 400, "invalid_request")
|
||||
|
||||
|
||||
def test_longest_filename_is_accepted(make_user, make_chat, upload) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
name = "я" * 251 + ".png"
|
||||
assert upload(alice, chat, filename=name)["filename"] == name
|
||||
|
||||
|
||||
def test_same_filename_gets_separate_attachments(
|
||||
api: httpx.Client, make_user, make_chat, upload
|
||||
) -> None:
|
||||
"""filename — только отображение: одинаковые имена не перезаписывают файл"""
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
first_content, second_content = png_bytes(10, 10), png_bytes(20, 20)
|
||||
first = upload(alice, chat, first_content, filename="same.png")
|
||||
second = upload(alice, chat, second_content, filename="same.png")
|
||||
assert first["id"] != second["id"]
|
||||
assert download(api, alice, first["id"]).content == first_content
|
||||
assert download(api, alice, second["id"]).content == second_content
|
||||
@@ -0,0 +1,166 @@
|
||||
"""
|
||||
Сообщения с attachment_ids: вложение только своего чата, порядок, пустой
|
||||
текст, идемпотентность; при любом отказе сообщение не появляется.
|
||||
"""
|
||||
|
||||
import uuid
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from helpers import (
|
||||
assert_error,
|
||||
assert_not_server_error,
|
||||
auth,
|
||||
message_headers,
|
||||
png_bytes,
|
||||
read_all_messages,
|
||||
)
|
||||
|
||||
|
||||
def history(api: httpx.Client, user: dict, chat: dict) -> list[dict]:
|
||||
items, _ = read_all_messages(api, user, chat["id"], 100)
|
||||
return items
|
||||
|
||||
|
||||
def test_message_with_attachment_is_readable_by_members(
|
||||
api: httpx.Client, make_user, make_chat, upload, send_attachments
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
bob = make_user("bob")
|
||||
chat = make_chat(alice, [alice, bob])
|
||||
attachment = upload(alice, chat)
|
||||
|
||||
response = send_attachments(alice, chat, [attachment["id"]])
|
||||
assert response.status_code == 201, response.text
|
||||
message = response.json()
|
||||
assert message["text"] == "" and message["attachment_ids"] == [attachment["id"]]
|
||||
|
||||
assert history(api, bob, chat) == [message]
|
||||
content = api.get(
|
||||
f"/api/v1/attachments/{attachment['id']}/content", headers=auth(bob)
|
||||
)
|
||||
assert content.status_code == 200
|
||||
|
||||
|
||||
def test_any_member_may_reference_chat_attachment_and_order_is_kept(
|
||||
make_user, make_chat, upload, send_attachments
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
bob = make_user("bob")
|
||||
chat = make_chat(alice, [alice, bob])
|
||||
ids = [upload(alice, chat, png_bytes(i + 1, i + 1))["id"] for i in range(10)]
|
||||
reordered = list(reversed(ids))
|
||||
|
||||
response = send_attachments(bob, chat, reordered, text="от Боба")
|
||||
assert response.status_code == 201, response.text
|
||||
assert response.json()["attachment_ids"] == reordered
|
||||
|
||||
|
||||
def test_text_message_has_empty_attachment_ids(make_user, make_chat, send_message) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
assert send_message(alice, chat, "только текст")["attachment_ids"] == []
|
||||
|
||||
|
||||
def test_attachment_of_other_chat_is_rejected(
|
||||
api: httpx.Client, make_user, make_chat, upload, send_attachments
|
||||
) -> None:
|
||||
"""Алиса — участник обоих чатов, но файл привязан к другому чату"""
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice], title="Чат A")
|
||||
other = make_chat(alice, [alice], title="Чат B")
|
||||
foreign = upload(alice, other)
|
||||
own = upload(alice, chat)
|
||||
|
||||
for ids in ([foreign["id"]], [own["id"], foreign["id"]]):
|
||||
response = send_attachments(alice, chat, ids, text="чужой файл")
|
||||
assert_not_server_error(response)
|
||||
assert_error(response, 404, "not_found")
|
||||
assert history(api, alice, chat) == []
|
||||
|
||||
|
||||
def test_foreign_attachment_id_is_rejected(
|
||||
api: httpx.Client, make_user, make_chat, upload, send_attachments
|
||||
) -> None:
|
||||
"""Вложение из чата, где пользователь не участник, и несуществующее — 404"""
|
||||
alice = make_user("alice")
|
||||
eve = make_user("eve")
|
||||
chat = make_chat(alice, [alice])
|
||||
eve_chat = make_chat(eve, [eve])
|
||||
eve_attachment = upload(eve, eve_chat)
|
||||
|
||||
foreign = send_attachments(alice, chat, [eve_attachment["id"]])
|
||||
missing = send_attachments(alice, chat, [str(uuid.uuid4())])
|
||||
assert_error(foreign, 404, "not_found")
|
||||
assert_error(missing, 404, "not_found")
|
||||
assert foreign.json()["error"]["message"] == missing.json()["error"]["message"]
|
||||
assert history(api, alice, chat) == []
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"body",
|
||||
[
|
||||
{"text": ""},
|
||||
{"text": " "},
|
||||
{"text": "", "attachment_ids": []},
|
||||
{"text": "x", "attachment_ids": ["not-a-uuid"]},
|
||||
{"text": "x", "attachment_ids": "a"},
|
||||
{"text": "x", "attachment_ids": None},
|
||||
{"text": "x", "attachment_ids": [str(uuid.uuid4())] * 2},
|
||||
{"text": "x", "attachment_ids": [str(uuid.uuid4()) for _ in range(11)]},
|
||||
],
|
||||
ids=[
|
||||
"empty-text",
|
||||
"blank-text",
|
||||
"empty-both",
|
||||
"bad-uuid",
|
||||
"not-array",
|
||||
"null",
|
||||
"duplicates",
|
||||
"too-many",
|
||||
],
|
||||
)
|
||||
def test_invalid_attachment_ids_are_rejected(
|
||||
api: httpx.Client, make_user, make_chat, body: dict
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
response = api.post(
|
||||
f"/api/v1/chats/{chat['id']}/messages", json=body, headers=message_headers(alice)
|
||||
)
|
||||
assert_error(response, 400, "invalid_request")
|
||||
|
||||
|
||||
def test_idempotent_replay_with_attachments(
|
||||
api: httpx.Client, make_user, make_chat, upload, send_attachments
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
first, second = upload(alice, chat), upload(alice, chat)
|
||||
key = uuid.uuid4().hex
|
||||
|
||||
created = send_attachments(alice, chat, [first["id"]], key=key)
|
||||
replay = send_attachments(alice, chat, [first["id"]], key=key)
|
||||
assert created.status_code == replay.status_code == 201
|
||||
assert created.json() == replay.json()
|
||||
|
||||
changed = send_attachments(alice, chat, [first["id"], second["id"]], key=key)
|
||||
assert_error(changed, 409, "conflict")
|
||||
assert history(api, alice, chat) == [created.json()]
|
||||
|
||||
|
||||
def test_missing_attachment_ids_equals_empty_list_for_idempotency(
|
||||
api: httpx.Client, make_user, make_chat
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
key = uuid.uuid4().hex
|
||||
path = f"/api/v1/chats/{chat['id']}/messages"
|
||||
first = api.post(path, json={"text": "a"}, headers=message_headers(alice, key))
|
||||
second = api.post(
|
||||
path,
|
||||
json={"attachment_ids": [], "text": "a"},
|
||||
headers=message_headers(alice, key),
|
||||
)
|
||||
assert first.status_code == second.status_code == 201
|
||||
assert first.json() == second.json()
|
||||
@@ -0,0 +1,188 @@
|
||||
"""
|
||||
Согласованность S3 и PostgreSQL на живом стенде.
|
||||
|
||||
Сбои внедряются напрямую в хранилища: строка pending с объектом — процесс
|
||||
упал между PUT в S3 и подтверждением в БД; объект без строки — сирота.
|
||||
Затем janitor (тот же код и ключи, что в сервисе janitor) выполняет проход
|
||||
с коротким grace period. Обрыв загрузки идёт напрямую в API-реплику, минуя
|
||||
буферизацию nginx.
|
||||
|
||||
Запуск явно: make test-storage (RUN_STORAGE_TESTS=1).
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
import uuid
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from helpers import auth, container_json, png_bytes, psql, run_janitor
|
||||
|
||||
pytestmark = pytest.mark.skipif(
|
||||
os.environ.get("RUN_STORAGE_TESTS") != "1",
|
||||
reason="меняет данные стенда напрямую: запускайте через make test-storage",
|
||||
)
|
||||
|
||||
# Запас на время docker exec janitor (импорт кода под лимитом CPU 0.25)
|
||||
GRACE_SECONDS = 20
|
||||
STALE_ROW_AGE_SECONDS = 300
|
||||
|
||||
PUT_OBJECTS = """
|
||||
import asyncio, json
|
||||
from infrastructure.dependencies import storage_manager
|
||||
|
||||
async def main():
|
||||
s3 = await storage_manager.create_client()
|
||||
for key in {keys!r}:
|
||||
await s3.put_object(Bucket=storage_manager.bucket, Key=key, Body=b"x")
|
||||
await storage_manager.close()
|
||||
print(json.dumps({{"put": len({keys!r})}}))
|
||||
|
||||
asyncio.run(main())
|
||||
"""
|
||||
|
||||
EXISTING_OBJECTS = """
|
||||
import asyncio, json
|
||||
from infrastructure.dependencies import storage_manager
|
||||
|
||||
async def main():
|
||||
s3 = await storage_manager.create_client()
|
||||
found = {{}}
|
||||
for key in {keys!r}:
|
||||
try:
|
||||
await s3.head_object(Bucket=storage_manager.bucket, Key=key)
|
||||
found[key] = True
|
||||
except Exception:
|
||||
found[key] = False
|
||||
await storage_manager.close()
|
||||
print(json.dumps(found))
|
||||
|
||||
asyncio.run(main())
|
||||
"""
|
||||
|
||||
|
||||
def put_objects(*keys: str) -> None:
|
||||
container_json("janitor", PUT_OBJECTS.format(keys=list(keys)))
|
||||
|
||||
|
||||
def existing_objects(*keys: str) -> dict[str, bool]:
|
||||
return container_json("janitor", EXISTING_OBJECTS.format(keys=list(keys)))
|
||||
|
||||
|
||||
def insert_pending(chat: dict, owner: dict, key: str, age_seconds: int) -> None:
|
||||
"""Строка, какую оставляет падение API между PUT и подтверждением"""
|
||||
psql(
|
||||
f"""
|
||||
INSERT INTO attachments
|
||||
(chat_id, owner_id, filename, content_type, size_bytes, sha256,
|
||||
object_key, status, created_at, updated_at)
|
||||
VALUES
|
||||
('{chat["id"]}', '{owner["id"]}', 'crash.png', 'image/png', 1,
|
||||
sha256('x'), '{key}', 'pending',
|
||||
clock_timestamp() - make_interval(secs => {age_seconds}),
|
||||
clock_timestamp());
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
def row_status(key: str) -> str:
|
||||
return psql(f"SELECT coalesce(max(status), 'absent') FROM attachments WHERE object_key = '{key}';")
|
||||
|
||||
|
||||
def test_janitor_cleans_only_stale_unaccounted_data(
|
||||
api: httpx.Client, make_user, make_chat, upload, send_attachments
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
ready = upload(alice, chat, png_bytes(12, 12))
|
||||
linked = upload(alice, chat, png_bytes(13, 13))
|
||||
assert send_attachments(alice, chat, [linked["id"]]).status_code == 201
|
||||
|
||||
run_id = uuid.uuid4().hex
|
||||
crashed = f"originals/test-crashed-{run_id}"
|
||||
crashed_no_object = f"originals/test-crashed-before-put-{run_id}"
|
||||
orphan_old = f"originals/test-orphan-old-{run_id}"
|
||||
fresh_pending = f"originals/test-fresh-pending-{run_id}"
|
||||
orphan_fresh = f"originals/test-orphan-fresh-{run_id}"
|
||||
|
||||
# «Старые» сбои: строка старше grace по часам БД, объект — по времени ожидания.
|
||||
# Возраст меньше grace фонового сервиса janitor (900 с): строки забирает
|
||||
# только проход теста, без гонки с сервисом
|
||||
insert_pending(chat, alice, crashed, age_seconds=STALE_ROW_AGE_SECONDS)
|
||||
insert_pending(chat, alice, crashed_no_object, age_seconds=STALE_ROW_AGE_SECONDS)
|
||||
put_objects(crashed, orphan_old)
|
||||
time.sleep(GRACE_SECONDS + 2)
|
||||
|
||||
dry = run_janitor("--dry-run", "--grace-seconds", str(GRACE_SECONDS))
|
||||
assert dry["unfinished_claimed"] >= 2 and dry["orphan_objects_found"] >= 1
|
||||
assert existing_objects(crashed, orphan_old) == {crashed: True, orphan_old: True}
|
||||
|
||||
# «Свежие»: загрузка, которая могла бы ещё идти
|
||||
insert_pending(chat, alice, fresh_pending, age_seconds=0)
|
||||
put_objects(fresh_pending, orphan_fresh)
|
||||
report = run_janitor("--grace-seconds", str(GRACE_SECONDS))
|
||||
print("\nJANITOR REPORT:", json.dumps(report))
|
||||
|
||||
assert existing_objects(crashed, orphan_old, fresh_pending, orphan_fresh) == {
|
||||
crashed: False,
|
||||
orphan_old: False,
|
||||
fresh_pending: True,
|
||||
orphan_fresh: True,
|
||||
}
|
||||
assert row_status(crashed) == row_status(crashed_no_object) == "absent"
|
||||
assert row_status(fresh_pending) == "pending"
|
||||
|
||||
# Готовые вложения (в том числе привязанные к сообщению) не тронуты
|
||||
for attachment in (ready, linked):
|
||||
response = api.get(
|
||||
f"/api/v1/attachments/{attachment['id']}/content", headers=auth(alice)
|
||||
)
|
||||
assert response.status_code == 200
|
||||
|
||||
# Свежие данные становятся «старыми» и тоже убираются
|
||||
time.sleep(GRACE_SECONDS + 1)
|
||||
run_janitor("--grace-seconds", str(GRACE_SECONDS))
|
||||
assert existing_objects(fresh_pending, orphan_fresh) == {
|
||||
fresh_pending: False,
|
||||
orphan_fresh: False,
|
||||
}
|
||||
assert row_status(fresh_pending) == "absent"
|
||||
again = run_janitor("--dry-run", "--grace-seconds", str(GRACE_SECONDS))
|
||||
assert again["orphan_objects_found"] == 0
|
||||
|
||||
|
||||
INTERRUPTED_UPLOAD = """
|
||||
import json, socket
|
||||
body = {body!r}
|
||||
request = (
|
||||
"POST /api/v1/chats/{chat_id}/attachments?filename=cut.png HTTP/1.1\\r\\n"
|
||||
"Host: api\\r\\n"
|
||||
"Authorization: Bearer {token}\\r\\n"
|
||||
"Content-Type: image/png\\r\\n"
|
||||
"Content-Length: " + str(len(body)) + "\\r\\n\\r\\n"
|
||||
).encode()
|
||||
sent = 0
|
||||
with socket.create_connection(("api", 8080), timeout=5) as connection:
|
||||
connection.sendall(request)
|
||||
connection.sendall(body[: len(body) // 3])
|
||||
sent = len(body) // 3
|
||||
print(json.dumps({{"sent": sent, "declared": len(body)}}))
|
||||
"""
|
||||
|
||||
|
||||
def test_interrupted_upload_leaves_nothing(make_user, make_chat) -> None:
|
||||
"""Клиент оборвал соединение посреди тела, прямо к реплике API"""
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
body = list(png_bytes(400, 400, noise=True))
|
||||
result = container_json(
|
||||
"janitor",
|
||||
INTERRUPTED_UPLOAD.format(
|
||||
body=bytes(body), chat_id=chat["id"], token=alice["token"]
|
||||
),
|
||||
)
|
||||
assert 0 < result["sent"] < result["declared"]
|
||||
time.sleep(1)
|
||||
rows = psql(f"SELECT count(*) FROM attachments WHERE chat_id = '{chat['id']}';")
|
||||
assert rows == "0"
|
||||
@@ -0,0 +1,99 @@
|
||||
"""
|
||||
Недоступность S3: контейнер s3 останавливается через docker compose
|
||||
(volume сохраняется), затем запускается снова.
|
||||
|
||||
Ожидаемое поведение: загрузка и скачивание — быстрый 503 в формате контракта,
|
||||
readiness — 503 (вложения входят в обязательный путь lab4), но метаданные
|
||||
и сообщения продолжают работать: nginx не исключает реплики по readiness.
|
||||
После восстановления незавершённых строк не остаётся: компенсация или
|
||||
janitor их дочищают.
|
||||
|
||||
Запуск явно: make test-s3-failure (RUN_FAILURE_TESTS=1).
|
||||
"""
|
||||
|
||||
import os
|
||||
import time
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from helpers import (
|
||||
assert_error,
|
||||
auth,
|
||||
compose,
|
||||
png_bytes,
|
||||
psql,
|
||||
run_janitor,
|
||||
upload_raw,
|
||||
)
|
||||
|
||||
pytestmark = pytest.mark.skipif(
|
||||
os.environ.get("RUN_FAILURE_TESTS") != "1",
|
||||
reason="останавливает контейнер s3: запускайте через make test-s3-failure",
|
||||
)
|
||||
|
||||
# connect timeout 2 с × 2 попытки + проверка изображения
|
||||
BOUNDED_RESPONSE_SEC = 6
|
||||
READY_TIMEOUT_SEC = 60
|
||||
|
||||
|
||||
def unfinished_rows(chat_id: str) -> int:
|
||||
return int(
|
||||
psql(
|
||||
f"SELECT count(*) FROM attachments "
|
||||
f"WHERE chat_id = '{chat_id}' AND status <> 'ready';"
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def wait_upload_works(api: httpx.Client, user: dict, chat_id: str) -> httpx.Response:
|
||||
deadline = time.monotonic() + READY_TIMEOUT_SEC
|
||||
while True:
|
||||
response = upload_raw(api, user, chat_id, png_bytes())
|
||||
if response.status_code == 201 or time.monotonic() > deadline:
|
||||
return response
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def test_s3_outage_is_isolated_and_leaves_no_garbage(
|
||||
api: httpx.Client, make_user, make_chat, upload, send_attachments
|
||||
) -> None:
|
||||
alice = make_user("alice")
|
||||
bob = make_user("bob")
|
||||
chat = make_chat(alice, [alice, bob])
|
||||
before = upload(alice, chat)
|
||||
|
||||
compose("stop", "s3")
|
||||
try:
|
||||
started = time.monotonic()
|
||||
failed_upload = upload_raw(api, alice, chat["id"], png_bytes(64, 64))
|
||||
elapsed = time.monotonic() - started
|
||||
assert_error(failed_upload, 503, "unavailable")
|
||||
assert elapsed < BOUNDED_RESPONSE_SEC, elapsed
|
||||
assert "s3" not in failed_upload.json()["error"]["message"].lower()
|
||||
|
||||
download = api.get(
|
||||
f"/api/v1/attachments/{before['id']}/content", headers=auth(bob)
|
||||
)
|
||||
assert_error(download, 503, "unavailable")
|
||||
|
||||
# Путь без байтов S3 работает: метаданные и сообщения
|
||||
metadata = api.get(f"/api/v1/attachments/{before['id']}", headers=auth(bob))
|
||||
assert metadata.status_code == 200 and metadata.json() == before
|
||||
message = send_attachments(alice, chat, [before["id"]], text="S3 лежит")
|
||||
assert message.status_code == 201, message.text
|
||||
assert api.get("/health/live").status_code == 200
|
||||
started = time.monotonic()
|
||||
assert_error(api.get("/health/ready"), 503, "unavailable")
|
||||
assert time.monotonic() - started < BOUNDED_RESPONSE_SEC
|
||||
finally:
|
||||
compose("up", "-d", "--wait", "s3")
|
||||
|
||||
after = wait_upload_works(api, alice, chat["id"])
|
||||
assert after.status_code == 201, after.text
|
||||
content = api.get(f"/api/v1/attachments/{before['id']}/content", headers=auth(bob))
|
||||
assert content.status_code == 200
|
||||
|
||||
# Компенсация не смогла удалить объект при лежащем S3: строка deleting
|
||||
# дочищается janitor независимо от grace period
|
||||
run_janitor()
|
||||
assert unfinished_rows(chat["id"]) == 0
|
||||
@@ -0,0 +1,157 @@
|
||||
"""
|
||||
Защита хранилища вне API: приватный bucket, ограниченные ключи API,
|
||||
закрытые административные интерфейсы, идемпотентный bootstrap.
|
||||
|
||||
Проверки заходят внутрь контейнеров стенда (docker compose exec/run),
|
||||
поэтому запускаются явно: make test-storage (RUN_STORAGE_TESTS=1).
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from helpers import ROOT, auth, compose, container_json
|
||||
|
||||
pytestmark = pytest.mark.skipif(
|
||||
os.environ.get("RUN_STORAGE_TESTS") != "1",
|
||||
reason="заходит в контейнеры стенда: запускайте через make test-storage",
|
||||
)
|
||||
|
||||
# Порты SeaweedFS кроме S3: master, volume, filer (HTTP с веб-интерфейсами
|
||||
# и gRPC). Они слушают только loopback контейнера s3.
|
||||
ADMIN_PORTS = (9333, 19333, 8080, 18080, 8888, 18888, 8181, 9101)
|
||||
|
||||
|
||||
def test_anonymous_s3_access_is_denied(api: httpx.Client, make_user, make_chat, upload) -> None:
|
||||
"""Прямой неподписанный GET объекта (ключ известен) и списка bucket — 403"""
|
||||
alice = make_user("alice")
|
||||
chat = make_chat(alice, [alice])
|
||||
attachment = upload(alice, chat)
|
||||
object_key = compose(
|
||||
"exec",
|
||||
"-T",
|
||||
"postgres",
|
||||
"sh",
|
||||
"-c",
|
||||
'psql -X -q -tA -U "$POSTGRES_USER" -d "$POSTGRES_DB" -c '
|
||||
f"\"SELECT object_key FROM attachments WHERE id = '{attachment['id']}'\"",
|
||||
).strip()
|
||||
assert object_key.startswith("originals/")
|
||||
|
||||
result = container_json(
|
||||
"api",
|
||||
f"""
|
||||
import json, urllib.error, urllib.request
|
||||
from config import S3_BUCKET, S3_ENDPOINT
|
||||
codes = {{}}
|
||||
for name, path in {{
|
||||
"object": "/" + S3_BUCKET + "/{object_key}",
|
||||
"bucket_list": "/" + S3_BUCKET,
|
||||
"service": "/",
|
||||
}}.items():
|
||||
try:
|
||||
with urllib.request.urlopen(S3_ENDPOINT + path, timeout=3) as response:
|
||||
codes[name] = response.status
|
||||
except urllib.error.HTTPError as error:
|
||||
codes[name] = error.code
|
||||
print(json.dumps(codes))
|
||||
""",
|
||||
)
|
||||
assert result == {"object": 403, "bucket_list": 403, "service": 403}
|
||||
# Через API участник по-прежнему скачивает файл
|
||||
content = api.get(f"/api/v1/attachments/{attachment['id']}/content", headers=auth(alice))
|
||||
assert content.status_code == 200
|
||||
|
||||
|
||||
def test_api_credentials_are_limited_to_own_bucket_objects() -> None:
|
||||
"""Ключи API: объекты своего bucket — да; bucket, политика, ACL — нет"""
|
||||
result = container_json(
|
||||
"api",
|
||||
"""
|
||||
import asyncio, json
|
||||
from infrastructure.dependencies import storage_manager
|
||||
from infrastructure.utils import storage_error_code
|
||||
|
||||
async def attempt(name, call, results):
|
||||
try:
|
||||
await call
|
||||
results[name] = "allowed"
|
||||
except Exception as error:
|
||||
results[name] = storage_error_code(error)
|
||||
|
||||
async def main():
|
||||
s3 = await storage_manager.create_client()
|
||||
bucket = storage_manager.bucket
|
||||
key = "originals/security-probe"
|
||||
policy = json.dumps({"Version": "2012-10-17", "Statement": [{"Effect": "Allow",
|
||||
"Principal": "*", "Action": "s3:GetObject",
|
||||
"Resource": "arn:aws:s3:::" + bucket + "/*"}]})
|
||||
results = {}
|
||||
await attempt("put_object", s3.put_object(Bucket=bucket, Key=key, Body=b"x"), results)
|
||||
await attempt("get_object", s3.get_object(Bucket=bucket, Key=key), results)
|
||||
await attempt("delete_object", s3.delete_object(Bucket=bucket, Key=key), results)
|
||||
await attempt("create_bucket", s3.create_bucket(Bucket="intruder-bucket"), results)
|
||||
await attempt("delete_bucket", s3.delete_bucket(Bucket=bucket), results)
|
||||
await attempt("put_bucket_policy", s3.put_bucket_policy(Bucket=bucket, Policy=policy), results)
|
||||
await attempt("put_bucket_acl", s3.put_bucket_acl(Bucket=bucket, ACL="public-read"), results)
|
||||
await storage_manager.close()
|
||||
print(json.dumps(results))
|
||||
|
||||
asyncio.run(main())
|
||||
""",
|
||||
)
|
||||
assert result["put_object"] == result["get_object"] == "allowed"
|
||||
assert result["delete_object"] == "allowed"
|
||||
for forbidden in ("create_bucket", "delete_bucket", "put_bucket_policy", "put_bucket_acl"):
|
||||
assert result[forbidden] == "AccessDenied", result
|
||||
|
||||
|
||||
def test_api_container_has_no_admin_credentials() -> None:
|
||||
files = compose("exec", "-T", "api", "ls", "/run/secrets").split()
|
||||
assert sorted(files) == ["s3_access_key_id", "s3_secret_access_key"]
|
||||
|
||||
|
||||
def test_admin_interfaces_are_not_reachable() -> None:
|
||||
"""Из сети storage открыт только S3 API; наружу стенда S3 не опубликован"""
|
||||
result = container_json(
|
||||
"api",
|
||||
f"""
|
||||
import json, socket
|
||||
state = {{}}
|
||||
for port in (9000,) + {ADMIN_PORTS!r}:
|
||||
try:
|
||||
socket.create_connection(("s3", port), timeout=2).close()
|
||||
state[port] = "open"
|
||||
except OSError as error:
|
||||
state[port] = type(error).__name__
|
||||
print(json.dumps(state))
|
||||
""",
|
||||
)
|
||||
assert result.pop("9000") == "open"
|
||||
assert all(value != "open" for value in result.values()), result
|
||||
|
||||
for line in compose("ps", "--format", "json", "s3").splitlines():
|
||||
publishers = json.loads(line)["Publishers"] or []
|
||||
assert all(item["PublishedPort"] == 0 for item in publishers), publishers
|
||||
|
||||
|
||||
def test_balancer_network_cannot_reach_storage() -> None:
|
||||
"""nginx (сеть edge) не видит S3: клиентский трафик идёт только через API"""
|
||||
result = subprocess.run(
|
||||
["docker", "compose", "--env-file", ".env", "exec", "-T", "nginx",
|
||||
"wget", "-q", "-T", "2", "-O", "/dev/null", "http://s3:9000/"],
|
||||
cwd=ROOT,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=30,
|
||||
)
|
||||
assert result.returncode != 0
|
||||
|
||||
|
||||
def test_bucket_bootstrap_is_idempotent() -> None:
|
||||
for _ in range(2):
|
||||
output = compose("run", "--rm", "--no-deps", "s3-bootstrap")
|
||||
assert "уже существует" in output
|
||||
assert "приватен" in output
|
||||
@@ -0,0 +1,12 @@
|
||||
"""
|
||||
Unit-тесты слоя сервисов без стенда: зависимости заменены фейками интерфейсов.
|
||||
Конфигурация берётся из .env.example; сеть, PostgreSQL и S3 не нужны.
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
os.environ["ENV_FILE"] = str(ROOT / ".env.example")
|
||||
sys.path.insert(0, str(ROOT / "src"))
|
||||
@@ -0,0 +1,219 @@
|
||||
"""
|
||||
In-memory реализации интерфейсов с внедрением отказов.
|
||||
|
||||
fail — имена методов, которые бросают UnavailableError (как репозитории
|
||||
при недоступной БД/S3); hang — методы, которые зависают.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import io
|
||||
from collections.abc import AsyncIterator
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import BinaryIO
|
||||
from uuid import UUID, uuid4
|
||||
|
||||
from domain import (
|
||||
AttachmentSchema,
|
||||
AttachmentStatus,
|
||||
ChatSchema,
|
||||
NewAttachmentSchema,
|
||||
PageKey,
|
||||
StoredAttachmentSchema,
|
||||
UnfinishedUploadSchema,
|
||||
)
|
||||
from domain.errors import UnavailableError
|
||||
from interfaces import AttachmentRepository, ChatRepository, ObjectStorage, StoredObject
|
||||
|
||||
HANG_SEC = 3600
|
||||
|
||||
|
||||
class FaultInjection:
|
||||
def __init__(self) -> None:
|
||||
self.fail: set[str] = set()
|
||||
self.hang: set[str] = set()
|
||||
self.calls: list[str] = []
|
||||
|
||||
async def _enter(self, name: str) -> None:
|
||||
self.calls.append(name)
|
||||
if name in self.hang:
|
||||
await asyncio.sleep(HANG_SEC)
|
||||
if name in self.fail:
|
||||
raise UnavailableError()
|
||||
|
||||
|
||||
class FakeChatRepository(ChatRepository):
|
||||
"""Пользователь — участник любого чата, кроме перечисленных в foreign"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.foreign: set[UUID] = set()
|
||||
|
||||
async def create(self, title: str, created_by: UUID, member_ids: list[UUID]) -> ChatSchema:
|
||||
raise NotImplementedError
|
||||
|
||||
async def get_for_member(self, chat_id: UUID, member_id: UUID) -> ChatSchema | None:
|
||||
if chat_id in self.foreign:
|
||||
return None
|
||||
return ChatSchema(
|
||||
id=chat_id, title="chat", member_ids=[member_id], created_at=datetime.now(UTC)
|
||||
)
|
||||
|
||||
async def list_for_member(
|
||||
self, member_id: UUID, after: PageKey | None, limit: int
|
||||
) -> list[ChatSchema]:
|
||||
raise NotImplementedError
|
||||
|
||||
|
||||
class FakeAttachmentRepository(FaultInjection, AttachmentRepository):
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self.rows: dict[UUID, dict] = {}
|
||||
self.ready_returns_none = False
|
||||
|
||||
def add_row(self, object_key: str, status: AttachmentStatus, age_seconds: float) -> UUID:
|
||||
attachment_id = uuid4()
|
||||
self.rows[attachment_id] = {
|
||||
"status": status,
|
||||
"object_key": object_key,
|
||||
"created_at": datetime.now(UTC) - timedelta(seconds=age_seconds),
|
||||
"new": None,
|
||||
}
|
||||
return attachment_id
|
||||
|
||||
async def create_pending(self, attachment: NewAttachmentSchema) -> UUID:
|
||||
await self._enter("create_pending")
|
||||
attachment_id = self.add_row(attachment.object_key, AttachmentStatus.PENDING, 0)
|
||||
self.rows[attachment_id]["new"] = attachment
|
||||
return attachment_id
|
||||
|
||||
async def mark_ready(self, attachment_id: UUID, grace_seconds: int) -> AttachmentSchema | None:
|
||||
await self._enter("mark_ready")
|
||||
row = self.rows.get(attachment_id)
|
||||
if self.ready_returns_none or row is None or row["status"] != AttachmentStatus.PENDING:
|
||||
return None
|
||||
if row["created_at"] <= datetime.now(UTC) - timedelta(seconds=grace_seconds):
|
||||
return None
|
||||
row["status"] = AttachmentStatus.READY
|
||||
new: NewAttachmentSchema = row["new"]
|
||||
return AttachmentSchema(
|
||||
id=attachment_id,
|
||||
chat_id=new.chat_id,
|
||||
owner_id=new.owner_id,
|
||||
filename=new.filename,
|
||||
content_type=new.content_type,
|
||||
size_bytes=new.size_bytes,
|
||||
sha256=new.sha256.hex(),
|
||||
created_at=row["created_at"],
|
||||
updated_at=datetime.now(UTC),
|
||||
)
|
||||
|
||||
async def claim_pending(self, attachment_id: UUID) -> UnfinishedUploadSchema | None:
|
||||
await self._enter("claim_pending")
|
||||
row = self.rows.get(attachment_id)
|
||||
if row is None or row["status"] != AttachmentStatus.PENDING:
|
||||
return None
|
||||
row["status"] = AttachmentStatus.DELETING
|
||||
return UnfinishedUploadSchema(id=attachment_id, object_key=row["object_key"])
|
||||
|
||||
def _unfinished(self, grace_seconds: int) -> list[UUID]:
|
||||
threshold = datetime.now(UTC) - timedelta(seconds=grace_seconds)
|
||||
return [
|
||||
attachment_id
|
||||
for attachment_id, row in self.rows.items()
|
||||
if row["status"] == AttachmentStatus.DELETING
|
||||
or (row["status"] == AttachmentStatus.PENDING and row["created_at"] < threshold)
|
||||
]
|
||||
|
||||
async def claim_unfinished(self, grace_seconds: int, limit: int) -> list[UnfinishedUploadSchema]:
|
||||
await self._enter("claim_unfinished")
|
||||
# Повторный вызов в том же проходе не должен возвращать те же строки
|
||||
claimed = [
|
||||
attachment_id
|
||||
for attachment_id in self._unfinished(grace_seconds)
|
||||
if not self.rows[attachment_id].get("claimed_now")
|
||||
][:limit]
|
||||
for attachment_id in claimed:
|
||||
self.rows[attachment_id]["status"] = AttachmentStatus.DELETING
|
||||
self.rows[attachment_id]["claimed_now"] = True
|
||||
return [
|
||||
UnfinishedUploadSchema(id=i, object_key=self.rows[i]["object_key"]) for i in claimed
|
||||
]
|
||||
|
||||
async def list_unfinished(self, grace_seconds: int, limit: int) -> list[UnfinishedUploadSchema]:
|
||||
await self._enter("list_unfinished")
|
||||
return [
|
||||
UnfinishedUploadSchema(id=i, object_key=self.rows[i]["object_key"])
|
||||
for i in self._unfinished(grace_seconds)[:limit]
|
||||
]
|
||||
|
||||
async def delete_claimed(self, attachment_ids: list[UUID]) -> int:
|
||||
await self._enter("delete_claimed")
|
||||
deleted = [
|
||||
i
|
||||
for i in attachment_ids
|
||||
if i in self.rows and self.rows[i]["status"] == AttachmentStatus.DELETING
|
||||
]
|
||||
for attachment_id in deleted:
|
||||
del self.rows[attachment_id]
|
||||
return len(deleted)
|
||||
|
||||
async def get_for_member(
|
||||
self, attachment_id: UUID, member_id: UUID
|
||||
) -> StoredAttachmentSchema | None:
|
||||
raise NotImplementedError
|
||||
|
||||
async def find_known_keys(self, object_keys: list[str]) -> set[str]:
|
||||
await self._enter("find_known_keys")
|
||||
known = {row["object_key"] for row in self.rows.values()}
|
||||
return {key for key in object_keys if key in known}
|
||||
|
||||
def statuses(self) -> list[str]:
|
||||
return sorted(row["status"] for row in self.rows.values())
|
||||
|
||||
|
||||
class FakeStoredObject(StoredObject):
|
||||
def __init__(self, data: bytes) -> None:
|
||||
self._data = data
|
||||
self.content_length = len(data)
|
||||
|
||||
async def iter_chunks(self) -> AsyncIterator[bytes]:
|
||||
yield self._data
|
||||
|
||||
async def close(self) -> None:
|
||||
pass
|
||||
|
||||
|
||||
class FakeObjectStorage(FaultInjection, ObjectStorage):
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self.objects: dict[str, tuple[bytes, datetime]] = {}
|
||||
|
||||
def add_object(self, key: str, age_seconds: float) -> None:
|
||||
self.objects[key] = (b"x", datetime.now(UTC) - timedelta(seconds=age_seconds))
|
||||
|
||||
async def put(
|
||||
self, key: str, body: BinaryIO, size: int, content_type: str, sha256: bytes
|
||||
) -> None:
|
||||
# Как S3: объект появляется до того, как вызывающий получит ответ
|
||||
self.objects[key] = (body.read(), datetime.now(UTC))
|
||||
await self._enter("put")
|
||||
|
||||
async def open(self, key: str) -> StoredObject | None:
|
||||
await self._enter("open")
|
||||
stored = self.objects.get(key)
|
||||
return FakeStoredObject(stored[0]) if stored else None
|
||||
|
||||
async def delete(self, key: str) -> None:
|
||||
await self._enter("delete")
|
||||
self.objects.pop(key, None)
|
||||
|
||||
async def list_objects(self, prefix: str) -> AsyncIterator[tuple[str, datetime]]:
|
||||
await self._enter("list_objects")
|
||||
for key, (_, modified_at) in list(self.objects.items()):
|
||||
if key.startswith(prefix):
|
||||
yield key, modified_at
|
||||
|
||||
|
||||
async def chunks_of(data: bytes, size: int = 64 * 1024) -> AsyncIterator[bytes]:
|
||||
stream = io.BytesIO(data)
|
||||
while chunk := stream.read(size):
|
||||
yield chunk
|
||||
@@ -0,0 +1,261 @@
|
||||
"""
|
||||
Согласованность S3 и БД при загрузке: любой отказ после записи строки
|
||||
не оставляет неучтённых объектов — компенсация сразу или janitor позже.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import hashlib
|
||||
import io
|
||||
from collections.abc import AsyncIterator
|
||||
from datetime import UTC, datetime
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
from fakes import (
|
||||
FakeAttachmentRepository,
|
||||
FakeChatRepository,
|
||||
FakeObjectStorage,
|
||||
chunks_of,
|
||||
)
|
||||
from PIL import Image
|
||||
|
||||
from domain import (
|
||||
AttachmentStatus,
|
||||
AttachmentVariant,
|
||||
StoredAttachmentSchema,
|
||||
UserSchema,
|
||||
)
|
||||
from domain.errors import (
|
||||
InvalidRequestError,
|
||||
NotFoundError,
|
||||
PayloadTooLargeError,
|
||||
UnavailableError,
|
||||
UnsupportedMediaTypeError,
|
||||
)
|
||||
from infrastructure.media import ImageInspector
|
||||
from infrastructure.services import AttachmentService, StorageReconciler
|
||||
|
||||
MAX_BYTES = 1024 * 1024
|
||||
GRACE_SECONDS = 900
|
||||
USER = UserSchema(
|
||||
id=uuid4(), username="alice", display_name="Алиса", created_at=datetime.now(UTC)
|
||||
)
|
||||
|
||||
|
||||
def png(width: int = 8, height: int = 8) -> bytes:
|
||||
buffer = io.BytesIO()
|
||||
Image.new("RGB", (width, height), (1, 2, 3)).save(buffer, "PNG")
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
class Stand:
|
||||
"""Сервис с фейками; inspector настоящий"""
|
||||
|
||||
def __init__(self, store_timeout: float = 5) -> None:
|
||||
self.chats = FakeChatRepository()
|
||||
self.attachments = FakeAttachmentRepository()
|
||||
self.storage = FakeObjectStorage()
|
||||
self.inspector = ImageInspector(workers=1, max_pixels=1_000_000)
|
||||
self.service = AttachmentService(
|
||||
self.chats,
|
||||
self.attachments,
|
||||
self.storage,
|
||||
self.inspector,
|
||||
max_upload_bytes=MAX_BYTES,
|
||||
spool_memory_bytes=1024,
|
||||
store_timeout_seconds=store_timeout,
|
||||
pending_grace_seconds=GRACE_SECONDS,
|
||||
)
|
||||
|
||||
async def upload(self, data: bytes | None = None, content_type: str = "image/png"):
|
||||
data = data if data is not None else png()
|
||||
return await self.service.upload(
|
||||
USER, uuid4(), "a.png", content_type, len(data), chunks_of(data, 100)
|
||||
)
|
||||
|
||||
async def reconcile(self, grace_seconds: int = GRACE_SECONDS):
|
||||
reconciler = StorageReconciler(self.attachments, self.storage, grace_seconds)
|
||||
return await reconciler.run_once()
|
||||
|
||||
|
||||
def run(coro):
|
||||
return asyncio.run(coro)
|
||||
|
||||
|
||||
def test_success_stores_object_and_ready_row() -> None:
|
||||
stand = Stand()
|
||||
data = png()
|
||||
attachment = run(stand.upload(data))
|
||||
assert attachment.sha256 == hashlib.sha256(data).hexdigest()
|
||||
assert stand.attachments.statuses() == [AttachmentStatus.READY]
|
||||
[(stored, _)] = stand.storage.objects.values()
|
||||
assert stored == data
|
||||
[key] = stand.storage.objects
|
||||
assert key.startswith("originals/") and "a.png" not in key
|
||||
# Строка записана до PUT, подтверждена после
|
||||
assert stand.attachments.calls[:2] == ["create_pending", "mark_ready"]
|
||||
|
||||
|
||||
def test_s3_failure_after_write_is_compensated() -> None:
|
||||
"""PUT дошёл до S3, но ответ — ошибка: объект удаляется, строка тоже"""
|
||||
stand = Stand()
|
||||
stand.storage.fail.add("put")
|
||||
with pytest.raises(UnavailableError):
|
||||
run(stand.upload())
|
||||
assert stand.storage.objects == {}
|
||||
assert stand.attachments.rows == {}
|
||||
|
||||
|
||||
def test_db_failure_between_s3_and_commit_is_compensated() -> None:
|
||||
"""Объект записан в S3, подтверждение в БД не прошло"""
|
||||
stand = Stand()
|
||||
stand.attachments.fail.add("mark_ready")
|
||||
with pytest.raises(UnavailableError):
|
||||
run(stand.upload())
|
||||
assert stand.storage.objects == {}
|
||||
assert stand.attachments.rows == {}
|
||||
|
||||
|
||||
def test_db_down_leaves_pending_row_that_janitor_cleans() -> None:
|
||||
"""
|
||||
БД пропала после PUT: ни подтвердить, ни компенсировать. Объект учтён
|
||||
строкой pending; janitor после grace period удаляет и объект, и строку.
|
||||
"""
|
||||
stand = Stand()
|
||||
stand.attachments.fail.update({"mark_ready", "claim_pending"})
|
||||
with pytest.raises(UnavailableError):
|
||||
run(stand.upload())
|
||||
assert len(stand.storage.objects) == 1
|
||||
assert stand.attachments.statuses() == [AttachmentStatus.PENDING]
|
||||
|
||||
stand.attachments.fail.clear()
|
||||
fresh = run(stand.reconcile(GRACE_SECONDS))
|
||||
assert fresh.unfinished_claimed == 0, "свежая загрузка не трогается"
|
||||
assert len(stand.storage.objects) == 1
|
||||
|
||||
report = run(stand.reconcile(grace_seconds=0))
|
||||
assert report.unfinished_objects_deleted == report.unfinished_rows_deleted == 1
|
||||
assert stand.storage.objects == {} and stand.attachments.rows == {}
|
||||
|
||||
|
||||
def test_s3_down_during_compensation_leaves_deleting_row_for_janitor() -> None:
|
||||
stand = Stand()
|
||||
stand.attachments.fail.add("mark_ready")
|
||||
stand.storage.fail.add("delete")
|
||||
with pytest.raises(UnavailableError):
|
||||
run(stand.upload())
|
||||
assert stand.attachments.statuses() == [AttachmentStatus.DELETING]
|
||||
assert len(stand.storage.objects) == 1
|
||||
|
||||
stand.storage.fail.clear()
|
||||
# deleting очищается независимо от возраста
|
||||
report = run(stand.reconcile(GRACE_SECONDS))
|
||||
assert report.unfinished_rows_deleted == 1
|
||||
assert stand.storage.objects == {} and stand.attachments.rows == {}
|
||||
|
||||
|
||||
def test_store_timeout_is_compensated() -> None:
|
||||
stand = Stand(store_timeout=0.2)
|
||||
stand.storage.hang.add("put")
|
||||
with pytest.raises(UnavailableError):
|
||||
run(stand.upload())
|
||||
assert stand.storage.objects == {} and stand.attachments.rows == {}
|
||||
|
||||
|
||||
def test_cancelled_upload_is_compensated() -> None:
|
||||
"""Остановка реплики посреди PUT: задача отменяется, компенсация выполняется"""
|
||||
stand = Stand()
|
||||
stand.storage.hang.add("put")
|
||||
|
||||
async def scenario() -> None:
|
||||
task = asyncio.create_task(stand.upload())
|
||||
while "put" not in stand.storage.calls:
|
||||
await asyncio.sleep(0.01)
|
||||
task.cancel()
|
||||
with pytest.raises(asyncio.CancelledError):
|
||||
await task
|
||||
|
||||
run(scenario())
|
||||
assert stand.storage.objects == {} and stand.attachments.rows == {}
|
||||
|
||||
|
||||
def test_upload_claimed_by_janitor_is_not_confirmed() -> None:
|
||||
stand = Stand()
|
||||
stand.attachments.ready_returns_none = True
|
||||
with pytest.raises(UnavailableError):
|
||||
run(stand.upload())
|
||||
assert stand.storage.objects == {} and stand.attachments.rows == {}
|
||||
|
||||
|
||||
def test_validation_errors_store_nothing() -> None:
|
||||
stand = Stand()
|
||||
cases = [
|
||||
(png(), "image/jpeg", UnsupportedMediaTypeError),
|
||||
(b"not an image", "image/png", UnsupportedMediaTypeError),
|
||||
(png()[:40], "image/png", UnsupportedMediaTypeError),
|
||||
(png(2000, 1000), "image/png", PayloadTooLargeError),
|
||||
(b"", "image/png", InvalidRequestError),
|
||||
]
|
||||
for data, content_type, error in cases:
|
||||
with pytest.raises(error):
|
||||
run(stand.upload(data, content_type))
|
||||
assert stand.storage.objects == {} and stand.attachments.rows == {}
|
||||
assert "create_pending" not in stand.attachments.calls
|
||||
|
||||
|
||||
def test_declared_length_over_limit_is_rejected_without_reading() -> None:
|
||||
stand = Stand()
|
||||
consumed = []
|
||||
|
||||
async def body() -> AsyncIterator[bytes]:
|
||||
consumed.append(True)
|
||||
yield b"x"
|
||||
|
||||
with pytest.raises(PayloadTooLargeError):
|
||||
run(
|
||||
stand.service.upload(
|
||||
USER, uuid4(), "a.png", "image/png", MAX_BYTES + 1, body()
|
||||
)
|
||||
)
|
||||
assert consumed == []
|
||||
|
||||
|
||||
def test_streamed_body_over_limit_stops_reading() -> None:
|
||||
"""Без Content-Length чтение обрывается на первом байте сверх лимита"""
|
||||
stand = Stand()
|
||||
chunks_read = 0
|
||||
|
||||
async def endless() -> AsyncIterator[bytes]:
|
||||
nonlocal chunks_read
|
||||
while True:
|
||||
chunks_read += 1
|
||||
yield b"\x00" * 64 * 1024
|
||||
|
||||
with pytest.raises(PayloadTooLargeError):
|
||||
run(stand.service.upload(USER, uuid4(), "a.png", "image/png", None, endless()))
|
||||
assert chunks_read == MAX_BYTES // (64 * 1024) + 1
|
||||
|
||||
|
||||
def test_foreign_chat_is_404_before_reading_body() -> None:
|
||||
stand = Stand()
|
||||
chat_id = uuid4()
|
||||
stand.chats.foreign.add(chat_id)
|
||||
with pytest.raises(NotFoundError):
|
||||
run(stand.service.upload(USER, chat_id, "a.png", "image/png", 10, chunks_of(b"")))
|
||||
|
||||
|
||||
def test_missing_variant_is_404() -> None:
|
||||
stand = Stand()
|
||||
attachment = run(stand.upload())
|
||||
|
||||
async def get_for_member(attachment_id, member_id):
|
||||
[key] = stand.storage.objects
|
||||
return StoredAttachmentSchema(attachment=attachment, object_key=key)
|
||||
|
||||
stand.attachments.get_for_member = get_for_member
|
||||
_, content = run(
|
||||
stand.service.open_content(USER, attachment.id, AttachmentVariant.ORIGINAL)
|
||||
)
|
||||
assert content.content_length == attachment.size_bytes
|
||||
with pytest.raises(NotFoundError):
|
||||
run(stand.service.open_content(USER, attachment.id, AttachmentVariant.THUMBNAIL))
|
||||
@@ -0,0 +1,96 @@
|
||||
"""
|
||||
Janitor: незавершённые загрузки и сироты удаляются только после grace period;
|
||||
готовые и свежие вложения не трогаются; dry-run ничего не меняет.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
|
||||
import pytest
|
||||
from fakes import FakeAttachmentRepository, FakeObjectStorage
|
||||
|
||||
from domain import AttachmentStatus
|
||||
from domain.errors import UnavailableError
|
||||
from infrastructure.services import StorageReconciler
|
||||
|
||||
GRACE = 600
|
||||
OLD = 3600
|
||||
FRESH = 1
|
||||
|
||||
|
||||
def build() -> tuple[FakeAttachmentRepository, FakeObjectStorage]:
|
||||
rows, storage = FakeAttachmentRepository(), FakeObjectStorage()
|
||||
cases = {
|
||||
"originals/ready-old": (AttachmentStatus.READY, OLD),
|
||||
"originals/ready-fresh": (AttachmentStatus.READY, FRESH),
|
||||
"originals/pending-old": (AttachmentStatus.PENDING, OLD),
|
||||
"originals/pending-fresh": (AttachmentStatus.PENDING, FRESH),
|
||||
"originals/deleting-fresh": (AttachmentStatus.DELETING, FRESH),
|
||||
}
|
||||
for key, (status, age) in cases.items():
|
||||
rows.add_row(key, status, age)
|
||||
storage.add_object(key, age)
|
||||
# pending без объекта: процесс упал до PUT
|
||||
rows.add_row("originals/pending-no-object", AttachmentStatus.PENDING, OLD)
|
||||
storage.add_object("originals/orphan-old", OLD)
|
||||
storage.add_object("originals/orphan-fresh", FRESH)
|
||||
storage.add_object("other/not-ours", OLD)
|
||||
return rows, storage
|
||||
|
||||
|
||||
def run(rows, storage, dry_run: bool = False):
|
||||
return asyncio.run(StorageReconciler(rows, storage, GRACE).run_once(dry_run))
|
||||
|
||||
|
||||
def test_reconcile_removes_only_stale_unaccounted_data() -> None:
|
||||
rows, storage = build()
|
||||
report = run(rows, storage)
|
||||
|
||||
assert sorted(storage.objects) == [
|
||||
"originals/orphan-fresh",
|
||||
"originals/pending-fresh",
|
||||
"originals/ready-fresh",
|
||||
"originals/ready-old",
|
||||
"other/not-ours",
|
||||
]
|
||||
assert sorted(row["object_key"] for row in rows.rows.values()) == [
|
||||
"originals/pending-fresh",
|
||||
"originals/ready-fresh",
|
||||
"originals/ready-old",
|
||||
]
|
||||
assert report.unfinished_claimed == 3
|
||||
assert report.unfinished_rows_deleted == 3
|
||||
assert report.orphan_objects_found == report.orphan_objects_deleted == 1
|
||||
|
||||
|
||||
def test_dry_run_changes_nothing() -> None:
|
||||
rows, storage = build()
|
||||
before_rows = {k: dict(v) for k, v in rows.rows.items()}
|
||||
before_objects = dict(storage.objects)
|
||||
report = run(rows, storage, dry_run=True)
|
||||
assert rows.rows == before_rows and storage.objects == before_objects
|
||||
assert report.unfinished_claimed == 3 and report.orphan_objects_found == 1
|
||||
assert report.orphan_objects_deleted == 0
|
||||
|
||||
|
||||
def test_second_run_is_noop() -> None:
|
||||
rows, storage = build()
|
||||
run(rows, storage)
|
||||
report = run(rows, storage)
|
||||
assert report.unfinished_claimed == 0 and report.orphan_objects_found == 0
|
||||
|
||||
|
||||
def test_interrupted_cleanup_is_resumed() -> None:
|
||||
"""S3 упал после claim: строки остаются deleting и дочищаются в следующий раз"""
|
||||
rows, storage = build()
|
||||
storage.fail.add("delete")
|
||||
with pytest.raises(UnavailableError):
|
||||
run(rows, storage)
|
||||
assert AttachmentStatus.PENDING not in [
|
||||
row["status"] for row in rows.rows.values() if "old" in row["object_key"]
|
||||
]
|
||||
storage.fail.clear()
|
||||
for row in rows.rows.values():
|
||||
row.pop("claimed_now", None)
|
||||
run(rows, storage)
|
||||
assert not any("old" in key and "ready" not in key for key in storage.objects)
|
||||
assert all(row["status"] != AttachmentStatus.DELETING for row in rows.rows.values())
|
||||
Reference in New Issue
Block a user