1 Commits
Author SHA1 Message Date
HellsTomatoandCopilot 496f0d5a64 Apply completed lab 5 implementation
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
2026-10-31 00:38:41 +03:00
36 changed files with 4413 additions and 15 deletions
+2
View File
@@ -0,0 +1,2 @@
# Shell-скрипты запускаются в bash/sh: CRLF при checkout на Windows их ломает.
*.sh text eol=lf
+24
View File
@@ -0,0 +1,24 @@
# Первый этап: сборка приложения через 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
# cwebp (libwebp) — кодировщик варианта optimized в worker.
RUN apt-get update && apt-get install -y --no-install-recommends webp && rm -rf /var/lib/apt/lists/*
# Переносим готовое приложение из этапа сборки.
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"]
+179 -15
View File
@@ -1,37 +1,201 @@
# Отчёт — лабораторная 5
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Гавриков В.Д БПИ2303
- Целевая оценка: **5**, трек 5 — **трек 2 «Доказанная идемпотентность pipeline»**
- Commit/PR: после публикации
- Источники и помощь ИИ: Spring Boot 3.3.5, RabbitMQ 4.0.5 + Java-клиент amqp-client 5.21.0, AWS SDK for Java v2 2.29.52, SeaweedFS 3.99, Flyway 10, ImageIO (JDK 21), libwebp `cwebp` 1.2.2 (Ubuntu jammy), nginx 1.28.0. Реализация, тесты и отчёт подготовлены с помощью ИИ-ассистента (Claude Code); всё ниже проверено запуском на стенде.
## Запуск из чистого 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 их нет; повторный запуск файлы не меняет):
# пароли БД/Redis, ключи S3 трёх ролей (admin, api, worker), пользователи RabbitMQ api/worker и definitions.
python3 scripts/init_secrets.py # Windows: py -3 scripts\init_secrets.py
# 2. Сборка и запуск; --wait ждёт healthy всех сервисов (≈40–60 с после сборки).
docker compose up -d --build --wait
# 3. Проверки.
make test
python3 tests/attachments_negative.py --with-docker
python3 tests/pipeline_experiment.py --output evidence/pipeline_experiment.json # уровни 3–4 и трек 2, ≈4 мин
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
docker compose start api-1 api-2 # вернуть остановленную тестом реплику
make test-persistence ACTION_SCRIPT=scripts/restart.sh
scripts/check-private-bucket.sh
```
Операторские команды: `scripts/stop-worker.sh` / `docker compose start worker`; `docker compose run --rm jobctl status | replay <job_id>…|--all-failed | reprocess --pipeline-version=N <attachment_id>…|--all | redispatch [--older-than=S]`; глубина очередей — `docker compose exec rabbitmq rabbitmqctl list_queues name messages`.
Остановка без потери данных: `docker compose down`. Намеренное удаление учебных данных: `docker compose down -v` (секреты в `secrets/` остаются; чтобы сменить их, удалите `secrets/` **вместе** с volumes — пароль PostgreSQL задаётся при первой инициализации тома, хеши паролей брокера — при импорте definitions).
Порядок старта задан `depends_on`: postgres, redis, s3, rabbitmq → `s3-init` и `migration` (Flyway `V1`–`V4`) → `api-1`, `api-2`, `worker` → nginx. Действий оператора не требуется.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ─► nginx :8080 ─► api-1 / api-2 ─┬─► PostgreSQL: метаданные, jobs, outbox, варианты, audit (источник истины)
├─► Redis: Bearer-сессии
├─► S3 staging/<id>: полный проверенный оригинал до ответа 202
└─ outbox relay ─► RabbitMQ: exchange attachments → quorum attachments.process
(DLX → attachments.dlq)
worker ◄── attachments.process (manual ack, prefetch 1 × WORKER_CONCURRENCY=2)
├─► S3: staging → originals/<id> (серверная копия), variants/<id>/v<ver>/{thumbnail.jpg,crop.jpg,optimized.webp}
└─► PostgreSQL: захват попытки (lease), heartbeat, атомарная фиксация результата
```
| Роль | Service | Образ | Health/readiness | Volume | Credentials |
| --- | --- | --- | --- | --- | --- |
| LB | nginx | nginx:1.28.0-alpine | пассивная | — | — (единственный опубликованный порт 8080) |
| API ×2 | api-1, api-2 | messenger-api:lab5 (Dockerfile) | `/health/ready` (PostgreSQL + Redis) | нет | пароль БД, Redis, ключи S3 **api**, брокер **api** (только publish) |
| Worker | worker | тот же образ, режим `worker` | файл `/tmp/worker-alive` моложе 15 с (подключён к брокеру) | нет | пароль БД, ключи S3 **worker**, брокер **worker** |
| Брокер | rabbitmq | rabbitmq:4.0.5-alpine, `hostname: rabbitmq` | `rabbitmq-diagnostics check_port_connectivity` | rabbitmqdata | definitions из `secrets/` |
| БД | postgres | postgres:16.4 | `pg_isready` | pgdata | `POSTGRES_PASSWORD_FILE` |
| Сессии | redis | redis:7.4.1 | `redis-cli ping` | redisdata (AOF) | `requirepass` |
| S3 | s3 | chrislusf/seaweedfs:3.99 | `GET /healthz` | s3data | identities admin / api / worker |
| Однократно | migration, s3-init | образ API (`migrate`), curl 8.11.1 | exit 0 | — | пароль БД / admin-ключи S3 |
| Инструменты (profile `tools`) | jobctl, reconciler, s3-probe | образ API, curl 8.11.1 | по требованию | — | пароль БД, ключи S3 api |
Права RabbitMQ (definitions, импорт при каждом старте): `api` — `configure ^$`, `write ^attachments$`, `read ^$`; `worker` — `configure ^$`, `write ^attachments$`, `read ^attachments\.process$`. Гостевого пользователя нет, management UI не включён, порт 5672 только во внутренней сети. `hostname: rabbitmq` обязателен: имя узла `rabbit@rabbitmq` задаёт каталог данных в volume, без него пересозданный контейнер не увидел бы прежние очереди.
**Что перенесено из lab4 без изменений:** весь API, nginx, идемпотентность, сессии, проверка PNG/JPEG до декодирования (`ImageCheck`), лимиты и таймауты загрузки, приватный bucket, сверка PostgreSQL↔S3 (`Reconciler`, теперь пропускает вложения в работе pipeline), hooks failover/restart.
**Что изменено:**
- `POST …/attachments` → **202** со снимком `status=queued`, `variants=[]`, `error_code=null`. Готовность — через `GET /attachments/{id}`: `queued → processing → ready | failed`, `variants` — thumbnail/crop/optimized текущей версии pipeline, `error_code` только у failed.
- `content` для queued/processing/failed → **409**; отсутствующий вариант ready → 404; `variant` вне enum → 400.
- В сообщение можно прикрепить queued/processing/ready; failed → **409**; проверка идёт после ключа идемпотентности, поэтому повтор успешного POST возвращает сохранённое сообщение.
- Новый код: [Jobs.java](src/main/java/ru/mtusi/messenger/Jobs.java) (jobs, outbox relay, захват/аренда/фиксация, retry, sweep, jobctl), [Worker.java](src/main/java/ru/mtusi/messenger/Worker.java) (consumer, шаги обработки), [ImagePipeline.java](src/main/java/ru/mtusi/messenger/ImagePipeline.java) (варианты), [Broker.java](src/main/java/ru/mtusi/messenger/Broker.java) (confirms), миграция [V4__pipeline.sql](src/main/resources/db/migration/V4__pipeline.sql).
**Что сохранено в момент 202** ([Attachments.upload](src/main/java/ru/mtusi/messenger/Attachments.java)): после всех проверок lab4 тело из временного файла записывается в `staging/<id>` приватного S3 (PUT завершён); затем **одна транзакция** PostgreSQL пишет строку `attachments` (`queued`), `jobs` (attempt 1) и `outbox` (attempt 1). 202 уходит только после COMMIT. Не удался PUT → 503 и в БД ничего; не удался COMMIT → staging удаляется (иначе его уберёт очистка по retention). Байтов и credentials в брокере нет — только ID.
**Публикация (transactional outbox).** Relay (`Jobs.relay`, раз в секунду в обеих API-репликах и в worker) берёт строки `outbox` с `FOR UPDATE SKIP LOCKED`, публикует пачку с **publisher confirms** и `mandatory` (неотмаршрутизированное сообщение = ошибка), ждёт подтверждения и только потом удаляет строки в той же транзакции. Падение до publish — строки остаются и публикуются другим relay; падение после confirm до DELETE — повторная публикация, её гасит consumer. Брокер недоступен — API продолжает принимать загрузки, outbox копится.
**Сообщение** — ровно JSON по [jobs.schema.json](contracts/jobs.schema.json): `schema_version=1, job_id, type=attachment.process.v1, attachment_id, pipeline_version, attempt, created_at` (время создания job, RFC 3339 UTC). AMQP-свойства: `delivery_mode=2`, `content_type=application/json`, `message_id=<job_id>/<attempt>`, `type`. `traceparent` не передаётся (трассировка — lab6). Worker разбирает строго (лишнее поле, чужой `type`/`schema_version` → `basic.reject` без requeue → DLQ).
**Обработка в worker** ([Worker.process](src/main/java/ru/mtusi/messenger/Worker.java)), источник истины — строка `jobs`, сообщение лишь сигнал «попытка N готова»:
1. **Захват**: `UPDATE jobs SET state='processing', lease_until=now()+15s … WHERE job_id=? AND state='queued' AND attempt=?` (+ вложение `queued → processing`). Не захватилось → no-op и ack, причина в `job_audit`: `duplicate_done`, `duplicate_in_progress`, `stale_attempt`, `dropped_failed`.
2. **Heartbeat** каждые 5 с продлевает аренду, но не дальше `JOB_TIMEOUT_SECONDS=60` от начала попытки.
3. Доверенные метаданные — из БД (тип, размер, SHA-256, ключ); источник — `staging/<id>`, если его уже нет — `originals/<id>`. Скачанный файл сверяется по размеру и SHA-256.
4. Публикация оригинала: серверная копия `staging/<id> → originals/<id>` (повтор кладёт те же байты).
5. Варианты → PUT по **детерминированным ключам** `variants/<id>/v<ver>/<name>`; перед каждым PUT проверка аренды и таймаута.
6. **Фиксация** одной транзакцией: `SELECT … FOR UPDATE` строки job с проверкой `state='processing' AND attempt=N` (fencing), `INSERT attachment_variants … ON CONFLICT DO NOTHING` (PK = ключ эффекта `(attachment_id, pipeline_version, name)`), `UPDATE attachments SET state='ready', pipeline_version=v WHERE coalesce(pipeline_version,0) <= v` (указатель версии только растёт), `jobs.state='done'`.
7. После COMMIT — удаление staging, затем **ack**.
| Переход контракта | Реализация |
| --- | --- |
| нет → queued | staging PUT + транзакция attachments/jobs/outbox → 202 |
| queued → processing | захват по `(job_id, state='queued', attempt)`, lease 15 с |
| processing → queued (временная ошибка) | `attempt+1`, `next_attempt_at = now + backoff`, новая строка outbox с `available_at` |
| processing → ready | транзакция шага 6; ready только когда все 3 варианта и оригинал записаны |
| processing → failed | постоянная ошибка (`invalid_image`, `source_missing`, `processing_failed`) или исчерпаны попытки (`retry_exhausted`) |
| processing → queued (истёк lease) | `Jobs.sweep` каждые 2 с: `lease_until < now()` → `attempt+1` (или failed при исчерпании) |
| failed → queued | только `jobctl replay`: тот же `job_id`, `attempt+1`, новый бюджет попыток, запись `replayed` в audit |
**Повторы.** `JOB_MAX_ATTEMPTS=5`; задержка перед попыткой N+1 — equal jitter: `cap = min(30 с, 1 с·2^(N-1))`, `delay = cap/2 + random(0…cap/2)`. Временные — ошибки S3/IO, таймаут попытки, cwebp; постоянные — недекодируемое изображение, отсутствие/порча источника, неизвестная версия pipeline (без повторов). DLQ `attachments.dlq` — для нераспознанных сообщений и превышения `x-delivery-limit=50` (БД недоступна: сообщение возвращается с паузой 5 с). Реестр failed — `jobs.state='failed'` (`jobctl status`).
**Варианты** ([ImagePipeline](src/main/java/ru/mtusi/messenger/ImagePipeline.java)): thumbnail — JPEG, вписан в 256×256 без увеличения, округление вниз, минимум 1 px (320×200 → 256×160); crop — JPEG 128×128 из центрального квадрата (маленькие увеличиваются); optimized — WebP, вписан в 1280×1280 без увеличения, `cwebp -q 80 -metadata none` (EXIF/XMP/ICC не переносятся; маленький файл может вырасти — это не обещается). EXIF Orientation (APP1 JPEG) применяется ко всем вариантам, alpha компонуется на белый. Уменьшение — последовательными halving-шагами (bilinear), последний шаг bicubic. Качество JPEG 0.85 (v1). Метаданные исходника в варианты не попадают: растр перекодируется.
**Ограничения worker:** байты — ≤ 10 MiB (API) и сверка размера/SHA-256 перед обработкой; пиксели — ≤ 40 Мпикс по заголовку ещё раз до декодирования; память — декодирование с прореживанием до ≤ 12 Мпикс (растр ≤ ~48 MiB на задачу), куча JVM 65% от лимита 512M, конкуренция 2; время — `JOB_TIMEOUT_SECONDS=60` на попытку (watchdog прерывает ImageIO `reader.abort()` и убивает cwebp, аренда дальше не продлевается), cwebp ≤ 30 с.
**Очистка staging:** сразу после COMMIT результата; пропущенные (падение между COMMIT и удалением) и прочие — `Jobs.sweepStaging` раз в минуту: для ready — сразу, для failed и непривязанных объектов — после `STAGING_RETENTION_SECONDS=86400`; queued/processing не трогаются.
**Соответствие `.env.example`:** `BROKER_URL_FILE` → `/run/secrets/broker.url` (у API и worker разные пользователи); `WORKER_CONCURRENCY=2`, `JOB_MAX_ATTEMPTS=5`, `JOB_TIMEOUT_SECONDS=60`, `STAGING_RETENTION_SECONDS=86400` — env worker/API в compose; дополнительно `JOB_LEASE_SECONDS=15`, `PIPELINE_VERSION=1`, `JOB_BACKOFF_BASE_MS=1000`, `JOB_BACKOFF_MAX_MS=30000` (значения по умолчанию в коде); `FAULT_INJECTION=0` (1 — только для эксперимента). Остальные — как в lab4.
## Доказательства критериев
### Уровень 3
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` | `PASS: lab5 public API scenario` (202 queued → ready ≤ 60 с, оригинал побайтно, настоящий JPEG thumbnail 256×160, checksum и размер совпадают) | вывод команды |
| Минимум lab4 сохранён с переходом 201 → 202 | `python3 tests/attachments_negative.py --with-docker`, `scripts/check-private-bucket.sh` | `PASS: 12 attachment checks` (лимиты 413/415/400/404, S3 down → 503, upload → stop реплики → download через другую); приватный bucket: все PASS, наружу публикуется только nginx | вывод команд |
| Возможности lab3 сохранены | `make test-failover`, `make test-persistence` | failover: 2 реплики, 72 записи, 0 ошибок, восстановление записи 2.99 с; persistence: `PASS: persistence preserved confirmed data and existing session` — hook (`docker compose down` + `up -d`, volumes сохранены) пересоздал все контейнеры: до — postgres/redis/s3 Up 43 мин, после — 49 с, api/worker 28 с ([до](evidence/persistence_before.txt) / [после](evidence/persistence_after.txt)) | вывод команд |
| 202 только после устойчивого приёма; остановка API после ответа не теряет работу | `tests/pipeline_experiment.py`, сценарий A | PASS: после 202 перезапущены api-1, api-2 и rabbitmq (volumes сохранены); задание осталось `queued`, сообщение в очереди до и после рестарта (`attachments.process`: 1 → 1); после старта worker — ready | [evidence/pipeline_experiment.json](evidence/pipeline_experiment.json) |
| Отдельные broker и worker; durable; at-least-once; ack после устойчивого эффекта | compose (`rabbitmq`, `worker`), quorum-очередь, `delivery_mode=2`, confirms, manual ack после COMMIT | сценарий A: сообщение пережило рестарт брокера с volume; сценарий B: падение после COMMIT до ack → повторная доставка → no-op | там же |
| Недоступный worker не переводит API на синхронный resize | сценарий A | worker остановлен: upload 202 `queued`, `content` и `variant=thumbnail` → 409, сообщение с queued-вложением 201, другие сообщения 201 | там же |
| Состояния queued/processing/ready/failed в API | smoke, сценарии A–C | ready с 3 вариантами; failed с `invalid_image` / `retry_exhausted` и `error_code` | там же |
| Ограниченный retry, финальное failed с безопасным error_code | сценарий B, `fault-transient` | `fault-transient`: 5 попыток (attempt 1–5), между ними 4 отложенных повтора, затем `failed` / `retry_exhausted`; arithmetic JPEG — `failed` / `invalid_image` сразу | там же |
| Повтор одной job не создаёт второго набора вариантов | инварианты I2 | PASS: у каждого из 9 ключей (вложение, версия) ровно 3 строки вариантов; 27 объектов `variants/…` в S3 = 27 строкам БД, в том числе после двух падений `crash-after-s3` | там же |
| Демонстрация «worker stop → upload → message → restart API/broker → worker → ready» | сценарий A | PASS за 54.5 с: worker остановлен → upload 202 → content 409 → сообщение с вложением 201 → рестарт API и брокера → worker → ready, оригинал побайтно, thumbnail 256×160 | там же |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| crop 128×128 и optimized WebP по контракту, параметры описаны | smoke-фикстура в сценарии A, `attachments_negative.py` | thumbnail 256×160 JPEG, crop 128×128 JPEG, optimized 320×200 WebP (`RIFF…WEBP`, без увеличения), SHA-256 bytes = метаданные; параметры — раздел «Варианты» | [evidence/pipeline_experiment.json](evidence/pipeline_experiment.json) |
| Невалидные/огромные изображения ограничены по bytes, пикселям, времени, памяти | API-лимиты lab4 (`attachments_negative.py`); worker: arithmetic JPEG (SOF9) | структурно валидный, но недекодируемый JPEG → `failed`/`invalid_image` с первой попытки, без повторов; content → 409, прикрепление → 409 | там же |
| Transactional outbox, crash между COMMIT и publish | сценарий B, `fault-crash-before-publish` | PASS: relay упал после COMMIT, но до publish (процесс остановлен `halt`); строка outbox осталась, её опубликовал другой relay → ready без ручного вмешательства (audit: accepted → claimed → done) | там же |
| Backoff с jitter, постоянные/временные ошибки, DLQ/реестр failed, безопасный replay | сценарий B, `fault-transient`, `jobctl replay` | задержки повторов 945 / 1988 / 2378 / 7098 мс (окна 0.5–1 / 1–2 / 2–4 / 4–8 с); постоянная ошибка без повторов; `jobctl replay` → тот же job_id, attempt 6 → ready; повторный replay и replay done-задания → `skipped: job is done` | там же |
| Остановка worker после записи объекта, до ack | сценарий B, `fault-crash-after-s3`, `fault-crash-after-commit` | PASS: падение после записи в S3 до COMMIT → аренда истекла → новая попытка перезаписала те же ключи, SHA-256 объектов = БД; падение после COMMIT до ack → повторная доставка → `duplicate_done`, attempt 1 остался единственным | там же |
| Timeout/lease для зависшего processing, ограниченный prefetch, очистка staging | lease 15 с (в эксперименте 6 с) + heartbeat, `basic.qos(1)` × 2 канала, `sweepStaging` | истёкшая аренда → `lease_expired` → attempt+1; ready-вложения без staging (I5), staging failed-вложения сохранён до retention; у worker 2 неподтверждённых сообщения максимум | там же |
### Уровень 5 — трек 2
| Критерий трека | Команда/сценарий | Наблюдаемый результат |
| --- | --- | --- |
| Versioned pipeline | `PIPELINE_VERSION`, `ImagePipeline.VERSIONS` (v1: JPEG 0.85 / WebP 80; v2: 0.92 / 90), `jobctl reprocess --pipeline-version=2` | новая версия — новая логическая job (`UNIQUE(attachment_id, pipeline_version)`), свой набор ключей `v2/…` |
| Автоматический fault-injection: дубль, reorder, crash до/после side effect, устаревшая job | `python3 tests/pipeline_experiment.py` | PASS: дубли publish и доставки, reorder (устаревший attempt=1, v2 раньше v1), падения до/после эффекта, устаревшая v1 после v2 — см. «Эксперименты» |
| Инварианты; нет потери подтверждённых задач и перезаписи нового результата старым | там же, блок invariants | PASS: 9 из 9 принятых вложений в ожидаемом финальном состоянии; ровно 3 варианта на ключ эффекта; S3 = БД (27/27 SHA-256); каждое done-задание зафиксировано 1 раз; указатель версии остался 2 |
| Почему это не exactly-once | раздел «Эксперименты» | доставка at-least-once + идемпотентный эффект |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
### Трек 2: доказанная идемпотентность pipeline
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
**Гипотеза.** При at-least-once доставке, дублях, перестановке сообщений, падениях до и после побочного эффекта и устаревшей job после новой версии: ни одна принятая (202) работа не теряется; на ключ эффекта `(attachment_id, pipeline_version, variant)` приходится ровно один зафиксированный результат; новый результат не перезаписывается старым.
**Методика.** [tests/pipeline_experiment.py](tests/pipeline_experiment.py) — black-box через API плюс наблюдение через psql, `s3-probe` (листинг и SHA-256 объектов) и `rabbitmqctl`. Скрипт сам пересоздаёт api-1, api-2 и worker с `FAULT_INJECTION=1` и арендой 6 с, а в конце возвращает обычный режим. Точка сбоя выбирается префиксом имени файла `fault-<point>` и срабатывает **один раз на вложение** (отметка в `fault_marks` коммитится до `Runtime.halt(137)`, то есть до `kill -9` процесса). Каждый сценарий использует своё вложение. Дубли и reorder вносятся вставкой строк в `outbox`, и relay публикует их как настоящие сообщения. Стенд: один Docker-host (Apple M3 Pro, OrbStack), лимиты как в compose; один прогон — 217 с. Сырые данные — [evidence/pipeline_experiment.json](evidence/pipeline_experiment.json): audit каждой job, задержки, инварианты.
| Внедрение | Окно отказа | Ожидаем | Наблюдали (job_audit) |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `crash-before-publish` (relay в API/worker) | после COMMIT, до publish | outbox переживает падение | accepted → claimed → done |
| `crash-after-publish` | после confirm, до DELETE outbox | повторная публикация гасится | done → `duplicate_done` |
| `crash-after-claim` | захват есть, эффекта нет | аренда истекает, новая попытка | claimed(1) → `duplicate_in_progress` (redelivery при живой аренде) → `lease_expired` → claimed(2) → done(2) |
| `crash-after-s3` | объекты в S3 записаны, COMMIT нет | та же работа, те же ключи | claimed(1) → lease_expired → claimed(2) → lease_expired (worker уронил соседний сценарий) → claimed(3) → done(3); объектов в S3 ровно 3 |
| `crash-after-commit` | COMMIT есть, ack нет | повтор = no-op | done(1) → `duplicate_done` |
| дубль `attempt=1` после перехода на attempt ≥ 2 | reorder | отброшен | `stale_attempt` |
| 3 дубля v1 во время обработки, 2 — после | дубль | отброшены | 3× `duplicate_in_progress`, 2× `duplicate_done` |
| v1 медленная (40 с до COMMIT), v2 через `jobctl reprocess` | устаревшая job после новой версии | v1 не откатывает указатель | v2: done `current`; v1: done `superseded`; `attachments.pipeline_version = 2`, API отдаёт варианты v2 |
| временная ошибка во всех 5 попытках, затем replay | retry/replay | backoff → failed → одна новая попытка | 945/1988/2378/7098 мс → `retry_exhausted` → replay attempt 6 → done; повторный replay — skipped |
| arithmetic JPEG | постоянная ошибка | без повторов | claimed → failed `invalid_image` |
**Инварианты** (проверяются скриптом по всем вложениям прогона): **I1** — все 9 принятых вложений финальны: 8 ready и 1 failed (ожидаемый invalid_image), застрявших нет. **I2** — на каждый ключ (вложение, версия) ровно 3 строки вариантов, объекты `variants/<id>/…` в S3 совпадают со строками БД (27 = 27). **I3** — SHA-256 байтов каждого объекта в S3 равен зафиксированному (27/27); перезапись после `crash-after-s3` дала те же байты. **I4** — каждое done-задание зафиксировано ровно один раз (9×1; у failed — 0), после done захватов нет. **I5** — staging ready-вложений удалён; остался только staging failed-вложения (retention). За прогон погашено 4 `duplicate_done`, 6 `duplicate_in_progress`, 1 `stale_attempt`. Результат: **PASS**.
**Почему это не exactly-once доставка.** Сообщение реально доставлялось несколько раз: повторная публикация после падения relay, redelivery после падения до ack. Атомарно «опубликовать и удалить строку outbox» или «зафиксировать результат и ack» нельзя: это разные системы без общей транзакции. Exactly-once здесь только у **эффекта**: решение принимает одна транзакция PostgreSQL (fencing по `attempt` + PK ключа эффекта), а записи в S3 идемпотентны (детерминированные ключи и байты). Побочные затраты при этом повторяются: при `crash-after-s3` изображение отрисовано и загружено три раза, в S3 остался один набор.
**Ограничения эксперимента.** Один прогон и один worker-контейнер; перестановка версий в сценарии C задаётся временем (v1 спит 40 с, `jobctl` стартует ≈ 10 с); точки сбоя — учебный механизм по имени файла; не проверены сетевые разделения и потеря данных брокером (volume удалён). Счётчик `messages` в `rabbitmqctl list_queues` у quorum-очереди обновляется с задержкой до ~5 с, поэтому скрипт ждёт пустую очередь двумя чтениями.
### Отказы
| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных |
| --- | --- | --- | --- |
| Worker остановлен | приём продолжается, ресайза в API нет | upload 202, content 409, сообщения 201 | после старта worker — ready; потерь нет |
| Рестарт API и брокера с volumes | принятая работа сохраняется | задание queued, сообщение в quorum-очереди до и после | ready после старта worker |
| Падение relay до publish / после publish | работа не теряется / дубль безвреден | ready / `duplicate_done` | автоматически (другой relay, ≈ 1 с) |
| Падение worker до эффекта, после S3, после COMMIT | один результат | ready, 3 объекта, SHA-256 = БД | аренда 6 с (в обычном режиме 15 с) + рестарт контейнера |
| Остановка обслужившей API-реплики (`make test-failover`) | запись через другую | 72 записи, 0 ошибок | первая запись 2.99 с |
| S3 недоступен (`attachments_negative.py --with-docker`) | вложения 503, текст работает | upload/download 503, сообщения 201 | после старта S3 скачивание работает |
## Ответы на вопросы защиты
**Чем publisher confirm отличается от consumer ack?** Confirm — ответ брокера издателю: сообщение принято и записано в quorum-очередь (relay удаляет строку outbox только после него). Ack — ответ consumer брокеру: сообщение можно удалить, потому что результат обработки устойчиво зафиксирован (у нас — после COMMIT в PostgreSQL). Это разные границы: confirm ничего не говорит об обработке, ack — о доставке издателю.
**Что именно сохранено в момент 202?** Полный проверенный оригинал в `staging/<id>` (S3 PUT завершён) и закоммиченные в одной транзакции строки `attachments` (queued), `jobs` (attempt 1) и `outbox`. Брокер в этот момент может быть недоступен — намерение уже в БД, relay опубликует его позже. Варианты и `originals/<id>` ещё не созданы.
**Почему повторная доставка нормальна и где ключ идемпотентности job?** При at-least-once сообщение повторяется, если consumer упал до ack, relay — после confirm до удаления outbox, или брокер перезапустился. Ключ эффекта — `(attachment_id, pipeline_version, variant)`: детерминированные ключи S3 (повтор перезаписывает тот же объект теми же байтами) и PK `attachment_variants`; дубль сообщения гасится ещё раньше — по состоянию и `attempt` в строке `jobs` (`duplicate_done`, `stale_attempt`).
**Как отличить зависший worker от долго работающего и не запустить два неконтролируемых дубля?** Живой worker каждые 5 с продлевает аренду (heartbeat), но не дальше 60 с от начала попытки; умерший или зависший перестаёт — через 15 с аренда истекает, и sweep выдаёт следующую попытку с `attempt+1`. Номер попытки — fencing token: старая попытка, проснувшись, не сможет ни продлить аренду, ни зафиксировать результат (`state='processing' AND attempt=N` под `FOR UPDATE`), а её возможные записи в S3 идут в те же детерминированные ключи с теми же байтами.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один Docker-host и по одному экземпляру PostgreSQL, Redis, S3, RabbitMQ (SPOF); quorum-очередь из одного узла даёт durability на диске, но не репликацию.
- Relay — polling раз в секунду (1 транзакция/с на процесс в простое, до +1 с к времени до ready); при длинной недоступности брокера outbox растёт без ограничения, объём приёма не ограничен (трек 1 не выбран).
- Сообщение без строки outbox (ушло в DLQ после 50 доставок при недоступной БД) восстанавливается вручную: `jobctl redispatch`; автоматического повторного опубликования «застрявших» queued нет.
- Объекты вариантов попытки, которая записала S3 и затем окончательно упала (`retry_exhausted`), остаются без строки БД: сверка обходит только `originals/`. Оригиналы failed-вложений также не удаляются.
- Варианты v1 после перехода на v2 не удаляются (нужны для отката); retention старых версий не реализован.
- Fault injection включается переменной окружения, точка выбирается префиксом имени файла — только для учебного стенда; в обычном режиме `FAULT_INJECTION=0`.
- Ключи идемпотентности сообщений хранятся бессрочно (как в lab4).
+353
View File
@@ -0,0 +1,353 @@
# Compose-стенд lab5: nginx → 2 API-реплики → PostgreSQL + Redis + SeaweedFS (S3); RabbitMQ → worker
# (асинхронные варианты изображений).
# Перед первым запуском: python3 scripts/init_secrets.py — секреты появятся в secrets/ (вне Git).
# Общие переменные; FAULT_INJECTION=1 включают только эксперименты (tests/pipeline_experiment.py).
x-env: &env
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
JOB_MAX_ATTEMPTS: 5
PIPELINE_VERSION: 1
FAULT_INJECTION: ${FAULT_INJECTION:-0}
# Общая часть API-реплик, worker, migration и инструментов: один образ, разные режимы запуска.
x-api: &api
build: .
image: messenger-api:lab5
environment: *env
# Секреты читаются 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
- source: broker_api_url
target: broker.url
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
# Запас на одновременный старт нескольких JVM при лимите 1 CPU; healthy наступает с первой успешной проверки.
start_period: 90s
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
# Worker: отдельный процесс (режим worker) с собственными ключами S3 и пользователем брокера.
worker:
<<: *api
command: ["worker"]
environment:
<<: *env
WORKER_CONCURRENCY: 2
JOB_TIMEOUT_SECONDS: 60
JOB_LEASE_SECONDS: ${JOB_LEASE_SECONDS:-15}
STAGING_RETENTION_SECONDS: 86400
# Куча до 65% лимита: декодирование одного изображения ограничено ~48 MiB растра.
JAVA_TOOL_OPTIONS: -XX:MaxRAMPercentage=65
secrets:
- source: db_password
target: spring.datasource.password
- source: s3_worker_access_key
target: s3.access-key
- source: s3_worker_secret_key
target: s3.secret-key
- source: broker_worker_url
target: broker.url
depends_on:
postgres:
condition: service_healthy
rabbitmq:
condition: service_healthy
s3-init:
condition: service_completed_successfully
migration:
condition: service_completed_successfully
# Живой = подключён к брокеру (файл обновляется каждые 2 с).
healthcheck:
test: ["CMD-SHELL", "test -n \"$$(find /tmp/worker-alive -newermt '-15 seconds' 2>/dev/null)\""]
interval: 5s
timeout: 3s
retries: 3
start_period: 90s
# Операторские команды заданий: docker compose run --rm jobctl status | replay | reprocess | redispatch.
jobctl:
<<: *api
entrypoint: ["java", "-Dfile.encoding=UTF-8", "-jar", "/app/messenger.jar", "jobctl"]
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
healthcheck:
disable: true
restart: "no"
# Однократные миграции 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"
# RabbitMQ: durable quorum-очередь attachments.process + DLQ. Пользователи, права и топология —
# из definitions-файла (secrets/), management UI не включён, порт наружу не публикуется.
rabbitmq:
image: rabbitmq:4.0.5-alpine
# Имя узла rabbit@rabbitmq задаёт каталог данных в volume: без фиксированного hostname
# пересозданный контейнер не увидел бы прежние очереди и сообщения.
hostname: rabbitmq
volumes:
- rabbitmqdata:/var/lib/rabbitmq
- ./infra/rabbitmq/rabbitmq.conf:/etc/rabbitmq/conf.d/90-lab.conf:ro
secrets:
- source: rabbitmq_definitions
target: rabbitmq_definitions.json
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "check_port_connectivity"]
interval: 10s
timeout: 10s
retries: 12
start_period: 20s
restart: unless-stopped
stop_grace_period: 30s
deploy:
resources:
limits:
cpus: '1.0'
memory: 512M
# 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:
rabbitmqdata:
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
s3_worker_access_key:
file: ./secrets/s3_worker_access_key
s3_worker_secret_key:
file: ./secrets/s3_worker_secret_key
broker_api_url:
file: ./secrets/broker_api_url
broker_worker_url:
file: ./secrets/broker_worker_url
rabbitmq_definitions:
file: ./secrets/rabbitmq_definitions.json
+8
View File
@@ -0,0 +1,8 @@
api-1 Up 28 seconds (healthy)
api-2 Up 28 seconds (healthy)
nginx Up 11 seconds
postgres Up 49 seconds (healthy)
rabbitmq Up 49 seconds (healthy)
redis Up 49 seconds (healthy)
s3 Up 49 seconds (healthy)
worker Up 28 seconds (healthy)
+8
View File
@@ -0,0 +1,8 @@
api-1 Up 2 minutes (healthy)
api-2 Up 22 seconds (healthy)
nginx Up 41 minutes
postgres Up 43 minutes (healthy)
rabbitmq Up 14 minutes (healthy)
redis Up 43 minutes (healthy)
s3 Up 39 minutes (healthy)
worker Up 2 minutes (healthy)
+409
View File
@@ -0,0 +1,409 @@
{
"experiment": "lab5 pipeline: grade 3/4 scenarios and track 2 idempotency",
"lease_seconds": 6,
"scenarios": {
"A_worker_down_restart": {
"attachment_id": "c5bf7bbb-abea-4d5c-80d1-48efcc34a91f",
"job_id": "2acff2d8-8269-420b-a802-f1f23b20c942",
"message_id": "604ad2bf-7068-4f96-8cc9-60f8cdab679e",
"queue_before_restart": {
"attachments.dlq": 0,
"attachments.process": 1
},
"queue_after_restart": {
"attachments.process": 1,
"attachments.dlq": 0
},
"content_while_queued": 409,
"seconds": 54.5,
"result": "PASS"
},
"B_faults": {
"fired_points": [
"crash-after-claim",
"crash-after-claim",
"crash-after-commit",
"crash-after-commit",
"crash-after-publish",
"crash-after-publish",
"crash-after-s3",
"crash-after-s3",
"crash-before-publish",
"crash-before-publish",
"crash-before-publish"
],
"audit": {
"crash-before-publish": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"done",
"current"
]
],
"crash-after-publish": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"done",
"current"
],
[
1,
"duplicate_done",
""
]
],
"crash-after-claim": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"lease_expired",
"next_attempt=2 delay_ms=0 error=lease expired"
],
[
2,
"claimed",
""
],
[
2,
"done",
"current"
]
],
"crash-after-s3": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"lease_expired",
"next_attempt=2 delay_ms=0 error=lease expired"
],
[
2,
"claimed",
""
],
[
2,
"duplicate_in_progress",
""
],
[
2,
"lease_expired",
"next_attempt=3 delay_ms=0 error=lease expired"
],
[
3,
"claimed",
""
],
[
3,
"done",
"current"
]
],
"crash-after-commit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"done",
"current"
],
[
1,
"duplicate_done",
""
]
]
},
"transient": {
"job_id": "0b7a7379-c023-4871-beca-76fe73780fad",
"backoff_delays_ms": [
945,
1988,
2378,
7098
],
"audit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"retry_scheduled",
"next_attempt=2 delay_ms=945 error=java.io.IOException: injected transient fault"
],
[
1,
"stale_attempt",
""
],
[
2,
"claimed",
""
],
[
2,
"retry_scheduled",
"next_attempt=3 delay_ms=1988 error=java.io.IOException: injected transient fault"
],
[
3,
"claimed",
""
],
[
3,
"retry_scheduled",
"next_attempt=4 delay_ms=2378 error=java.io.IOException: injected transient fault"
],
[
4,
"claimed",
""
],
[
4,
"retry_scheduled",
"next_attempt=5 delay_ms=7098 error=java.io.IOException: injected transient fault"
],
[
5,
"claimed",
""
],
[
5,
"failed",
"retry_exhausted"
],
[
6,
"replayed",
"operator"
],
[
6,
"claimed",
""
],
[
6,
"done",
"current"
]
],
"replay": {
"0b7a7379-c023-4871-beca-76fe73780fad": "queued as attempt 6",
"c5a76b6f-cb78-4bb2-a3ce-56502133a6aa": "skipped: job is done"
},
"replay_again": {
"0b7a7379-c023-4871-beca-76fe73780fad": "skipped: job is done"
}
},
"invalid_image": {
"job_id": "6c89d573-f66d-4b67-be04-03f6b7030d2e",
"audit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"failed",
"invalid_image"
]
]
},
"seconds": 90.4,
"result": "PASS"
},
"C_stale_version": {
"attachment_id": "c6904d45-3832-4731-8661-82169a0b71ce",
"v1_job": "2abffab8-72d2-4726-9441-598acf257ec6",
"v2_job": "32e448a7-84db-4001-808a-c53377550780",
"reprocess": {
"jobs_created": 1
},
"v1_audit": [
[
1,
"accepted",
""
],
[
1,
"claimed",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"duplicate_in_progress",
""
],
[
1,
"done",
"superseded"
],
[
1,
"duplicate_done",
""
],
[
1,
"duplicate_done",
""
]
],
"v2_audit": [
[
1,
"claimed",
""
],
[
1,
"done",
"current"
]
],
"pointer": 2,
"seconds": 45.2,
"result": "PASS"
}
},
"invariants": {
"I1_no_lost_accepted_work": {
"fa60a320-1a8a-4cb8-a7dc-4037e41797c4": "ready",
"78e1f160-8ca0-4c80-91ea-8c44891c74b2": "ready",
"beb1fce9-e687-4aa1-a2c4-d7fbdfebfacb": "ready",
"3238db95-e369-4739-88f1-4032337deec6": "ready",
"c6904d45-3832-4731-8661-82169a0b71ce": "ready",
"c5bf7bbb-abea-4d5c-80d1-48efcc34a91f": "ready",
"00f1b5f4-a9b5-475f-8a98-b6db047bb533": "failed",
"ae0fe87f-6416-4483-8822-ac13b3f224df": "ready",
"120ba64d-a663-4ac5-b97f-9ffe79404a7d": "ready"
},
"I2_variants_per_effect_key": {
"120ba64d-a663-4ac5-b97f-9ffe79404a7d/v1": 3,
"3238db95-e369-4739-88f1-4032337deec6/v1": 3,
"78e1f160-8ca0-4c80-91ea-8c44891c74b2/v1": 3,
"ae0fe87f-6416-4483-8822-ac13b3f224df/v1": 3,
"beb1fce9-e687-4aa1-a2c4-d7fbdfebfacb/v1": 3,
"c5bf7bbb-abea-4d5c-80d1-48efcc34a91f/v1": 3,
"c6904d45-3832-4731-8661-82169a0b71ce/v1": 3,
"c6904d45-3832-4731-8661-82169a0b71ce/v2": 3,
"fa60a320-1a8a-4cb8-a7dc-4037e41797c4/v1": 3
},
"I2_s3_variant_objects": 27,
"I3_checksums_equal": 27,
"I4_commits_per_job": [
0,
1,
1,
1,
1,
1,
1,
1,
1,
1
],
"I5_staging": {
"staging_left_for_run": [
"00f1b5f4-a9b5-475f-8a98-b6db047bb533"
]
},
"duplicates_dropped": {
"duplicate_done": 4,
"duplicate_in_progress": 6,
"stale_attempt": 1
},
"result": "PASS"
},
"seconds_total": 217.0
}
+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"}}';
}
}
+5
View File
@@ -0,0 +1,5 @@
# Пользователи, права, exchange и очереди импортируются при каждом старте (идемпотентно, по хешу файла).
load_definitions = /run/secrets/rabbitmq_definitions.json
# Пороги flow control ниже лимита контейнера 512M: при нехватке памяти/диска брокер тормозит издателей, а не падает.
vm_memory_high_watermark.absolute = 256MiB
disk_free_limit.absolute = 200MB
+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"
+38
View File
@@ -0,0 +1,38 @@
<?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>
<!-- RabbitMQ: publisher confirms и ручной ack без обёрток Spring AMQP; версия из BOM Spring Boot. -->
<dependency><groupId>com.rabbitmq</groupId><artifactId>amqp-client</artifactId></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"
+84
View File
@@ -0,0 +1,84 @@
#!/usr/bin/env python3
"""Создаёт синтетические секреты локального стенда в secrets/ (вне Git); значения не печатает.
Повторный запуск не меняет существующие файлы: пароль PostgreSQL задаётся при первой
инициализации volume, и его смена сломала бы уже созданный стенд.
"""
import base64
import hashlib
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)
worker_key, worker_secret = value('s3_worker_access_key', access_key), value('s3_worker_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]},
{'name': 'worker', 'credentials': [{'accessKey': worker_key, 'secretKey': worker_secret}],
'actions': ['Read:' + BUCKET, 'Write:' + BUCKET, 'List:' + BUCKET]},
]}, indent=2))
def rabbit_hash(password):
# Формат rabbit_password_hashing_sha256: base64(salt4 + sha256(salt4 + password)).
salt = os.urandom(4)
return base64.b64encode(salt + hashlib.sha256(salt + password.encode()).digest()).decode()
# RabbitMQ: пользователь api только публикует в exchange attachments, worker ещё и читает очередь.
# configure-прав нет ни у кого: топологию создаёт definitions-файл при старте брокера.
api_pw, worker_pw = value('broker_api_password', token), value('broker_worker_password', token)
value('broker_api_url', lambda: 'amqp://api:%s@rabbitmq:5672/%%2F' % api_pw)
value('broker_worker_url', lambda: 'amqp://worker:%s@rabbitmq:5672/%%2F' % worker_pw)
user = lambda name, pw: {'name': name, 'password_hash': rabbit_hash(pw), 'hashing_algorithm': 'rabbit_password_hashing_sha256', 'tags': []}
exchange = lambda name, kind: {'name': name, 'vhost': '/', 'type': kind, 'durable': True, 'auto_delete': False, 'internal': False, 'arguments': {}}
queue = lambda name, args: {'name': name, 'vhost': '/', 'durable': True, 'auto_delete': False, 'arguments': args}
binding = lambda source, queue, key: {'source': source, 'vhost': '/', 'destination': queue, 'destination_type': 'queue', 'routing_key': key, 'arguments': {}}
value('rabbitmq_definitions.json', lambda: json.dumps({
'users': [user('api', api_pw), user('worker', worker_pw)],
'vhosts': [{'name': '/'}],
'permissions': [
{'user': 'api', 'vhost': '/', 'configure': '^$', 'write': '^attachments$', 'read': '^$'},
{'user': 'worker', 'vhost': '/', 'configure': '^$', 'write': '^attachments$', 'read': '^attachments\\.process$'},
],
'exchanges': [exchange('attachments', 'direct'), exchange('attachments.dlx', 'fanout')],
# Quorum-очередь: реплицируемый журнал на диске, сообщения переживают рестарт брокера с volume.
'queues': [queue('attachments.process', {'x-queue-type': 'quorum', 'x-dead-letter-exchange': 'attachments.dlx', 'x-delivery-limit': 50}),
queue('attachments.dlq', {'x-queue-type': 'quorum'})],
'bindings': [binding('attachments', 'attachments.process', 'process'), binding('attachments.dlx', 'attachments.dlq', '')],
}, 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"
+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)"
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
# Останавливает worker (graceful: текущие попытки дорабатываются ≤ 25 с); очередь и задания остаются.
# Запуск обратно: docker compose start worker
set -eu
cd "$(dirname "$0")/.."
docker compose stop worker
@@ -0,0 +1,217 @@
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.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 участникам чата.
// Приём (lab5): оригинал → staging в S3, затем вложение + job + outbox одной транзакцией → 202 queued;
// варианты создаёт worker асинхронно.
@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<Variant> variants, String error_code, Instant created_at, Instant updated_at) {}
record Variant(String name, String content_type, long size_bytes, int width, int height, String sha256) {}
final MessengerApplication.Api api;
final JdbcTemplate db;
final Storage storage;
final Jobs jobs;
// Не больше N загрузок на реплику одновременно: диск под временные файлы и CPU проверки ограничены.
final Semaphore uploads = new Semaphore(Integer.parseInt(System.getenv().getOrDefault("MAX_CONCURRENT_UPLOADS", "8")));
Attachments(MessengerApplication.Api api, JdbcTemplate db, Storage storage, Jobs jobs) {
this.api = api;
this.db = db;
this.storage = storage;
this.jobs = jobs;
}
@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. Полный проверенный оригинал — в устойчивый staging (приватный S3-префикс), до записи в БД.
UUID attachmentId = UUID.randomUUID();
String staging = Storage.STAGING + attachmentId;
String hash = HexFormat.of().formatHex(sha.digest());
try {
storage.put(staging, tmp, declared);
} catch (SdkException e) {
log.warn("S3 staging put failed for attachment {}: {}", attachmentId, e.toString());
throw unavailable("object storage is unavailable");
}
// 4. Метаданные, задание и outbox — одна транзакция; 202 только после её COMMIT.
// Не записалось — убираем staging (иначе его удалит очистка staging по retention).
Instant created = now();
try {
jobs.accept(attachmentId, id, user, filename, declared, size, hash, image.width(), image.height(), created);
} catch (RuntimeException e) {
try { storage.delete(staging); } catch (SdkException ignored) {}
throw e;
}
return ResponseEntity.status(202).body(new Attachment(attachmentId, id, user, filename, declared, size, hash, "queued", List.of(), null, created, created));
} 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));
String name = variant == null ? "original" : variant;
if (!name.equals("original") && !VARIANTS.contains(name)) api.bad();
// queued/processing/failed — 409: оригинал ещё не опубликован, варианты не готовы.
if (!v.attachment().status().equals("ready")) throw new ApiException(HttpStatus.CONFLICT, "conflict", "attachment is not ready");
Attachment a = v.attachment();
String key = v.key(), type = a.content_type();
long size = a.size_bytes();
if (!name.equals("original")) {
Object[] x = db.query("select object_key,content_type,size_bytes from attachment_variants where attachment_id=? and pipeline_version=? and name=?",
rs -> rs.next() ? new Object[]{rs.getString(1), rs.getString(2), rs.getLong(3)} : null, id, v.version(), name);
if (x == null) throw api.notFound();
key = (String) x[0];
type = (String) x[1];
size = (long) x[2];
}
ResponseInputStream<GetObjectResponse> in;
try {
in = storage.get(key);
} catch (NoSuchKeyException e) {
// Метаданные есть, объекта нет: рассинхронизация, её покажет и исправит сверка.
log.error("object {} is missing for ready attachment {}", 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) {
s.setContentType(type);
s.setContentLengthLong(size);
s.setHeader("Cache-Control", "private, no-store");
s.setHeader("X-Content-Type-Options", "nosniff");
in.transferTo(s.getOutputStream());
}
}
record Visible(Attachment attachment, String key, Integer version) {}
// Вложения чатов, где пользователь участник; uploading/lost и чужие — 404 без раскрытия существования.
// Варианты — только текущей (последней зафиксированной) версии pipeline.
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,state,error_code,pipeline_version from attachments a"
+ " where id=? and state in ('queued','processing','ready','failed') and exists(select 1 from chat_members m where m.chat_id=a.chat_id and m.user_id=?)", rs -> {
if (!rs.next()) return null;
String state = rs.getString(11);
Integer version = rs.getObject(13, Integer.class);
List<Variant> variants = state.equals("ready") && version != null ? db.query("select name,content_type,size_bytes,width,height,sha256 from attachment_variants"
+ " where attachment_id=? and pipeline_version=? order by array_position(array['thumbnail','crop','optimized']::text[],name::text)",
(x, n) -> new Variant(x.getString(1), x.getString(2), x.getLong(3), x.getInt(4), x.getInt(5), x.getString(6)), id, version) : List.of();
return 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), state, variants, state.equals("failed") ? rs.getString(12) : null, rs.getTimestamp(8).toInstant(), rs.getTimestamp(9).toInstant()),
rs.getString(10), version);
}, 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,67 @@
package ru.mtusi.messenger;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ExecutorService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
// RabbitMQ: exchange attachments → quorum-очередь attachments.process (DLX → attachments.dlq).
// Топологию и пользователей создаёт definitions-файл брокера; клиент ничего не объявляет.
@Component
class Broker {
static final String EXCHANGE = "attachments", ROUTING_KEY = "process", QUEUE = "attachments.process";
final ConnectionFactory factory = new ConnectionFactory();
Connection connection;
Channel channel;
volatile boolean returned;
Broker(@Value("${broker.url:amqp://localhost}") String url) throws Exception {
factory.setUri(url.trim());
// Переподключение делаем сами (следующий тик relay/supervisor), без скрытых повторов публикаций.
factory.setAutomaticRecoveryEnabled(false);
factory.setConnectionTimeout(3000);
factory.setRequestedHeartbeat(10);
}
Connection connect(String name, ExecutorService executor) throws Exception {
return factory.newConnection(executor, name);
}
record Message(String id, byte[] body) {}
// Пачка с publisher confirms: возврат без исключения = брокер сохранил все сообщения в очереди.
synchronized void publish(List<Message> messages) throws Exception {
try {
if (channel == null || !channel.isOpen()) {
connection = factory.newConnection("publisher");
channel = connection.createChannel();
channel.confirmSelect();
// mandatory: сообщение без маршрута брокер подтвердил бы, но не сохранил — считаем ошибкой.
channel.addReturnListener(r -> returned = true);
}
returned = false;
for (Message m : messages) {
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder().contentType("application/json").deliveryMode(2)
.messageId(m.id()).type(Jobs.TYPE).timestamp(new Date()).build();
channel.basicPublish(EXCHANGE, ROUTING_KEY, true, props, m.body());
}
channel.waitForConfirmsOrDie(5000);
if (returned) throw new IOException("message was not routed to a queue");
} catch (Exception e) {
close();
throw e;
}
}
synchronized void close() {
if (connection != null) connection.abort(1000);
connection = null;
channel = null;
}
}
@@ -0,0 +1,207 @@
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.zip.CRC32;
import java.util.zip.DataFormatException;
import java.util.zip.Inflater;
// Потоковая проверка PNG/JPEG по содержимому без декодирования в пиксели: память — буферы по 64 KiB,
// а не ширина × высота. Размеры читаются из заголовка, лимит пикселей применяется до распаковки.
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();
if (Arrays.equals(head, PNG_SIGNATURE)) return png(new DataInputStream(in));
if (head.length >= 3 && (head[0] & 0xff) == 0xff && (head[1] & 0xff) == 0xd8 && (head[2] & 0xff) == 0xff) return jpeg(in);
throw bad("not a PNG or JPEG");
}
}
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,215 @@
package ru.mtusi.messenger;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageReadParam;
import javax.imageio.ImageReader;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.ImageOutputStream;
// Варианты изображения: thumbnail (JPEG, вписан в 256×256), crop (JPEG 128×128 из центрального квадрата),
// optimized (WebP, вписан в 1280×1280). EXIF orientation применяется, alpha компонуется на белый,
// метаданные исходника не переносятся. Версия pipeline задаёт параметры кодирования.
final class ImagePipeline {
record Params(float jpegQuality, int webpQuality) {}
static final Map<Integer, Params> VERSIONS = Map.of(1, new Params(0.85f, 80), 2, new Params(0.92f, 90));
// Декодирование с прореживанием до ≤ 12 Мпикс: растр одной задачи ≤ ~48 MiB при любом исходнике ≤ 40 Мпикс.
static final long DECODE_PIXELS = 12_000_000L, MAX_PIXELS = 40_000_000L;
record Output(String name, String contentType, String file, int width, int height, Path path) {}
static final class Invalid extends Exception {
Invalid(String message) { super(message); }
}
static List<Output> render(Path source, String contentType, int version, Path dir, Jobs.Claim c) throws IOException, Invalid {
Params p = VERSIONS.get(version);
if (p == null) throw new Jobs.Permanent("unsupported_pipeline", "unknown pipeline_version " + version);
int orientation = contentType.equals("image/jpeg") ? orientation(source) : 1;
ImageReader reader = ImageIO.getImageReadersByMIMEType(contentType).next();
BufferedImage img;
int w, h;
try (ImageInputStream in = ImageIO.createImageInputStream(source.toFile())) {
reader.setInput(in, true, true);
w = reader.getWidth(0);
h = reader.getHeight(0);
// Повторная проверка лимита пикселей по заголовку до декодирования.
if ((long) w * h > MAX_PIXELS) throw new Invalid("too many pixels");
int s = 1;
while ((long) ((w + s - 1) / s) * ((h + s - 1) / s) > DECODE_PIXELS) s++;
ImageReadParam param = reader.getDefaultReadParam();
param.setSourceSubsampling(s, s, 0, 0);
c.reader = reader;
img = reader.read(0, param);
} catch (IOException | RuntimeException e) {
c.check();
throw new Invalid(e.toString());
} finally {
c.reader = null;
reader.dispose();
}
// abort() по таймауту или потере аренды прерывает read: частичный растр не используем.
c.check();
int dw = img.getWidth(), dh = img.getHeight();
boolean swap = orientation >= 5;
int ow = swap ? h : w, oh = swap ? w : h;
List<Output> out = new ArrayList<>();
int[] t = fit(ow, oh, 256);
out.add(jpeg("thumbnail", orient(scale(img, 0, 0, dw, dh, swap ? t[1] : t[0], swap ? t[0] : t[1]), orientation), p.jpegQuality(), dir));
c.check();
int side = Math.min(dw, dh);
out.add(jpeg("crop", orient(scale(img, (dw - side) / 2, (dh - side) / 2, side, side, 128, 128), orientation), p.jpegQuality(), dir));
c.check();
int[] o = fit(ow, oh, 1280);
out.add(webp(orient(scale(img, 0, 0, dw, dh, swap ? o[1] : o[0], swap ? o[0] : o[1]), orientation), p.webpQuality(), dir, c));
return out;
}
// Вписать в box×box с сохранением пропорций, без увеличения; округление вниз, минимум 1 px.
static int[] fit(int w, int h, int box) {
if (w <= box && h <= box) return new int[]{w, h};
return w >= h ? new int[]{box, (int) Math.max(1, (long) h * box / w)} : new int[]{(int) Math.max(1, (long) w * box / h), box};
}
// Область исходника → tw×th на белом фоне; сильное уменьшение — последовательными halving-шагами.
static BufferedImage scale(BufferedImage src, int sx, int sy, int sw, int sh, int tw, int th) {
BufferedImage cur = src;
while (sw / 2 >= tw && sh / 2 >= th) {
BufferedImage next = canvas(sw / 2, sh / 2);
draw(next, cur, sx, sy, sw, sh, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
cur = next;
sx = 0;
sy = 0;
sw = next.getWidth();
sh = next.getHeight();
}
BufferedImage out = canvas(tw, th);
draw(out, cur, sx, sy, sw, sh, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
return out;
}
static BufferedImage canvas(int w, int h) {
BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Graphics2D g = img.createGraphics();
g.setColor(Color.WHITE);
g.fillRect(0, 0, w, h);
g.dispose();
return img;
}
static void draw(BufferedImage dst, BufferedImage src, int sx, int sy, int sw, int sh, Object interpolation) {
Graphics2D g = dst.createGraphics();
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, interpolation);
g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
g.drawImage(src, 0, 0, dst.getWidth(), dst.getHeight(), sx, sy, sx + sw, sy + sh, null);
g.dispose();
}
// EXIF Orientation 1–8 → поворот/отражение готового (маленького) растра.
static BufferedImage orient(BufferedImage s, int o) {
if (o <= 1 || o > 8) return s;
int w = s.getWidth(), h = s.getHeight();
BufferedImage d = new BufferedImage(o >= 5 ? h : w, o >= 5 ? w : h, BufferedImage.TYPE_INT_RGB);
for (int y = 0; y < h; y++)
for (int x = 0; x < w; x++) {
int dx, dy;
switch (o) {
case 2 -> { dx = w - 1 - x; dy = y; }
case 3 -> { dx = w - 1 - x; dy = h - 1 - y; }
case 4 -> { dx = x; dy = h - 1 - y; }
case 5 -> { dx = y; dy = x; }
case 6 -> { dx = h - 1 - y; dy = x; }
case 7 -> { dx = h - 1 - y; dy = w - 1 - x; }
default -> { dx = y; dy = w - 1 - x; }
}
d.setRGB(dx, dy, s.getRGB(x, y));
}
return d;
}
// Тег 0x0112 из APP1 Exif; любая нестандартная структура — ориентация по умолчанию.
static int orientation(Path file) {
try (DataInputStream in = new DataInputStream(new BufferedInputStream(Files.newInputStream(file)))) {
if (in.readUnsignedShort() != 0xFFD8) return 1;
while (true) {
int marker = in.readUnsignedShort();
if ((marker & 0xFF00) != 0xFF00 || marker == 0xFFDA || marker == 0xFFD9) return 1;
int len = in.readUnsignedShort();
if (len < 2) return 1;
byte[] seg = new byte[len - 2];
in.readFully(seg);
if (marker == 0xFFE1 && seg.length > 14 && new String(seg, 0, 6, StandardCharsets.ISO_8859_1).equals("Exif\0\0")) {
ByteBuffer b = ByteBuffer.wrap(seg).order(seg[6] == 'I' ? ByteOrder.LITTLE_ENDIAN : ByteOrder.BIG_ENDIAN);
int ifd = 6 + b.getInt(10), n = b.getShort(ifd) & 0xFFFF;
for (int i = 0; i < n; i++) {
int e = ifd + 2 + i * 12;
if ((b.getShort(e) & 0xFFFF) == 0x0112) {
int v = b.getShort(e + 8) & 0xFFFF;
return v >= 1 && v <= 8 ? v : 1;
}
}
return 1;
}
}
} catch (IOException | RuntimeException e) {
return 1;
}
}
static Output jpeg(String name, BufferedImage img, float quality, Path dir) throws IOException {
Path file = dir.resolve(name + ".jpg");
ImageWriter writer = ImageIO.getImageWritersByFormatName("jpeg").next();
ImageWriteParam param = writer.getDefaultWriteParam();
param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
param.setCompressionQuality(quality);
try (ImageOutputStream out = ImageIO.createImageOutputStream(file.toFile())) {
writer.setOutput(out);
writer.write(null, new IIOImage(img, null, null), param);
} finally {
writer.dispose();
}
return new Output(name, "image/jpeg", name + ".jpg", img.getWidth(), img.getHeight(), file);
}
// cwebp (libwebp): -q качество, -metadata none — без EXIF/XMP/ICC. Отдельный процесс с таймаутом.
static Output webp(BufferedImage img, int quality, Path dir, Jobs.Claim c) throws IOException {
Path png = dir.resolve("optimized.png"), file = dir.resolve("optimized.webp");
ImageIO.write(img, "png", png.toFile());
Process proc = new ProcessBuilder("cwebp", "-quiet", "-q", String.valueOf(quality), "-metadata", "none", png.toString(), "-o", file.toString())
.redirectErrorStream(true).redirectOutput(ProcessBuilder.Redirect.DISCARD).start();
c.process = proc;
try {
if (!proc.waitFor(30, TimeUnit.SECONDS)) {
proc.destroyForcibly();
throw new IOException("cwebp timeout");
}
} catch (InterruptedException e) {
proc.destroyForcibly();
Thread.currentThread().interrupt();
throw new IOException("interrupted");
} finally {
c.process = null;
}
c.check();
if (proc.exitValue() != 0) throw new IOException("cwebp exit code " + proc.exitValue());
return new Output("optimized", "image/webp", "optimized.webp", img.getWidth(), img.getHeight(), file);
}
}
+436
View File
@@ -0,0 +1,436 @@
package ru.mtusi.messenger;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.IOException;
import java.sql.Timestamp;
import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;
import javax.imageio.ImageReader;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;
import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;
import software.amazon.awssdk.services.s3.model.S3Object;
// Задания обработки вложений. Источник истины — таблица jobs в PostgreSQL; сообщение брокера —
// только сигнал «попытка attempt задания job_id готова к запуску» (contracts/jobs.schema.json).
//
// - вложение, job и запись outbox пишутся одной транзакцией с приёмом файла, публикует relay;
// - attempt — fencing token: захват, продление аренды и фиксация результата сверяют его в БД;
// - эффект идемпотентен по (attachment_id, pipeline_version, variant): детерминированные ключи S3 и PK.
@Component
class Jobs {
static final String TYPE = "attachment.process.v1";
static final int MAX_ATTEMPTS = env("JOB_MAX_ATTEMPTS", 5);
static final int TIMEOUT_SECONDS = env("JOB_TIMEOUT_SECONDS", 60);
static final int LEASE_SECONDS = env("JOB_LEASE_SECONDS", 15);
static final int PIPELINE_VERSION = env("PIPELINE_VERSION", 1);
static final long BACKOFF_BASE_MS = env("JOB_BACKOFF_BASE_MS", 1000), BACKOFF_MAX_MS = env("JOB_BACKOFF_MAX_MS", 30000);
static final long STAGING_RETENTION_SECONDS = env("STAGING_RETENTION_SECONDS", 86400);
// Внедрение сбоев только при FAULT_INJECTION=1; точку выбирает префикс имени файла fault-<point>.
static final boolean FAULTS = "1".equals(System.getenv("FAULT_INJECTION"));
static final String ACTOR = System.getenv().getOrDefault("HOSTNAME", "local");
static final ObjectMapper JSON = new ObjectMapper();
static final Logger log = LoggerFactory.getLogger(Jobs.class);
final JdbcTemplate db;
final TransactionTemplate tx, separate;
final Broker broker;
final boolean relayEnabled;
long relayPausedUntil, lastWarning;
Jobs(JdbcTemplate db, PlatformTransactionManager tm, Broker broker, @Value("${outbox.enabled:true}") boolean relayEnabled) {
this.db = db;
this.broker = broker;
this.relayEnabled = relayEnabled;
tx = new TransactionTemplate(tm);
separate = new TransactionTemplate(tm);
separate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
}
static int env(String name, int fallback) {
return Integer.parseInt(System.getenv().getOrDefault(name, String.valueOf(fallback)));
}
@JsonInclude(JsonInclude.Include.NON_NULL)
record Msg(Integer schema_version, UUID job_id, String type, UUID attachment_id, Integer pipeline_version, Integer attempt,
String created_at, String traceparent, String tracestate) {}
record Variant(String name, String contentType, long size, int width, int height, String sha256, String key) {}
record Source(String contentType, long size, String sha256, String key) {}
// Приём: метаданные, задание и outbox — одна транзакция. После COMMIT работа не теряется
// ни при падении API, ни при недоступном брокере: relay опубликует позже.
void accept(UUID id, UUID chat, UUID owner, String filename, String type, long size, String sha256, int width, int height, Instant at) {
Timestamp ts = Timestamp.from(at);
tx.executeWithoutResult(s -> {
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(?,?,?,?,?,?,?,?,?,'queued',?,?,?)", id, chat, owner, filename, type, size, sha256, width, height, Storage.ORIGINALS + id, ts, ts);
UUID job = UUID.randomUUID();
db.update("insert into jobs(job_id,attachment_id,pipeline_version,state,attempt,attempts_limit,created_at,updated_at) values(?,?,?,'queued',1,?,?,?)",
job, id, PIPELINE_VERSION, MAX_ATTEMPTS, ts, ts);
db.update("insert into outbox(job_id,attempt) values(?,1)", job);
audit(job, 1, "accepted", null);
});
}
// Outbox relay работает в API-репликах и в worker; FOR UPDATE SKIP LOCKED делит записи между ними.
// Падение после publish до DELETE даёт повторную публикацию — её гасит идемпотентный consumer.
// ponytail: опрос раз в секунду (+≤1 с к времени до ready); LISTEN/NOTIFY — если задержка станет важна.
@Scheduled(fixedDelayString = "${outbox.poll:PT1S}")
void relay() {
if (!relayEnabled || System.currentTimeMillis() < relayPausedUntil) return;
try {
while (Boolean.TRUE.equals(tx.execute(s -> relayBatch()))) {
// полная пачка: сразу следующая
}
} catch (RuntimeException e) {
relayPausedUntil = System.currentTimeMillis() + 2000;
if (System.currentTimeMillis() - lastWarning > 30000) {
lastWarning = System.currentTimeMillis();
log.warn("outbox relay paused: {}", e.toString());
}
}
}
record Pending(long id, UUID job, int attempt, UUID attachment, int version, Instant created, String filename) {}
boolean relayBatch() {
List<Pending> rows = db.query("select o.id,o.job_id,o.attempt,j.attachment_id,j.pipeline_version,j.created_at,a.filename from outbox o"
+ " join jobs j on j.job_id=o.job_id join attachments a on a.id=j.attachment_id where o.available_at<=now() order by o.id limit 100 for update of o skip locked",
(rs, n) -> new Pending(rs.getLong(1), rs.getObject(2, UUID.class), rs.getInt(3), rs.getObject(4, UUID.class), rs.getInt(5), rs.getTimestamp(6).toInstant(), rs.getString(7)));
if (rows.isEmpty()) return false;
List<Broker.Message> messages = new ArrayList<>();
for (Pending r : rows) {
crash("crash-before-publish", r.attachment(), r.filename());
messages.add(new Broker.Message(r.job() + "/" + r.attempt(), message(r.job(), r.attempt(), r.attachment(), r.version(), r.created())));
}
try {
broker.publish(messages);
} catch (Exception e) {
throw new IllegalStateException("publish failed: " + e, e);
}
for (Pending r : rows) crash("crash-after-publish", r.attachment(), r.filename());
db.update("delete from outbox where id=any(?)", (Object) rows.stream().map(Pending::id).toArray(Long[]::new));
return rows.size() == 100;
}
static byte[] message(UUID job, int attempt, UUID attachment, int version, Instant created) {
try {
return JSON.writeValueAsBytes(new Msg(1, job, TYPE, attachment, version, attempt, created.toString(), null, null));
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
// Строгая проверка по jobs.schema.json; лишние поля — ошибка разбора (сообщение уйдёт в DLQ).
static Msg parse(byte[] body) throws IOException {
Msg m = JSON.readValue(body, Msg.class);
if (!Integer.valueOf(1).equals(m.schema_version()) || !TYPE.equals(m.type()) || m.job_id() == null || m.attachment_id() == null
|| m.pipeline_version() == null || m.pipeline_version() < 1 || m.attempt() == null || m.attempt() < 1 || m.created_at() == null)
throw new IOException("message does not match jobs.schema.json");
Instant.parse(m.created_at());
return m;
}
// Захват попытки: только queued с тем же attempt. Иначе дубль или устаревшее сообщение — no-op и ack.
Claim claim(Msg m) {
return tx.execute(s -> {
List<Claim> claimed = db.query("update jobs j set state='processing',lease_owner=?,lease_until=now()+make_interval(secs=>?),started_at=now(),updated_at=now()"
+ " from attachments a where j.job_id=? and j.state='queued' and j.attempt=? and j.attachment_id=? and j.pipeline_version=? and a.id=j.attachment_id"
+ " returning a.filename", (rs, n) -> new Claim(m.job_id(), m.attachment_id(), m.attempt(), m.pipeline_version(), rs.getString(1)),
ACTOR, LEASE_SECONDS, m.job_id(), m.attempt(), m.attachment_id(), m.pipeline_version());
if (claimed.isEmpty()) {
// Причина — в audit: по нему эксперимент считает погашенные дубли.
String why = db.query("select state,attempt from jobs where job_id=?", rs -> !rs.next() ? "unknown_job"
: rs.getString(1).equals("done") ? "duplicate_done" : rs.getInt(2) > m.attempt() ? "stale_attempt"
: rs.getString(1).equals("processing") ? "duplicate_in_progress" : rs.getString(1).equals("failed") ? "dropped_failed" : "mismatch", m.job_id());
if (!why.equals("unknown_job")) audit(m.job_id(), m.attempt(), why, null);
log.info("job {} attempt {}: {}, ack without processing", m.job_id(), m.attempt(), why);
return null;
}
// ready-вложение (новая версия pipeline) остаётся ready: старый результат отдаётся до новой фиксации.
db.update("update attachments set state='processing',updated_at=now() where id=? and state='queued'", m.attachment_id());
audit(m.job_id(), m.attempt(), "claimed", null);
return claimed.get(0);
});
}
Source source(UUID attachment) {
return db.queryForObject("select content_type,size_bytes,sha256,object_key from attachments where id=?",
(rs, n) -> new Source(rs.getString(1), rs.getLong(2), rs.getString(3), rs.getString(4)), attachment);
}
// Heartbeat: продлевает аренду, но не дальше JOB_TIMEOUT_SECONDS от начала попытки.
boolean extend(Claim c) {
return db.update("update jobs set lease_until=now()+make_interval(secs=>?) where job_id=? and state='processing' and attempt=? and started_at>now()-make_interval(secs=>?)",
LEASE_SECONDS, c.job, c.attempt, TIMEOUT_SECONDS) == 1;
}
// Фиксация результата: варианты, указатель версии и done — атомарно и только владельцем попытки.
boolean complete(Claim c, List<Variant> variants) {
return Boolean.TRUE.equals(tx.execute(s -> {
if (lock(c) == null) return false;
for (Variant v : variants)
db.update("insert into attachment_variants(attachment_id,pipeline_version,name,content_type,size_bytes,width,height,sha256,object_key,job_id)"
+ " values(?,?,?,?,?,?,?,?,?,?) on conflict do nothing", c.attachment, c.version, v.name(), v.contentType(), v.size(), v.width(), v.height(), v.sha256(), v.key(), c.job);
// Указатель текущей версии только растёт: старая job после новой не перезапишет результат.
boolean current = db.update("update attachments set state='ready',error_code=null,pipeline_version=?,updated_at=now() where id=? and state<>'lost'"
+ " and coalesce(pipeline_version,0)<=?", c.version, c.attachment, c.version) == 1;
db.update("update jobs set state='done',lease_owner=null,lease_until=null,error_code=null,updated_at=now() where job_id=?", c.job);
audit(c.job, c.attempt, "done", current ? "current" : "superseded");
return true;
}));
}
// Временная ошибка: следующая попытка через backoff с jitter, после исчерпания — failed/retry_exhausted.
void retry(Claim c, Exception error) {
tx.executeWithoutResult(s -> {
Integer limit = lock(c);
if (limit == null) return;
if (c.attempt >= limit) {
failLocked(c.job, c.attempt, c.attachment, "retry_exhausted", error.toString());
return;
}
long cap = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS << Math.min(20, c.attempt - 1));
long delay = cap / 2 + ThreadLocalRandom.current().nextLong(cap / 2 + 1);
requeueLocked(c.job, c.attempt, c.attachment, delay, "retry_scheduled", error.toString());
});
}
void fail(Claim c, String code, String error) {
tx.executeWithoutResult(s -> {
if (lock(c) != null) failLocked(c.job, c.attempt, c.attachment, code, error);
});
}
// Fencing: попытка ещё владеет заданием; строка заблокирована до конца транзакции. null — не владеет.
Integer lock(Claim c) {
Integer limit = db.query("select attempts_limit from jobs where job_id=? and state='processing' and attempt=? for update",
rs -> rs.next() ? rs.getInt(1) : null, c.job, c.attempt);
if (limit == null) log.warn("job {} attempt {} no longer owns the lease, result discarded", c.job, c.attempt);
return limit;
}
void requeueLocked(UUID job, int attempt, UUID attachment, long delayMs, String event, String error) {
db.update("update jobs set state='queued',attempt=attempt+1,lease_owner=null,lease_until=null,next_attempt_at=now()+make_interval(secs=>?),last_error=?,updated_at=now() where job_id=?",
delayMs / 1000.0, truncate(error), job);
db.update("update attachments set state='queued',updated_at=now() where id=? and state='processing'", attachment);
db.update("insert into outbox(job_id,attempt,available_at) values(?,?,now()+make_interval(secs=>?))", job, attempt + 1, delayMs / 1000.0);
audit(job, attempt, event, "next_attempt=" + (attempt + 1) + " delay_ms=" + delayMs + " error=" + truncate(error));
}
void failLocked(UUID job, int attempt, UUID attachment, String code, String error) {
db.update("update jobs set state='failed',error_code=?,last_error=?,lease_owner=null,lease_until=null,updated_at=now() where job_id=?", code, truncate(error), job);
// failed только у вложения без готовой версии: ready (другая версия pipeline) не откатывается.
db.update("update attachments set state='failed',error_code=?,updated_at=now() where id=? and state in ('queued','processing') and pipeline_version is null", code, attachment);
audit(job, attempt, "failed", code);
}
// Истёкшая аренда: worker умер или завис (heartbeat не продлевал) — следующая попытка, без второго эффекта.
void sweep() {
tx.executeWithoutResult(s -> {
List<Object[]> expired = db.query("select job_id,attempt,attempts_limit,attachment_id from jobs where state='processing' and lease_until<now()"
+ " order by lease_until limit 100 for update skip locked", (rs, n) -> new Object[]{rs.getObject(1, UUID.class), rs.getInt(2), rs.getInt(3), rs.getObject(4, UUID.class)});
for (Object[] j : expired) {
UUID job = (UUID) j[0], attachment = (UUID) j[3];
int attempt = (int) j[1];
if (attempt >= (int) j[2]) failLocked(job, attempt, attachment, "retry_exhausted", "lease expired");
else requeueLocked(job, attempt, attachment, 0, "lease_expired", "lease expired");
}
});
}
// Staging удаляется после безопасной фиксации (ready); непривязанные и failed — после retention.
int sweepStaging(Storage storage) {
int deleted = 0;
Instant cutoff = Instant.now().minusSeconds(STAGING_RETENTION_SECONDS);
for (ListObjectsV2Response page : storage.list(Storage.STAGING)) {
Map<UUID, S3Object> objects = new HashMap<>();
for (S3Object o : page.contents()) {
try { objects.put(UUID.fromString(o.key().substring(Storage.STAGING.length())), o); } catch (IllegalArgumentException ignored) {}
}
if (objects.isEmpty()) continue;
Map<UUID, Object[]> rows = new HashMap<>();
db.query("select id,state,updated_at from attachments where id=any(?)", rs -> {
rows.put(rs.getObject(1, UUID.class), new Object[]{rs.getString(2), rs.getTimestamp(3).toInstant()});
}, (Object) objects.keySet().toArray(new UUID[0]));
for (Map.Entry<UUID, S3Object> e : objects.entrySet()) {
Object[] r = rows.get(e.getKey());
boolean delete = r == null ? e.getValue().lastModified().isBefore(cutoff)
: r[0].equals("ready") || (r[0].equals("failed") && ((Instant) r[1]).isBefore(cutoff));
if (delete) {
storage.delete(e.getValue().key());
deleted++;
}
}
}
if (deleted > 0) log.info("staging sweep deleted {} objects", deleted);
return deleted;
}
// Операторские команды: docker compose run --rm jobctl <command>.
int cli(String[] args) throws IOException {
String command = args.length > 0 ? args[0] : "";
Object result;
switch (command) {
case "status" -> {
Map<String, Object> r = new LinkedHashMap<>();
r.put("jobs", db.queryForList("select pipeline_version,state,count(*) from jobs group by 1,2 order by 1,2"));
r.put("attachments", db.queryForList("select state,count(*) from attachments group by 1 order by 1"));
r.put("outbox_pending", db.queryForObject("select count(*) from outbox", Long.class));
r.put("failed", db.queryForList("select job_id::text,attachment_id::text,pipeline_version,attempt,error_code,updated_at::text from jobs where state='failed' order by updated_at desc limit 50"));
result = r;
}
case "replay" -> {
List<UUID> ids = args.length > 1 && args[1].equals("--all-failed")
? db.queryForList("select job_id from jobs where state='failed'", UUID.class) : ids(args, 1);
Map<String, String> r = new LinkedHashMap<>();
for (UUID id : ids) r.put(id.toString(), replay(id));
result = r;
}
case "reprocess" -> {
if (args.length < 3 || !args[1].startsWith("--pipeline-version=")) return usage();
int version = Integer.parseInt(args[1].substring(19));
boolean all = args[2].equals("--all");
result = Map.of("jobs_created", reprocess(version, all ? List.of() : ids(args, 2), all));
}
case "redispatch" -> {
long older = args.length > 1 && args[1].startsWith("--older-than=") ? Long.parseLong(args[1].substring(13)) : 300;
result = Map.of("republished", redispatch(older));
}
default -> { return usage(); }
}
System.out.println(JSON.copy().enable(SerializationFeature.INDENT_OUTPUT).writeValueAsString(result));
return 0;
}
static int usage() {
System.err.println("usage: jobctl status | replay <job_id>...|--all-failed | reprocess --pipeline-version=N <attachment_id>...|--all | redispatch [--older-than=SECONDS]");
return 2;
}
static List<UUID> ids(String[] args, int from) {
List<UUID> ids = new ArrayList<>();
for (int i = from; i < args.length; i++) ids.add(UUID.fromString(args[i]));
return ids;
}
// Явный replay только failed: done-задание не исполняется повторно, прежний эффект защищён PK и fencing.
String replay(UUID job) {
return tx.execute(s -> {
Object[] j = db.query("select state,attempt,attachment_id from jobs where job_id=? for update",
rs -> rs.next() ? new Object[]{rs.getString(1), rs.getInt(2), rs.getObject(3, UUID.class)} : null, job);
if (j == null) return "unknown job";
if (!j[0].equals("failed")) return "skipped: job is " + j[0];
int attempt = (int) j[1] + 1;
db.update("update jobs set state='queued',attempt=?,attempts_limit=?,error_code=null,next_attempt_at=now(),updated_at=now() where job_id=?",
attempt, attempt + MAX_ATTEMPTS - 1, job);
db.update("update attachments set state='queued',error_code=null,updated_at=now() where id=? and state='failed'", j[2]);
db.update("insert into outbox(job_id,attempt) values(?,?)", job, attempt);
audit(job, attempt, "replayed", "operator");
return "queued as attempt " + attempt;
});
}
// Новая версия pipeline — новая логическая работа (новый job_id); на одну версию не больше одной job.
int reprocess(int version, List<UUID> ids, boolean all) {
return db.update("with j as (insert into jobs(job_id,attachment_id,pipeline_version,state,attempt,attempts_limit,created_at,updated_at)"
+ " select gen_random_uuid(),id,?,'queued',1,?,now(),now() from attachments where state in ('queued','processing','ready') and (? or id=any(?))"
+ " on conflict (attachment_id,pipeline_version) do nothing returning job_id) insert into outbox(job_id,attempt) select job_id,1 from j",
version, MAX_ATTEMPTS, all, ids.toArray(new UUID[0]));
}
// Ручное восстановление queued-заданий, чьё сообщение потеряно (например, ушло в DLQ по delivery-limit).
int redispatch(long olderThanSeconds) {
return db.update("with r as (update jobs j set next_attempt_at=now(),updated_at=now() where state='queued' and next_attempt_at<now()-make_interval(secs=>?)"
+ " and not exists(select 1 from outbox o where o.job_id=j.job_id) returning job_id,attempt) insert into outbox(job_id,attempt) select job_id,attempt from r", olderThanSeconds);
}
void audit(UUID job, int attempt, String event, String detail) {
db.update("insert into job_audit(job_id,attempt,event,actor,detail) values(?,?,?,?,?)", job, attempt, event, ACTOR, detail);
}
static String truncate(String s) {
return s == null || s.length() <= 500 ? s : s.substring(0, 500);
}
// Аварийная остановка процесса в заданной точке, один раз на вложение (отметка коммитится до halt).
void crash(String point, UUID attachment, String filename) {
if (!FAULTS || filename == null || !filename.startsWith("fault-" + point)) return;
Integer fired = separate.execute(s -> db.update("insert into fault_marks(point,attachment_id) values(?,?) on conflict do nothing", point, attachment));
if (fired == null || fired == 0) return;
log.warn("FAULT INJECTION {}: halting process (attachment {})", point, attachment);
// Пауза, чтобы уже отправляемый HTTP-ответ этого процесса дошёл: падение — именно в фоновой точке.
try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
Runtime.getRuntime().halt(137);
}
// Захваченная попытка в worker: флаги для heartbeat/таймаута и ссылки, которые прерывает abort().
static final class Claim {
final UUID job, attachment;
final int attempt, version;
final String filename;
final long started = System.nanoTime();
volatile boolean fenced;
volatile ImageReader reader;
volatile Process process;
Claim(UUID job, UUID attachment, int attempt, int version, String filename) {
this.job = job;
this.attachment = attachment;
this.attempt = attempt;
this.version = version;
this.filename = filename;
}
long elapsedSeconds() {
return (System.nanoTime() - started) / 1_000_000_000L;
}
// Перед каждым побочным эффектом: аренда потеряна — стоп без записи; превышен таймаут — временная ошибка.
void check() {
if (fenced) throw new Fenced();
if (elapsedSeconds() >= TIMEOUT_SECONDS) throw new TimedOut();
}
void abort() {
ImageReader r = reader;
if (r != null) r.abort();
Process p = process;
if (p != null) p.destroyForcibly();
}
}
static final class Fenced extends RuntimeException {
Fenced() { super("lease lost"); }
}
static final class TimedOut extends RuntimeException {
TimedOut() { super("job timeout exceeded"); }
}
static final class Permanent extends RuntimeException {
final String code;
Permanent(String code, String message) {
super(message);
this.code = code;
}
}
}
@@ -0,0 +1,469 @@
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 и выход),
// worker (обработка заданий из брокера), reconcile (сверка БД и S3) и jobctl (операторские команды заданий).
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("worker")) {
// Без HTTP: процесс живёт за счёт потоков consumer/планировщика; SIGTERM — graceful stop.
new SpringApplicationBuilder(MessengerApplication.class).web(WebApplicationType.NONE)
.properties("reconcile.enabled=false", "worker.enabled=true").run();
return;
}
if (!mode.equals("reconcile") && !mode.equals("jobctl")) {
System.err.println("usage: [api | migrate | worker | reconcile [--apply] [--grace-seconds=N] [--verify-checksums] | jobctl <command>]");
System.exit(2);
}
ConfigurableApplicationContext ctx = new SpringApplicationBuilder(MessengerApplication.class)
.web(WebApplicationType.NONE)
.properties("reconcile.enabled=false", "outbox.enabled=false", "spring.main.banner-mode=off", "logging.level.root=WARN")
.run();
int code;
try {
String[] rest = Arrays.copyOfRange(args, 1, args.length);
code = mode.equals("jobctl") ? ctx.getBean(Jobs.class).cli(rest) : ctx.getBean(Reconciler.class).cli(rest);
} catch (Exception e) {
LoggerFactory.getLogger(MessengerApplication.class).error(mode + " 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");
// Хеш тела для повторов с тем же ключом: отсутствующий 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);
}
// Вложения этого чата: queued/processing/ready можно, failed — 409; чужое или неизвестное — 404.
// Проверка после ключа: повтор успешного запроса возвращает сохранённое сообщение; ошибка откатывает ключ.
if(!attachments.isEmpty()) {
List<String> states=db.queryForList("select state from attachments where chat_id=? and id=any(?) and state in ('queued','processing','ready','failed')",String.class,id,attachments.toArray(new UUID[0]));
if(states.size()!=attachments.size()) throw notFound();
if(states.contains("failed")) throw new ApiException(HttpStatus.CONFLICT,"conflict","failed attachment cannot be attached");
}
// Сообщение и его вложения пишутся в той же транзакции, что и ключ: появится всё или ничего.
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), повторный запуск ничего не меняет;
// - queued/processing/failed — зона pipeline (lab5): оригинал публикует worker, сверка их не трогает.
@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");
}
case "queued", "processing", "failed" -> count(findings, "pipeline_not_published");
default -> count(findings, "lost_known");
}
}
void both(S3Object o, Row r) {
switch (r.state()) {
case "queued", "processing", "failed" -> count(findings, "pipeline_in_progress");
case "uploading" -> {
if (r.updated().isAfter(cutoff)) { count(findings, "upload_in_progress_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,90 @@
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 {
// Опубликованные оригиналы (их обходит сверка), устойчивый staging приёма и варианты worker.
static final String ORIGINALS = "originals/", STAGING = "staging/", VARIANTS = "variants/";
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));
}
// Скачивание во временный файл worker (файла ещё не должно быть).
void download(String key, Path file) {
s3.getObject(b -> b.bucket(bucket).key(key), file);
}
// Серверное копирование staging → конечный префикс: байты не проходят через worker.
void copy(String from, String to) {
s3.copyObject(b -> b.sourceBucket(bucket).sourceKey(from).destinationBucket(bucket).destinationKey(to));
}
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 list(ORIGINALS);
}
ListObjectsV2Iterable list(String prefix) {
return s3.listObjectsV2Paginator(b -> b.bucket(bucket).prefix(prefix));
}
static boolean isOriginal(S3Object o) {
return o.key().startsWith(ORIGINALS);
}
}
@@ -0,0 +1,260 @@
package ru.mtusi.messenger;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.ShutdownSignalException;
import jakarta.annotation.PreDestroy;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.time.Instant;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HexFormat;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
import javax.imageio.ImageIO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Component;
import software.amazon.awssdk.core.exception.SdkException;
// Worker — отдельный процесс (режим worker). Потребляет attachments.process с ручным ack:
// ack только после зафиксированного результата или осознанного no-op для дубля.
// Конкуренция ограничена: WORKER_CONCURRENCY каналов, у каждого prefetch 1.
@Component
@ConditionalOnProperty(name = "worker.enabled", havingValue = "true")
class Worker {
static final Logger log = LoggerFactory.getLogger(Worker.class);
static final int CONCURRENCY = Jobs.env("WORKER_CONCURRENCY", 2);
static final Path ALIVE = Path.of("/tmp/worker-alive");
final Broker broker;
final Jobs jobs;
final Storage storage;
final Set<Jobs.Claim> inflight = ConcurrentHashMap.newKeySet();
final ExecutorService consumers = Executors.newFixedThreadPool(CONCURRENCY);
final ScheduledExecutorService timer = Executors.newScheduledThreadPool(3);
final Map<Channel, String> subscriptions = new LinkedHashMap<>();
Connection connection;
volatile boolean stopping;
Worker(Broker broker, Jobs jobs, Storage storage) {
this.broker = broker;
this.jobs = jobs;
this.storage = storage;
ImageIO.setUseCache(false);
int beat = Math.max(1, Jobs.LEASE_SECONDS / 3);
timer.scheduleWithFixedDelay(() -> quietly("broker supervisor", this::supervise), 0, 2, TimeUnit.SECONDS);
timer.scheduleWithFixedDelay(() -> quietly("heartbeat", this::heartbeat), beat, beat, TimeUnit.SECONDS);
timer.scheduleWithFixedDelay(() -> quietly("lease sweep", jobs::sweep), 2, 2, TimeUnit.SECONDS);
timer.scheduleWithFixedDelay(() -> quietly("staging sweep", () -> jobs.sweepStaging(storage)), 10, 60, TimeUnit.SECONDS);
}
static void quietly(String what, Runnable task) {
try {
task.run();
} catch (RuntimeException e) {
log.warn("{} failed: {}", what, e.toString());
}
}
// (Пере)подключение к брокеру; файл ALIVE — healthcheck контейнера.
synchronized void supervise() {
if (stopping) return;
try {
if (connection == null || !connection.isOpen()) {
subscriptions.clear();
connection = broker.connect("worker-" + Jobs.ACTOR, consumers);
for (int i = 0; i < CONCURRENCY; i++) {
Channel ch = connection.createChannel();
ch.basicQos(1);
subscriptions.put(ch, ch.basicConsume(Broker.QUEUE, false, consumer(ch)));
}
log.info("consuming {} with concurrency {}", Broker.QUEUE, CONCURRENCY);
}
Files.writeString(ALIVE, Instant.now().toString());
} catch (Exception e) {
log.warn("broker unavailable: {}", e.toString());
if (connection != null) connection.abort();
connection = null;
}
}
DefaultConsumer consumer(Channel ch) {
return new DefaultConsumer(ch) {
@Override
public void handleDelivery(String tag, Envelope envelope, AMQP.BasicProperties props, byte[] body) {
deliver(ch, envelope.getDeliveryTag(), body);
}
};
}
void deliver(Channel ch, long tag, byte[] body) {
Jobs.Msg m;
try {
m = Jobs.parse(body);
} catch (IOException | RuntimeException e) {
log.warn("malformed job message rejected to DLQ: {}", e.toString());
settle(() -> ch.basicReject(tag, false));
return;
}
try {
process(m);
} catch (DataAccessException e) {
// Без БД нельзя ни захватить, ни зафиксировать: вернуть сообщение после паузы (delivery-limit → DLQ).
log.warn("database unavailable, requeue job {}: {}", m.job_id(), e.toString());
sleep(5000);
settle(() -> ch.basicNack(tag, false, true));
return;
}
settle(() -> ch.basicAck(tag, false));
}
interface Io {
void run() throws IOException;
}
// Канал закрыт (рестарт брокера) — неподтверждённое сообщение брокер доставит повторно.
static void settle(Io action) {
try {
action.run();
} catch (IOException | ShutdownSignalException e) {
log.warn("ack/nack failed, broker will redeliver: {}", e.toString());
}
}
record Result(List<Jobs.Variant> variants, boolean fromStaging) {}
void process(Jobs.Msg m) {
Jobs.Claim c = jobs.claim(m);
if (c == null) return;
inflight.add(c);
try {
jobs.crash("crash-after-claim", c.attachment, c.filename);
Result r = run(c);
jobs.crash("crash-after-s3", c.attachment, c.filename);
if (Jobs.FAULTS && c.filename.startsWith("fault-slow") && c.version == 1) sleep(40000);
c.check();
if (!jobs.complete(c, r.variants())) return;
jobs.crash("crash-after-commit", c.attachment, c.filename);
// Staging удаляем только после COMMIT результата; не вышло — уберёт sweepStaging.
if (r.fromStaging()) {
try { storage.delete(Storage.STAGING + c.attachment); } catch (SdkException e) { log.warn("staging cleanup deferred: {}", e.toString()); }
}
log.info("job {} attempt {} done: attachment {} v{}", c.job, c.attempt, c.attachment, c.version);
} catch (Jobs.Fenced e) {
log.warn("job {} attempt {}: lease lost, stopping without commit", c.job, c.attempt);
} catch (ImagePipeline.Invalid e) {
jobs.fail(c, "invalid_image", e.getMessage());
} catch (Jobs.Permanent e) {
jobs.fail(c, e.code, e.getMessage());
} catch (DataAccessException e) {
throw e;
} catch (Exception e) {
log.warn("job {} attempt {} failed: {}", c.job, c.attempt, e.toString());
jobs.retry(c, e);
} finally {
inflight.remove(c);
}
}
Result run(Jobs.Claim c) throws Exception {
Path dir = Files.createTempDirectory("job-");
try {
// Доверенные метаданные — из БД; из сообщения берётся только ID.
Jobs.Source s = jobs.source(c.attachment);
String staging = Storage.STAGING + c.attachment;
boolean fromStaging = storage.size(staging) != null;
if (!fromStaging && storage.size(s.key()) == null) throw new Jobs.Permanent("source_missing", "neither staging nor original object exists");
Path src = dir.resolve("source");
storage.download(fromStaging ? staging : s.key(), src);
if (Files.size(src) != s.size() || !sha256(src).equals(s.sha256())) throw new Jobs.Permanent("processing_failed", "source checksum mismatch");
c.check();
// Публикация оригинала в конечный префикс: серверная копия тех же байтов, повтор безопасен.
if (fromStaging) storage.copy(staging, s.key());
if (Jobs.FAULTS && c.filename.startsWith("fault-transient") && c.attempt <= Jobs.MAX_ATTEMPTS) throw new IOException("injected transient fault");
List<Jobs.Variant> variants = new ArrayList<>();
for (ImagePipeline.Output o : ImagePipeline.render(src, s.contentType(), c.version, dir, c)) {
c.check();
// Детерминированный ключ эффекта (attachment, version, variant): повтор перезаписывает тот же объект.
String key = Storage.VARIANTS + c.attachment + "/v" + c.version + "/" + o.file();
storage.put(key, o.path(), o.contentType());
variants.add(new Jobs.Variant(o.name(), o.contentType(), Files.size(o.path()), o.width(), o.height(), sha256(o.path()), key));
}
return new Result(variants, fromStaging);
} finally {
try (Stream<Path> files = Files.walk(dir)) {
files.sorted(Comparator.reverseOrder()).forEach(p -> p.toFile().delete());
}
}
}
// Продление аренды работающих попыток; не продлилась (истекла/перехвачена) — прервать без фиксации.
void heartbeat() {
for (Jobs.Claim c : inflight) {
if (c.elapsedSeconds() >= Jobs.TIMEOUT_SECONDS) {
c.abort();
continue;
}
try {
if (!jobs.extend(c)) {
c.fenced = true;
c.abort();
}
} catch (RuntimeException e) {
log.warn("heartbeat for job {} failed: {}", c.job, e.toString());
}
}
}
static String sha256(Path file) throws IOException {
MessageDigest sha = Attachments.sha256();
try (InputStream in = new DigestInputStream(Files.newInputStream(file), sha)) {
in.transferTo(java.io.OutputStream.nullOutputStream());
}
return HexFormat.of().formatHex(sha.digest());
}
static void sleep(long ms) {
try {
Thread.sleep(ms);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
// SIGTERM: перестать брать новые сообщения, дождаться текущих попыток (≤ 25 с), закрыть соединение.
@PreDestroy
void stop() {
stopping = true;
synchronized (this) {
subscriptions.forEach((ch, tag) -> {
try { ch.basicCancel(tag); } catch (Exception ignored) {}
});
}
long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(25);
while (!inflight.isEmpty() && System.nanoTime() < deadline) sleep(200);
timer.shutdownNow();
synchronized (this) {
if (connection != null) connection.abort();
}
consumers.shutdown();
}
}
+18
View File
@@ -0,0 +1,18 @@
# 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
# Два потока планировщика: долгий обход Reconciler не задерживает outbox relay (раз в секунду).
spring.task.scheduling.pool.size=2
@@ -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);
@@ -0,0 +1,78 @@
-- Version 4 (lab5): асинхронная обработка вложений. Состояния, задания, outbox, результаты по ключу эффекта.
ALTER TABLE attachments DROP CONSTRAINT attachments_state_check;
-- uploading — только строки lab4; queued → processing → ready | failed; lost ставит сверка.
ALTER TABLE attachments ADD CONSTRAINT attachments_state_check
CHECK (state IN ('uploading', 'queued', 'processing', 'ready', 'failed', 'lost'));
-- error_code — безопасный машинный код для failed; pipeline_version — текущая (последняя зафиксированная) версия вариантов.
ALTER TABLE attachments ADD COLUMN error_code VARCHAR(32), ADD COLUMN pipeline_version INT;
-- Одна логическая работа на (вложение, версия pipeline). attempt — номер управляемой попытки и fencing token.
CREATE TABLE jobs (
job_id UUID PRIMARY KEY,
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
pipeline_version INT NOT NULL CHECK (pipeline_version >= 1),
state VARCHAR(16) NOT NULL CHECK (state IN ('queued', 'processing', 'done', 'failed')),
attempt INT NOT NULL CHECK (attempt >= 1),
attempts_limit INT NOT NULL,
lease_owner TEXT,
lease_until TIMESTAMPTZ,
started_at TIMESTAMPTZ,
next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(),
error_code VARCHAR(32),
last_error TEXT,
created_at TIMESTAMPTZ NOT NULL,
updated_at TIMESTAMPTZ NOT NULL,
UNIQUE (attachment_id, pipeline_version)
);
CREATE INDEX jobs_leases ON jobs(lease_until) WHERE state = 'processing';
CREATE INDEX jobs_failed ON jobs(updated_at) WHERE state = 'failed';
-- Transactional outbox: намерение опубликовать попытку, пишется в одной транзакции с её созданием.
CREATE TABLE outbox (
id BIGSERIAL PRIMARY KEY,
job_id UUID NOT NULL REFERENCES jobs(job_id) ON DELETE CASCADE,
attempt INT NOT NULL,
available_at TIMESTAMPTZ NOT NULL DEFAULT now(),
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX outbox_available ON outbox(available_at, id);
-- Результат: PK = ключ эффекта (attachment_id, pipeline_version, variant) — повтор не создаёт второй набор.
CREATE TABLE attachment_variants (
attachment_id UUID NOT NULL REFERENCES attachments(id) ON DELETE CASCADE,
pipeline_version INT NOT NULL,
name VARCHAR(16) NOT NULL CHECK (name IN ('thumbnail', 'crop', 'optimized')),
content_type VARCHAR(20) NOT NULL,
size_bytes BIGINT NOT NULL CHECK (size_bytes > 0),
width INT NOT NULL CHECK (width > 0),
height INT NOT NULL CHECK (height > 0),
sha256 CHAR(64) NOT NULL,
object_key TEXT COLLATE "C" NOT NULL UNIQUE,
job_id UUID NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (attachment_id, pipeline_version, name)
);
-- Журнал для оператора и экспериментов: захваты, повторы, погашенные дубли, replay.
CREATE TABLE job_audit (
id BIGSERIAL PRIMARY KEY,
job_id UUID NOT NULL,
attempt INT NOT NULL,
event VARCHAR(32) NOT NULL,
actor TEXT NOT NULL,
detail TEXT,
at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
);
CREATE INDEX job_audit_job ON job_audit(job_id);
-- Однократные точки внедрения сбоев (FAULT_INJECTION=1), см. Jobs.crash.
CREATE TABLE fault_marks (
point TEXT NOT NULL,
attachment_id UUID NOT NULL,
PRIMARY KEY (point, attachment_id)
);
-- Перенос данных lab4: готовые оригиналы получают задание v1 (оригинал уже в originals/, staging нет).
INSERT INTO jobs(job_id, attachment_id, pipeline_version, state, attempt, attempts_limit, created_at, updated_at)
SELECT gen_random_uuid(), id, 1, 'queued', 1, 5, now(), now() FROM attachments WHERE state = 'ready';
INSERT INTO outbox(job_id, attempt) SELECT job_id, 1 FROM jobs;
+224
View File
@@ -0,0 +1,224 @@
#!/usr/bin/env python3
"""Собственные проверки вложений (с lab4; в lab5 upload → 202 queued), только стандартная библиотека.
Покрывают: слишком большой файл, повреждённые PNG/JPEG, подмену MIME, decompression bomb,
опасные filename, чужое/неизвестное attachment_id, вложение другого чата, постороннего пользователя,
идемпотентность с вложениями. Ни одна пользовательская ошибка не должна давать 500.
--with-docker дополнительно (через docker compose из корня репозитория):
* останавливает S3: загрузка/скачивание -> 503, текстовые сообщения и /health/ready работают,
неудачная загрузка не оставляет строк в БД;
* останавливает 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=202, 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 == 202 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 = c.wait_ready(bob, upload(PNG)['json'])
att_jpg = c.wait_ready(bob, 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)
ok('corrupted/truncated 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)')
# Варианты lab5: thumbnail/crop JPEG, optimized WebP; мусорное имя — 400.
types = {'original': 'image/png', 'thumbnail': 'image/jpeg', 'crop': 'image/jpeg', 'optimized': 'image/webp'}
for name, ctype in types.items():
got = c.call('GET', '/api/v1/attachments/%s/content?variant=%s' % (att_png['id'], name), actor=bob)
check(got['headers'].get_content_type() == ctype, 'variant %s has wrong content type' % name)
c.call('GET', '/api/v1/attachments/%s/content?variant=../../etc' % att_png['id'], 400, actor=bob)
ok('variants: original/thumbnail/crop/optimized 200 with own types, garbage 400')
if args.with_docker:
# Недоступный S3: вложения 503, текстовый путь живёт, после сбоя нет зависших строк.
compose('stop', 's3')
try:
rows_before = sql('select count(*) from attachments')
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') == rows_before, 'failed upload left a 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 rows left; recovered after start')
# Остановка реплики, принявшей загрузку: другая скачивает тот же файл.
r = upload(PNG)
served = r['headers']['X-Instance-Id']
c.wait_ready(bob, r['json'])
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

+285
View File
@@ -0,0 +1,285 @@
#!/usr/bin/env python3
"""Сквозная проверка pipeline lab5 (уровни 3–4) и эксперимент трека 2 «доказанная идемпотентность».
Гипотеза: при at-least-once доставке, дублях, перестановке сообщений, падениях до/после побочного
эффекта и устаревшей job после новой версии ни одна принятая (202) работа не теряется, на ключ эффекта
(attachment_id, pipeline_version, variant) приходится ровно один результат, а указатель версии не откатывается.
Сценарии (FAULT_INJECTION=1 включает точки сбоя по префиксу имени файла fault-<point>, каждая — один раз):
A worker остановлен → upload 202, content 409, сообщение с вложением 201 → рестарт API и брокера → worker → ready;
B падения: relay до publish (разрыв COMMIT/publish), relay после publish до удаления outbox (дубль),
worker после захвата (до эффекта), после записи в S3 до COMMIT, после COMMIT до ack; временная ошибка до
исчерпания попыток (backoff+jitter → failed) и replay; постоянная ошибка (arithmetic JPEG);
C устаревшая job: v1 медленная (40 с перед COMMIT), v2 (jobctl reprocess) фиксируется раньше; дубли v1 во время и после обработки;
затем инварианты по БД, S3 и API.
Запуск из корня репозитория при работающем стенде (docker compose из этого каталога; для другого проекта —
COMPOSE_PROJECT_NAME/COMPOSE_FILE):
python3 tests/pipeline_experiment.py --output evidence/pipeline_experiment.json
Скрипт пересоздаёт api-1, api-2 и worker с FAULT_INJECTION=1 и арендой 6 с, в конце возвращает обычный режим.
"""
import hashlib
import json
import os
import re
import struct
import subprocess
import time
from pathlib import Path
from client import ROOT, Client, arguments, check, run
from image_probe import jpeg_size
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
BUCKET = 'messenger-attachments'
LEASE = 6
FAULT_ENV = {'FAULT_INJECTION': '1', 'JOB_LEASE_SECONDS': str(LEASE)}
CRASHES = ['crash-before-publish', 'crash-after-publish', 'crash-after-claim', 'crash-after-s3', 'crash-after-commit']
def compose(*args, env=None, stdin=None):
p = subprocess.run(['docker', 'compose', *args], cwd=ROOT, input=stdin, capture_output=True, text=True, env={**os.environ, **(env or {})})
check(p.returncode == 0, 'docker compose %s failed: %s' % (' '.join(args[:2]), p.stderr[-400:]))
return p.stdout
def sql(query):
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-At', '-F', '|', '-c', query).strip()
def rows(query):
out = sql(query)
return [line.split('|') for line in out.split('\n')] if out else []
def queue():
out = compose('exec', '-T', 'rabbitmq', 'rabbitmqctl', '-q', 'list_queues', 'name', 'messages')
return {k: int(v) for k, v in (line.split('\t') for line in out.strip().split('\n') if '\t' in line and not line.startswith('name'))}
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)"; }\n'
'url=http://s3:8333/' + BUCKET + '\n' + '\n'.join(commands) + '\n')
return compose('run', '--rm', '-T', 's3-probe', stdin=script)
def s3_keys(prefix):
return re.findall(r'<Key>([^<]+)</Key>', s3(['sign | curl -K - -s --aws-sigv4 aws:amz:us-east-1:s3 "$url?list-type=2&prefix=%s"' % prefix]))
def s3_sha256(keys):
out = s3(['echo "%s $(sign | curl -K - -s --aws-sigv4 aws:amz:us-east-1:s3 "$url/%s" | sha256sum | cut -d" " -f1)"' % (k, k) for k in keys])
return dict(line.split(' ') for line in out.strip().split('\n') if line)
def jobctl(*args):
out = compose('run', '--rm', '-T', 'jobctl', *args)
return json.loads(out[out.index('{'):])
def arithmetic_jpeg():
# Структурно корректный JPEG (SOF9, arithmetic coding): API принимает, ImageIO декодировать не умеет.
seg = lambda marker, body: b'\xff' + bytes([marker]) + struct.pack('>H', len(body) + 2) + body
return (b'\xff\xd8' + seg(0xC9, struct.pack('>BHHB', 8, 16, 16, 1) + b'\x01\x11\x00')
+ seg(0xDA, b'\x01\x01\x00\x00\x3f\x00') + b'\x00' * 32 + b'\xff\xd9')
def wait_until(what, condition, timeout):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
value = condition()
if value:
return value
except Exception:
pass # API-реплика или брокер перезапускаются после внедрённого падения
time.sleep(0.5)
check(False, 'timeout waiting for ' + what)
def events(job):
return [(int(a), e, d) for a, e, d in rows("select attempt,event,coalesce(detail,'') from job_audit where job_id='%s' order by id" % job)]
def invariants(ids, invalid_id):
in_list = ','.join("'%s'" % i for i in ids)
jobs_of = 'select job_id from jobs where attachment_id in (%s)' % in_list
states = dict(rows('select id,state from attachments where id in (%s)' % in_list))
check(all(states[i] == 'ready' for i in ids if i != invalid_id) and states[invalid_id] == 'failed', 'I1: accepted work lost or stuck: %s' % states)
effects = rows('select attachment_id,pipeline_version,count(*) from attachment_variants where attachment_id in (%s) group by 1,2' % in_list)
check(all(int(n) == 3 for _, _, n in effects), 'I2: effect key has not exactly 3 variants')
db_sha = dict(rows('select object_key,sha256 from attachment_variants where attachment_id in (%s)' % in_list))
s3_variants = sorted(k for i in ids for k in s3_keys('variants/' + i + '/'))
check(s3_variants == sorted(db_sha), 'I2: S3 variant objects differ from DB rows')
s3_sha = s3_sha256(sorted(db_sha))
check(s3_sha == db_sha, 'I3: S3 bytes differ from committed checksums')
# I4: каждое done-задание зафиксировано ровно один раз, failed — ни разу; после done захватов нет.
commits = rows("select j.state,count(a.*) filter (where a.event='done') from jobs j left join job_audit a on a.job_id=j.job_id where j.job_id in (%s) group by j.job_id,j.state" % jobs_of)
check(all(int(n) == (1 if s == 'done' else 0) for s, n in commits), 'I4: a job was committed more than once (or failed job committed): %s' % commits)
after_done = sql("select count(*) from job_audit a join job_audit d on d.job_id=a.job_id and d.event='done' and a.event='claimed' and a.id>d.id where a.job_id in (%s)" % jobs_of)
check(after_done == '0', 'I4: a done job was claimed again')
# I5: staging ready-вложений удалён (сразу после COMMIT или sweepStaging), failed хранится до retention.
ready_ids = {i for i in ids if states[i] == 'ready'}
staging = wait_until('staging cleanup', lambda: (lambda left: {'staging_left_for_run': sorted(left & set(ids))} if not left & ready_ids else None)(
{k.split('/')[1] for k in s3_keys('staging/')}), 90)
duplicates = dict(rows("select event,count(*) from job_audit where event in ('duplicate_done','duplicate_in_progress','stale_attempt') and job_id in (%s) group by 1" % jobs_of))
result = {'I1_no_lost_accepted_work': states, 'I2_variants_per_effect_key': {'%s/v%s' % (a, v): int(n) for a, v, n in effects},
'I2_s3_variant_objects': len(s3_variants), 'I3_checksums_equal': len(s3_sha),
'I4_commits_per_job': sorted(int(n) for _, n in commits), 'I5_staging': staging,
'duplicates_dropped': {k: int(v) for k, v in duplicates.items()}, 'result': 'PASS'}
print('PASS invariants: %d attachments final, %d variant objects = DB rows, checksums equal, every done job committed once, dropped %s'
% (len(ids), len(s3_variants), result['duplicates_dropped']))
return result
def main():
def configure(p):
p.add_argument('--output', default=None)
args = arguments('Lab5 pipeline end-to-end checks and track-2 idempotency experiment', configure)
c = Client(args.base_url, args.ca_file, timeout=20)
started = time.monotonic()
compose('up', '-d', '--wait', 'api-1', 'api-2', 'worker', env=FAULT_ENV)
alice, bob, eve, chat = c.bootstrap()
report = {'experiment': 'lab5 pipeline: grade 3/4 scenarios and track 2 idempotency', 'lease_seconds': LEASE, 'scenarios': {}}
def upload(name, data=PNG, ctype='image/png'):
att = c.call('POST', '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], name), 202, actor=alice, raw=data,
headers={'Content-Type': ctype}, schema='Attachment')['json']
check(att['status'] == 'queued' and att['variants'] == [] and att['error_code'] is None, 'upload must return a queued snapshot')
return att
def meta(att):
return c.call('GET', '/api/v1/attachments/' + att['id'], actor=bob, schema='Attachment')['json']
def final(att, timeout=120):
return wait_until('final state of ' + att['filename'], lambda: (lambda m: m if m['status'] in ('ready', 'failed') else None)(meta(att)), timeout)
def job_of(att, version=1):
return sql("select job_id from jobs where attachment_id='%s' and pipeline_version=%d" % (att['id'], version))
# A. Worker остановлен: приём не зависит от worker, задание переживает рестарт API и брокера.
t0 = time.monotonic()
# Сначала очередь пуста (worker разобрал прежнее); счётчик list_queues у quorum-очереди обновляется
# с задержкой до ~5 с, поэтому пустоту подтверждаем двумя чтениями с паузой.
empty = lambda: queue().get('attachments.process', 1) == 0
wait_until('queue drained', lambda: empty() and (time.sleep(6) or empty()), 120)
compose('stop', 'worker')
demo = upload('demo.png')
for suffix in ('/content', '/content?variant=thumbnail'):
c.call('GET', '/api/v1/attachments/%s%s' % (demo['id'], suffix), 409, actor=bob)
linked = c.message(alice, chat, '', attachments=[demo['id']])['json']
c.message(bob, chat, 'worker остановлен, текст идёт')
depth = lambda least: (lambda q: q if q.get('attachments.process', 0) >= least else None)(queue())
depth_before = wait_until('job message in broker', lambda: depth(1), 30)
compose('restart', 'api-1', 'api-2', 'rabbitmq')
# После рестарта quorum-очередь сначала выбирает лидера; ждём, пока она снова покажет сообщение.
depth_after = wait_until('queued job after broker restart', lambda: depth(1), 90)
wait_until('API after restart', lambda: c.call('GET', '/health/ready', schema='Health'), 90)
check(meta(demo)['status'] == 'queued', 'attachment must stay queued while worker is down')
compose('start', 'worker')
ready = final(demo)
check(ready['status'] == 'ready' and ready['error_code'] is None, 'demo attachment did not become ready')
got = {v: c.call('GET', '/api/v1/attachments/%s/content?variant=%s' % (demo['id'], v), actor=bob) for v in ('original', 'thumbnail', 'crop', 'optimized')}
check(got['original']['bytes'] == PNG, 'original changed')
variants = {v['name']: v for v in ready['variants']}
check(sorted(variants) == ['crop', 'optimized', 'thumbnail'], 'expected thumbnail, crop, optimized')
check(jpeg_size(got['thumbnail']['bytes']) == (256, 160) and jpeg_size(got['crop']['bytes']) == (128, 128), 'JPEG variant dimensions')
check(got['optimized']['bytes'][:4] == b'RIFF' and got['optimized']['bytes'][8:12] == b'WEBP', 'optimized is not WebP')
check((variants['optimized']['width'], variants['optimized']['height']) == (320, 200), 'optimized must not upscale 320x200')
for v in ('thumbnail', 'crop', 'optimized'):
check(hashlib.sha256(got[v]['bytes']).hexdigest() == variants[v]['sha256'], 'variant checksum mismatch: ' + v)
report['scenarios']['A_worker_down_restart'] = {
'attachment_id': demo['id'], 'job_id': job_of(demo), 'message_id': linked['id'],
'queue_before_restart': depth_before, 'queue_after_restart': depth_after,
'content_while_queued': 409, 'seconds': round(time.monotonic() - t0, 1), 'result': 'PASS'}
print('PASS A: worker down -> 202/409/message 201 -> API+broker restart keeps job -> worker -> ready')
# B. Падения в окнах отказа, временная и постоянная ошибки. Relay работает и в API-репликах:
# его падение роняет реплику, поэтому эти два сценария идут по одному, остальные — параллельно.
t0 = time.monotonic()
crash = {}
for p in CRASHES[:2]:
crash[p] = upload('fault-%s.png' % p)
final(crash[p], 180)
wait_until('API after relay crash', lambda: c.call('GET', '/health/ready', schema='Health'), 90)
crash.update({p: upload('fault-%s.png' % p) for p in CRASHES[2:]})
transient = upload('fault-transient.png')
invalid = upload('arith.jpg', arithmetic_jpeg(), 'image/jpeg')
# Перестановка: устаревшее сообщение attempt=1, когда задание уже на attempt≥2.
tjob = job_of(transient)
wait_until('transient job retry', lambda: int(sql("select attempt from jobs where job_id='%s'" % tjob)) >= 2, 240)
sql("insert into outbox(job_id,attempt) values('%s',1)" % tjob)
results = {p: final(a, 300) for p, a in crash.items()}
bad = final(invalid)
exhausted = final(transient, 300)
check(all(r['status'] == 'ready' for r in results.values()), 'crash scenario did not reach ready: %s' % {p: r['status'] for p, r in results.items()})
check(bad['status'] == 'failed' and bad['error_code'] == 'invalid_image', 'arithmetic JPEG must fail with invalid_image')
check(exhausted['status'] == 'failed' and exhausted['error_code'] == 'retry_exhausted', 'transient job must end with retry_exhausted')
c.call('GET', '/api/v1/attachments/%s/content' % bad['id'], 409, actor=bob)
c.call('POST', '/api/v1/chats/%s/messages' % chat['id'], 409, actor=alice, body={'text': '', 'attachment_ids': [bad['id']]},
headers={'Idempotency-Key': 'failed-' + bad['id']})
fired = sorted(r[0] for r in rows('select point from fault_marks'))
check(all(p in fired for p in CRASHES), 'not all crash points fired: %s' % fired)
per = {p: events(job_of(a)) for p, a in crash.items()}
check(any(e == 'lease_expired' for _, e, _ in per['crash-after-claim']), 'crash before effect: lease did not expire')
check(any(e == 'lease_expired' for _, e, _ in per['crash-after-s3']), 'crash after S3 write: lease did not expire')
check([a for a, e, _ in per['crash-after-commit'] if e == 'done'] == [1] and any(e == 'duplicate_done' for _, e, _ in per['crash-after-commit']),
'crash after commit: redelivery must be a no-op')
check(any(e.startswith('duplicate') or e == 'stale_attempt' for _, e, _ in per['crash-after-publish']), 'duplicate publish not observed')
tev = events(tjob)
delays = [int(re.search(r'delay_ms=(\d+)', d).group(1)) for _, e, d in tev if e == 'retry_scheduled']
check(len(delays) == 4 and [a for a, e, _ in tev if e == 'claimed'] == [1, 2, 3, 4, 5], 'transient job: expected 5 attempts, 4 backoffs')
check(any(e == 'stale_attempt' for _, e, _ in tev), 'stale attempt=1 message was not dropped')
check(sum(e == 'failed' for _, e, _ in events(job_of(invalid))) == 1 and not any(e == 'retry_scheduled' for _, e, _ in events(job_of(invalid))),
'permanent error must not be retried')
# Replay: failed → queued (новая попытка того же job_id); повтор replay и replay done-задания — no-op.
replay = jobctl('replay', tjob, job_of(crash['crash-after-commit']))
replayed = final(transient, 60)
check(replayed['status'] == 'ready', 'replayed job did not become ready')
again = jobctl('replay', tjob)
check(again[tjob].startswith('skipped') and replay[job_of(crash['crash-after-commit'])].startswith('skipped'), 'replay of done job must be skipped')
report['scenarios']['B_faults'] = {
'fired_points': fired,
'audit': {p: [list(e) for e in v] for p, v in per.items()},
'transient': {'job_id': tjob, 'backoff_delays_ms': delays, 'audit': [list(e) for e in events(tjob)], 'replay': replay, 'replay_again': again},
'invalid_image': {'job_id': job_of(invalid), 'audit': [list(e) for e in events(job_of(invalid))]},
'seconds': round(time.monotonic() - t0, 1), 'result': 'PASS'}
print('PASS B: crash windows recovered, duplicates dropped, backoff %s ms -> retry_exhausted -> replay -> ready, invalid_image not retried' % delays)
# C. Устаревшая job после новой версии + дубли во время и после обработки.
t0 = time.monotonic()
slow = upload('fault-slow.png')
v1 = job_of(slow)
wait_until('v1 claimed', lambda: sql("select state from jobs where job_id='%s'" % v1) == 'processing', 30)
created = jobctl('reprocess', '--pipeline-version=2', slow['id'])
for _ in range(3):
sql("insert into outbox(job_id,attempt) values('%s',1)" % v1)
wait_until('v1 done', lambda: sql("select state from jobs where job_id='%s'" % v1) == 'done', 90)
for _ in range(2):
sql("insert into outbox(job_id,attempt) values('%s',1)" % v1)
time.sleep(3)
m = meta(slow)
v2 = job_of(slow, 2)
v1_events, v2_events = events(v1), events(v2)
check(sql("select pipeline_version from attachments where id='%s'" % slow['id']) == '2', 'stale v1 job rolled back the version pointer')
check(('superseded' in [d for _, e, d in v1_events if e == 'done']), 'v1 must be committed as superseded after v2')
v2_rows = {r[0]: r[1] for r in rows("select name,sha256 from attachment_variants where attachment_id='%s' and pipeline_version=2" % slow['id'])}
check({v['name']: v['sha256'] for v in m['variants']} == v2_rows and len(v2_rows) == 3, 'API must serve v2 variants')
check(sum(e == 'duplicate_in_progress' for _, e, _ in v1_events) >= 1 and sum(e == 'duplicate_done' for _, e, _ in v1_events) >= 2, 'duplicates of v1 were not dropped')
report['scenarios']['C_stale_version'] = {'attachment_id': slow['id'], 'v1_job': v1, 'v2_job': v2, 'reprocess': created,
'v1_audit': [list(e) for e in v1_events], 'v2_audit': [list(e) for e in v2_events],
'pointer': 2, 'seconds': round(time.monotonic() - t0, 1), 'result': 'PASS'}
print('PASS C: v2 committed first, late v1 committed as superseded, pointer stays 2, duplicates dropped')
# Инварианты по всем вложениям прогона.
ids = [demo['id'], slow['id'], transient['id'], invalid['id']] + [a['id'] for a in crash.values()]
report['invariants'] = invariants(ids, invalid['id'])
report['seconds_total'] = round(time.monotonic() - started, 1)
compose('up', '-d', '--wait', 'api-1', 'api-2', 'worker')
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'], [202, 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)