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