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