2 Commits
Author SHA1 Message Date
HellsTomatoandCopilot 18bef74c66 Update completed lab 4 implementation
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-31 10:42:32 +03:00
HellsTomatoandCopilot 3ed3ce07cf Apply completed lab 4 implementation
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-31 00:38:42 +03:00
31 changed files with 3611 additions and 17 deletions
+2
View File
@@ -0,0 +1,2 @@
# Shell-скрипты запускаются в bash/sh: CRLF при checkout на Windows их ломает.
*.sh text eol=lf
+22
View File
@@ -0,0 +1,22 @@
# Первый этап: сборка приложения через Maven и JDK.
FROM maven:3.9.9-eclipse-temurin-21 AS build
# Рабочая папка внутри контейнера сборки.
WORKDIR /build
# Сначала копируем зависимости для ускорения повторной сборки.
COPY pom.xml .
RUN mvn -B -q dependency:go-offline
# Копируем исходный код и собираем JAR-файл.
COPY src src
RUN mvn -B -q package -DskipTests
# Второй этап: запускаем приложение в лёгком JRE-образе.
FROM eclipse-temurin:21.0.4_7-jre-jammy
WORKDIR /app
# Переносим готовое приложение из этапа сборки.
COPY --from=build /build/target/messenger-1.0.0.jar /app/messenger.jar
# Запускаем контейнер не от root-пользователя.
RUN useradd --system --uid 10001 app
USER 10001
# Приложение слушает порт 8080.
EXPOSE 8080
# Команда запуска Spring Boot-приложения.
ENTRYPOINT ["java","-Dfile.encoding=UTF-8","-jar","/app/messenger.jar"]
+173 -17
View File
@@ -1,37 +1,193 @@
# Отчёт — лабораторная 4
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Гавриков В.Д БПИ2303
- Целевая оценка: **5**, трек 5 — **трек 2 «Согласованность двух хранилищ»**
- Commit/PR: после публикации
- Источники: Spring Boot 3.3.5, AWS SDK for Java v2 2.29.52, Flyway 10, SeaweedFS 3.99, nginx 1.28.0.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужно: Docker Engine + Compose v2.24+, Python 3.9+. Проверено: macOS 14 (Apple M3 Pro, 11 CPU, 18 GiB), OrbStack, Docker 29.8.2, Compose 5.5.0.
```sh
# 1. Синтетические секреты в secrets/ (в Git их нет; повторный запуск файлы не меняет).
python3 scripts/init_secrets.py # Windows: py -3 scripts\init_secrets.py
# 2. Сборка и запуск; --wait ждёт healthy всех сервисов (≈30–40 с на первом запуске после сборки).
docker compose up -d --build --wait
# 3. Проверки.
make test
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
docker compose start api-1 api-2 # вернуть остановленную тестом реплику
make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 tests/attachments_negative.py --with-docker
scripts/check-private-bucket.sh
```
Остановка без потери данных: `docker compose down`. Намеренное удаление учебных данных: `docker compose down -v` (секреты в `secrets/` остаются; чтобы сменить их, удалите `secrets/` **вместе** с volumes — пароль PostgreSQL задаётся при первой инициализации тома).
Порядок старта задан `depends_on`: postgres, redis, s3 → `s3-init` (bucket) и `migration` (Flyway) → `api-1`, `api-2` → nginx. Действий оператора не требуется.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab3, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──► nginx :8080 ──► api-1 ─┬─► PostgreSQL (пользователи, чаты, сообщения, метаданные вложений)
└──► api-2 ─┼─► Redis (Bearer-сессии)
└─► SeaweedFS S3 (байты вложений, приватный bucket)
однократно: s3-init (bucket), migration (Flyway); по требованию: reconciler, s3-probe (profile tools)
```
| Роль | Service | Образ | Health/readiness | Volume | Сеть/порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| LB | nginx | nginx:1.28.0-alpine | пассивная (max_fails=3, fail_timeout=10s) | — | **единственный** опубликованный порт 8080 | — |
| API ×2 | api-1, api-2 | messenger-api:lab4 (из Dockerfile) | `/health/ready` каждые 5 с | нет (stateless) | 8080 только во внутренней сети | `/run/secrets`: пароль БД, Redis, ключи S3 **api** |
| Миграции | migration | тот же образ, режим `migrate` | завершение с кодом 0 | — | внутренняя | только пароль БД |
| БД | postgres | postgres:16.4 | `pg_isready` | pgdata | 5432 внутренняя | `POSTGRES_PASSWORD_FILE` |
| Сессии | redis | redis:7.4.1 | `redis-cli ping` с паролем | redisdata (AOF) | 6379 внутренняя | `requirepass` в redis.conf из secrets |
| S3 | s3 | chrislusf/seaweedfs:3.99 | `GET /healthz` | s3data | **только :8333** в сеть стенда; master/volume/filer слушают 127.0.0.1 | identities из `s3_config.json` |
| Bootstrap S3 | s3-init | curlimages/curl:8.11.1 | завершение с кодом 0 | — | внутренняя | только ключи S3 **admin** |
| Сверка | reconciler | тот же образ, режим `reconcile` | запуск по требованию | — | внутренняя | пароль БД, ключи S3 api |
**Почему SeaweedFS, а не MinIO:** образы `minio/minio` и `quay.io/minio/minio` с этой машины не скачиваются (registry отвечает `access denied`). SeaweedFS 3.99 проверен: S3 API, identities с правами на конкретный bucket, anonymous → 403.
**Что перенесено из lab3:** весь API, nginx-балансировка, идемпотентность, failover/restart hooks, скрипты замеров. В lab3 по ходу курса исправлены (и перенесены сюда): гонка идемпотентности (503 при параллельных повторах выключал обе реплики в nginx), DNS реплик в nginx (`resolve`), прозрачный повтор любых POST (`non_idempotent` теперь только для сообщений), 500 на неизвестный путь/метод/Content-Type, `created_at` чата, тайминги shutdown, скрипты замеров.
**Что нового в lab4:**
- `POST /api/v1/chats/{id}/attachments?filename=…` — сырые байты PNG/JPEG, `201 ready`; `GET /api/v1/attachments/{id}` и `/content` — только участникам чата, байты потоком из S3, без redirect.
- `attachment_ids` в сообщениях: 0–10 уникальных id, только готовые вложения этого чата (иначе 404), `text=""` допустим с вложением, порядок сохраняется (`message_attachments.position`). Идемпотентность учитывает вложения: отсутствие поля и `[]` дают один хеш.
- Миграции — Flyway (`V1`–`V3`) в одноразовом контейнере; реплики миграции не запускают (`spring.flyway.enabled=false`).
- Секреты — файлы из `secrets/`, монтируются compose `secrets:`; Spring читает их через `configtree` (имя файла = имя свойства). В compose.yaml паролей нет.
- Код: [Attachments.java](src/main/java/ru/mtusi/messenger/Attachments.java) (upload/download), [ImageCheck.java](src/main/java/ru/mtusi/messenger/ImageCheck.java) (проверка формата), [Storage.java](src/main/java/ru/mtusi/messenger/Storage.java) (S3), [Reconciler.java](src/main/java/ru/mtusi/messenger/Reconciler.java) (сверка), миграция [V3__attachments.sql](src/main/resources/db/migration/V3__attachments.sql).
**Загрузка и транзакционные границы** ([Attachments.upload](src/main/java/ru/mtusi/messenger/Attachments.java)):
1. Сессия → членство в чате (404) → `filename` (400) → `Content-Type` (415) → `Content-Length > 10 MiB` (413, до чтения тела).
2. Тело читается во временный файл с жёстким лимитом 10 MiB, SHA-256 считается по ходу. Файл удаляется в `finally`: это буфер проверки, а не хранилище — оригинала на API после запроса нет.
3. `ImageCheck`: формат по сигнатуре; размеры из заголовка (> 40 Мпикс → 413) **до распаковки**; PNG — CRC всех chunk и `inflate` IDAT «в никуда» со счётчиком (ровно ожидаемое число байтов); JPEG — структура сегментов, SOF, сканы, EOI. Затем **полное декодирование** ImageIO с прореживанием: декодер читает все строки PNG и все сканы JPEG, но растр ограничен ~0.25 Мпикс; ошибка или предупреждение декодера → 415. Только структурной проверки мало: PNG с верными CRC и фильтром строки 5 или JPEG из 27 байт SOI/SOF/SOS/EOI без таблиц и данных скана её проходят, но не декодируются. Память — буферы по 64 KiB и прореженный растр. Заявленный `Content-Type` должен совпасть с содержимым (415).
4. INSERT строки `state='uploading'` (**намерение до S3**) → S3 PUT по серверному ключу `originals/<uuid>` → UPDATE `state='ready'` → `201`.
5. Компенсация: PUT не удался → строка удаляется, ответ 503; UPDATE не удался → объект удаляется. Если не удалась и компенсация (процесс упал), остаётся `uploading`-строка — её найдёт сверка после grace period.
`/health/ready` проверяет PostgreSQL и Redis, но **не S3**: текстовые сообщения — обязательный синхронный путь, и они продолжают работать при недоступном S3 (вложения отвечают 503). Проверено ниже.
**Соответствие `.env.example`:** `S3_ENDPOINT/S3_REGION/S3_BUCKET` — env в compose; `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE`, `DATABASE_URL_FILE` → файлы `/run/secrets/s3.access-key`, `s3.secret-key`, `spring.datasource.password`; `MAX_UPLOAD_BYTES=10485760` и `MAX_IMAGE_PIXELS=40000000` — константы контракта в коде; `SESSION_STORE` = Redis; `API_REPLICAS=2` — сервисы api-1/api-2.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
### Уровень 3
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий README | Команда/сценарий | Наблюдаемый результат |
| --- | --- | --- |
| Публичный smoke | `make test` | `PASS: lab4 public API scenario` |
| Возможности lab3 сохранены | `make test` (сценарий накопительный), `make test-failover` | PASS; failover: 2 реплики, 98 записей, 0 ошибок, восстановление записи 2.18 с |
| S3 в стенде, метаданные в PostgreSQL, байты в приватном bucket | `docker compose ps`; `scripts/check-private-bucket.sh` | сервис `s3` с volume `s3data`; таблица `attachments` без байтов; anonymous GET/HEAD/LIST/PUT → 403 |
| 201 ready, оригинал побайтно, checksum, посторонний 404 | `make test`, `tests/attachments_negative.py` | PASS: SHA-256 и размер совпадают, `eve` получает 404 на метаданные и bytes |
| PNG/JPEG ≤10 MiB и ≤40 Мпикс, MIME по содержимому, опасные filename, лимиты до чтения/декодирования | `tests/attachments_negative.py` | PASS (см. уровень 4) |
| Upload → остановка обслужившей реплики → download через другую | `tests/attachments_negative.py --with-docker` | `PASS upload replica … stopped: other replica serves identical bytes` |
| Restart с volumes сохраняет метаданные и оригинал | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` (тест в lab4 перечитывает файл) |
### Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат |
| --- | --- | --- |
| Тесты: большой файл, повреждённое изображение, подмена MIME, чужое attachment_id, файл другого чата; нет 500 | `python3 tests/attachments_negative.py --with-docker` | `PASS: 12 attachment checks` — 10 MiB+1 → 413 (API), 12 MiB → 413 JSON (nginx); битые/обрезанные PNG/JPEG → 415, недекодируемые при корректной структуре (PNG 1×1 с фильтром строки 5, JPEG 27 байт без таблиц и данных скана) → 415; PNG как `image/jpeg`, GIF/SVG как `image/png` → 415; >40 Мпикс → 413, «бомба» с ложным заголовком → 415, честные 36 Мпикс приняты; `../`, `/`, `\`, NUL, управляющие → 400; вложение другого чата/неизвестное → 404; каждый 4xx проверен на отсутствие `internal_error` |
| Недоступность S3 | там же, `--with-docker` | S3 остановлен: upload/download → 503 `unavailable`, метаданные 200, текстовое сообщение 201, `/health/ready` 200, `uploading`-строк 0 (компенсация); после старта S3 скачивание снова работает |
| Прерывание загрузки и отказ между S3/БД не оставляют вечных объектов | порядок «намерение → PUT → ready», компенсация, `Reconciler` (автоматически раз в 15 мин в API-репликах, grace 1 ч, pg advisory lock — одна реплика за раз) | после всех негативных тестов и отключения S3 сверка: 82 объекта = 82 строки, находок 0; эксперимент трека 2 ниже |
| Лимиты/таймауты, RAM не растёт от загрузки; ≥10 одновременных загрузок с пиком памяти | `python3 tests/upload_memory.py --runs 1,10,20` | 10 и 20 одновременных загрузок по 9.8 MiB: все 201; память процессов API (anon) +4…7 MiB к фону (см. эксперимент) |
| Bucket bootstrap идемпотентен | `docker compose up` повторно / `docker compose run --rm s3-init` | `bucket messenger-attachments already exists`, `anonymous list -> 403, bucket is private` |
| Отдельные S3 credentials с ограниченными правами | `s3_config.json` (identity `api`: Read/Write/List только на свой bucket); `scripts/check-private-bucket.sh` | контроль: ключ API читает свой объект (200); создать другой bucket → 403 **AccessDenied** (не ошибка подписи); удалить свой bucket → 403. Admin-ключи есть только у `s3-init` и самого `s3` |
| Административная консоль не открыта в общей сети | `scripts/check-private-bucket.sh` | master UI :9333, filer UI :8888, volume :8080 из сети стенда недоступны (слушают 127.0.0.1); с хоста порты публикует только nginx |
| Проверка private bucket вне API | `scripts/check-private-bucket.sh` (запросы из отдельного контейнера `s3-probe`) | `PASS anonymous GET/HEAD/LIST/PUT -> 403` |
Лимиты и таймауты: nginx `client_max_body_size 11m`, `client_body_timeout 15s`, тело буферизуется в nginx (медленный клиент не держит поток API); Tomcat `connection-timeout 10s`; не больше 8 одновременных загрузок на реплику (`MAX_CONCURRENT_UPLOADS`, ожидание слота 10 с, иначе 503); S3-клиент: connect 2 с, socket 30 с, весь вызов ≤ 60 с.
### Уровень 5 — трек 2
| Критерий трека | Команда/сценарий | Наблюдаемый результат |
| --- | --- | --- |
| Повторяемый reconciler orphan/missing | `docker compose run --rm reconciler [--apply] [--grace-seconds=N] [--verify-checksums]` | JSON-отчёт: находки, действия, стоимость |
| Ошибки на обеих сторонах, обнаружение, безопасное исправление, dry-run и повтор | `python3 tests/reconcile_experiment.py --cost 1000,10000` | PASS: dry-run — 12 находок в 9 категориях, состояние до и после совпадает (11 строк, 12 объектов); apply — `objects_deleted 5, rows_deleted 2, marked_lost 3`; повторный apply — 0 действий; `--verify-checksums` — подмена байтов того же размера → lost, ложный lost с верной SHA-256 → restored; повтор — 0 действий |
| Свежие и используемые вложения не удаляются | там же | свежий orphan и строка `uploading` моложе grace — `*_kept`, не тронуты; используемое и только что загруженное вложение скачиваются, байты совпадают; сообщение с вложением не изменилось; строка используемого вложения без объекта не удалена, а помечена `lost` (download → 404 `not_found`, не 500) |
| Стоимость обхода | там же, `--cost` | 1 000 строк: 1.0 с, 1 LIST, 2 запроса БД; с `--verify-checksums` 18.9 с (996 GET). 10 000 строк: 5.3 с, 10 LIST, 11 запросов БД; с проверкой сумм 87.6 с (9 996 GET) |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### ≥10 одновременных загрузок: пик памяти
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
Методика: `tests/upload_memory.py` загружает через nginx N одновременных PNG по 9.79 MiB (случайные пиксели, не сжимаются); память читается из cgroup v2 каждые 0.2 с: `anon` — память процессов (heap JVM и native), `current` — плюс page cache временных файлов. Лимиты: API 512M (heap JVM ≤128 MiB), nginx 128M, s3 512M. Сырые данные: [evidence/upload_memory.json](evidence/upload_memory.json), [до исправления](evidence/upload_memory_before_gomemlimit.json).
| N | Ответы | Время, с (p50 / max) | API anon, MiB: фон → пик (api-1 / api-2) | API current пик | nginx current / anon | S3 anon пик |
| --- | --- | --- | --- | --- | --- | --- |
| 1 | 201 ×1 | 1.04 / 1.04 | 194.6→205.0 / 196.2→196.3 | 263 / 198 | 20.6 / 8.1 | 128 |
| 10 | 201 ×10 | 4.90 / 4.94 | 205.1→209.2 / 196.5→212.0 | 263 / 266 | 108 / 8.5 | 239 |
| 20 | 201 ×20 | 10.42 / 11.30 | 209.2→214.7 / 212.1→219.3 | 298 / 301 | 128 / 8.8 | 430 |
Вывод: память процессов API почти не зависит от числа и размера загрузок (+4…15 MiB на 10–20 файлов по 10 MiB) — тело идёт потоком через 64 KiB буфер во временный файл, проверка не декодирует пиксели. Рост `current` — page cache временных файлов, ядро его вытесняет. nginx: anon ≈ 9 MiB, остальное — page cache буферов тел.
**Подтверждённое улучшение.** Первый прогон показал, что узкое место — не API, а SeaweedFS: при 10 загрузках его память процесса дошла до 507 MiB из 512M (`memory.events max` = 5415 срабатываний лимита). Гипотеза: сборщик мусора Go не знает о лимите контейнера. Добавлен `GOMEMLIMIT=320MiB`; повтор того же профиля:
| N | S3 anon пик до | S3 anon пик после |
| --- | --- | --- |
| 10 | 507.0 MiB | 239.0 MiB |
| 20 | 502.2 MiB | 430.0 MiB |
Ограничение: при 20 одновременных загрузках S3 всё ещё близко к лимиту; дальнейшие рычаги — уменьшить `MAX_CONCURRENT_UPLOADS` (сейчас до 16 PUT в S3 одновременно) или дать S3 больше памяти. Генератор closed-loop, один прогон на точку.
### Отказы
| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Остановка обслужившей API-реплики (`make test-failover`) | запись продолжается через другую | 98 записей, 0 ошибок | первая запись 2.18 с; потерь и дублей нет |
| Остановка реплики, принявшей загрузку | скачивание через другую | 5 скачиваний, байты идентичны, другой X-Instance-Id | мгновенно; потерь нет |
| Остановка S3 | вложения 503, текст работает | upload/download 503, сообщение 201, ready 200 | после старта S3 скачивание работает; висящих `uploading` 0 |
| Restart всего стенда (`scripts/restart.sh`) | данные, сессия и файл сохранены | PASS persistence | потерь нет |
### Трек 2: согласованность PostgreSQL и S3
Гипотеза: сверка находит расхождения обеих сторон, dry-run ничего не меняет, apply исправляет только безопасное (старше grace и не используемое сообщением), повторный запуск ничего нового не находит, свежие и используемые вложения остаются доступны.
Методика: `tests/reconcile_experiment.py` готовит вложения через API, затем ломает состояние **мимо API**: в S3 — подписанными запросами из контейнера `s3-probe` (ключи API), в БД — `psql` в контейнере postgres. Grace сокращён до 90 с: сбои вносятся, выжидается 92 с, затем создаются «свежие» объекты; после этого цепочка `dry-run → apply → apply → apply --verify-checksums → apply --verify-checksums`. Состояние (строки по состояниям и число объектов по листингу S3) снимается до и после dry-run. Сырые данные: [evidence/reconcile_experiment.json](evidence/reconcile_experiment.json).
| Внесённый сбой | Находка | Действие apply |
| --- | --- | --- |
| 3 объекта без строк + строка удалена из БД (объект остался) | `orphan_object` ×4 | объект удалён после повторной проверки БД по ключу |
| Объект без строки моложе grace | `orphan_object_fresh_kept` | не тронут |
| Строка `uploading` старше grace, объект есть | `stale_upload_with_object` | строка и объект удалены |
| Строка `uploading` старше grace, объекта нет | `stale_upload` | строка удалена |
| Строка `uploading` моложе grace | `upload_in_progress_kept` | не тронута |
| Строка `uploading` старше grace (2 ч), объект только что записан | `stale_upload_fresh_object_kept` | не тронуты: удаляем, только когда старше grace и строка, и объект (`LastModified`) |
| Объект используемого вложения удалён | `missing_object_used` (отсутствие подтверждено HEAD) | `lost`, строка и сообщение сохранены |
| Объект неиспользуемого вложения удалён | `missing_object` | `lost` |
| Объект подменён байтами другого размера | `size_mismatch` | `lost` |
| Объект подменён байтами того же размера | только с `--verify-checksums`: `checksum_mismatch` | `lost` |
| Строка ложно помечена `lost`, объект цел | `lost_object_back_unverified`; с `--verify-checksums` — `lost_object_back` | `ready` только после сверки SHA-256 |
Результат: PASS. Dry-run не изменил ни строк, ни объектов; первый apply — `{"objects_deleted": 5, "rows_deleted": 2, "marked_lost": 3}`; второй apply — 0 действий (остались только `lost_known` и свежие `*_kept`); проверка сумм — `{"marked_lost": 1, "restored": 1}`; её повтор — 0 действий. После сверки исправные вложения скачиваются побайтно, потерянные отвечают 404, а не 500.
Стоимость обхода (`--cost 1000,10000`, dry-run, grace 0; маленькие PNG):
| Строк | Обычный обход | `--verify-checksums` |
| --- | --- | --- |
| 1 000 | 996 мс; 1 LIST, 2 запроса БД | 18 881 мс; 996 GET, 0.6 MiB прочитано |
| 10 000 | 5 290 мс; 10 LIST, 11 запросов БД | 87 638 мс; 9 996 GET, 1.2 MiB прочитано |
Вывод: обычный обход — merge-join двух отсортированных потоков, стоимость линейна (≈ 1 LIST и 1 запрос БД на 1 000 ключей, память O(страница)); подходит для запуска раз в 15 минут. Проверка SHA-256 — один GET на объект, время определяется числом запросов, а не байтами (здесь файлы по ~100 байт; на реальных 10 MiB-файлах это ещё и полный объём хранилища), поэтому она запускается только вручную. Ограничения: один прогон на точку; ключ сбоя «тот же размер, другие байты» без `--verify-checksums` не обнаруживается — это осознанный компромисс стоимости.
## Ответы на вопросы защиты
**Почему файл в Docker volume одной API-реплики не равен объектному хранилищу?** Volume привязан к контейнеру/узлу: другая реплика его не видит, и после остановки загрузившей реплики файл недоступен (именно это проверяет сценарий upload → stop → download). S3 — отдельный общий сервис с собственным хранением, доступный всем репликам по сети.
**Когда можно честно вернуть 201?** Только когда оригинал сохранён в S3 и метаданные `ready` закоммичены в PostgreSQL. У нас UPDATE в `ready` идёт после успешного PUT; до этого клиент получает только ошибку.
**Что произойдёт, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет?** Клиент получит ошибку и не узнает id; API пытается удалить объект. Если и это не удалось (процесс упал), остаются объект и строка `uploading`: сверка после grace period удаляет их. Объект без строки вообще невозможен в нормальной работе — строка пишется **до** PUT; если он всё же появился (ручное вмешательство, сбой компенсации), сверка удалит его после grace, предварительно перепроверив БД по ключу.
**Почему случайный object key и приватный bucket не заменяют ACL приложения?** Ключ — не секрет доступа: он может утечь в логах или от бывшего участника, а bucket приватен лишь от анонимов, не от владельца ключей API. Право «участник этого чата» знает только приложение, поэтому каждый GET метаданных и байтов проверяет членство по БД.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один Docker-host: выдерживается отказ процесса API или S3, но не узла. PostgreSQL, Redis, S3 и nginx — по одному экземпляру (SPOF).
- SeaweedFS запущен одним процессом `weed server` без репликации томов; потеря volume `s3data` = потеря файлов.
- Временный файл загрузки лежит на диске контейнера API до конца запроса; для асинхронной обработки в lab5 нужен устойчивый staging (S3-префикс).
- Ключи идемпотентности хранятся бессрочно (контракт требует минимум 24 ч).
- Вариантов изображений в lab4 нет: `variant=thumbnail` → 404.
+247
View File
@@ -0,0 +1,247 @@
# Compose-стенд lab4: nginx → 2 API-реплики → PostgreSQL (метаданные) + Redis (сессии) + SeaweedFS (S3, байты).
# Перед первым запуском: python3 scripts/init_secrets.py — секреты появятся в secrets/ (вне Git).
# Общая часть API-реплик, migration и reconciler: один образ, разные режимы запуска.
x-api: &api
build: .
image: messenger-api:lab4
environment:
SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/messenger
SPRING_DATASOURCE_USERNAME: messenger
SPRING_DATA_REDIS_HOST: redis
SESSION_TTL_SECONDS: 3600
S3_ENDPOINT: http://s3:8333
S3_REGION: us-east-1
S3_BUCKET: messenger-attachments
# Секреты читаются Spring как свойства: имя файла в /run/secrets = имя свойства (configtree).
secrets:
- source: db_password
target: spring.datasource.password
- source: redis_password
target: spring.data.redis.password
- source: s3_api_access_key
target: s3.access-key
- source: s3_api_secret_key
target: s3.secret-key
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
s3-init:
condition: service_completed_successfully
migration:
condition: service_completed_successfully
healthcheck:
test: ["CMD", "wget", "--spider", "-q", "http://localhost:8080/health/ready"]
interval: 5s
timeout: 3s
retries: 3
start_period: 30s
restart: unless-stopped
stop_grace_period: 30s
deploy:
resources:
limits:
cpus: '1.0'
memory: 512M
reservations:
cpus: '0.5'
memory: 256M
services:
# Nginx балансирует запросы между API-репликами; единственный опубликованный порт стенда.
nginx:
image: nginx:1.28.0-alpine
ports:
- "8080:8080"
volumes:
- ./infra/nginx/nginx.conf:/etc/nginx/conf.d/default.conf:ro
depends_on:
api-1:
condition: service_healthy
api-2:
condition: service_healthy
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 128M
# Две взаимозаменяемые API-реплики без локального состояния.
api-1: *api
api-2: *api
# Однократные миграции Flyway до запуска реплик; нужен только пароль БД.
migration:
<<: *api
command: ["migrate"]
secrets:
- source: db_password
target: spring.datasource.password
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
restart: "no"
# Сверка БД и S3 по требованию: docker compose run --rm reconciler [--apply] [--grace-seconds=N].
reconciler:
<<: *api
# Режим в entrypoint: аргументы docker compose run дописываются к нему.
entrypoint: ["java", "-Dfile.encoding=UTF-8", "-jar", "/app/messenger.jar", "reconcile"]
command: []
profiles: ["tools"]
secrets:
- source: db_password
target: spring.datasource.password
- source: s3_api_access_key
target: s3.access-key
- source: s3_api_secret_key
target: s3.secret-key
depends_on:
postgres:
condition: service_healthy
s3:
condition: service_healthy
healthcheck:
disable: true
restart: "no"
# PostgreSQL — источник истины: пользователи, чаты, сообщения, метаданные вложений.
postgres:
image: postgres:16.4
environment:
POSTGRES_DB: messenger
POSTGRES_USER: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
- db_password
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: '2.0'
memory: 1G
# Redis хранит Bearer-сессии; пароль и AOF заданы в redis.conf из secrets/.
redis:
image: redis:7.4.1
command: ["redis-server", "/run/secrets/redis.conf"]
secrets:
- source: redis_conf
target: redis.conf
- redis_password
volumes:
- redisdata:/data
healthcheck:
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 10
restart: unless-stopped
deploy:
resources:
limits:
cpus: '0.5'
memory: 256M
# SeaweedFS: master/volume/filer слушают только 127.0.0.1 внутри контейнера (их HTTP-админки
# без авторизации), в сеть стенда открыт только S3 :8333. Наружу порты не публикуются.
s3:
image: chrislusf/seaweedfs:3.99
command:
- server
- -dir=/data
- -ip=127.0.0.1
- -ip.bind=127.0.0.1
- -s3
- -s3.ip.bind=0.0.0.0
- -s3.port=8333
- -s3.config=/run/secrets/s3_config.json
- -master.volumeSizeLimitMB=1024
- -volume.max=0
# Мягкий предел кучи Go ниже лимита контейнера: без него при 10+ параллельных загрузках
# SeaweedFS упирался в 512M (tests/upload_memory.py, REPORT.md).
environment:
GOMEMLIMIT: 320MiB
secrets:
- source: s3_config
target: s3_config.json
volumes:
- s3data:/data
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8333/healthz"]
interval: 5s
timeout: 3s
retries: 20
restart: unless-stopped
deploy:
resources:
limits:
cpus: '1.0'
memory: 512M
# Однократный идемпотентный bootstrap приватного bucket (admin-ключи есть только здесь и в s3).
s3-init:
image: curlimages/curl:8.11.1
entrypoint: ["/bin/sh", "/init/s3-init.sh"]
environment:
S3_ENDPOINT: http://s3:8333
S3_REGION: us-east-1
S3_BUCKET: messenger-attachments
volumes:
- ./infra/s3/s3-init.sh:/init/s3-init.sh:ro
secrets:
- s3_admin_access_key
- s3_admin_secret_key
depends_on:
s3:
condition: service_healthy
restart: "no"
# Клиент S3 мимо API для проверок и внедрения сбоев: scripts/check-private-bucket.sh,
# tests/reconcile_experiment.py. Только ключи API; скрипт читается из stdin.
s3-probe:
image: curlimages/curl:8.11.1
profiles: ["tools"]
entrypoint: ["/bin/sh", "-eu", "-s"]
secrets:
- source: s3_api_access_key
target: s3.access-key
- source: s3_api_secret_key
target: s3.secret-key
restart: "no"
volumes:
pgdata:
redisdata:
s3data:
# Файлы создаёт scripts/init_secrets.py; в Git их нет.
secrets:
db_password:
file: ./secrets/db_password
redis_password:
file: ./secrets/redis_password
redis_conf:
file: ./secrets/redis.conf
s3_config:
file: ./secrets/s3_config.json
s3_api_access_key:
file: ./secrets/s3_api_access_key
s3_api_secret_key:
file: ./secrets/s3_api_secret_key
s3_admin_access_key:
file: ./secrets/s3_admin_access_key
s3_admin_secret_key:
file: ./secrets/s3_admin_secret_key
+300
View File
@@ -0,0 +1,300 @@
{
"experiment": "reconciler fault injection (track 2)",
"grace_seconds": 90,
"injected": {
"orphan_objects_old": 3,
"object_without_row": 1,
"orphan_object_fresh": 1,
"stale_upload_with_object": 1,
"stale_upload_without_object": 1,
"upload_in_progress": 1,
"missing_object_used": 1,
"missing_object_unreferenced": 1,
"size_mismatch": 1,
"checksum_mismatch": 1,
"false_lost": 1
},
"state_before": {
"rows": [
"lost:1",
"ready:7",
"uploading:3"
],
"objects": 12
},
"state_after_dry_run": {
"rows": [
"lost:1",
"ready:7",
"uploading:3"
],
"objects": 12
},
"dry_run": {
"mode": "dry-run",
"grace_seconds": 90,
"verify_checksums": false,
"duration_ms": 671,
"cost": {
"s3_list_requests": 1,
"s3_objects": 12,
"db_queries": 1,
"db_rows": 11,
"s3_head_requests": 2
},
"findings": {
"size_mismatch": 1,
"orphan_object": 4,
"orphan_object_fresh_kept": 1,
"stale_upload_with_object": 1,
"missing_object_used": 1,
"upload_in_progress_kept": 1,
"lost_object_back_unverified": 1,
"missing_object": 1,
"stale_upload": 1
},
"actions": {},
"details": [
{
"kind": "size_mismatch",
"key": "originals/0836f158-90ec-46a7-86c1-1dc2ee443c36",
"attachment_id": "0836f158-90ec-46a7-86c1-1dc2ee443c36"
},
{
"kind": "orphan_object",
"key": "originals/3a27e460-a35f-4cd5-adcb-cef04b952caa"
},
{
"kind": "orphan_object",
"key": "originals/676da6c0-1670-40f1-966e-5177f90382a9"
},
{
"kind": "stale_upload_with_object",
"key": "originals/6c3a748b-23d3-4911-8a22-e912935726d1",
"attachment_id": "6c3a748b-23d3-4911-8a22-e912935726d1"
},
{
"kind": "missing_object",
"key": "originals/79e49f97-9d5a-427c-806e-27e92706983e",
"attachment_id": "79e49f97-9d5a-427c-806e-27e92706983e"
},
{
"kind": "orphan_object",
"key": "originals/dd2e6a38-071e-46ca-9ccc-f37e3fdbc9f8"
},
{
"kind": "orphan_object",
"key": "originals/e332f279-138e-4e26-8ed9-c198ca6f0868"
},
{
"kind": "missing_object",
"key": "originals/ecdee330-3a4b-4b07-8b74-121871b098cd",
"attachment_id": "ecdee330-3a4b-4b07-8b74-121871b098cd"
},
{
"kind": "stale_upload",
"key": "originals/f957c914-3f81-4212-a39e-3885c019674a",
"attachment_id": "f957c914-3f81-4212-a39e-3885c019674a"
}
]
},
"apply": {
"mode": "apply",
"grace_seconds": 90,
"verify_checksums": false,
"duration_ms": 580,
"cost": {
"s3_list_requests": 1,
"s3_objects": 12,
"db_queries": 10,
"db_rows": 11,
"s3_delete_requests": 5,
"s3_head_requests": 2
},
"findings": {
"size_mismatch": 1,
"orphan_object": 4,
"orphan_object_fresh_kept": 1,
"stale_upload_with_object": 1,
"missing_object_used": 1,
"upload_in_progress_kept": 1,
"lost_object_back_unverified": 1,
"missing_object": 1,
"stale_upload": 1
},
"actions": {
"marked_lost": 3,
"objects_deleted": 5,
"rows_deleted": 2
},
"details": [
{
"kind": "size_mismatch",
"key": "originals/0836f158-90ec-46a7-86c1-1dc2ee443c36",
"attachment_id": "0836f158-90ec-46a7-86c1-1dc2ee443c36"
},
{
"kind": "orphan_object",
"key": "originals/3a27e460-a35f-4cd5-adcb-cef04b952caa"
},
{
"kind": "orphan_object",
"key": "originals/676da6c0-1670-40f1-966e-5177f90382a9"
},
{
"kind": "stale_upload_with_object",
"key": "originals/6c3a748b-23d3-4911-8a22-e912935726d1",
"attachment_id": "6c3a748b-23d3-4911-8a22-e912935726d1"
},
{
"kind": "missing_object",
"key": "originals/79e49f97-9d5a-427c-806e-27e92706983e",
"attachment_id": "79e49f97-9d5a-427c-806e-27e92706983e"
},
{
"kind": "orphan_object",
"key": "originals/dd2e6a38-071e-46ca-9ccc-f37e3fdbc9f8"
},
{
"kind": "orphan_object",
"key": "originals/e332f279-138e-4e26-8ed9-c198ca6f0868"
},
{
"kind": "missing_object",
"key": "originals/ecdee330-3a4b-4b07-8b74-121871b098cd",
"attachment_id": "ecdee330-3a4b-4b07-8b74-121871b098cd"
},
{
"kind": "stale_upload",
"key": "originals/f957c914-3f81-4212-a39e-3885c019674a",
"attachment_id": "f957c914-3f81-4212-a39e-3885c019674a"
}
]
},
"apply_again": {
"mode": "apply",
"grace_seconds": 90,
"verify_checksums": false,
"duration_ms": 395,
"cost": {
"s3_list_requests": 1,
"s3_objects": 7,
"db_queries": 1,
"db_rows": 9
},
"findings": {
"lost_known": 3,
"orphan_object_fresh_kept": 1,
"upload_in_progress_kept": 1,
"lost_object_back_unverified": 1
},
"actions": {},
"details": []
},
"verify_checksums": {
"mode": "apply",
"grace_seconds": 90,
"verify_checksums": true,
"duration_ms": 680,
"cost": {
"s3_list_requests": 1,
"s3_objects": 7,
"db_queries": 3,
"db_rows": 9,
"s3_get_requests": 4,
"bytes_read": 447268
},
"findings": {
"lost_known": 3,
"checksum_mismatch": 1,
"orphan_object_fresh_kept": 1,
"upload_in_progress_kept": 1,
"lost_object_back": 1
},
"actions": {
"marked_lost": 1,
"restored": 1
},
"details": [
{
"kind": "checksum_mismatch",
"key": "originals/4f742657-3624-4fb6-af3b-6e5b8fad28d9",
"attachment_id": "4f742657-3624-4fb6-af3b-6e5b8fad28d9"
},
{
"kind": "lost_object_back",
"key": "originals/c5e10e84-7b30-4c28-9f53-16a31a14dc45",
"attachment_id": "c5e10e84-7b30-4c28-9f53-16a31a14dc45"
}
]
},
"verify_again": {
"mode": "apply",
"grace_seconds": 90,
"verify_checksums": true,
"duration_ms": 711,
"cost": {
"s3_list_requests": 1,
"s3_objects": 7,
"db_queries": 1,
"db_rows": 9,
"s3_get_requests": 3,
"bytes_read": 335451
},
"findings": {
"lost_known": 4,
"orphan_object_fresh_kept": 1,
"upload_in_progress_kept": 1
},
"actions": {},
"details": []
},
"state_after": {
"rows": [
"lost:4",
"ready:9995",
"uploading:1"
],
"objects": 1000
},
"cost": [
{
"rows": 1000,
"dry_run": {
"duration_ms": 996,
"s3_list_requests": 1,
"s3_objects": 998,
"db_queries": 2,
"db_rows": 1000
},
"verify_checksums": {
"duration_ms": 18881,
"s3_list_requests": 1,
"s3_objects": 998,
"db_queries": 2,
"db_rows": 1000,
"s3_get_requests": 996,
"bytes_read": 627464
}
},
{
"rows": 10000,
"dry_run": {
"duration_ms": 5290,
"s3_list_requests": 10,
"s3_objects": 9998,
"db_queries": 11,
"db_rows": 10000
},
"verify_checksums": {
"duration_ms": 87638,
"s3_list_requests": 10,
"s3_objects": 9998,
"db_queries": 11,
"db_rows": 10000,
"s3_get_requests": 9996,
"bytes_read": 1248464
}
}
]
}
+124
View File
@@ -0,0 +1,124 @@
{
"experiment": "concurrent ~10 MiB PNG uploads through nginx",
"api_memory_limit": "512M per replica, JVM heap max 128 MiB",
"max_concurrent_uploads_per_replica": 8,
"results": [
{
"concurrent_uploads": 1,
"file_mib": 9.79,
"statuses": {
"201": 1
},
"replicas_used": 1,
"wall_seconds": 1.14,
"latency_seconds": {
"p50": 1.13,
"max": 1.13
},
"memory": {
"api-1": {
"baseline_current_mib": 261.4,
"baseline_anon_mib": 198.2,
"peak_current_mib": 286.6,
"peak_anon_mib": 209.3
},
"api-2": {
"baseline_current_mib": 234.7,
"baseline_anon_mib": 218.9,
"peak_current_mib": 235.2,
"peak_anon_mib": 218.9
},
"nginx": {
"baseline_current_mib": 10.7,
"baseline_anon_mib": 8.1,
"peak_current_mib": 21.1,
"peak_anon_mib": 8.1
},
"s3": {
"baseline_current_mib": 67.5,
"baseline_anon_mib": 52.4,
"peak_current_mib": 88.3,
"peak_anon_mib": 71.7
}
}
},
{
"concurrent_uploads": 10,
"file_mib": 9.79,
"statuses": {
"201": 10
},
"replicas_used": 2,
"wall_seconds": 2.55,
"latency_seconds": {
"p50": 2.41,
"max": 2.54
},
"memory": {
"api-1": {
"baseline_current_mib": 276.2,
"baseline_anon_mib": 209.5,
"peak_current_mib": 330.6,
"peak_anon_mib": 215.6
},
"api-2": {
"baseline_current_mib": 235.8,
"baseline_anon_mib": 219.2,
"peak_current_mib": 285.7,
"peak_anon_mib": 222.4
},
"nginx": {
"baseline_current_mib": 11.0,
"baseline_anon_mib": 8.2,
"peak_current_mib": 109.5,
"peak_anon_mib": 8.5
},
"s3": {
"baseline_current_mib": 88.3,
"baseline_anon_mib": 62.9,
"peak_current_mib": 349.1,
"peak_anon_mib": 239.4
}
}
},
{
"concurrent_uploads": 20,
"file_mib": 9.79,
"statuses": {
"201": 20
},
"replicas_used": 2,
"wall_seconds": 6.51,
"latency_seconds": {
"p50": 6.01,
"max": 6.5
},
"memory": {
"api-1": {
"baseline_current_mib": 285.5,
"baseline_anon_mib": 218.9,
"peak_current_mib": 326.5,
"peak_anon_mib": 220.0
},
"api-2": {
"baseline_current_mib": 238.5,
"baseline_anon_mib": 222.6,
"peak_current_mib": 312.1,
"peak_anon_mib": 227.7
},
"nginx": {
"baseline_current_mib": 11.0,
"baseline_anon_mib": 8.3,
"peak_current_mib": 128.0,
"peak_anon_mib": 8.7
},
"s3": {
"baseline_current_mib": 333.6,
"baseline_anon_mib": 209.7,
"peak_current_mib": 512.0,
"peak_anon_mib": 372.5
}
}
}
]
}
@@ -0,0 +1,124 @@
{
"experiment": "concurrent ~10 MiB PNG uploads through nginx",
"api_memory_limit": "512M per replica, JVM heap max 128 MiB",
"max_concurrent_uploads_per_replica": 8,
"results": [
{
"concurrent_uploads": 1,
"file_mib": 9.79,
"statuses": {
"201": 1
},
"replicas_used": 1,
"wall_seconds": 0.56,
"latency_seconds": {
"p50": 0.55,
"max": 0.55
},
"memory": {
"api-1": {
"baseline_current_mib": 229.4,
"baseline_anon_mib": 228.3,
"peak_current_mib": 229.9,
"peak_anon_mib": 228.3
},
"api-2": {
"baseline_current_mib": 226.6,
"baseline_anon_mib": 210.4,
"peak_current_mib": 249.1,
"peak_anon_mib": 213.4
},
"nginx": {
"baseline_current_mib": 12.9,
"baseline_anon_mib": 8.3,
"peak_current_mib": 22.3,
"peak_anon_mib": 8.3
},
"s3": {
"baseline_current_mib": 147.2,
"baseline_anon_mib": 139.2,
"peak_current_mib": 253.5,
"peak_anon_mib": 178.8
}
}
},
{
"concurrent_uploads": 10,
"file_mib": 9.79,
"statuses": {
"201": 10
},
"replicas_used": 2,
"wall_seconds": 4.53,
"latency_seconds": {
"p50": 4.27,
"max": 4.52
},
"memory": {
"api-1": {
"baseline_current_mib": 229.9,
"baseline_anon_mib": 228.6,
"peak_current_mib": 281.5,
"peak_anon_mib": 231.3
},
"api-2": {
"baseline_current_mib": 240.0,
"baseline_anon_mib": 213.7,
"peak_current_mib": 292.8,
"peak_anon_mib": 217.0
},
"nginx": {
"baseline_current_mib": 12.9,
"baseline_anon_mib": 8.5,
"peak_current_mib": 111.2,
"peak_anon_mib": 8.7
},
"s3": {
"baseline_current_mib": 253.3,
"baseline_anon_mib": 178.9,
"peak_current_mib": 512.0,
"peak_anon_mib": 507.0
}
}
},
{
"concurrent_uploads": 20,
"file_mib": 9.79,
"statuses": {
"201": 20
},
"replicas_used": 2,
"wall_seconds": 11.85,
"latency_seconds": {
"p50": 10.9,
"max": 11.82
},
"memory": {
"api-1": {
"baseline_current_mib": 232.2,
"baseline_anon_mib": 231.4,
"peak_current_mib": 314.0,
"peak_anon_mib": 234.2
},
"api-2": {
"baseline_current_mib": 244.3,
"baseline_anon_mib": 217.2,
"peak_current_mib": 326.4,
"peak_anon_mib": 221.7
},
"nginx": {
"baseline_current_mib": 12.8,
"baseline_anon_mib": 8.6,
"peak_current_mib": 128.0,
"peak_anon_mib": 9.1
},
"s3": {
"baseline_current_mib": 509.1,
"baseline_anon_mib": 346.5,
"peak_current_mib": 512.0,
"peak_anon_mib": 502.2
}
}
}
]
}
+70
View File
@@ -0,0 +1,70 @@
# Встроенный DNS Docker: адреса реплик перечитываются каждые 5 секунд. Поэтому nginx
# стартует, даже если одна реплика остановлена, и находит пересозданный контейнер с новым IP.
resolver 127.0.0.11 valid=5s ipv6=off;
upstream api_backend {
# zone нужна для resolve: адреса реплик хранятся в общей памяти воркеров nginx.
zone api_backend 64k;
# Балансировка между API-репликами round-robin.
# max_fails и fail_timeout обеспечивают пассивную проверку здоровья.
server api-1:8080 resolve max_fails=3 fail_timeout=10s;
server api-2:8080 resolve max_fails=3 fail_timeout=10s;
# Переиспользование соединений с репликами.
keepalive 32;
}
server {
listen 8080;
server_name localhost;
# Таймауты для предотвращения зависаний.
# proxy_connect_timeout 1s — быстрое обнаружение отказа backend.
proxy_connect_timeout 1s;
proxy_send_timeout 60s;
proxy_read_timeout 60s;
# Передача заголовков клиента в backend (наследуется всеми location ниже).
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
# Поддержка keepalive соединений с backend.
proxy_http_version 1.1;
proxy_set_header Connection "";
# Повтор на другой реплике: не более 2 попыток и 10 секунд.
proxy_next_upstream_tries 2;
proxy_next_upstream_timeout 10s;
# Вложения до 10 MiB проверяет API (JSON 413 с X-Request-Id). Запас до 11m, чтобы ответ
# 413 на 10 MiB + 1 байт давало приложение; всё больше nginx отсекает сам, не читая тело.
# Тело буферизуется в nginx: медленный клиент не держит поток API.
client_max_body_size 11m;
client_body_timeout 15s;
error_page 413 = @payload_too_large;
# Основной location для API и health.
location / {
proxy_pass http://api_backend;
# Уже отправленный POST (users, chats, auth/sessions) не повторяем:
# прозрачный повтор может создать второй объект (contracts/README.md).
proxy_next_upstream error timeout http_503;
}
# Отправку сообщения повторять безопасно: дубль отсекает Idempotency-Key.
# Загрузку вложения (POST .../attachments) nginx не повторяет: контракт запрещает прозрачный retry.
location ~ ^/api/v1/chats/[^/]+/messages$ {
proxy_pass http://api_backend;
proxy_next_upstream error timeout http_503 non_idempotent;
}
# Ответ nginx на слишком большое тело — в формате ошибки контракта, а не HTML.
location @payload_too_large {
default_type application/json;
add_header X-Request-Id $request_id always;
return 413 '{"error":{"code":"payload_too_large","message":"payload too large","request_id":"$request_id"}}';
}
}
+26
View File
@@ -0,0 +1,26 @@
#!/bin/sh
# Идемпотентный bootstrap S3: bucket создаётся один раз, повторный запуск ничего не меняет.
# Работает с admin-ключами; API их не получает. Ключи передаются curl через stdin, не в argv.
set -eu
url="$S3_ENDPOINT/$S3_BUCKET"
s3() {
printf 'user = "%s:%s"\n' "$(cat /run/secrets/s3_admin_access_key)" "$(cat /run/secrets/s3_admin_secret_key)" |
curl -K - -s -o /dev/null -w '%{http_code}' --aws-sigv4 "aws:amz:$S3_REGION:s3" "$@"
}
code=$(s3 -I "$url")
case "$code" in
200) echo "bucket $S3_BUCKET already exists" ;;
404)
code=$(s3 -X PUT "$url")
# 409: bucket успели создать параллельно — это тоже успех.
[ "$code" = 200 ] || [ "$code" = 409 ] || { echo "create bucket failed: HTTP $code" >&2; exit 1; }
echo "bucket $S3_BUCKET created" ;;
*) echo "head bucket failed: HTTP $code" >&2; exit 1 ;;
esac
# Bucket приватный: анонимный листинг и чтение должны получать 403.
anon=$(curl -s -o /dev/null -w '%{http_code}' "$url?list-type=2")
[ "$anon" = 403 ] || { echo "bucket is not private: anonymous list -> HTTP $anon" >&2; exit 1; }
echo "anonymous list -> 403, bucket is private"
+36
View File
@@ -0,0 +1,36 @@
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.3.5</version>
<relativePath/>
</parent>
<groupId>ru.mtusi</groupId>
<artifactId>messenger</artifactId>
<version>1.0.0</version>
<properties><java.version>21</java.version></properties>
<dependencyManagement>
<dependencies>
<!-- AWS SDK v2 для S3-совместимого SeaweedFS. -->
<dependency><groupId>software.amazon.awssdk</groupId><artifactId>bom</artifactId><version>2.29.52</version><type>pom</type><scope>import</scope></dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency>
<dependency><groupId>org.springframework.security</groupId><artifactId>spring-security-crypto</artifactId></dependency>
<dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId><scope>runtime</scope></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
<dependency><groupId>org.flywaydb</groupId><artifactId>flyway-core</artifactId></dependency>
<dependency><groupId>org.flywaydb</groupId><artifactId>flyway-database-postgresql</artifactId></dependency>
<dependency>
<groupId>software.amazon.awssdk</groupId><artifactId>s3</artifactId>
<exclusions><exclusion><groupId>software.amazon.awssdk</groupId><artifactId>netty-nio-client</artifactId></exclusion></exclusions>
</dependency>
<!-- Синхронный HTTP-клиент с пулом соединений и настраиваемыми таймаутами. -->
<dependency><groupId>software.amazon.awssdk</groupId><artifactId>apache-client</artifactId></dependency>
</dependencies>
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>
+41
View File
@@ -0,0 +1,41 @@
#!/bin/sh
# Проверка приватности S3 мимо API (уровень 4). Запросы идут из отдельного контейнера s3-probe
# в сети стенда — ближе всего к атакующему внутри; с хоста S3 вообще недоступен.
# Нужен хотя бы один загруженный файл (например, после make test). Секреты не печатаются.
set -eu
cd "$(dirname "$0")/.."
key=$(docker compose exec -T postgres psql -U messenger -d messenger -At -c "select object_key from attachments where state='ready' limit 1")
[ -n "$key" ] || { echo "no attachments yet: run make test first" >&2; exit 2; }
docker compose run --rm -T -e KEY="$key" s3-probe <<'EOF'
url="http://s3:8333/messenger-attachments"
fail=0
expect() { # expect <описание> <ожидаемый код> <фактический код>
if [ "$2" = "$3" ]; then echo "PASS $1 -> $3"; else echo "FAIL $1 -> $3 (expected $2)"; fail=1; fi
}
signed() { # подписанный запрос ключами API; ключи идут в curl через stdin, не в argv
printf 'user = "%s:%s"\n' "$(cat /run/secrets/s3.access-key)" "$(cat /run/secrets/s3.secret-key)" |
curl -K - -s -o /tmp/body -w '%{http_code}' -m 5 --aws-sigv4 aws:amz:us-east-1:s3 "$@"
}
anon() { curl -s -o /dev/null -w '%{http_code}' -m 5 "$@"; }
expect "anonymous GET object" 403 "$(anon "$url/$KEY")"
expect "anonymous HEAD object" 403 "$(anon -I "$url/$KEY")"
expect "anonymous LIST bucket" 403 "$(anon "$url?list-type=2")"
expect "anonymous PUT object" 403 "$(anon -X PUT --data-binary x "$url/originals/anon-probe")"
# Контроль: подпись верна и ключ API читает свой bucket — значит, 403 ниже вызваны именно правами.
expect "API key GET object (control)" 200 "$(signed "$url/$KEY")"
expect "API key create other bucket" 403 "$(signed -X PUT http://s3:8333/probe-other-bucket)"
grep -q AccessDenied /tmp/body && echo "PASS ...denied by policy (AccessDenied), not by signature" || { echo "FAIL unexpected error body"; fail=1; }
expect "API key delete own bucket" 403 "$(signed -X DELETE "$url")"
# HTTP-админки SeaweedFS (master UI, filer UI, volume) слушают только 127.0.0.1 внутри контейнера s3.
for port in 9333 8888 8080; do expect "admin port s3:$port reachable" 000 "$(anon "http://s3:$port/")"; done
exit $fail
EOF
# С хоста опубликован только порт nginx.
if docker compose ps --format '{{.Service}} {{.Ports}}' | grep -v '^nginx' | grep -q -- '->'; then
echo "FAIL services other than nginx publish host ports"; exit 1
fi
echo "PASS only nginx publishes host ports"
+49
View File
@@ -0,0 +1,49 @@
#!/usr/bin/env python3
"""Создаёт синтетические секреты локального стенда в secrets/ (вне Git); значения не печатает.
Повторный запуск не меняет существующие файлы: пароль PostgreSQL задаётся при первой
инициализации volume, и его смена сломала бы уже созданный стенд.
"""
import json
import os
import secrets
import string
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
DIR = ROOT / 'secrets'
BUCKET = os.environ.get('S3_BUCKET', 'messenger-attachments')
def value(name, generate):
path = DIR / name
if not path.exists():
path.write_text(generate(), encoding='utf-8')
# 644: файлы монтируются в контейнеры, где сервисы работают не от root; каталог закрыт 700.
os.chmod(path, 0o644)
return path.read_text(encoding='utf-8')
def token():
return secrets.token_urlsafe(30)
def access_key():
return ''.join(secrets.choice(string.ascii_uppercase + string.digits) for _ in range(20))
DIR.mkdir(exist_ok=True)
os.chmod(DIR, 0o700)
value('db_password', token)
redis_password = value('redis_password', token)
value('redis.conf', lambda: 'requirepass %s\nappendonly yes\ndir /data\n' % redis_password)
api_key, api_secret = value('s3_api_access_key', access_key), value('s3_api_secret_key', token)
admin_key, admin_secret = value('s3_admin_access_key', access_key), value('s3_admin_secret_key', token)
# admin нужен только s3-init для создания bucket; API получает права лишь на свой bucket.
value('s3_config.json', lambda: json.dumps({'identities': [
{'name': 'admin', 'credentials': [{'accessKey': admin_key, 'secretKey': admin_secret}],
'actions': ['Admin', 'Read', 'Write', 'List']},
{'name': 'api', 'credentials': [{'accessKey': api_key, 'secretKey': api_secret}],
'actions': ['Read:' + BUCKET, 'Write:' + BUCKET, 'List:' + BUCKET]},
]}, indent=2))
print('secrets ready in %s (values are not printed)' % DIR)
+47
View File
@@ -0,0 +1,47 @@
#!/bin/bash
# Поочерёдная остановка каждой API-реплики под нагрузкой (уровень «4»).
# RPS, ошибки и p50/p95/p99 даёт tests/load.py (POST сообщений через nginx),
# время восстановления — от запуска реплики до её возвращения в балансировку nginx.
# Время переключения LB на живую реплику измеряет make test-failover (first_recovery_seconds).
set -euo pipefail
cd "$(dirname "$0")/.."
BASE_URL="${BASE_URL:-http://localhost:8080}"
DURATION="${DURATION:-40}"
OUTPUT_DIR="${OUTPUT_DIR:-evidence/failover}"
mkdir -p "$OUTPUT_DIR"
# healthy ещё не значит «в балансировке»: nginx держит упавшую реплику выключенной fail_timeout=10s.
in_rotation() {
local id; id=$(docker compose ps -q "$1" | cut -c1-12)
for _ in $(seq 60); do
curl -s -D - -o /dev/null "$BASE_URL/health/live" | grep -qi "x-instance-id: $id" && return 0
sleep 0.5
done
echo "$1 не вернулась в балансировку за 30 s" >&2; return 1
}
for svc in api-1 api-2; do
result="$OUTPUT_DIR/${svc}_$(date +%Y%m%d_%H%M%S).json"
echo "=== Остановка $svc под нагрузкой (${DURATION}s, 4 потока POST сообщений) ==="
python3 tests/load.py --base-url "$BASE_URL" --duration "$DURATION" --concurrency 4 --output "$result" >/dev/null &
load_pid=$!
sleep 5
docker compose stop "$svc"
echo "$svc остановлена, запросы обслуживает другая реплика"
sleep 10
start=$SECONDS
docker compose up -d --no-deps --wait "$svc"
in_rotation "$svc"
echo "Время восстановления $svc (запуск → снова в балансировке): $((SECONDS - start)) s"
wait "$load_pid" || echo "load.py завершился с ошибкой"
cat "$result"
echo
done
echo "Результаты в: $OUTPUT_DIR"
+290
View File
@@ -0,0 +1,290 @@
#!/usr/bin/env python3
"""
Reconciler для согласованности S3 и PostgreSQL (Трек 5).
Функции:
- Обнаружение orphan объектов (в S3, но нет в БД)
- Обнаружение missing файлов (в БД, но нет в S3)
- Dry-run режим для безопасной проверки
- Grace period для защиты свежих файлов
- Метрики и отчет
"""
import argparse
import sys
import json
from datetime import datetime, timedelta, timezone
import psycopg2
import boto3
from botocore.client import Config
def parse_args():
parser = argparse.ArgumentParser(description='S3/DB reconciler for attachments')
parser.add_argument('--db-host', default='localhost', help='PostgreSQL host')
parser.add_argument('--db-port', type=int, default=5432, help='PostgreSQL port')
parser.add_argument('--db-name', default='messenger', help='Database name')
parser.add_argument('--db-user', default='messenger', help='Database user')
parser.add_argument('--db-password', default='messenger', help='Database password')
parser.add_argument('--s3-endpoint', default='http://localhost:9000', help='S3 endpoint')
parser.add_argument('--s3-access-key', default='minioadmin', help='S3 access key')
parser.add_argument('--s3-secret-key', default='minioadmin', help='S3 secret key')
parser.add_argument('--s3-bucket', default='messenger-attachments', help='S3 bucket name')
parser.add_argument('--grace-period-hours', type=int, default=1, help='Grace period in hours for fresh files')
parser.add_argument('--dry-run', action='store_true', help='Dry run mode (no deletions)')
parser.add_argument('--output', default='reconciler_report.json', help='Output report file')
return parser.parse_args()
def connect_db(args):
"""Подключение к PostgreSQL."""
return psycopg2.connect(
host=args.db_host,
port=args.db_port,
dbname=args.db_name,
user=args.db_user,
password=args.db_password
)
def connect_s3(args):
"""Подключение к S3 (MinIO)."""
return boto3.client(
's3',
endpoint_url=args.s3_endpoint,
aws_access_key_id=args.s3_access_key,
aws_secret_access_key=args.s3_secret_key,
config=Config(signature_version='s3v4')
)
def get_db_attachments(conn):
"""Получить список всех s3_key из БД с метаданными."""
cur = conn.cursor()
cur.execute("""
SELECT id, s3_key, created_at, status, chat_id
FROM attachments
ORDER BY created_at DESC
""")
attachments = {}
for row in cur.fetchall():
att_id, s3_key, created_at, status, chat_id = row
attachments[s3_key] = {
'id': str(att_id),
'created_at': created_at,
'status': status,
'chat_id': str(chat_id)
}
cur.close()
return attachments
def get_s3_objects(s3_client, bucket):
"""Получить список всех объектов из S3."""
objects = {}
paginator = s3_client.get_paginator('list_objects_v2')
for page in paginator.paginate(Bucket=bucket, Prefix='attachments/'):
if 'Contents' not in page:
continue
for obj in page['Contents']:
key = obj['Key']
objects[key] = {
'size': obj['Size'],
'last_modified': obj['LastModified']
}
return objects
def find_orphans(s3_objects, db_attachments, grace_period_hours):
"""Найти orphan объекты в S3 (нет в БД)."""
orphans = []
grace_cutoff = datetime.now(timezone.utc) - timedelta(hours=grace_period_hours)
for s3_key, s3_meta in s3_objects.items():
if s3_key not in db_attachments:
# Проверяем grace period.
if s3_meta['last_modified'] > grace_cutoff:
continue
orphans.append({
's3_key': s3_key,
'size': s3_meta['size'],
'last_modified': s3_meta['last_modified'].isoformat(),
'age_hours': (datetime.now(timezone.utc) - s3_meta['last_modified']).total_seconds() / 3600
})
return orphans
def find_missing(db_attachments, s3_objects, grace_period_hours):
"""Найти missing файлы (в БД, но нет в S3)."""
missing = []
grace_cutoff = datetime.now(timezone.utc) - timedelta(hours=grace_period_hours)
for s3_key, db_meta in db_attachments.items():
if s3_key not in s3_objects:
# Проверяем grace period.
created_at_utc = db_meta['created_at'].replace(tzinfo=timezone.utc)
if created_at_utc > grace_cutoff:
continue
missing.append({
's3_key': s3_key,
'attachment_id': db_meta['id'],
'created_at': db_meta['created_at'].isoformat(),
'status': db_meta['status'],
'chat_id': db_meta['chat_id'],
'age_hours': (datetime.now(timezone.utc) - created_at_utc).total_seconds() / 3600
})
return missing
def delete_orphans(s3_client, bucket, orphans, dry_run):
"""Удалить orphan объекты из S3."""
deleted = 0
for orphan in orphans:
s3_key = orphan['s3_key']
if dry_run:
print(f"[DRY-RUN] Would delete S3 object: {s3_key}")
else:
try:
s3_client.delete_object(Bucket=bucket, Key=s3_key)
print(f"Deleted S3 orphan: {s3_key}")
deleted += 1
except Exception as e:
print(f"Failed to delete {s3_key}: {e}", file=sys.stderr)
return deleted
def mark_missing(conn, missing, dry_run):
"""Отметить missing файлы в БД (status=failed, error_code)."""
marked = 0
cur = conn.cursor()
for miss in missing:
att_id = miss['attachment_id']
if dry_run:
print(f"[DRY-RUN] Would mark attachment {att_id} as failed (s3_object_missing)")
else:
try:
cur.execute("""
UPDATE attachments
SET status = 'failed', error_code = 's3_object_missing'
WHERE id = %s AND status != 'failed'
""", (att_id,))
if cur.rowcount > 0:
print(f"Marked attachment {att_id} as failed")
marked += 1
except Exception as e:
print(f"Failed to mark {att_id}: {e}", file=sys.stderr)
if not dry_run:
conn.commit()
cur.close()
return marked
def generate_report(args, db_attachments, s3_objects, orphans, missing, deleted_count, marked_count):
"""Сгенерировать JSON-отчет."""
total_db = len(db_attachments)
total_s3 = len(s3_objects)
total_orphans = len(orphans)
total_missing = len(missing)
# Размеры.
orphan_bytes = sum(o['size'] for o in orphans)
report = {
'timestamp': datetime.now(timezone.utc).isoformat(),
'parameters': {
'grace_period_hours': args.grace_period_hours,
'dry_run': args.dry_run
},
'summary': {
'total_db_attachments': total_db,
'total_s3_objects': total_s3,
'orphan_objects': total_orphans,
'orphan_bytes': orphan_bytes,
'missing_files': total_missing,
'deleted_orphans': deleted_count,
'marked_missing': marked_count
},
'orphans': orphans[:100], # Первые 100 для отчета.
'missing': missing[:100]
}
with open(args.output, 'w') as f:
json.dump(report, f, indent=2, default=str)
return report
def main():
args = parse_args()
print("=== S3/DB Reconciler ===")
print(f"Mode: {'DRY-RUN' if args.dry_run else 'LIVE'}")
print(f"Grace period: {args.grace_period_hours} hours")
print()
# Подключение.
print("Connecting to PostgreSQL...")
conn = connect_db(args)
print("Connecting to S3...")
s3 = connect_s3(args)
# Сканирование.
print("Scanning database...")
db_attachments = get_db_attachments(conn)
print(f"Found {len(db_attachments)} attachments in database")
print("Scanning S3 bucket...")
s3_objects = get_s3_objects(s3, args.s3_bucket)
print(f"Found {len(s3_objects)} objects in S3")
print()
# Поиск несоответствий.
print("Finding orphan objects...")
orphans = find_orphans(s3_objects, db_attachments, args.grace_period_hours)
print(f"Found {len(orphans)} orphan objects (older than {args.grace_period_hours}h)")
print("Finding missing files...")
missing = find_missing(db_attachments, s3_objects, args.grace_period_hours)
print(f"Found {len(missing)} missing files (older than {args.grace_period_hours}h)")
print()
# Очистка.
deleted_count = 0
marked_count = 0
if orphans:
print("Processing orphan objects...")
deleted_count = delete_orphans(s3, args.s3_bucket, orphans, args.dry_run)
print()
if missing:
print("Processing missing files...")
marked_count = mark_missing(conn, missing, args.dry_run)
print()
# Отчет.
print("Generating report...")
report = generate_report(args, db_attachments, s3_objects, orphans, missing, deleted_count, marked_count)
print(f"Report saved to: {args.output}")
print()
# Итоги.
print("=== Summary ===")
print(f"Database attachments: {report['summary']['total_db_attachments']}")
print(f"S3 objects: {report['summary']['total_s3_objects']}")
print(f"Orphan objects: {report['summary']['orphan_objects']} ({report['summary']['orphan_bytes']} bytes)")
print(f"Missing files: {report['summary']['missing_files']}")
if not args.dry_run:
print(f"Deleted orphans: {deleted_count}")
print(f"Marked missing: {marked_count}")
else:
print("(DRY-RUN: no changes made)")
conn.close()
if __name__ == '__main__':
main()
+21
View File
@@ -0,0 +1,21 @@
#!/bin/bash
# Скрипт перезапуска всего стенда с сохранением volumes.
set -e
echo "Останавливаем все контейнеры стенда..."
docker compose down
echo "Запускаем стенд заново..."
docker compose up -d
echo "Ожидаем готовности сервисов..."
sleep 10
echo "Проверяем статус контейнеров..."
docker compose ps
echo "Проверяем health check..."
curl -f http://localhost:8080/health/ready || echo "API ещё не готов"
echo "Стенд успешно перезапущен"
+49
View File
@@ -0,0 +1,49 @@
#!/bin/bash
# Rolling update под нагрузкой: реплики пересобираются и заменяются по одной,
# пока tests/load.py пишет сообщения через nginx.
set -euo pipefail
cd "$(dirname "$0")/.."
BASE_URL="${BASE_URL:-http://localhost:8080}"
DURATION="${DURATION:-60}"
OUTPUT_DIR="${OUTPUT_DIR:-evidence/rolling}"
mkdir -p "$OUTPUT_DIR"
result="$OUTPUT_DIR/rolling_$(date +%Y%m%d_%H%M%S).json"
# healthy ещё не значит «в балансировке»: nginx держит упавшую реплику выключенной fail_timeout=10s.
# Ждём ответ с X-Instance-Id новой реплики, иначе следующая замена оставит nginx без живых backend.
in_rotation() {
local id; id=$(docker compose ps -q "$1" | cut -c1-12)
for _ in $(seq 60); do
curl -s -D - -o /dev/null "$BASE_URL/health/live" | grep -qi "x-instance-id: $id" && return 0
sleep 0.5
done
echo "$1 не вернулась в балансировку за 30 s" >&2; return 1
}
echo "=== Rolling update под нагрузкой (${DURATION}s, 4 потока POST сообщений) ==="
docker compose ps
python3 tests/load.py --base-url "$BASE_URL" --duration "$DURATION" --concurrency 4 --output "$result" >/dev/null &
load_pid=$!
sleep 5
for svc in api-1 api-2; do
# Сборка до остановки: пока собирается образ, реплика продолжает работать.
echo "Собираем образ $svc..."
docker compose build -q "$svc"
# --force-recreate заменяет контейнер, даже если образ не изменился.
echo "Заменяем $svc и ждём healthy..."
start=$SECONDS
docker compose up -d --no-deps --force-recreate --wait "$svc"
in_rotation "$svc"
echo "$svc заменена и снова в балансировке за $((SECONDS - start)) s"
done
echo "Ожидание завершения нагрузки..."
wait "$load_pid" || echo "load.py завершился с ошибкой"
docker compose ps
echo "=== Нагрузка во время rolling update ==="
cat "$result"
+13
View File
@@ -0,0 +1,13 @@
#!/bin/sh
# Останавливает ровно ту API-реплику, чей X-Instance-Id передан тестом в TARGET_INSTANCE_ID,
# и оставляет её остановленной. X-Instance-Id = hostname = первые 12 символов ID контейнера.
# Восстановление после теста: docker compose start api-1 api-2
set -eu
: "${TARGET_INSTANCE_ID:?тест передаёт X-Instance-Id обслужившей реплики}"
case "$TARGET_INSTANCE_ID" in
*[!0-9a-f]* | "") echo "unexpected instance id" >&2; exit 2 ;;
esac
cid=$(docker compose ps -q api-1 api-2 | grep "^$TARGET_INSTANCE_ID" || true)
[ "$(printf "%s\n" "$cid" | grep -c .)" -eq 1 ] || { echo "no single running api container for $TARGET_INSTANCE_ID" >&2; exit 1; }
docker stop "$cid" >/dev/null
echo "stopped $(docker inspect -f "{{.Name}}" "$cid") ($TARGET_INSTANCE_ID)"
+109
View File
@@ -0,0 +1,109 @@
#!/bin/bash
# Скрипт для тестирования reconciler (Трек 5).
set -e
echo "=== Testing Reconciler (Трек 5) ==="
echo
# Проверка, что стенд запущен.
if ! docker compose ps | grep -q "Up"; then
echo "Error: Docker Compose stack is not running"
exit 1
fi
# Установка зависимостей для reconciler.
echo "Installing Python dependencies..."
pip3 install -q psycopg2-binary boto3 2>/dev/null || pip install -q psycopg2-binary boto3
# 1. Baseline: reconciler на чистой системе.
echo "Step 1: Running reconciler on clean system (baseline)..."
python3 scripts/reconciler.py \
--db-host localhost \
--s3-endpoint http://localhost:9000 \
--grace-period-hours 0 \
--dry-run \
--output evidence/reconciler_baseline.json
echo "Baseline report saved to evidence/reconciler_baseline.json"
echo
# 2. Создание тестовых orphan объектов в S3.
echo "Step 2: Creating orphan objects in S3..."
docker compose exec -T minio sh -c "
mc alias set myminio http://localhost:9000 minioadmin minioadmin
echo 'orphan test data' | mc pipe myminio/messenger-attachments/attachments/test-orphan-1.jpg
echo 'orphan test data 2' | mc pipe myminio/messenger-attachments/attachments/test-orphan-2.png
mc ls myminio/messenger-attachments/attachments/ | grep test-orphan
"
echo "Created 2 orphan objects"
echo
# 3. Создание missing file (удаление объекта из S3, но оставляем запись в БД).
echo "Step 3: Simulating missing file (requires manual setup via API)..."
echo "Note: This step requires an actual attachment uploaded via API first."
echo "Skipping automatic missing file creation in test script."
echo
# 4. Запуск reconciler в dry-run режиме.
echo "Step 4: Running reconciler in dry-run mode..."
python3 scripts/reconciler.py \
--db-host localhost \
--s3-endpoint http://localhost:9000 \
--grace-period-hours 0 \
--dry-run \
--output evidence/reconciler_dryrun.json
echo "Dry-run report saved to evidence/reconciler_dryrun.json"
echo
# 5. Запуск reconciler в live режиме (удаление orphans).
echo "Step 5: Running reconciler in LIVE mode (cleanup)..."
python3 scripts/reconciler.py \
--db-host localhost \
--s3-endpoint http://localhost:9000 \
--grace-period-hours 0 \
--output evidence/reconciler_cleanup.json
echo "Cleanup report saved to evidence/reconciler_cleanup.json"
echo
# 6. Проверка, что orphans удалены.
echo "Step 6: Verifying orphan cleanup..."
docker compose exec -T minio sh -c "
mc alias set myminio http://localhost:9000 minioadmin minioadmin
mc ls myminio/messenger-attachments/attachments/ | grep test-orphan || echo 'All test orphans removed successfully'
"
echo
# 7. Тест grace period (свежие файлы не трогаются).
echo "Step 7: Testing grace period protection..."
docker compose exec -T minio sh -c "
mc alias set myminio http://localhost:9000 minioadmin minioadmin
echo 'fresh orphan' | mc pipe myminio/messenger-attachments/attachments/test-fresh.jpg
"
python3 scripts/reconciler.py \
--db-host localhost \
--s3-endpoint http://localhost:9000 \
--grace-period-hours 1 \
--dry-run \
--output evidence/reconciler_grace.json
# Проверяем, что свежий файл НЕ попал в список orphans.
if grep -q "test-fresh.jpg" evidence/reconciler_grace.json; then
echo "WARNING: Fresh file should not be in orphans list (grace period failed)"
else
echo "Grace period protection works: fresh file excluded from cleanup"
fi
# Очистка тестового файла.
docker compose exec -T minio sh -c "
mc alias set myminio http://localhost:9000 minioadmin minioadmin
mc rm myminio/messenger-attachments/attachments/test-fresh.jpg
"
echo
echo "=== Reconciler Testing Complete ==="
echo "Reports saved in evidence/ directory:"
echo " - reconciler_baseline.json"
echo " - reconciler_dryrun.json"
echo " - reconciler_cleanup.json"
echo " - reconciler_grace.json"
@@ -0,0 +1,200 @@
package ru.mtusi.messenger;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.Timestamp;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.HexFormat;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.core.exception.SdkException;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.NoSuchKeyException;
import ru.mtusi.messenger.MessengerApplication.ApiException;
// Вложения: метаданные в PostgreSQL, байты в приватном S3. Доступ только через API участникам чата.
@RestController
class Attachments {
static final long MAX_BYTES = 10L * 1024 * 1024;
static final Set<String> VARIANTS = Set.of("thumbnail", "crop", "optimized");
static final Logger log = LoggerFactory.getLogger(Attachments.class);
record Attachment(UUID id, UUID chat_id, UUID owner_id, String filename, String content_type, long size_bytes, String sha256,
String status, List<Object> variants, String error_code, Instant created_at, Instant updated_at) {}
final MessengerApplication.Api api;
final JdbcTemplate db;
final Storage storage;
// Не больше N загрузок на реплику одновременно: диск под временные файлы и CPU проверки ограничены.
final Semaphore uploads = new Semaphore(Integer.parseInt(System.getenv().getOrDefault("MAX_CONCURRENT_UPLOADS", "8")));
Attachments(MessengerApplication.Api api, JdbcTemplate db, Storage storage) {
this.api = api;
this.db = db;
this.storage = storage;
}
@PostMapping("/api/v1/chats/{id}/attachments")
ResponseEntity<Attachment> upload(@PathVariable UUID id, @RequestParam(required = false) String filename, HttpServletRequest r)
throws IOException, InterruptedException {
// Порядок как у остальных endpoint: сессия → доступ к чату → входные данные.
UUID user = api.auth(r);
if (!api.member(id, user)) throw api.notFound();
if (!validFilename(filename)) api.bad();
String declared = declaredType(r.getContentType());
if (declared == null) throw unsupported();
// Заявленный размер проверяем до чтения тела.
if (r.getContentLengthLong() > MAX_BYTES) throw tooLarge();
if (!uploads.tryAcquire(10, TimeUnit.SECONDS)) throw unavailable("too many concurrent uploads, retry later");
Path tmp = Files.createTempFile("upload-", ".bin");
try {
// 1. Тело — во временный файл с жёстким лимитом, SHA-256 считается по ходу. Файл живёт
// только до конца запроса: это буфер проверки, а не хранилище оригинала.
MessageDigest sha = sha256();
long size = 0;
try (InputStream in = r.getInputStream(); OutputStream out = Files.newOutputStream(tmp)) {
byte[] buf = new byte[65536];
while (true) {
int n;
try { n = in.read(buf); } catch (IOException e) { throw new ApiException(HttpStatus.BAD_REQUEST, "invalid_request", "upload interrupted"); }
if (n < 0) break;
size += n;
if (size > MAX_BYTES) throw tooLarge();
sha.update(buf, 0, n);
out.write(buf, 0, n);
}
}
if (size == 0) api.bad();
// 2. Формат по содержимому, лимит пикселей по заголовку — до распаковки.
ImageCheck.Info image;
try { image = ImageCheck.inspect(tmp); } catch (ImageCheck.Invalid e) { throw e.tooLarge ? tooLarge() : unsupported(); }
if (!image.contentType().equals(declared)) throw unsupported();
// 3. Намерение в БД до S3 PUT: любой сбой дальше оставляет след, который найдёт сверка.
UUID attachmentId = UUID.randomUUID();
String key = Storage.ORIGINALS + attachmentId;
String hash = HexFormat.of().formatHex(sha.digest());
Instant created = now();
db.update("insert into attachments(id,chat_id,owner_id,filename,content_type,size_bytes,sha256,width,height,state,object_key,created_at,updated_at) values(?,?,?,?,?,?,?,?,?,'uploading',?,?,?)",
attachmentId, id, user, filename, declared, size, hash, image.width(), image.height(), key, Timestamp.from(created), Timestamp.from(created));
// 4. S3 PUT. Не удался — сразу компенсируем строку; если и это не вышло, её уберёт сверка.
try {
storage.put(key, tmp, declared);
} catch (SdkException e) {
log.warn("S3 put failed for attachment {}: {}", attachmentId, e.toString());
try { db.update("delete from attachments where id=? and state='uploading'", attachmentId); } catch (DataAccessException ignored) {}
throw unavailable("object storage is unavailable");
}
// 5. ready — только после сохранения объекта. Не записалось — удаляем объект, строку уберёт сверка.
Instant ready = now();
try {
db.update("update attachments set state='ready', updated_at=? where id=?", Timestamp.from(ready), attachmentId);
} catch (DataAccessException e) {
try { storage.delete(key); } catch (SdkException ignored) {}
throw e;
}
return ResponseEntity.status(201).body(new Attachment(attachmentId, id, user, filename, declared, size, hash, "ready", List.of(), null, created, ready));
} finally {
Files.deleteIfExists(tmp);
uploads.release();
}
}
@GetMapping("/api/v1/attachments/{id}")
Attachment metadata(@PathVariable UUID id, HttpServletRequest r) {
return visible(id, api.auth(r)).attachment();
}
// Байты отдаются потоком из S3 через авторизованный API, без redirect на bucket.
@GetMapping("/api/v1/attachments/{id}/content")
void content(@PathVariable UUID id, @RequestParam(required = false) String variant, HttpServletRequest r, HttpServletResponse s) throws IOException {
Visible v = visible(id, api.auth(r));
if (variant != null && !variant.equals("original")) {
// Вариантов в lab4 нет: известное имя — 404 (варианта нет), прочее — неверный параметр.
if (VARIANTS.contains(variant)) throw api.notFound();
api.bad();
}
ResponseInputStream<GetObjectResponse> in;
try {
in = storage.get(v.key());
} catch (NoSuchKeyException e) {
// Метаданные есть, объекта нет: рассинхронизация, её покажет и исправит сверка.
log.error("object {} is missing for ready attachment {}", v.key(), id);
throw new ApiException(HttpStatus.INTERNAL_SERVER_ERROR, "internal_error", "internal server error");
} catch (SdkException e) {
throw unavailable("object storage is unavailable");
}
try (in) {
Attachment a = v.attachment();
s.setContentType(a.content_type());
s.setContentLengthLong(a.size_bytes());
s.setHeader("Cache-Control", "private, no-store");
s.setHeader("X-Content-Type-Options", "nosniff");
in.transferTo(s.getOutputStream());
}
}
record Visible(Attachment attachment, String key) {}
// Только ready-вложения чатов, где пользователь участник; иначе 404 без раскрытия существования.
Visible visible(UUID id, UUID user) {
Visible v = db.query("select id,chat_id,owner_id,filename,content_type,size_bytes,sha256,created_at,updated_at,object_key from attachments a where id=? and state='ready'"
+ " and exists(select 1 from chat_members m where m.chat_id=a.chat_id and m.user_id=?)", rs -> rs.next()
? new Visible(new Attachment(rs.getObject(1, UUID.class), rs.getObject(2, UUID.class), rs.getObject(3, UUID.class), rs.getString(4), rs.getString(5),
rs.getLong(6), rs.getString(7), "ready", List.of(), null, rs.getTimestamp(8).toInstant(), rs.getTimestamp(9).toInstant()), rs.getString(10))
: null, id, user);
if (v == null) throw api.notFound();
return v;
}
// filename только для отображения: 1–255 code points, без путей, NUL и управляющих символов.
static boolean validFilename(String name) {
if (name == null || name.isBlank() || name.equals(".") || name.equals("..")) return false;
if (name.codePointCount(0, name.length()) > 255) return false;
return name.codePoints().noneMatch(c -> c == '/' || c == '\\' || Character.getType(c) == Character.CONTROL
|| c == 0x2028 || c == 0x2029 || Character.getType(c) == Character.SURROGATE);
}
static String declaredType(String header) {
try {
MediaType t = MediaType.parseMediaType(header);
String base = t.getType() + "/" + t.getSubtype();
return base.equals("image/png") || base.equals("image/jpeg") ? base : null;
} catch (RuntimeException e) {
return null;
}
}
static Instant now() { return Instant.now().truncatedTo(ChronoUnit.MICROS); }
static MessageDigest sha256() {
try { return MessageDigest.getInstance("SHA-256"); } catch (NoSuchAlgorithmException e) { throw new IllegalStateException(e); }
}
static ApiException tooLarge() { return new ApiException(HttpStatus.PAYLOAD_TOO_LARGE, "payload_too_large", "attachment exceeds 10 MiB or 40 megapixels"); }
static ApiException unsupported() { return new ApiException(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "unsupported_media_type", "only valid PNG or JPEG content is accepted"); }
static ApiException unavailable(String message) { return new ApiException(HttpStatus.SERVICE_UNAVAILABLE, "unavailable", message); }
}
@@ -0,0 +1,242 @@
package ru.mtusi.messenger;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Iterator;
import java.util.zip.CRC32;
import java.util.zip.DataFormatException;
import java.util.zip.Inflater;
import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.stream.ImageInputStream;
// Проверка PNG/JPEG по содержимому в два шага. Сначала потоковый разбор (буферы по 64 KiB): сигнатура,
// CRC/сегменты и размеры из заголовка — лимит пикселей применяется до распаковки. Затем полное декодирование
// с прореживанием: структура ещё не значит, что картинка читается (фильтр строки PNG вне 0–4, JPEG без
// таблиц или данных скана), а растр ограничен ~0.25 Мпикс, поэтому память не растёт с размером изображения.
final class ImageCheck {
static final long MAX_PIXELS = 40_000_000L;
static final byte[] PNG_SIGNATURE = {(byte) 0x89, 'P', 'N', 'G', '\r', '\n', 0x1a, '\n'};
record Info(String contentType, int width, int height) {}
// tooLarge: валидный формат, но больше 40 Мпикс (413); иначе файл повреждён или чужого формата (415).
static final class Invalid extends Exception {
final boolean tooLarge;
Invalid(String message, boolean tooLarge) { super(message); this.tooLarge = tooLarge; }
}
private ImageCheck() {}
static Info inspect(Path file) throws IOException, Invalid {
try (InputStream in = new BufferedInputStream(Files.newInputStream(file), 65536)) {
in.mark(8);
byte[] head = in.readNBytes(8);
in.reset();
Info info;
if (Arrays.equals(head, PNG_SIGNATURE)) info = png(new DataInputStream(in));
else if (head.length >= 3 && (head[0] & 0xff) == 0xff && (head[1] & 0xff) == 0xd8 && (head[2] & 0xff) == 0xff) info = jpeg(in);
else throw bad("not a PNG or JPEG");
decode(file, info);
return info;
}
}
static final long DECODE_PIXELS = 250_000;
// Декодер читает все строки PNG и все сканы JPEG, но в растр попадает каждый step-й пиксель.
// Ошибка или предупреждение декодера (например, «Premature end of JPEG file») — файл не принимаем.
static void decode(Path file, Info info) throws IOException, Invalid {
ImageIO.setUseCache(false);
Iterator<ImageReader> readers = ImageIO.getImageReadersByMIMEType(info.contentType());
if (!readers.hasNext()) throw bad("no decoder for " + info.contentType());
ImageReader reader = readers.next();
boolean[] warned = {false};
reader.addIIOReadWarningListener((source, warning) -> warned[0] = true);
try (ImageInputStream in = ImageIO.createImageInputStream(file.toFile())) {
reader.setInput(in, true, true);
ImageReadParam param = reader.getDefaultReadParam();
int step = (int) Math.ceil(Math.sqrt((double) info.width() * info.height() / DECODE_PIXELS));
if (step > 1) param.setSourceSubsampling(step, step, 0, 0);
reader.read(0, param);
} catch (IOException | RuntimeException e) {
throw bad("image cannot be decoded: " + e.getMessage());
} finally {
reader.dispose();
}
if (warned[0]) throw bad("image data is corrupt or incomplete");
}
static Invalid bad(String message) { return new Invalid(message, false); }
static void checkPixels(long width, long height) throws Invalid {
if (width <= 0 || height <= 0) throw bad("zero image dimension");
if (width * height > MAX_PIXELS) throw new Invalid("image exceeds 40 megapixels", true);
}
// PNG: CRC каждого chunk, IHDR первым, IEND последним, а IDAT распаковывается в никуда со счётчиком байтов.
// Ровно ожидаемое число байтов после inflate ловит и обрыв, и мусор, и «бомбу» с честным заголовком.
static Info png(DataInputStream in) throws IOException, Invalid {
in.readFully(new byte[8]);
CRC32 crc = new CRC32();
Inflater inflater = new Inflater();
byte[] buf = new byte[65536], out = new byte[65536];
int width = 0, height = 0;
long expected = -1, produced = 0;
boolean first = true, inIdat = false, idatDone = false;
try {
while (true) {
int length = in.readInt();
if (length < 0) throw bad("invalid PNG chunk length");
byte[] type = new byte[4];
in.readFully(type);
String name = new String(type, StandardCharsets.ISO_8859_1);
crc.reset();
crc.update(type);
if (first != name.equals("IHDR")) throw bad("IHDR must be the first chunk");
boolean idat = name.equals("IDAT");
if (idat && (idatDone || expected < 0)) throw bad("IDAT chunks must be consecutive after IHDR");
if (inIdat && !idat) idatDone = true;
inIdat = idat;
if (first) {
if (length != 13) throw bad("invalid IHDR");
byte[] h = new byte[13];
in.readFully(h);
crc.update(h);
width = int32(h, 0);
height = int32(h, 4);
checkPixels(width, height);
expected = rawSize(width, height, h[8] & 0xff, h[9] & 0xff, h[12] & 0xff);
if (h[10] != 0 || h[11] != 0) throw bad("unsupported PNG compression/filter");
} else {
for (long left = length; left > 0; ) {
int n = in.read(buf, 0, (int) Math.min(buf.length, left));
if (n < 0) throw new EOFException();
crc.update(buf, 0, n);
left -= n;
if (!idat || inflater.finished()) continue;
inflater.setInput(buf, 0, n);
while (!inflater.finished() && !inflater.needsInput()) {
int k = inflater.inflate(out);
produced += k;
if (produced > expected) throw bad("PNG pixel data is larger than IHDR declares");
if (k == 0 && inflater.needsDictionary()) throw bad("invalid PNG zlib stream");
if (k == 0) break;
}
}
}
if (in.readInt() != (int) crc.getValue()) throw bad("PNG chunk CRC mismatch");
first = false;
if (name.equals("IEND")) {
if (!inflater.finished() || produced != expected) throw bad("PNG pixel data is truncated");
if (in.read() != -1) throw bad("data after PNG IEND");
return new Info("image/png", width, height);
}
}
} catch (EOFException e) {
throw bad("truncated PNG");
} catch (DataFormatException e) {
throw bad("invalid PNG zlib stream");
} finally {
inflater.end();
}
}
// Размер распакованных строк PNG (с байтом фильтра); для Adam7 — сумма по семи проходам.
static long rawSize(long width, long height, int depth, int colorType, int interlace) throws Invalid {
int channels = switch (colorType) {
case 0 -> depth == 1 || depth == 2 || depth == 4 || depth == 8 || depth == 16 ? 1 : 0;
case 3 -> depth == 1 || depth == 2 || depth == 4 || depth == 8 ? 1 : 0;
case 2 -> depth == 8 || depth == 16 ? 3 : 0;
case 4 -> depth == 8 || depth == 16 ? 2 : 0;
case 6 -> depth == 8 || depth == 16 ? 4 : 0;
default -> 0;
};
if (channels == 0) throw bad("invalid PNG color type/bit depth");
long bits = (long) channels * depth;
if (interlace == 0) return height * (1 + (width * bits + 7) / 8);
if (interlace != 1) throw bad("invalid PNG interlace method");
int[][] passes = {{0, 0, 8, 8}, {4, 0, 8, 8}, {0, 4, 4, 8}, {2, 0, 4, 4}, {0, 2, 2, 4}, {1, 0, 2, 2}, {0, 1, 1, 2}};
long total = 0;
for (int[] p : passes) {
long w = width > p[0] ? (width - p[0] + p[2] - 1) / p[2] : 0;
long h = height > p[1] ? (height - p[1] + p[3] - 1) / p[3] : 0;
if (w > 0 && h > 0) total += h * (1 + (w * bits + 7) / 8);
}
return total;
}
// JPEG: SOI, корректные длины сегментов, SOF до первого SOS, энтропийные данные до EOI.
// Байты после EOI допускаются: их дописывают многие камеры и телефоны.
static Info jpeg(InputStream in) throws IOException, Invalid {
in.skipNBytes(2);
int width = 0, height = 0, marker = -1;
boolean scan = false;
try {
while (true) {
if (marker < 0) {
if (in.read() != 0xff) throw bad("invalid JPEG marker");
do marker = read(in); while (marker == 0xff);
}
int m = marker;
marker = -1;
if (m == 0xd9) {
if (width == 0 || !scan) throw bad("JPEG has no frame or scan");
return new Info("image/jpeg", width, height);
}
if (m == 0x01 || (m >= 0xd0 && m <= 0xd7)) continue;
if (m == 0xd8 || m == 0x00) throw bad("unexpected JPEG marker");
int length = (read(in) << 8) | read(in);
if (length < 2) throw bad("invalid JPEG segment length");
boolean sof = m >= 0xc0 && m <= 0xcf && m != 0xc4 && m != 0xc8 && m != 0xcc;
if (sof) {
if (length < 8 || width != 0) throw bad("invalid JPEG frame header");
in.skipNBytes(1);
height = (read(in) << 8) | read(in);
width = (read(in) << 8) | read(in);
checkPixels(width, height);
in.skipNBytes(length - 7);
} else if (m == 0xda) {
if (width == 0) throw bad("JPEG scan before frame header");
in.skipNBytes(length - 2);
marker = entropy(in);
scan = true;
} else {
in.skipNBytes(length - 2);
}
}
} catch (EOFException e) {
throw bad("truncated JPEG");
}
}
// Пропускает сжатые данные скана; FF00 — экранированный байт, FFD0..FFD7 — restart-маркеры.
static int entropy(InputStream in) throws IOException {
boolean ff = false;
while (true) {
int c = read(in);
if (!ff) { ff = c == 0xff; continue; }
if (c == 0xff) continue;
if (c == 0x00 || (c >= 0xd0 && c <= 0xd7)) { ff = false; continue; }
return c;
}
}
static int read(InputStream in) throws IOException {
int c = in.read();
if (c < 0) throw new EOFException();
return c;
}
static int int32(byte[] b, int at) {
return ((b[at] & 0xff) << 24) | ((b[at + 1] & 0xff) << 16) | ((b[at + 2] & 0xff) << 8) | (b[at + 3] & 0xff);
}
}
@@ -0,0 +1,457 @@
package ru.mtusi.messenger;
import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.*;
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;
import com.fasterxml.jackson.databind.JsonNode;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.*;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.filter.OncePerRequestFilter;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.databind.MapperFeature;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.time.*;
import java.util.*;
import java.util.Base64;
// Главная аннотация Spring Boot: включает запуск приложения и автоматическую настройку.
// @EnableScheduling запускает периодическую сверку БД и S3 (Reconciler) в API-репликах.
@SpringBootApplication
@EnableScheduling
public class MessengerApplication {
// Идентификатор экземпляра API = hostname контейнера (первые 12 символов ID контейнера в Docker).
// По нему scripts/stop-one.sh находит и останавливает нужную реплику.
private static final String INSTANCE_ID = System.getenv().getOrDefault("HOSTNAME", UUID.randomUUID().toString());
// Один образ — три режима: api (HTTP-сервер, по умолчанию), migrate (Flyway и выход)
// и reconcile (сверка БД и S3 и выход; аргументы см. Reconciler.cli).
public static void main(String[] args) throws IOException {
String mode = args.length > 0 ? args[0] : "api";
if (mode.equals("api")) {
SpringApplication.run(MessengerApplication.class, args);
return;
}
if (mode.equals("migrate")) {
// Только Flyway, без контекста Spring: контейнеру migration не нужны ни Redis, ни S3, ни их секреты.
String password = java.nio.file.Files.readString(java.nio.file.Path.of("/run/secrets/spring.datasource.password")).trim();
org.flywaydb.core.Flyway.configure().dataSource(System.getenv("SPRING_DATASOURCE_URL"), System.getenv("SPRING_DATASOURCE_USERNAME"), password).load().migrate();
return;
}
if (!mode.equals("reconcile")) {
System.err.println("usage: [api | migrate | reconcile [--apply] [--grace-seconds=N] [--verify-checksums]]");
System.exit(2);
}
ConfigurableApplicationContext ctx = new SpringApplicationBuilder(MessengerApplication.class)
.web(WebApplicationType.NONE)
.properties("reconcile.enabled=false", "spring.main.banner-mode=off", "logging.level.root=WARN")
.run();
int code;
try {
code = ctx.getBean(Reconciler.class).cli(Arrays.copyOfRange(args, 1, args.length));
} catch (Exception e) {
LoggerFactory.getLogger(MessengerApplication.class).error("reconcile failed", e);
code = 1;
}
int exit = code;
System.exit(SpringApplication.exit(ctx, () -> exit));
}
// @Bean регистрирует возвращаемый объект в контейнере Spring.
// BCrypt хранит пароль в виде хеша, поэтому исходный пароль не попадает в базу.
@Bean
BCryptPasswordEncoder passwordEncoder() {
// Возвращаем BCrypt-кодировщик, который Spring передаст контроллеру.
return new BCryptPasswordEncoder();
}
// Отключаем автоматическое превращение чисел в строки при чтении JSON.
@Bean
Jackson2ObjectMapperBuilderCustomizer strictJson() {
return builder -> builder.featuresToDisable(MapperFeature.ALLOW_COERCION_OF_SCALARS);
}
// @Bean регистрирует фильтр в контейнере Spring.
// Фильтр добавляет общий идентификатор каждому HTTP-ответу.
@Bean OncePerRequestFilter requestId() {
return new OncePerRequestFilter() {
// Метод фильтра вызывается для каждого HTTP-запроса.
protected void doFilterInternal(HttpServletRequest r, HttpServletResponse s, FilterChain c)
throws ServletException, IOException {
// Создаём уникальный идентификатор текущего запроса.
String id=UUID.randomUUID().toString();
// Добавляем идентификатор в HTTP-ответ.
s.setHeader("X-Request-Id", id);
// Добавляем стабильный идентификатор экземпляра API.
s.setHeader("X-Instance-Id", INSTANCE_ID);
// Сохраняем тот же идентификатор для обработчика ошибок.
r.setAttribute("requestId", id);
// Передаём запрос дальше по цепочке Spring.
c.doFilter(r, s);
}
};
}
// Эти record-классы описывают JSON-модели ответов и запросов.
// Публичная модель пользователя без пароля.
record User(UUID id, String username, String display_name, Instant created_at) {}
// Модель чата со списком участников.
record Chat(UUID id, String title, List<UUID> member_ids, Instant created_at) {}
// Модель сообщения с автором, временем создания и вложениями (в порядке из запроса).
record Message(UUID id, UUID chat_id, UUID sender_id, String text, Instant created_at, List<UUID> attachment_ids) {}
// Универсальная модель страницы списка.
record Page<T>(List<T> items, String next_cursor) {}
// Ответ успешного входа с Bearer-токеном.
record Session(String token, String token_type, Instant expires_at, User user) {}
// Тело запроса регистрации.
record UserIn(JsonNode username, JsonNode display_name, JsonNode password) {}
// Тело запроса создания чата.
record ChatIn(JsonNode title, List<UUID> member_ids) {}
// Тело запроса отправки сообщения; attachment_ids необязателен (по умолчанию []).
record MessageIn(JsonNode text, JsonNode attachment_ids) {}
// Поля внутренней ошибки API.
record Error(String code, String message, String request_id) {}
// Обёртка, требуемая форматом JSON ошибки.
record ErrorBody(Error error) {}
// Исключение хранит HTTP-статус и безопасный код ошибки.
static class ApiException extends RuntimeException {
// HTTP-статус, который будет отправлен клиенту.
final HttpStatus status;
// Короткий код ошибки для программы-клиента.
final String code;
ApiException(HttpStatus s, String c, String m) {
// Сохраняем текст сообщения в стандартном RuntimeException.
super(m);
status=s;
code=c;
}
}
// @RestController объединяет @Controller и @ResponseBody.
// Методы этого класса принимают HTTP-запросы и возвращают JSON.
@RestController
static class Api {
// JdbcTemplate работает с PostgreSQL, RedisTemplate — с Redis-сессиями.
// JdbcTemplate отправляет SQL-запросы в PostgreSQL.
final JdbcTemplate db;
// StringRedisTemplate работает со строковыми ключами Redis.
final StringRedisTemplate redis;
// BCryptPasswordEncoder проверяет и хеширует пароли.
final BCryptPasswordEncoder encoder;
// Генератор создаёт 32 случайных байта для каждой сессии.
final SecureRandom random = new SecureRandom();
// TTL можно уменьшить через переменную окружения для проверки expiry.
final long ttl = Long.parseLong(System.getenv().getOrDefault("SESSION_TTL_SECONDS", "3600"));
Api(JdbcTemplate d, StringRedisTemplate r, BCryptPasswordEncoder e) {
// Сохраняем зависимости, созданные Spring Boot.
db=d;
redis=r;
encoder=e;
}
// Метод проверяет доступность PostgreSQL тестовым запросом.
void dbOk() {
try {
// Простой запрос проверяет соединение с PostgreSQL.
db.queryForObject("select 1", Integer.class);
} catch (Exception e) {
// Внутреннюю ошибку базы не показываем клиенту.
throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","database is unavailable");
}
}
// Метод проверяет Bearer-токен и возвращает UUID пользователя.
UUID auth(HttpServletRequest req) {
// Читаем заголовок авторизации из HTTP-запроса.
String h=req.getHeader("Authorization");
// Защищённые методы принимают только Bearer-схему.
if (h==null || !h.startsWith("Bearer ")) throw unauth();
// В Redis хранится связь токена с UUID пользователя.
try { String v=redis.opsForValue().get("session:"+h.substring(7)); if(v==null) throw unauth(); return UUID.fromString(v); }
catch (ApiException e) { throw e; } catch (Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
}
ApiException unauth() { return new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","valid Bearer session required"); }
// Загружаем пользователя по UUID из PostgreSQL.
// Метод ищет пользователя в PostgreSQL по его UUID.
User user(UUID id) {
return db.query("select id,username,display_name,created_at from users where id=?", rs -> rs.next()
? new User(rs.getObject(1,UUID.class),rs.getString(2),rs.getString(3),rs.getTimestamp(4).toInstant()) : null, id);
}
// Метод проверяет, состоит ли пользователь в выбранном чате.
boolean member(UUID chat, UUID user) {
// Пользователь должен состоять в чате, иначе ресурс для него скрыт.
return Boolean.TRUE.equals(db.queryForObject("select exists(select 1 from chat_members where chat_id=? and user_id=?)",Boolean.class,chat,user));
}
// Загружает один чат и его участников напрямую по идентификатору.
Chat chatById(UUID id) {
return db.query("select id,title,created_at from chats where id=?",rs -> rs.next()
? new Chat(rs.getObject(1,UUID.class),rs.getString(2),
db.query("select user_id from chat_members where chat_id=?",(z,k)->z.getObject(1,UUID.class),id),
rs.getTimestamp(3).toInstant()) : null,id);
}
// Считает символы как Unicode code points, а не как UTF-16 char.
int codePointLength(String value) {
return value.codePointCount(0,value.length());
}
// Возвращает значение только если JSON-поле действительно является строкой.
String string(JsonNode value) { return value!=null && value.isTextual()?value.textValue():null; }
// PostgreSQL не хранит нулевой байт, поэтому заменяем его безопасным символом.
String databaseText(String value) { return value==null?null:value.replace('\0','\uFFFD'); }
// Проверяет обязательную непустую строку и её максимальную длину.
boolean text(String value, int max) { return value!=null && !value.isBlank() && codePointLength(value)<=max; }
// Предварительный SHA-256 сохраняет весь пароль перед ограниченным BCrypt.
String passwordValue(String value) {
try { return Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest(value.getBytes(StandardCharsets.UTF_8))); }
catch (Exception e) { throw new IllegalStateException("password hashing is unavailable",e); }
}
// Готовность проверяет не только Java-процесс, но и его зависимости.
// @GetMapping связывает GET-запрос с Java-методом.
@GetMapping({"/health/live","/health/ready"})
// Для ready дополнительно проверяем PostgreSQL и Redis.
// Метод возвращает JSON со статусом приложения.
Map<String,String> health(HttpServletRequest r) { if (r.getRequestURI().endsWith("ready")) { dbOk(); try { redis.hasKey("health"); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); } } return Map.of("status","ok"); }
// @PostMapping связывает POST-запрос с методом регистрации.
@PostMapping("/api/v1/users")
// @RequestBody преобразует JSON-тело запроса в объект UserIn.
ResponseEntity<User> register(@RequestBody UserIn in) {
String username=in==null?null:string(in.username());
String displayName=in==null?null:string(in.display_name());
String password=in==null?null:string(in.password());
// До запроса в базу проверяем формат обязательных полей.
if(username==null || !username.matches("[a-z0-9_]{3,32}") || !text(displayName,100) || password==null || password.isBlank() || codePointLength(password)<12 || codePointLength(password)>128) bad();
displayName=databaseText(displayName);
// Создаём UUID пользователя и фиксируем время регистрации.
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Значения передаются параметрами, а не склеиваются со строкой SQL.
try { db.update("insert into users values(?,?,?,?,?)",id,username,displayName,encoder.encode(passwordValue(password)),java.sql.Timestamp.from(now)); }
// Уникальное ограничение username превращаем в понятный ответ 409.
catch(DuplicateKeyException e) { throw new ApiException(HttpStatus.CONFLICT,"conflict","username is already used"); }
// Возвращаем созданного пользователя без пароля.
return ResponseEntity.status(201).body(new User(id,username,displayName,now));
}
// POST-метод входа проверяет Basic-логин и создаёт Bearer-сессию.
@PostMapping("/api/v1/auth/sessions")
// HttpServletRequest позволяет прочитать заголовок Authorization.
ResponseEntity<Session> login(HttpServletRequest req) {
// Читаем Basic-заголовок, который используется только при входе.
String h=req.getHeader("Authorization");
if(h==null || !h.startsWith("Basic ")) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","Basic authentication required"); }
// Basic используется только для входа, после него клиент получает Bearer-токен.
String[] p; try { p=new String(Base64.getDecoder().decode(h.substring(6)),StandardCharsets.UTF_8).split(":",2); } catch(Exception e) { p=new String[0]; }
// Получаем BCrypt-хеш пользователя из PostgreSQL.
String hash=p.length==2 ? db.query("select password_hash from users where username=?",rs -> rs.next()?rs.getString(1):null,p[0]) : null;
// Сравниваем введённый пароль с сохранённым хешем.
if(p.length!=2 || hash==null || codePointLength(p[1])<12 || codePointLength(p[1])>128 || !encoder.matches(passwordValue(p[1]),hash)) { HttpHeaders x=new HttpHeaders(); x.set("WWW-Authenticate","Basic realm=\"messenger\", charset=\"UTF-8\""); throw new ApiException(HttpStatus.UNAUTHORIZED,"unauthorized","invalid credentials"); }
// После успешной проверки загружаем полную модель пользователя.
User u=user(db.queryForObject("select id from users where username=?",UUID.class,p[0]));
// Генерируем непрозрачный случайный токен сессии.
byte[] secret=new byte[32]; random.nextBytes(secret);
String token=Base64.getUrlEncoder().withoutPadding().encodeToString(secret);
// Вычисляем момент, когда сессия перестанет действовать.
Instant exp=Instant.now().plusSeconds(ttl);
// Сессия автоматически удалится из Redis после окончания TTL.
try { redis.opsForValue().set("session:"+token,u.id().toString(),Duration.ofSeconds(ttl)); } catch(Exception e) { throw new ApiException(HttpStatus.SERVICE_UNAVAILABLE,"unavailable","session store is unavailable"); }
return ResponseEntity.status(201).body(new Session(token,"Bearer",exp,u));
}
// @DeleteMapping связывает DELETE-запрос с удалением сессии.
// Logout сразу удаляет текущий токен из Redis.
@DeleteMapping("/api/v1/auth/sessions/current") ResponseEntity<Void> logout(HttpServletRequest r) { auth(r); redis.delete("session:"+r.getHeader("Authorization").substring(7)); return ResponseEntity.noContent().build(); }
// GET-запрос возвращает данные текущего авторизованного пользователя.
@GetMapping("/api/v1/users/me") User me(HttpServletRequest r) { return user(auth(r)); }
// @Transactional объединяет несколько SQL-команд в одну транзакцию.
// Если одна команда завершится ошибкой, изменения откатываются.
// Вставка чата и всех его участников выполняется как одна транзакция.
@Transactional
// POST-запрос создаёт новый чат.
@PostMapping("/api/v1/chats") ResponseEntity<Chat> createChat(@RequestBody ChatIn in,HttpServletRequest r) {
// Владелец чата определяется по Bearer-сессии.
String title=in==null?null:string(in.title());
UUID owner=auth(r); if(!text(title,100)||in.member_ids()==null||in.member_ids().isEmpty()||in.member_ids().size()>100||new HashSet<>(in.member_ids()).size()!=in.member_ids().size()||!in.member_ids().contains(owner)) bad();
// Проверяем существование каждого участника.
for(UUID id:in.member_ids()) if(user(id)==null) bad();
// ID и время создаются сервером. PostgreSQL хранит микросекунды, поэтому ответ POST совпадает с GET.
UUID id=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Записываем чат и участников в одной транзакции.
title=databaseText(title);
db.update("insert into chats values(?,?,?)",id,title,java.sql.Timestamp.from(now)); for(UUID m:in.member_ids()) db.update("insert into chat_members values(?,?)",id,m);
// Возвращаем созданную модель чата.
return ResponseEntity.status(201).body(new Chat(id,title,in.member_ids(),now));
}
// GET-запрос получает список чатов текущего пользователя.
@GetMapping("/api/v1/chats")
Page<Chat> chats(HttpServletRequest r) {
// Определяем пользователя, для которого строится список.
UUID u=auth(r);
String cursor=r.getParameter("cursor");
int limit=parseLimit(r.getParameter("limit"));
// Запрашиваем только чаты, где пользователь является участником.
String sql="select c.id,c.title,c.created_at from chats c join chat_members m on m.chat_id=c.id where m.user_id=? ";
List<Object> args=new ArrayList<>(List.of(u));
if(cursor!=null) {
try {
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
if(p.length!=2) bad();
sql+="and (c.created_at,c.id)>(?,?) ";
args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[0]).toInstant()));
args.add(UUID.fromString(p[1]));
} catch(Exception e) { if(e instanceof ApiException a) throw a; bad(); }
}
sql+="order by c.created_at,c.id limit ?";
args.add(limit+1);
List<Chat> x=db.query(sql,(rs,n)->new Chat(rs.getObject(1,UUID.class),rs.getString(2),db.query("select user_id from chat_members where chat_id=?", (z,k)->z.getObject(1,UUID.class),rs.getObject(1)),rs.getTimestamp(3).toInstant()),args.toArray());
String next=x.size()>limit?Base64.getUrlEncoder().withoutPadding().encodeToString((x.get(limit-1).created_at()+"|"+x.get(limit-1).id()).getBytes(StandardCharsets.UTF_8)):null;
return new Page<>(x.subList(0,Math.min(limit,x.size())),next);
}
// {id} является переменной частью URL.
@GetMapping("/api/v1/chats/{id}")
// @PathVariable получает id из адреса запроса.
Chat chat(@PathVariable UUID id,HttpServletRequest r) {
// Сначала проверяем токен и членство в чате.
UUID u=auth(r); if(!member(id,u)) throw notFound();
// Загружаем чат напрямую, поэтому поздние записи не зависят от первой страницы списка.
Chat result=chatById(id);
if(result==null) throw notFound();
return result;
}
// POST-запрос добавляет сообщение в выбранный чат.
// @PathVariable получает id чата, а @RequestBody — текст из JSON.
@Transactional
@PostMapping("/api/v1/chats/{id}/messages") ResponseEntity<Message> message(@PathVariable UUID id,@RequestBody MessageIn in,HttpServletRequest r) {
// Автор сообщения берётся из сессии, а не из тела запроса.
String messageText=databaseText(in==null?null:string(in.text()));
UUID u=auth(r); if(!member(id,u)) throw notFound();
List<UUID> attachments=attachmentIds(in==null?null:in.attachment_ids());
// Пустой текст допустим только с вложением; непустой не может состоять из одних пробелов.
if(messageText==null || codePointLength(messageText)>4000 || (messageText.isEmpty()?attachments.isEmpty():messageText.isBlank())) bad();
// Проверяем обязательный Idempotency-Key.
String key=r.getHeader("Idempotency-Key");
if(key==null || !key.matches("[A-Za-z0-9._:-]{1,128}")) throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","valid Idempotency-Key required");
// Все вложения должны быть готовыми вложениями этого чата; чужое или неизвестное — 404.
if(!attachments.isEmpty() && db.queryForObject("select count(*) from attachments where chat_id=? and state='ready' and id=any(?)",Integer.class,id,attachments.toArray(new UUID[0]))!=attachments.size()) throw notFound();
// Хеш тела для повторов с тем же ключом: отсутствующий attachment_ids и [] дают одно значение.
String bodyHash;
try { bodyHash=Base64.getEncoder().encodeToString(MessageDigest.getInstance("SHA-256").digest((messageText+"\0"+attachments).getBytes(StandardCharsets.UTF_8))); }
catch(Exception e) { throw new IllegalStateException("hash unavailable",e); }
// Сервер создаёт ID и время сообщения.
UUID mid=UUID.randomUUID(); Instant now=Instant.now().truncatedTo(java.time.temporal.ChronoUnit.MICROS);
// Сначала занимаем ключ. При одновременном повторе через другую реплику PostgreSQL ждёт
// её транзакцию, а ON CONFLICT DO NOTHING не обрывает нашу транзакцию ошибкой (иначе был бы 503).
if(db.update("insert into idempotency_keys values(?,?,?,?,?,?) on conflict do nothing",key,u,id,bodyHash,mid,java.sql.Timestamp.from(now))==0) {
// Ключ уже занят: тот же body — возвращаем созданное сообщение, другой body — 409.
UUID existingId=db.query("select message_id,request_hash from idempotency_keys where user_id=? and chat_id=? and idempotency_key=?",rs -> {
if(rs.next()) {
if(!bodyHash.equals(rs.getString(2))) throw new ApiException(HttpStatus.CONFLICT,"conflict","different body with same idempotency key");
return rs.getObject(1,UUID.class);
}
return null;
},u,id,key);
Message existing=db.queryForObject(MESSAGE_SELECT+"where m.id=?",this::messageRow,existingId);
return ResponseEntity.status(201).body(existing);
}
// Сообщение и его вложения пишутся в той же транзакции, что и ключ: появится всё или ничего.
db.update("insert into messages values(?,?,?,?,?)",mid,id,u,messageText,java.sql.Timestamp.from(now));
for(int i=0;i<attachments.size();i++) db.update("insert into message_attachments values(?,?,?)",mid,attachments.get(i),i);
return ResponseEntity.status(201).body(new Message(mid,id,u,messageText,now,attachments));
}
// Колонки сообщения; attachment_ids собираются из message_attachments в порядке отправки.
static final String MESSAGE_SELECT="select m.id,m.chat_id,m.sender_id,m.text,m.created_at,"
+"coalesce((select array_agg(x.attachment_id order by x.position) from message_attachments x where x.message_id=m.id),'{}') from messages m ";
Message messageRow(java.sql.ResultSet rs,int n) throws java.sql.SQLException {
return new Message(rs.getObject(1,UUID.class),rs.getObject(2,UUID.class),rs.getObject(3,UUID.class),rs.getString(4),rs.getTimestamp(5).toInstant(),List.of((UUID[])rs.getArray(6).getArray()));
}
// attachment_ids: отсутствует — []; иначе массив 0–10 уникальных UUID в каноническом виде.
List<UUID> attachmentIds(JsonNode value) {
if(value==null) return List.of();
if(!value.isArray() || value.size()>10) bad();
List<UUID> ids=new ArrayList<>();
for(JsonNode x:value) {
String s=x.isTextual()?x.textValue():"";
try { UUID id=UUID.fromString(s); if(!id.toString().equalsIgnoreCase(s)) bad(); ids.add(id); } catch(IllegalArgumentException e) { bad(); }
}
if(new HashSet<>(ids).size()!=ids.size()) bad();
return ids;
}
// GET-запрос возвращает историю сообщений с cursor-пагинацией.
// @RequestParam получает limit и cursor из параметров URL.
@GetMapping("/api/v1/chats/{id}/messages") Page<Message> messages(@PathVariable UUID id,@RequestParam(required=false) String limit,@RequestParam(required=false) String cursor,HttpServletRequest r) {
// Историю может читать только участник чата.
UUID u=auth(r); if(!member(id,u)) throw notFound(); int pageLimit=parseLimit(limit);
// Начинаем параметризованный запрос истории.
String sql=MESSAGE_SELECT+"where m.chat_id=? ";
// Список параметров передаётся в JdbcTemplate отдельно от SQL.
List<Object> args=new ArrayList<>(List.of(id));
if(cursor!=null) {
try {
// Cursor хранит время и ID последнего сообщения предыдущей страницы.
// Декодируем cursor из Base64 в обычную строку.
String[] p=new String(Base64.getUrlDecoder().decode(cursor),StandardCharsets.UTF_8).split("\\|",-1);
if(p.length!=3 || !id.equals(UUID.fromString(p[0]))) bad();
// Добавляем условие keyset-пагинации после последнего сообщения.
sql+="and (m.created_at,m.id)>(?,?) "; args.add(java.sql.Timestamp.from(OffsetDateTime.parse(p[1]).toInstant())); args.add(UUID.fromString(p[2]));
} catch(Exception e) { bad(); }
}
// Сортируем историю и берём одну запись сверх лимита для следующего cursor.
sql+="order by m.created_at,m.id limit ?"; args.add(pageLimit+1);
// Выполняем запрос и превращаем строки базы в объекты Message.
List<Message> x=db.query(sql,this::messageRow,args.toArray());
// Если запись сверх лимита есть, кодируем её позицию как следующий cursor.
String next=x.size()>pageLimit?Base64.getUrlEncoder().withoutPadding().encodeToString((id+"|"+x.get(pageLimit-1).created_at()+"|"+x.get(pageLimit-1).id()).getBytes(StandardCharsets.UTF_8)):null; return new Page<>(x.subList(0,Math.min(pageLimit,x.size())),next);
}
// Преобразует limit списка чатов в число и проверяет диапазон.
int parseLimit(String value) { try { int limit=value==null?50:Integer.parseInt(value); if(limit<1||limit>100) bad(); return limit; } catch(NumberFormatException e) { bad(); return 0; } }
// Формируем ошибку, не раскрывая наличие чужого объекта.
ApiException notFound(){return new ApiException(HttpStatus.NOT_FOUND,"not_found","object not found");}
// Формируем общую ошибку некорректного запроса.
void bad(){throw new ApiException(HttpStatus.BAD_REQUEST,"invalid_request","invalid request");}
}
// @RestControllerAdvice применяет обработчики ко всем REST-контроллерам.
// Благодаря этому ошибки возвращаются в одном формате JSON.
@RestControllerAdvice static class Errors {
// Все ошибки API приводятся к одному JSON-формату.
// @ExceptionHandler связывает тип исключения с методом обработки.
// Здесь обрабатываются специально созданные ошибки API.
@ExceptionHandler(ApiException.class) ResponseEntity<ErrorBody> api(ApiException e,HttpServletRequest r){
// Создаём заголовки ответа с ошибкой.
HttpHeaders h=new HttpHeaders();
if(e.status==HttpStatus.UNAUTHORIZED) h.set("WWW-Authenticate",r.getRequestURI().equals("/api/v1/auth/sessions")?"Basic realm=\"messenger\", charset=\"UTF-8\"":"Bearer realm=\"messenger\"");
// Возвращаем статус, заголовки и единое тело ошибки.
return ResponseEntity.status(e.status).headers(h).body(new ErrorBody(new Error(e.code,e.getMessage(),id(r))));
}
// Неожиданные исключения превращаем в безопасный ответ 500.
// Этот обработчик является запасным для неожиданных исключений.
@ExceptionHandler(Exception.class) ResponseEntity<ErrorBody> other(Exception e,HttpServletRequest r){
// Ошибки самого Spring MVC (неизвестный путь, метод, Content-Type) сохраняют свой 4xx, а не становятся 500.
if(e instanceof org.springframework.web.ErrorResponse x && x.getStatusCode().is4xxClientError()) {
int s=x.getStatusCode().value();
Error err=s==404?new Error("not_found","object not found",id(r)):s==415?new Error("unsupported_media_type","unsupported media type",id(r)):new Error("invalid_request","invalid request",id(r));
return ResponseEntity.status(s).headers(x.getHeaders()).body(new ErrorBody(err));
}
LoggerFactory.getLogger(Errors.class).error("request failed",e); return ResponseEntity.status(500).body(new ErrorBody(new Error("internal_error","internal server error",id(r)))); }
// Неправильный JSON считается ошибкой входных данных клиента.
// Этот обработчик ловит неправильный или повреждённый JSON.
@ExceptionHandler(HttpMessageNotReadableException.class) ResponseEntity<ErrorBody> malformed(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
// Ошибка преобразования UUID или числового параметра означает неверный запрос.
@ExceptionHandler(MethodArgumentTypeMismatchException.class) ResponseEntity<ErrorBody> mismatch(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); }
// Ошибка PostgreSQL возвращается как временная недоступность зависимости.
@ExceptionHandler(DataAccessException.class) ResponseEntity<ErrorBody> database(DataAccessException e,HttpServletRequest r){ return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(new ErrorBody(new Error("unavailable","database is unavailable",id(r)))); }
// Получаем ID запроса, который добавил фильтр.
String id(HttpServletRequest r){ return String.valueOf(r.getAttribute("requestId")); }
}
}
@@ -0,0 +1,297 @@
package ru.mtusi.messenger;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.InputStream;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Timestamp;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.ConnectionCallback;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.S3Object;
// Сверка PostgreSQL и S3 (трек 2). Оба списка обходятся отсортированными по ключу и сливаются за O(n)
// с постоянной памятью: страница S3 по 1000 ключей и страница строк БД по 1000.
//
// Правила безопасности:
// - ничего моложе grace period (по LastModified объекта / updated_at строки) не трогаем:
// загрузка в процессе пишет строку до объекта и объект до ready;
// - ready-строки не удаляются никогда, а при отсутствии объекта (подтверждённом HEAD) помечаются lost;
// - строка, на которую ссылается сообщение, защищена FK message_attachments;
// - объект без строки удаляется только после повторной проверки по ключу в БД;
// - одновременно работает одна сверка (pg advisory lock), повторный запуск ничего не меняет.
@Component
class Reconciler {
static final long LOCK_ID = 4_040_404L;
static final int PAGE = 1000;
static final Logger log = LoggerFactory.getLogger(Reconciler.class);
final JdbcTemplate db;
final Storage storage;
final boolean enabled;
final long graceSeconds;
Reconciler(JdbcTemplate db, Storage storage, @Value("${reconcile.enabled:true}") boolean enabled, @Value("${reconcile.grace-seconds:3600}") long graceSeconds) {
this.db = db;
this.storage = storage;
this.enabled = enabled;
this.graceSeconds = graceSeconds;
}
// Автоматическая компенсация в API-репликах: раз в interval, в apply-режиме, с grace по умолчанию 1 час.
@Scheduled(initialDelayString = "${reconcile.initial-delay:PT1M}", fixedDelayString = "${reconcile.interval:PT15M}")
void scheduled() {
if (!enabled) return;
try {
Map<String, Object> report = run(true, Duration.ofSeconds(graceSeconds), false);
if (!Map.of().equals(report.get("actions"))) log.info("reconcile: {}", report);
} catch (RuntimeException e) {
log.warn("reconcile failed: {}", e.toString());
}
}
// CLI: reconcile [--apply] [--grace-seconds=N] [--verify-checksums]; по умолчанию dry-run.
int cli(String[] args) throws Exception {
boolean apply = false, verify = false;
long grace = graceSeconds;
for (String a : args) {
if (a.equals("--apply")) apply = true;
else if (a.equals("--dry-run")) apply = false;
else if (a.equals("--verify-checksums")) verify = true;
else if (a.startsWith("--grace-seconds=")) grace = Long.parseLong(a.substring(16));
else { System.err.println("unknown argument: " + a); return 2; }
}
Map<String, Object> report = run(apply, Duration.ofSeconds(grace), verify);
System.out.println(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(report));
return report.containsKey("skipped") ? 3 : 0;
}
Map<String, Object> run(boolean apply, Duration grace, boolean verify) {
return db.execute((ConnectionCallback<Map<String, Object>>) c -> {
try (PreparedStatement st = c.prepareStatement("select pg_try_advisory_lock(?)")) {
st.setLong(1, LOCK_ID);
try (ResultSet rs = st.executeQuery()) {
rs.next();
if (!rs.getBoolean(1)) return Map.of("skipped", "another reconcile is running");
}
}
try {
return new Pass(apply, grace, verify).scan();
} finally {
try (PreparedStatement st = c.prepareStatement("select pg_advisory_unlock(?)")) {
st.setLong(1, LOCK_ID);
st.execute();
}
}
});
}
record Row(UUID id, String key, String state, long size, String sha256, Instant updated, boolean used) {}
// Один проход сверки со счётчиками для отчёта и оценки стоимости.
final class Pass {
final boolean apply, verify;
final Duration grace;
final Instant cutoff;
final Map<String, Long> findings = new LinkedHashMap<>(), actions = new LinkedHashMap<>(), cost = new LinkedHashMap<>();
final List<Map<String, Object>> details = new ArrayList<>();
Pass(boolean apply, Duration grace, boolean verify) {
this.apply = apply;
this.grace = grace;
this.verify = verify;
cutoff = Instant.now().minus(grace);
}
Map<String, Object> scan() {
long started = System.nanoTime();
Iterator<S3Object> objects = objects();
Iterator<Row> rows = rows();
S3Object o = next(objects);
Row r = next(rows);
while (o != null || r != null) {
int cmp = o == null ? 1 : r == null ? -1 : o.key().compareTo(r.key());
if (cmp < 0) { objectWithoutRow(o); o = next(objects); }
else if (cmp > 0) { rowWithoutObject(r); r = next(rows); }
else { both(o, r); o = next(objects); r = next(rows); }
}
Map<String, Object> report = new LinkedHashMap<>();
report.put("mode", apply ? "apply" : "dry-run");
report.put("grace_seconds", grace.toSeconds());
report.put("verify_checksums", verify);
report.put("duration_ms", (System.nanoTime() - started) / 1_000_000);
report.put("cost", cost);
report.put("findings", findings);
report.put("actions", actions);
report.put("details", details.size() > 50 ? details.subList(0, 50) : details);
return report;
}
void objectWithoutRow(S3Object o) {
if (o.lastModified().isAfter(cutoff)) { count(findings, "orphan_object_fresh_kept"); return; }
count(findings, "orphan_object");
detail("orphan_object", o.key(), null);
if (!apply) return;
// Повторная проверка: строка могла появиться после чтения страницы БД.
count(cost, "db_queries");
if (Boolean.TRUE.equals(db.queryForObject("select exists(select 1 from attachments where object_key=?)", Boolean.class, o.key()))) return;
count(cost, "s3_delete_requests");
storage.delete(o.key());
count(actions, "objects_deleted");
}
void rowWithoutObject(Row r) {
switch (r.state()) {
case "uploading" -> {
if (r.updated().isAfter(cutoff)) { count(findings, "upload_in_progress_kept"); return; }
count(findings, "stale_upload");
detail("stale_upload", r.key(), r.id());
if (apply && deleteStaleRow(r)) count(actions, "rows_deleted");
}
case "ready" -> {
if (r.updated().isAfter(cutoff)) { count(findings, "fresh_row_kept"); return; }
// Листинг не считаем доказательством: отсутствие подтверждает HEAD (404).
count(cost, "s3_head_requests");
if (storage.size(r.key()) != null) return;
count(findings, r.used() ? "missing_object_used" : "missing_object");
detail("missing_object", r.key(), r.id());
if (apply && markLost(r)) count(actions, "marked_lost");
}
default -> count(findings, "lost_known");
}
}
void both(S3Object o, Row r) {
switch (r.state()) {
case "uploading" -> {
if (r.updated().isAfter(cutoff)) { count(findings, "upload_in_progress_kept"); return; }
// Старая строка, но свежий объект: PUT мог только что завершиться (медленная загрузка, повторы SDK).
// Удаляем, только когда старше grace обе стороны — как и объект без строки.
if (o.lastModified().isAfter(cutoff)) { count(findings, "stale_upload_fresh_object_kept"); return; }
// PUT прошёл, ready не записан: клиент получил ошибку и id не знает — объект и строку удаляем.
count(findings, "stale_upload_with_object");
detail("stale_upload_with_object", r.key(), r.id());
if (!apply || !deleteStaleRow(r)) return;
count(cost, "s3_delete_requests");
storage.delete(r.key());
count(actions, "rows_deleted");
count(actions, "objects_deleted");
}
case "ready" -> {
if (r.updated().isAfter(cutoff)) return;
String problem = o.size() != r.size() ? "size_mismatch" : verify && !checksumMatches(r) ? "checksum_mismatch" : null;
if (problem == null) return;
count(findings, problem);
detail(problem, r.key(), r.id());
if (apply && markLost(r)) count(actions, "marked_lost");
}
default -> {
// lost, но объект снова на месте: вернуть в ready можно только после сверки SHA-256,
// иначе файл, помеченный за неверную контрольную сумму, «воскрес» бы по одному размеру.
if (o.size() != r.size()) { count(findings, "lost_known"); return; }
if (!verify) { count(findings, "lost_object_back_unverified"); return; }
if (!checksumMatches(r)) { count(findings, "lost_known"); return; }
count(findings, "lost_object_back");
detail("lost_object_back", r.key(), r.id());
if (!apply) return;
count(cost, "db_queries");
if (db.update("update attachments set state='ready', updated_at=now() where id=? and state='lost'", r.id()) == 1) count(actions, "restored");
}
}
}
boolean deleteStaleRow(Row r) {
count(cost, "db_queries");
return db.update("delete from attachments a where id=? and state='uploading' and updated_at<? and not exists(select 1 from message_attachments x where x.attachment_id=a.id)",
r.id(), Timestamp.from(cutoff)) == 1;
}
boolean markLost(Row r) {
count(cost, "db_queries");
return db.update("update attachments set state='lost', updated_at=now() where id=? and state='ready'", r.id()) == 1;
}
boolean checksumMatches(Row r) {
count(cost, "s3_get_requests");
MessageDigest sha = Attachments.sha256();
try (InputStream in = new DigestInputStream(storage.get(r.key()), sha)) {
cost.merge("bytes_read", in.transferTo(java.io.OutputStream.nullOutputStream()), Long::sum);
} catch (java.io.IOException e) {
throw new IllegalStateException(e);
}
return java.util.HexFormat.of().formatHex(sha.digest()).equals(r.sha256());
}
// Ленивый обход листинга S3 постранично.
Iterator<S3Object> objects() {
Iterator<ListObjectsV2Response> pages = storage.list().iterator();
return new Iterator<>() {
Iterator<S3Object> page = List.<S3Object>of().iterator();
public boolean hasNext() {
while (!page.hasNext() && pages.hasNext()) {
count(cost, "s3_list_requests");
page = pages.next().contents().iterator();
}
return page.hasNext();
}
public S3Object next() {
S3Object o = page.next();
count(cost, "s3_objects");
return o;
}
};
}
// Keyset-пагинация строк по object_key (COLLATE "C" — тот же порядок, что у S3).
Iterator<Row> rows() {
return new Iterator<>() {
Iterator<Row> page = List.<Row>of().iterator();
String after = "";
boolean done;
public boolean hasNext() {
if (!page.hasNext() && !done) {
count(cost, "db_queries");
List<Row> rows = db.query("select id,object_key,state,size_bytes,sha256,updated_at,exists(select 1 from message_attachments x where x.attachment_id=a.id)"
+ " from attachments a where object_key>? order by object_key limit ?", (rs, n) -> new Row(rs.getObject(1, UUID.class), rs.getString(2),
rs.getString(3), rs.getLong(4), rs.getString(5), rs.getTimestamp(6).toInstant(), rs.getBoolean(7)), after, PAGE);
done = rows.size() < PAGE;
if (!rows.isEmpty()) after = rows.get(rows.size() - 1).key();
page = rows.iterator();
}
return page.hasNext();
}
public Row next() {
count(cost, "db_rows");
return page.next();
}
};
}
<T> T next(Iterator<T> it) { return it.hasNext() ? it.next() : null; }
void count(Map<String, Long> map, String name) { map.merge(name, 1L, Long::sum); }
void detail(String kind, String key, UUID id) {
Map<String, Object> d = new LinkedHashMap<>();
d.put("kind", kind);
d.put("key", key);
if (id != null) d.put("attachment_id", id);
details.add(d);
}
}
}
@@ -0,0 +1,76 @@
package ru.mtusi.messenger;
import java.net.URI;
import java.nio.file.Path;
import java.time.Duration;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.core.ResponseInputStream;
import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.GetObjectResponse;
import software.amazon.awssdk.services.s3.model.NoSuchKeyException;
import software.amazon.awssdk.services.s3.model.S3Object;
import software.amazon.awssdk.services.s3.model.S3Exception;
import software.amazon.awssdk.services.s3.paginators.ListObjectsV2Iterable;
// Байты вложений в приватном S3-bucket. Ключи API имеют права только на этот bucket.
@Component
class Storage {
// Оригиналы лежат под общим префиксом: его обходит сверка.
static final String ORIGINALS = "originals/";
final S3Client s3;
final String bucket;
Storage(@Value("${s3.endpoint}") String endpoint, @Value("${s3.region:us-east-1}") String region, @Value("${s3.bucket}") String bucket,
@Value("${s3.access-key}") String accessKey, @Value("${s3.secret-key}") String secretKey) {
this.bucket = bucket;
// Короткий connect timeout: недоступный S3 быстро даёт 503, а не держит поток API.
s3 = S3Client.builder()
.endpointOverride(URI.create(endpoint))
.region(Region.of(region))
.forcePathStyle(true)
.credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(accessKey.trim(), secretKey.trim())))
.httpClientBuilder(ApacheHttpClient.builder().maxConnections(64).connectionTimeout(Duration.ofSeconds(2)).socketTimeout(Duration.ofSeconds(30)))
.overrideConfiguration(c -> c.apiCallTimeout(Duration.ofSeconds(60)).apiCallAttemptTimeout(Duration.ofSeconds(30)))
.build();
}
// Файл читается потоком с диска: размер известен заранее, в RAM целиком не попадает.
void put(String key, Path file, String contentType) {
s3.putObject(b -> b.bucket(bucket).key(key).contentType(contentType), RequestBody.fromFile(file));
}
ResponseInputStream<GetObjectResponse> get(String key) {
return s3.getObject(b -> b.bucket(bucket).key(key));
}
void delete(String key) {
s3.deleteObject(b -> b.bucket(bucket).key(key));
}
// null — объекта точно нет (404); иначе его размер. Прочие ошибки S3 пробрасываются.
Long size(String key) {
try {
return s3.headObject(b -> b.bucket(bucket).key(key)).contentLength();
} catch (NoSuchKeyException e) {
return null;
} catch (S3Exception e) {
if (e.statusCode() == 404) return null;
throw e;
}
}
// Ленивый постраничный листинг (по 1000 ключей) в побайтовом порядке ключей.
ListObjectsV2Iterable list() {
return s3.listObjectsV2Paginator(b -> b.bucket(bucket).prefix(ORIGINALS));
}
static boolean isOriginal(S3Object o) {
return o.key().startsWith(ORIGINALS);
}
}
+15
View File
@@ -0,0 +1,15 @@
# Graceful shutdown: завершаем обработку текущих запросов перед остановкой.
server.shutdown=graceful
# Ожидание текущих запросов при shutdown: 20 с, меньше stop_grace_period 30s в compose.yaml,
# чтобы Docker не прислал SIGKILL посреди закрытия пулов PostgreSQL/Redis.
spring.lifecycle.timeout-per-shutdown-phase=20s
# Простой между пакетами тела запроса; медленную загрузку дополнительно буферизует nginx.
server.tomcat.connection-timeout=10s
# Лишние поля в JSON (например sender_id) по контракту дают 400, а не игнорируются.
spring.jackson.deserialization.fail-on-unknown-properties=true
# Секреты из /run/secrets: имя файла = имя свойства (spring.datasource.password, s3.access-key, ...).
spring.config.import=optional:configtree:/run/secrets/
# Миграции выполняет только контейнер migration (режим migrate), реплики их не запускают.
spring.flyway.enabled=false
@@ -0,0 +1,20 @@
-- Version 1: базовая схема мессенджера (lab2). Версии миграций ведёт Flyway (flyway_schema_history).
CREATE TABLE users (
id UUID PRIMARY KEY, username VARCHAR(32) UNIQUE NOT NULL,
display_name VARCHAR(100) NOT NULL, password_hash VARCHAR(100) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chats (
id UUID PRIMARY KEY, title VARCHAR(100) NOT NULL, created_at TIMESTAMPTZ NOT NULL
);
CREATE TABLE chat_members (
chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
user_id UUID REFERENCES users(id) ON DELETE CASCADE,
PRIMARY KEY (chat_id, user_id)
);
CREATE TABLE messages (
id UUID PRIMARY KEY, chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
sender_id UUID REFERENCES users(id), text VARCHAR(4000) NOT NULL,
created_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX messages_history ON messages(chat_id, created_at, id);
@@ -0,0 +1,11 @@
-- Version 2: идемпотентность отправки сообщения (lab3).
CREATE TABLE idempotency_keys (
idempotency_key VARCHAR(128) NOT NULL,
user_id UUID NOT NULL,
chat_id UUID NOT NULL,
request_hash VARCHAR(64) NOT NULL,
message_id UUID NOT NULL,
created_at TIMESTAMPTZ NOT NULL,
PRIMARY KEY (user_id, chat_id, idempotency_key)
);
CREATE INDEX idempotency_cleanup ON idempotency_keys(created_at);
@@ -0,0 +1,29 @@
-- Version 3: вложения (lab4). Байты лежат в S3, здесь только метаданные и связь с сообщениями.
CREATE TABLE attachments (
id UUID PRIMARY KEY,
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
owner_id UUID NOT NULL REFERENCES users(id),
-- Только отображаемое имя: в путях и S3-ключах не используется. VARCHAR считает code points.
filename VARCHAR(255) NOT NULL,
content_type VARCHAR(20) NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
size_bytes BIGINT NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
sha256 CHAR(64) NOT NULL,
width INT NOT NULL CHECK (width > 0),
height INT NOT NULL CHECK (height > 0),
-- uploading: намерение записано до S3 PUT; ready: объект сохранён; lost: сверка не нашла объект.
state VARCHAR(16) NOT NULL CHECK (state IN ('uploading', 'ready', 'lost')),
-- Ключ назначает сервер. COLLATE "C" даёт побайтовый порядок, как у листинга S3: сверка идёт слиянием.
object_key TEXT COLLATE "C" NOT NULL UNIQUE,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL
);
CREATE INDEX attachments_chat ON attachments(chat_id);
CREATE INDEX attachments_unfinished ON attachments(state, updated_at) WHERE state <> 'ready';
-- FK на attachments не даёт удалить вложение, на которое ссылается сообщение.
CREATE TABLE message_attachments (
message_id UUID NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
attachment_id UUID NOT NULL REFERENCES attachments(id),
position SMALLINT NOT NULL,
PRIMARY KEY (message_id, attachment_id)
);
CREATE INDEX message_attachments_attachment ON message_attachments(attachment_id);
+224
View File
@@ -0,0 +1,224 @@
#!/usr/bin/env python3
"""Собственные проверки вложений lab4 (уровень 4), только стандартная библиотека.
Покрывают: слишком большой файл, повреждённые PNG/JPEG, подмену MIME, decompression bomb,
опасные filename, чужое/неизвестное attachment_id, вложение другого чата, постороннего пользователя,
идемпотентность с вложениями. Ни одна пользовательская ошибка не должна давать 500.
--with-docker дополнительно (через docker compose из корня репозитория):
* останавливает S3: загрузка/скачивание -> 503, текстовые сообщения и /health/ready работают,
после неудачной загрузки не остаётся строк 'uploading' (компенсация);
* останавливает API-реплику, принявшую загрузку, и скачивает файл через другую.
Синтетический fixture tests/fixtures/sample.jpg получен из sample.png (sips, quality 85).
"""
import json
import os
import struct
import subprocess
import time
import urllib.error
import urllib.request
import uuid
import zlib
from urllib.parse import quote
from client import ROOT, Client, arguments, check, run
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
JPEG = (ROOT / 'tests/fixtures/sample.jpg').read_bytes()
MIB = 1024 * 1024
def png(width, height, idat=None, depth=8, color=2):
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
if idat is None:
row = b'\x00' + bytes(width * 3)
idat = zlib.compress(row * height, 9)
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', width, height, depth, color, 0, 0, 0))
+ chunk(b'IDAT', idat) + chunk(b'IEND', b''))
def flip(data, at):
return data[:at] + bytes([data[at] ^ 0xff]) + data[at + 1:]
def compose(*args, check_rc=True):
return subprocess.run(['docker', 'compose', *args], cwd=ROOT, check=check_rc, capture_output=True, text=True).stdout
def sql(query):
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-At', '-c', query).strip()
def main():
def configure(p):
p.add_argument('--with-docker', action='store_true', help='also stop S3 and the uploading replica via docker compose')
args = arguments('Negative attachment checks for lab4; creates synthetic data', configure)
c = Client(args.base_url, args.ca_file, timeout=20)
alice, bob, eve, chat = c.bootstrap()
other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой чат', 'member_ids': [alice['id'], eve['id']]}, schema='Chat')['json']
passed = []
def upload(data, ctype='image/png', expected=201, actor=alice, target=chat, name='file.png'):
r = c.call('POST', '/api/v1/chats/%s/attachments?filename=%s' % (target['id'], quote(name, safe='')), expected,
actor=actor, raw=data, headers={'Content-Type': ctype}, schema='Attachment' if expected == 201 else None)
if expected >= 400:
check(r['json']['error']['code'] != 'internal_error', 'user error turned into 500')
return r
def ok(name):
passed.append(name)
print('PASS', name)
# Валидные форматы и побайтовое скачивание.
att_png = upload(PNG)['json']
att_jpg = upload(JPEG, 'image/jpeg', name='photo.jpg')['json']
check(att_jpg['content_type'] == 'image/jpeg' and att_jpg['status'] == 'ready', 'jpeg metadata')
for att, data, ctype in ((att_png, PNG, 'image/png'), (att_jpg, JPEG, 'image/jpeg')):
got = c.call('GET', '/api/v1/attachments/' + att['id'] + '/content', actor=bob)
check(got['bytes'] == data and got['headers'].get_content_type() == ctype, 'download differs')
ok('valid PNG and JPEG upload/download byte-for-byte')
# Размер: API отклоняет 10 MiB + 1 байт, nginx — всё больше 11 MiB, оба JSON 413.
upload(PNG[:8] + bytes(10 * MIB + 1 - 8), expected=413)
req = urllib.request.Request(c.base + '/api/v1/chats/%s/attachments?filename=big.png' % chat['id'], data=bytes(12 * MIB), method='POST',
headers={'Authorization': 'Bearer ' + alice['token'], 'Content-Type': 'image/png'})
try:
urllib.request.urlopen(req, timeout=20)
check(False, 'oversized body accepted')
except urllib.error.HTTPError as e:
body = json.loads(e.read())
check(e.code == 413 and body['error']['code'] == 'payload_too_large' and e.headers.get('X-Request-Id'), 'nginx 413 must be contract JSON')
# Почти 10 MiB: случайные пиксели не сжимаются; у каждой строки байт фильтра 0.
big = png(1800, 1900, idat=zlib.compress(b''.join(b'\x00' + os.urandom(1800 * 3) for _ in range(1900)), 1))
check(len(big) <= 10 * MIB, 'fixture too large')
upload(big)
ok('10 MiB + 1 byte -> 413 (API), 12 MiB -> 413 JSON (nginx), valid %.1f MiB accepted' % (len(big) / MIB))
# Повреждённые изображения.
idat_at = PNG.find(b'IDAT') + 8
for broken in (flip(PNG, idat_at), PNG[:len(PNG) // 2], PNG + b'trailing', PNG[:8] + b'garbage' * 10):
upload(broken, expected=415)
for broken in (JPEG[:len(JPEG) // 2], JPEG[:4] + b'\x00' * 100, JPEG[:2] + b'\xff\xda\x00\x02' + JPEG[2:]):
upload(broken, 'image/jpeg', expected=415)
# Структурно корректные, но недекодируемые: PNG 1×1 RGB с верными CRC и фильтром строки 5;
# JPEG из 27 байт SOI/SOF0/SOS/EOI без таблиц квантования/Хаффмана и данных скана.
upload(png(1, 1, idat=zlib.compress(b'\x05' + bytes(3))), expected=415)
upload(bytes.fromhex('ffd8' 'ffc0000b08000100010101 1100'.replace(' ', '') + 'ffda0008010100003f00' 'ffd9'), 'image/jpeg', expected=415)
ok('corrupted/truncated/undecodable PNG and JPEG -> 415')
# Подмена MIME: проверяется содержимое, а не заголовок.
upload(PNG, 'image/jpeg', expected=415)
upload(JPEG, 'image/png', expected=415)
upload(b'GIF89a' + bytes(100), 'image/png', expected=415)
upload(b'<svg xmlns="http://www.w3.org/2000/svg"/>', 'image/png', expected=415)
upload(PNG, 'text/plain', expected=415)
upload(PNG, 'image/gif', expected=415)
ok('MIME spoofing (content vs Content-Type) -> 415')
# Decompression bomb: заголовок > 40 Мпикс -> 413 до распаковки; ложный маленький заголовок -> 415;
# честные 36 Мпикс (≈108 МБ пикселей) принимаются без декодирования в RAM.
upload(png(10000, 10000, idat=zlib.compress(bytes(1000))), expected=413)
upload(png(100, 100, idat=zlib.compress(bytes(50 * MIB), 9)), expected=415)
upload(png(6000, 6000))
ok('decompression bomb: >40 MP -> 413, lying header -> 415, honest 36 MP accepted')
# filename: только отображение; пути, NUL, управляющие символы и длина — 400.
for name in ('../evil.png', 'a/b.png', 'a\\b.png', 'a\x00b.png', 'a\x07b.png', 'line\nbreak.png', ' ', '..', 'x' * 256):
upload(PNG, name=name, expected=400)
c.call('POST', '/api/v1/chats/%s/attachments' % chat['id'], 400, actor=alice, raw=PNG, headers={'Content-Type': 'image/png'})
for name in ('фото 😀.png', '😀' * 255):
got = upload(PNG, name=name)['json']
check(got['filename'] == name, 'filename changed')
ok('dangerous filenames -> 400, Unicode up to 255 code points preserved')
# Доступ: посторонний не загружает и не читает, без сессии — 401, неизвестный id — 404.
upload(PNG, actor=eve, expected=404)
for suffix in ('', '/content'):
c.call('GET', '/api/v1/attachments/' + att_png['id'] + suffix, 404, actor=eve)
c.call('GET', '/api/v1/attachments/' + str(uuid.uuid4()) + suffix, 404, actor=alice)
c.call('GET', '/api/v1/attachments/not-a-uuid', 400, actor=alice)
c.call('POST', '/api/v1/chats/%s/attachments?filename=a.png' % chat['id'], 401, raw=PNG, headers={'Content-Type': 'image/png'})
ok('outsider/unknown attachment -> 404, no session -> 401')
# attachment_ids в сообщении.
path = '/api/v1/chats/%s/messages' % chat['id']
foreign = upload(PNG, target=other)['json']
def send(body, expected=201, key=None):
return c.call('POST', path, expected, actor=alice, body=body, headers={'Idempotency-Key': key or uuid.uuid4().hex},
schema='Message' if expected == 201 else None)
send({'text': 'чужое', 'attachment_ids': [foreign['id']]}, 404)
send({'text': 'неизвестное', 'attachment_ids': [str(uuid.uuid4())]}, 404)
send({'text': 'смесь', 'attachment_ids': [att_png['id'], foreign['id']]}, 404)
for bad in (['not-a-uuid'], [att_png['id'], att_png['id']], [str(uuid.uuid4()) for _ in range(11)], None, att_png['id'], [1]):
send({'text': 'x', 'attachment_ids': bad}, 400)
send({'text': ''}, 400)
send({'text': '', 'attachment_ids': []}, 400)
send({'text': ' ', 'attachment_ids': [att_png['id']]}, 400)
two = send({'text': '', 'attachment_ids': [att_jpg['id'], att_png['id']]})['json']
check(two['attachment_ids'] == [att_jpg['id'], att_png['id']] and two['text'] == '', 'attachment order or text changed')
history = c.call('GET', path + '?limit=100', actor=bob, schema='MessagePage')['json']['items']
check(any(m == two for m in history), 'history lost attachment_ids')
ok('foreign/unknown attachment -> 404, malformed attachment_ids -> 400, order preserved')
# Идемпотентность: отсутствующий attachment_ids == [], другой набор с тем же ключом — 409.
key = uuid.uuid4().hex
first = send({'text': 'ключ'}, key=key)['json']
check(send({'attachment_ids': [], 'text': 'ключ'}, key=key)['json'] == first, 'missing vs [] must be equal')
send({'text': 'ключ', 'attachment_ids': [att_png['id']]}, 409, key=key)
key = uuid.uuid4().hex
first = send({'text': 'с файлом', 'attachment_ids': [att_png['id']]}, key=key)['json']
check(send({'text': 'с файлом', 'attachment_ids': [att_png['id']]}, key=key)['json'] == first, 'replay with attachment differs')
send({'text': 'с файлом', 'attachment_ids': [att_jpg['id']]}, 409, key=key)
ok('idempotency with attachment_ids (missing == [], different set -> 409)')
# Варианты: в lab4 есть только original.
c.call('GET', '/api/v1/attachments/%s/content?variant=original' % att_png['id'], actor=bob)
c.call('GET', '/api/v1/attachments/%s/content?variant=thumbnail' % att_png['id'], 404, actor=bob)
c.call('GET', '/api/v1/attachments/%s/content?variant=../../etc' % att_png['id'], 400, actor=bob)
ok('variant: original 200, absent thumbnail 404, garbage 400')
if args.with_docker:
# Недоступный S3: вложения 503, текстовый путь живёт, после сбоя нет зависших строк.
compose('stop', 's3')
try:
r = upload(PNG, expected=503)
check(r['json']['error']['code'] == 'unavailable', 'S3 outage must be 503 unavailable')
c.call('GET', '/api/v1/attachments/' + att_png['id'] + '/content', 503, actor=bob)
c.call('GET', '/api/v1/attachments/' + att_png['id'], actor=bob, schema='Attachment')
send({'text': 'S3 лежит, текст идёт'})
c.call('GET', '/health/ready', schema='Health')
check(sql("select count(*) from attachments where state='uploading'") == '0', 'failed upload left an uploading row')
finally:
compose('start', 's3')
deadline = time.monotonic() + 60
while True:
try:
got = c.call('GET', '/api/v1/attachments/' + att_png['id'] + '/content', actor=bob)
break
except AssertionError:
check(time.monotonic() < deadline, 'downloads did not recover after S3 start')
time.sleep(1)
check(got['bytes'] == PNG, 'download after S3 recovery differs')
ok('S3 down: attachments 503, messages/ready OK, no uploading rows; recovered after start')
# Остановка реплики, принявшей загрузку: другая скачивает тот же файл.
r = upload(PNG)
served = r['headers']['X-Instance-Id']
cid = [x for x in compose('ps', '-q', 'api-1', 'api-2').split() if x.startswith(served)]
check(len(cid) == 1, 'cannot map X-Instance-Id to a container')
subprocess.run(['docker', 'stop', cid[0]], check=True, capture_output=True)
try:
for _ in range(5):
got = c.call('GET', '/api/v1/attachments/' + r['json']['id'] + '/content', actor=bob)
check(got['bytes'] == PNG and got['headers']['X-Instance-Id'] != served, 'download through other replica failed')
finally:
subprocess.run(['docker', 'start', cid[0]], check=True, capture_output=True)
ok('upload replica %s stopped: other replica serves identical bytes' % served)
print('PASS: %d attachment checks' % len(passed))
if __name__ == '__main__':
run(main)
BIN
View File
Binary file not shown.

After

Width:  |  Height:  |  Size: 10 KiB

+190
View File
@@ -0,0 +1,190 @@
#!/usr/bin/env python3
"""Трек 2: внедрение рассинхронизации БД и S3 и проверка сверки (dry-run -> apply -> повтор).
Гипотеза: сверка находит все виды расхождений, dry-run ничего не меняет, apply исправляет только
безопасное (старше grace и не используемое), повторный запуск ничего не находит, а свежие
и используемые вложения остаются доступны. --cost N1,N2 дополнительно меряет стоимость обхода.
Сбои вносятся мимо API: в S3 через сервис s3-probe (ключи API), в БД через psql в контейнере postgres.
Запуск из корня репозитория при работающем стенде: python3 tests/reconcile_experiment.py --output evidence/reconcile_experiment.json
"""
import json
import struct
import subprocess
import time
import uuid
import zlib
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from client import ROOT, Client, arguments, check, run
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
# Запас на цепочку из ~5 запусков сверки (JVM ≈ 10 с каждый) после появления «свежих» объектов.
GRACE = 90
BUCKET = 'messenger-attachments'
def tiny_png(seed):
# 1×1 PNG с уникальным пикселем: тысячи разных маленьких файлов для замера стоимости обхода.
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
pixel = b'\x00' + seed.to_bytes(3, 'big')
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 1, 1, 8, 2, 0, 0, 0))
+ chunk(b'IDAT', zlib.compress(pixel)) + chunk(b'IEND', b''))
def compose(*args, stdin=None):
p = subprocess.run(['docker', 'compose', *args], cwd=ROOT, input=stdin, capture_output=True, text=True)
check(p.returncode in (0, 3), 'docker compose %s failed: %s' % (args[0], p.stderr[-300:]))
return p.stdout
def sql(query):
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-At', '-c', query).strip()
def s3(commands):
# Подписанные запросы ключами API из контейнера s3-probe; ключи передаются curl через stdin.
script = '''sign() { printf 'user = "%s:%s"\\n' "$(cat /run/secrets/s3.access-key)" "$(cat /run/secrets/s3.secret-key)"; }
url=http://s3:8333/''' + BUCKET + '\n' + '\n'.join(commands) + '\n'
return compose('run', '--rm', '-T', 's3-probe', stdin=script)
def put(key, data):
# data — строка или @файл внутри s3-probe.
return 'sign | curl -K - -s -o /dev/null -w "PUT %%{http_code}\\n" --aws-sigv4 aws:amz:us-east-1:s3 -X PUT --data-binary "%s" "$url/%s"' % (data, key)
def delete(key):
return 'sign | curl -K - -s -o /dev/null -w "DELETE %%{http_code}\\n" --aws-sigv4 aws:amz:us-east-1:s3 -X DELETE "$url/%s"' % key
def reconcile(*flags):
out = compose('run', '--rm', '-T', 'reconciler', *flags)
return json.loads(out[out.index('{'):])
def snapshot():
# Один листинг S3 (до 1000 ключей хватает до замера стоимости) и счётчики строк по состояниям.
listing = s3(['sign | curl -K - -s --aws-sigv4 aws:amz:us-east-1:s3 "$url?list-type=2&prefix=originals/"'])
return {'rows': sql("select state || ':' || count(*) from attachments group by state order by state").split('\n'),
'objects': listing.count('<Key>')}
def main():
def configure(p):
p.add_argument('--cost', default='', help='comma-separated object counts for traversal cost, e.g. 1000,10000')
p.add_argument('--output', default=None)
args = arguments('Reconciler fault-injection experiment (track 2)', configure)
c = Client(args.base_url, args.ca_file, timeout=20)
alice, bob, eve, chat = c.bootstrap()
path = '/api/v1/chats/%s/messages' % chat['id']
def upload(data=PNG):
return c.call('POST', '/api/v1/chats/%s/attachments?filename=x.png' % chat['id'], 201, actor=alice, raw=data,
headers={'Content-Type': 'image/png'}, schema='Attachment')['json']
def attach(att):
return c.call('POST', path, 201, actor=alice, body={'text': 'с вложением', 'attachment_ids': [att['id']]},
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message')['json']
key = lambda att: 'originals/' + att['id']
# Исходные данные: используемое и неиспользуемое вложение, оба корректные.
used_ok = upload(); used_msg = attach(used_ok)
used_missing = upload(); attach(used_missing)
unref_missing, size_bad, checksum_bad, row_deleted, lost_back = (upload() for _ in range(5))
# Сбои со стороны S3 и со стороны БД.
orphan_old = ['originals/' + str(uuid.uuid4()) for _ in range(3)]
stale_with_object, stale_no_object = str(uuid.uuid4()), str(uuid.uuid4())
s3([delete(key(used_missing)), delete(key(unref_missing)),
put(key(size_bad), 'short'), # другой размер
'head -c %d /dev/zero > /tmp/same' % len(PNG),
put(key(checksum_bad), '@/tmp/same'), # тот же размер, другие байты
put('originals/' + stale_with_object, 'partial')]
+ [put(k, 'orphan') for k in orphan_old])
sql("delete from attachments where id='%s'" % row_deleted['id']) # объект без метаданных
sql("update attachments set state='lost' where id='%s'" % lost_back['id']) # ложная пометка lost
for aid, k in ((stale_with_object, 'originals/' + stale_with_object), (stale_no_object, 'originals/' + stale_no_object)):
# PUT прошёл/не прошёл, а ready не записан: «зависшая» загрузка.
sql("insert into attachments values('%s','%s','%s','x.png','image/png',%d,'%s',1,1,'uploading','%s',now(),now())"
% (aid, chat['id'], alice['id'], len(PNG), '0' * 64, k))
print('faults injected; waiting %d s so they are older than grace' % (GRACE + 2))
time.sleep(GRACE + 2)
# Свежие объекты (моложе grace) появляются после ожидания и должны уцелеть.
orphan_fresh = 'originals/' + str(uuid.uuid4())
inflight = str(uuid.uuid4())
s3([put(orphan_fresh, 'fresh')])
sql("insert into attachments values('%s','%s','%s','x.png','image/png',1,'%s',1,1,'uploading','originals/%s',now(),now())"
% (inflight, chat['id'], alice['id'], '0' * 64, inflight))
fresh_used = upload(); attach(fresh_used)
# Старое намерение (2 ч) и только что записанный объект того же ключа: PUT мог завершиться прямо сейчас,
# поэтому сверка обязана ждать grace и по объекту — строка и объект остаются.
old_intent = str(uuid.uuid4())
sql("insert into attachments values('%s','%s','%s','x.png','image/png',5,'%s',1,1,'uploading','originals/%s',now()-interval '2 hours',now()-interval '2 hours')"
% (old_intent, chat['id'], alice['id'], '0' * 64, old_intent))
s3([put('originals/' + old_intent, 'fresh')])
before = snapshot()
dry = reconcile('--dry-run', '--grace-seconds=%d' % GRACE)
after_dry = snapshot()
check(before == after_dry, 'dry-run changed state')
apply1 = reconcile('--apply', '--grace-seconds=%d' % GRACE)
apply2 = reconcile('--apply', '--grace-seconds=%d' % GRACE)
verify = reconcile('--apply', '--grace-seconds=%d' % GRACE, '--verify-checksums')
verify2 = reconcile('--apply', '--grace-seconds=%d' % GRACE, '--verify-checksums')
f = dry['findings']
check(f.get('orphan_object') == len(orphan_old) + 1, 'orphan objects (3 injected + deleted row) not found: %s' % f)
check(f.get('orphan_object_fresh_kept') == 1 and f.get('upload_in_progress_kept') == 1, 'fresh items not reported as kept: %s' % f)
check(f.get('stale_upload') == 1 and f.get('stale_upload_with_object') == 1, 'stale uploads not found: %s' % f)
check(f.get('stale_upload_fresh_object_kept') == 1, 'old intent with fresh object not kept: %s' % f)
check(f.get('missing_object_used') == 1 and f.get('missing_object') == 1, 'missing objects not found: %s' % f)
check(f.get('size_mismatch') == 1 and f.get('lost_object_back_unverified') == 1, 'size mismatch / lost-back not found: %s' % f)
check(not dry['actions'], 'dry-run reported actions')
a = apply1['actions']
check(a == {'objects_deleted': len(orphan_old) + 2, 'rows_deleted': 2, 'marked_lost': 3}, 'unexpected apply actions: %s' % a)
check(not apply2['actions'], 'second apply is not idempotent: %s' % apply2['actions'])
va = verify['actions']
check(verify['findings'].get('checksum_mismatch') == 1 and va == {'marked_lost': 1, 'restored': 1}, 'unexpected verify run: %s %s' % (verify['findings'], va))
check(not verify2['actions'], 'second verify run is not idempotent: %s' % verify2['actions'])
# Свежие и используемые вложения не тронуты и доступны; найденные потери скрыты (404), а не 500.
for att in (used_ok, fresh_used, lost_back):
check(c.call('GET', '/api/v1/attachments/%s/content' % att['id'], actor=bob)['bytes'] == PNG, 'healthy attachment lost')
for att in (used_missing, unref_missing, size_bad, checksum_bad):
c.call('GET', '/api/v1/attachments/%s/content' % att['id'], 404, actor=bob)
check(sql("select count(*) from attachments where id in ('%s','%s')" % (used_missing['id'], inflight)) == '2', 'used or in-flight row deleted')
history = c.call('GET', path + '?limit=100', actor=bob, schema='MessagePage')['json']['items']
check(any(m == used_msg for m in history), 'message with attachment changed')
check('orphan_object_fresh_kept' in apply2['findings'], 'fresh orphan was deleted')
check(verify2['findings'].get('stale_upload_fresh_object_kept') == 1 and sql("select count(*) from attachments where id='%s'" % old_intent) == '1',
'old intent row or its fresh object was deleted')
print('PASS: dry-run read-only, apply fixed %s, repeated apply/verify found nothing new' % json.dumps(a))
cost = []
for n in [int(x) for x in args.cost.split(',') if x]:
have = int(sql('select count(*) from attachments'))
with ThreadPoolExecutor(max_workers=16) as pool:
list(pool.map(lambda i: upload(tiny_png(have + i)), range(max(0, n - have))))
total = int(sql('select count(*) from attachments'))
plain = reconcile('--dry-run', '--grace-seconds=0')
checks = reconcile('--dry-run', '--grace-seconds=0', '--verify-checksums')
cost.append({'rows': total, 'dry_run': {'duration_ms': plain['duration_ms'], **plain['cost']},
'verify_checksums': {'duration_ms': checks['duration_ms'], **checks['cost']}})
print(json.dumps(cost[-1]))
report = {'experiment': 'reconciler fault injection (track 2)', 'grace_seconds': GRACE,
'injected': {'orphan_objects_old': len(orphan_old), 'object_without_row': 1, 'orphan_object_fresh': 1,
'stale_upload_with_object': 1, 'stale_upload_without_object': 1, 'upload_in_progress': 1,
'stale_upload_fresh_object': 1,
'missing_object_used': 1, 'missing_object_unreferenced': 1, 'size_mismatch': 1,
'checksum_mismatch': 1, 'false_lost': 1},
'state_before': before, 'state_after_dry_run': after_dry, 'dry_run': dry, 'apply': apply1,
'apply_again': apply2, 'verify_checksums': verify, 'verify_again': verify2, 'state_after': snapshot(), 'cost': cost}
if args.output:
Path(args.output).parent.mkdir(parents=True, exist_ok=True)
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')
if __name__ == '__main__':
run(main)
+107
View File
@@ -0,0 +1,107 @@
#!/usr/bin/env python3
"""Эксперимент уровня 4: N одновременных загрузок ~10 MiB и пик памяти контейнеров.
Память читается из cgroup v2 внутри контейнеров (memory.current и anon из memory.stat) каждые 0.2 с
через docker compose exec, пока идут загрузки. anon — память процессов (heap JVM и native),
memory.current дополнительно включает page cache временных файлов.
Пример: python3 tests/upload_memory.py --runs 1,10,20 --output evidence/upload_memory.json
"""
import json
import os
import struct
import subprocess
import threading
import time
import zlib
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from client import ROOT, Client, Failure, arguments, check, run
SERVICES = ('api-1', 'api-2', 'nginx', 's3')
# Свой дедлайн: docker exec не завершает процесс в контейнере, когда клиент отключается.
SAMPLER = ('end=$(($(date +%s)+180)); while [ $(date +%s) -lt $end ]; do '
'echo $(cat /sys/fs/cgroup/memory.current) $(grep "^anon " /sys/fs/cgroup/memory.stat | cut -d" " -f2) || exit; sleep 0.2; done')
def big_png():
# 1800×1900 RGB из случайных байтов не сжимается: файл ≈9.8 MiB, чуть меньше лимита 10 MiB.
def chunk(kind, data):
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
raw = b''.join(b'\x00' + os.urandom(1800 * 3) for _ in range(1900))
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 1800, 1900, 8, 2, 0, 0, 0))
+ chunk(b'IDAT', zlib.compress(raw, 1)) + chunk(b'IEND', b''))
class Sampler:
"""Фоновое чтение памяти одного контейнера; хранит максимум за время измерения."""
def __init__(self, service):
self.service, self.peak_current, self.peak_anon, self.base = service, 0, 0, None
self.proc = subprocess.Popen(['docker', 'compose', 'exec', '-T', service, 'sh', '-c', SAMPLER], cwd=ROOT,
stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
threading.Thread(target=self.read, daemon=True).start()
def read(self):
for line in self.proc.stdout:
parts = line.split()
if len(parts) != 2:
continue
current, anon = map(int, parts)
if self.base is None:
self.base = (current, anon)
self.peak_current, self.peak_anon = max(self.peak_current, current), max(self.peak_anon, anon)
def stop(self):
self.proc.terminate()
mib = lambda v: round(v / 2**20, 1)
return {'baseline_current_mib': mib(self.base[0]), 'baseline_anon_mib': mib(self.base[1]),
'peak_current_mib': mib(self.peak_current), 'peak_anon_mib': mib(self.peak_anon)}
def main():
def configure(p):
p.add_argument('--runs', default='1,10,20', help='comma-separated concurrency levels')
p.add_argument('--output', default=None)
args = arguments('Concurrent ~10 MiB uploads with peak container memory', configure)
c = Client(args.base_url, args.ca_file, timeout=120)
alice, bob, eve, chat = c.bootstrap()
data = big_png()
check(len(data) <= 10 * 2**20, 'fixture exceeds 10 MiB')
results = []
for n in [int(x) for x in args.runs.split(',')]:
samplers = [Sampler(s) for s in SERVICES]
time.sleep(1.5)
def one(_):
local = Client(args.base_url, args.ca_file, timeout=120)
started = time.monotonic()
try:
r = local.call('POST', '/api/v1/chats/%s/attachments?filename=big.png' % chat['id'], [201, 503], actor=alice,
raw=data, headers={'Content-Type': 'image/png'})
return r['status'], time.monotonic() - started, r['headers'].get('X-Instance-Id')
except Failure as e:
return str(e), time.monotonic() - started, None
started = time.monotonic()
with ThreadPoolExecutor(max_workers=n) as pool:
done = list(pool.map(one, range(n)))
wall = time.monotonic() - started
time.sleep(1)
memory = {s.service: s.stop() for s in samplers}
statuses = {}
for status, _, _ in done:
statuses[str(status)] = statuses.get(str(status), 0) + 1
latencies = sorted(d for _, d, _ in done)
result = {'concurrent_uploads': n, 'file_mib': round(len(data) / 2**20, 2), 'statuses': statuses,
'replicas_used': len({i for _, _, i in done if i}), 'wall_seconds': round(wall, 2),
'latency_seconds': {'p50': round(latencies[len(latencies) // 2], 2), 'max': round(latencies[-1], 2)},
'memory': memory}
print(json.dumps(result, ensure_ascii=False))
results.append(result)
report = {'experiment': 'concurrent ~10 MiB PNG uploads through nginx', 'api_memory_limit': '512M per replica, JVM heap max 128 MiB',
'max_concurrent_uploads_per_replica': 8, 'results': results}
if args.output:
Path(args.output).parent.mkdir(parents=True, exist_ok=True)
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n')
if __name__ == '__main__':
run(main)