feat: Саватеев А трек 4

This commit is contained in:
Enterxx2
2026-11-02 23:13:38 +03:00
parent 445cfe4789
commit 081d0fd2c8
76 changed files with 6387 additions and 77 deletions
+16
View File
@@ -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
+28 -3
View File
@@ -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
+116 -15
View File
@@ -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
View File
@@ -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
+254
View File
@@ -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
}
}
}
]
}
+21
View File
@@ -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
+19
View File
@@ -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 на финальной конфигурации перед сдачей.
+27
View File
@@ -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). Повторить на финальной конфигурации перед сдачей.
+9
View File
@@ -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) =========================
+17
View File
@@ -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;
+69
View File
@@ -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
View File
File diff suppressed because it is too large Load Diff
+2
View File
@@ -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"
+1 -1
View File
@@ -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}"
+73
View File
@@ -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
View File
@@ -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
+114
View File
@@ -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()
+317
View File
@@ -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()
+17 -4
View File
@@ -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()
+2
View File
@@ -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),
)
+3
View File
@@ -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",
]
+28
View File
@@ -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='')}"
+40
View File
@@ -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",
]
+27
View 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"
+26
View File
@@ -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",
]
+33
View File
@@ -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",
]
+161
View File
@@ -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/"
# Невидимое управление направлением текста: «photo‮gnp.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
+4
View File
@@ -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",
+16
View File
@@ -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):
"""Приложение не готово обслуживать запросы"""
+2
View File
@@ -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",
+37 -5
View File
@@ -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
View File
@@ -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
View File
@@ -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())
+9 -2
View File
@@ -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,
)
+187
View File
@@ -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,
)
+4
View File
@@ -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"]
+127
View File
@@ -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
+49
View File
@@ -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
+8 -1
View File
@@ -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",
]
+17
View File
@@ -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
+10 -1
View File
@@ -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)
+8
View File
@@ -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",
+48
View File
@@ -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
+5
View File
@@ -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",
]
+84
View File
@@ -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
+1
View File
@@ -13,6 +13,7 @@ class MessageRepository(ABC):
chat_id: UUID,
sender_id: UUID,
text: str,
attachment_ids: list[UUID],
idempotency: IdempotencyKeySchema,
) -> tuple[MessageSchema, bool]:
"""
+60
View File
@@ -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
+95
View File
@@ -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())))
+51
View File
@@ -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())
+49 -1
View File
@@ -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
+113
View File
@@ -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)
+65
View File
@@ -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")
+384
View File
@@ -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
+166
View File
@@ -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()
+188
View File
@@ -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"
+99
View File
@@ -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
+157
View File
@@ -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
+12
View File
@@ -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"))
+219
View File
@@ -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())