diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..0f43dbb6 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Shell-скрипты запускаются в bash/sh: CRLF при checkout на Windows их ломает. +*.sh text eol=lf diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..4b1657ed --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/REPORT.md b/REPORT.md index e98f75e9..09420771 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 …|--all-failed | reprocess --pipeline-version=N …|--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/: полный проверенный оригинал до ответа 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/ (серверная копия), variants//v/{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/` приватного 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=/`, `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/`, если его уже нет — `originals/`. Скачанный файл сверяется по размеру и SHA-256. +4. Публикация оригинала: серверная копия `staging/ → originals/` (повтор кладёт те же байты). +5. Варианты → PUT по **детерминированным ключам** `variants//v/`; перед каждым 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-` и срабатывает **один раз на вложение** (отметка в `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//…` в 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/` (S3 PUT завершён) и закоммиченные в одной транзакции строки `attachments` (queued), `jobs` (attempt 1) и `outbox`. Брокер в этот момент может быть недоступен — намерение уже в БД, relay опубликует его позже. Варианты и `originals/` ещё не созданы. + +**Почему повторная доставка нормальна и где ключ идемпотентности 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). diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..15506593 --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/evidence/persistence_after.txt b/evidence/persistence_after.txt new file mode 100644 index 00000000..67bd4d34 --- /dev/null +++ b/evidence/persistence_after.txt @@ -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) diff --git a/evidence/persistence_before.txt b/evidence/persistence_before.txt new file mode 100644 index 00000000..8c94a24e --- /dev/null +++ b/evidence/persistence_before.txt @@ -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) diff --git a/evidence/pipeline_experiment.json b/evidence/pipeline_experiment.json new file mode 100644 index 00000000..d85ba57d --- /dev/null +++ b/evidence/pipeline_experiment.json @@ -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 +} diff --git a/infra/nginx/nginx.conf b/infra/nginx/nginx.conf new file mode 100644 index 00000000..9caa18a1 --- /dev/null +++ b/infra/nginx/nginx.conf @@ -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"}}'; + } +} diff --git a/infra/rabbitmq/rabbitmq.conf b/infra/rabbitmq/rabbitmq.conf new file mode 100644 index 00000000..5cebc98d --- /dev/null +++ b/infra/rabbitmq/rabbitmq.conf @@ -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 diff --git a/infra/s3/s3-init.sh b/infra/s3/s3-init.sh new file mode 100644 index 00000000..b09c4cab --- /dev/null +++ b/infra/s3/s3-init.sh @@ -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" diff --git a/pom.xml b/pom.xml new file mode 100644 index 00000000..15d496e5 --- /dev/null +++ b/pom.xml @@ -0,0 +1,38 @@ + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.3.5 + + + ru.mtusi + messenger + 1.0.0 + 21 + + + + software.amazon.awssdkbom2.29.52pomimport + + + + org.springframework.bootspring-boot-starter-web + org.springframework.bootspring-boot-starter-jdbc + org.springframework.securityspring-security-crypto + org.postgresqlpostgresqlruntime + org.springframework.bootspring-boot-starter-data-redis + org.flywaydbflyway-core + org.flywaydbflyway-database-postgresql + + software.amazon.awssdks3 + software.amazon.awssdknetty-nio-client + + + com.rabbitmqamqp-client + + software.amazon.awssdkapache-client + + org.springframework.bootspring-boot-maven-plugin + diff --git a/scripts/check-private-bucket.sh b/scripts/check-private-bucket.sh new file mode 100644 index 00000000..f1315fe4 --- /dev/null +++ b/scripts/check-private-bucket.sh @@ -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" diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100644 index 00000000..1c1de2f1 --- /dev/null +++ b/scripts/init_secrets.py @@ -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) diff --git a/scripts/measure-failover.sh b/scripts/measure-failover.sh new file mode 100644 index 00000000..5dd5d6b1 --- /dev/null +++ b/scripts/measure-failover.sh @@ -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" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..80a16594 --- /dev/null +++ b/scripts/restart.sh @@ -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 "Стенд успешно перезапущен" diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100644 index 00000000..2c2a8e4a --- /dev/null +++ b/scripts/rolling-update.sh @@ -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" diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..4ad5878c --- /dev/null +++ b/scripts/stop-one.sh @@ -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)" diff --git a/scripts/stop-worker.sh b/scripts/stop-worker.sh new file mode 100644 index 00000000..8d003e00 --- /dev/null +++ b/scripts/stop-worker.sh @@ -0,0 +1,6 @@ +#!/bin/sh +# Останавливает worker (graceful: текущие попытки дорабатываются ≤ 25 с); очередь и задания остаются. +# Запуск обратно: docker compose start worker +set -eu +cd "$(dirname "$0")/.." +docker compose stop worker diff --git a/src/main/java/ru/mtusi/messenger/Attachments.java b/src/main/java/ru/mtusi/messenger/Attachments.java new file mode 100644 index 00000000..1fe51856 --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/Attachments.java @@ -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 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 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 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 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 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); } +} diff --git a/src/main/java/ru/mtusi/messenger/Broker.java b/src/main/java/ru/mtusi/messenger/Broker.java new file mode 100644 index 00000000..8a5695ac --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/Broker.java @@ -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 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; + } +} diff --git a/src/main/java/ru/mtusi/messenger/ImageCheck.java b/src/main/java/ru/mtusi/messenger/ImageCheck.java new file mode 100644 index 00000000..83066e19 --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/ImageCheck.java @@ -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); + } +} diff --git a/src/main/java/ru/mtusi/messenger/ImagePipeline.java b/src/main/java/ru/mtusi/messenger/ImagePipeline.java new file mode 100644 index 00000000..843c0a65 --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/ImagePipeline.java @@ -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 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 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 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); + } +} diff --git a/src/main/java/ru/mtusi/messenger/Jobs.java b/src/main/java/ru/mtusi/messenger/Jobs.java new file mode 100644 index 00000000..26ca14d7 --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/Jobs.java @@ -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-. + 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 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 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 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 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 expired = db.query("select job_id,attempt,attempts_limit,attachment_id from jobs where state='processing' and lease_until 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 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 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 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 . + int cli(String[] args) throws IOException { + String command = args.length > 0 ? args[0] : ""; + Object result; + switch (command) { + case "status" -> { + Map 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 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 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 ...|--all-failed | reprocess --pipeline-version=N ...|--all | redispatch [--older-than=SECONDS]"); + return 2; + } + + static List ids(String[] args, int from) { + List 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 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?)" + + " 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; + } + } +} diff --git a/src/main/java/ru/mtusi/messenger/MessengerApplication.java b/src/main/java/ru/mtusi/messenger/MessengerApplication.java new file mode 100644 index 00000000..2603f713 --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/MessengerApplication.java @@ -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 ]"); + 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 member_ids, Instant created_at) {} + // Модель сообщения с автором, временем создания и вложениями (в порядке из запроса). + record Message(UUID id, UUID chat_id, UUID sender_id, String text, Instant created_at, List attachment_ids) {} + // Универсальная модель страницы списка. + record Page(List 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 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 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 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 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 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 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 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 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 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(@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 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 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 attachmentIds(JsonNode value) { + if(value==null) return List.of(); + if(!value.isArray() || value.size()>10) bad(); + List 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 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 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 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 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 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 malformed(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); } + // Ошибка преобразования UUID или числового параметра означает неверный запрос. + @ExceptionHandler(MethodArgumentTypeMismatchException.class) ResponseEntity mismatch(HttpServletRequest r){ return ResponseEntity.badRequest().body(new ErrorBody(new Error("invalid_request","invalid request",id(r)))); } + // Ошибка PostgreSQL возвращается как временная недоступность зависимости. + @ExceptionHandler(DataAccessException.class) ResponseEntity 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")); } + } +} diff --git a/src/main/java/ru/mtusi/messenger/Reconciler.java b/src/main/java/ru/mtusi/messenger/Reconciler.java new file mode 100644 index 00000000..544ba35b --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/Reconciler.java @@ -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 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 report = run(apply, Duration.ofSeconds(grace), verify); + System.out.println(new ObjectMapper().writerWithDefaultPrettyPrinter().writeValueAsString(report)); + return report.containsKey("skipped") ? 3 : 0; + } + + Map run(boolean apply, Duration grace, boolean verify) { + return db.execute((ConnectionCallback>) 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 findings = new LinkedHashMap<>(), actions = new LinkedHashMap<>(), cost = new LinkedHashMap<>(); + final List> 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 scan() { + long started = System.nanoTime(); + Iterator objects = objects(); + Iterator 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 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 objects() { + Iterator pages = storage.list().iterator(); + return new Iterator<>() { + Iterator page = List.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 rows() { + return new Iterator<>() { + Iterator page = List.of().iterator(); + String after = ""; + boolean done; + public boolean hasNext() { + if (!page.hasNext() && !done) { + count(cost, "db_queries"); + List 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 next(Iterator it) { return it.hasNext() ? it.next() : null; } + + void count(Map map, String name) { map.merge(name, 1L, Long::sum); } + + void detail(String kind, String key, UUID id) { + Map d = new LinkedHashMap<>(); + d.put("kind", kind); + d.put("key", key); + if (id != null) d.put("attachment_id", id); + details.add(d); + } + } +} diff --git a/src/main/java/ru/mtusi/messenger/Storage.java b/src/main/java/ru/mtusi/messenger/Storage.java new file mode 100644 index 00000000..1c4112d1 --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/Storage.java @@ -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 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); + } +} diff --git a/src/main/java/ru/mtusi/messenger/Worker.java b/src/main/java/ru/mtusi/messenger/Worker.java new file mode 100644 index 00000000..cf43014a --- /dev/null +++ b/src/main/java/ru/mtusi/messenger/Worker.java @@ -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 inflight = ConcurrentHashMap.newKeySet(); + final ExecutorService consumers = Executors.newFixedThreadPool(CONCURRENCY); + final ScheduledExecutorService timer = Executors.newScheduledThreadPool(3); + final Map 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 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 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 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(); + } +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties new file mode 100644 index 00000000..6c2624df --- /dev/null +++ b/src/main/resources/application.properties @@ -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 diff --git a/src/main/resources/db/migration/V1__init.sql b/src/main/resources/db/migration/V1__init.sql new file mode 100644 index 00000000..f2d06e32 --- /dev/null +++ b/src/main/resources/db/migration/V1__init.sql @@ -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); diff --git a/src/main/resources/db/migration/V2__idempotency.sql b/src/main/resources/db/migration/V2__idempotency.sql new file mode 100644 index 00000000..6caada19 --- /dev/null +++ b/src/main/resources/db/migration/V2__idempotency.sql @@ -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); diff --git a/src/main/resources/db/migration/V3__attachments.sql b/src/main/resources/db/migration/V3__attachments.sql new file mode 100644 index 00000000..ef32616d --- /dev/null +++ b/src/main/resources/db/migration/V3__attachments.sql @@ -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); diff --git a/src/main/resources/db/migration/V4__pipeline.sql b/src/main/resources/db/migration/V4__pipeline.sql new file mode 100644 index 00000000..90b66b5d --- /dev/null +++ b/src/main/resources/db/migration/V4__pipeline.sql @@ -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; diff --git a/tests/attachments_negative.py b/tests/attachments_negative.py new file mode 100644 index 00000000..9bb4063d --- /dev/null +++ b/tests/attachments_negative.py @@ -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'', '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) diff --git a/tests/fixtures/sample.jpg b/tests/fixtures/sample.jpg new file mode 100644 index 00000000..208d00b6 Binary files /dev/null and b/tests/fixtures/sample.jpg differ diff --git a/tests/pipeline_experiment.py b/tests/pipeline_experiment.py new file mode 100644 index 00000000..57de42fc --- /dev/null +++ b/tests/pipeline_experiment.py @@ -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-, каждая — один раз): + 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'([^<]+)', 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) diff --git a/tests/upload_memory.py b/tests/upload_memory.py new file mode 100644 index 00000000..b65ffcff --- /dev/null +++ b/tests/upload_memory.py @@ -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)