Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
496f0d5a64 |
@@ -0,0 +1,2 @@
|
||||
# Shell-скрипты запускаются в bash/sh: CRLF при checkout на Windows их ломает.
|
||||
*.sh text eol=lf
|
||||
+24
@@ -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"]
|
||||
@@ -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
@@ -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
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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
|
||||
}
|
||||
@@ -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"}}';
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
@@ -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"
|
||||
@@ -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>
|
||||
@@ -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"
|
||||
@@ -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)
|
||||
@@ -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"
|
||||
@@ -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 "Стенд успешно перезапущен"
|
||||
@@ -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"
|
||||
@@ -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)"
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
@@ -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)
|
||||
Vendored
BIN
Binary file not shown.
|
After Width: | Height: | Size: 10 KiB |
@@ -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)
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user