ЛР 5 - БПИ2303 - Морару - на 5 #12
@@ -18,3 +18,6 @@ __pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
research
|
||||
student-tests
|
||||
tests
|
||||
|
||||
@@ -23,3 +23,23 @@ WORKER_CONCURRENCY=2
|
||||
JOB_MAX_ATTEMPTS=5
|
||||
JOB_TIMEOUT_SECONDS=60
|
||||
STAGING_RETENTION_SECONDS=86400
|
||||
# Implementation knobs (compose.yaml interpolation), see REPORT.md:
|
||||
LB_PORT=8080
|
||||
DB_POOL_MAX=8
|
||||
API_CPUS=1
|
||||
API_MEMORY=256m
|
||||
DB_CPUS=2
|
||||
SHUTDOWN_DRAIN_MS=2500
|
||||
# Reconciler DB <-> S3: never touches pending rows / unreferenced objects younger than grace.
|
||||
RECONCILE_GRACE_SECONDS=900
|
||||
RECONCILE_INTERVAL_SECONDS=300
|
||||
# Lab5: stats port, worker replicas/limits, pipeline and retry tuning.
|
||||
LB_STATS_PORT=8404
|
||||
WORKER_REPLICAS=2
|
||||
WORKER_CPUS=1
|
||||
WORKER_MEMORY=768m
|
||||
PIPELINE_VERSION=1
|
||||
JOB_RETRY_BASE_MS=2000
|
||||
JOB_REPUBLISH_SECONDS=600
|
||||
# Test stand only: an upload named failpoint-<point>.png kills the process once at that point (see REPORT.md).
|
||||
FAILPOINTS=0
|
||||
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
# Node 24 исполняет .ts напрямую (type stripping), отдельной сборки нет; типы проверяет `npm run typecheck`.
|
||||
FROM node:24.22.2-alpine3.24
|
||||
WORKDIR /app
|
||||
ENV NODE_ENV=production
|
||||
COPY package.json package-lock.json ./
|
||||
RUN npm ci --omit=dev && npm cache clean --force
|
||||
COPY src ./src
|
||||
USER node
|
||||
EXPOSE 8080
|
||||
# node работает как PID 1 и сам обрабатывает SIGTERM (graceful shutdown в src/main.ts).
|
||||
CMD ["node", "src/main.ts"]
|
||||
@@ -1,37 +1,340 @@
|
||||
# Отчёт — лабораторная 5
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Морару С. С., БПИ2303
|
||||
- Целевая оценка: **5**, трек 2 «Доказанная идемпотентность pipeline»
|
||||
- Commit/PR: ветка `solution/bpi2303-moraru` (fork `s.s.moraru/mtusi2026lab5` и PR — при публикации)
|
||||
- Источники: Node.js 24 (`node:http`, `node:crypto`, `node:zlib`, `node:stream`), `pg` 8.23.1, `@aws-sdk/client-s3` 3.1152.0, `amqplib` 2.2.0, `sharp` 0.35.5 (libvips 8.18.7), RabbitMQ 4.3, SeaweedFS 4.48, HAProxy 3.2, PostgreSQL 18; документация RabbitMQ: [Reliability](https://www.rabbitmq.com/docs/reliability), [Confirms](https://www.rabbitmq.com/docs/confirms), [Quorum queues](https://www.rabbitmq.com/docs/quorum-queues), [Definitions](https://www.rabbitmq.com/docs/definitions); паттерн transactional outbox.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Prerequisites: Docker Engine + Compose v2 (проверено Docker 29.8.2, Compose 5.5.0, OrbStack), Python 3.9+ (тесты), OpenSSL. Образы закреплены:
|
||||
|
||||
- `node:24.22.2-alpine3.24`;
|
||||
- `postgres:18.6-alpine`;
|
||||
- `haproxy:3.2.26-alpine`;
|
||||
- `chrislusf/seaweedfs:4.48@sha256:4e61d15fd35994cb1e43e1e553dff106794841fd9a99ade2fc8c8bfce4d7872d`;
|
||||
- `rabbitmq:4.3.6-alpine@sha256:6931816af1a943f471c038b278835d36692d55dec769232739296bb91b7de0f5`.
|
||||
|
||||
```sh
|
||||
scripts/init-secrets.sh # .env из .env.example, secrets/ (вне Git): пароли БД и RabbitMQ,
|
||||
# S3-ключи admin/api/worker/reconciler, definitions брокера
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait # postgres, rabbitmq, seaweedfs → s3 → migrate, s3-init (one-shot)
|
||||
# → api ×2, worker ×2, reconciler → lb
|
||||
make check && make validate PYTHON=.venv/bin/python # venv: python3 -m venv .venv && .venv/bin/pip install -r requirements-dev.txt
|
||||
make test BASE_URL=http://localhost:8080 # LB на 127.0.0.1:${LB_PORT:-8080}
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && docker compose start api
|
||||
python3 student-tests/attachments.py --base-url http://localhost:8080 # 43 негативных/граничных случая upload
|
||||
python3 student-tests/idempotency_race.py --base-url http://localhost:8080
|
||||
python3 student-tests/failures.py --base-url http://localhost:8080 # S3 остановлен/завис, down + up
|
||||
python3 student-tests/worker_outage.py --base-url http://localhost:8080 # уровень 3: worker остановлен, рестарт API и брокера
|
||||
python3 student-tests/pipeline_faults.py --base-url http://localhost:8080 # уровень 4 + трек 2: 14 сценариев fault-injection
|
||||
python3 student-tests/reprocess_v2.py --base-url http://localhost:8080 # трек 2: выкатка pipeline v2
|
||||
python3 research/worker_limits.py --base-url http://localhost:8080 # ресурсы worker на худших входах
|
||||
docker compose stop # безопасная остановка; удаление учебных данных: docker compose down -v
|
||||
```
|
||||
|
||||
Операторские команды заданий выполняются в контейнере API (нужен только доступ к БД):
|
||||
|
||||
```sh
|
||||
docker compose exec api node src/main.ts jobs failed # реестр failed (аналог DLQ)
|
||||
docker compose exec api node src/main.ts jobs show <attachment_id> # job, попытки и время следующей, replay-аудит, варианты
|
||||
docker compose exec api node src/main.ts jobs replay <attachment_id> # failed → queued с аудитом; done — отказ
|
||||
docker compose exec api node src/main.ts jobs reprocess --version=2 # переобработка ready новой версией pipeline
|
||||
docker compose exec rabbitmq rabbitmqctl list_queues -p messenger name type messages messages_unacknowledged consumers
|
||||
```
|
||||
|
||||
Типы: `npm ci && npm run typecheck`. Node 24 исполняет `.ts` напрямую (type stripping), сборки нет. На стенде автора 8080 и 8090 заняты, в `.env` стоят `LB_PORT=8095` и `LB_STATS_PORT=8415`; все проверки ниже запускались с `BASE_URL=http://localhost:8095`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
клиент ─► lb (HAProxy) ─► api ×2 ──► postgres: attachments, jobs, outbox, attachment_variants, job_replays
|
||||
│ │
|
||||
│ └────► s3 (SeaweedFS) staging/<id> ← полный проверенный оригинал до 202
|
||||
└─ relay (в каждой реплике API): outbox ─► rabbitmq: exchange attachments → quorum-очередь
|
||||
attachments.process (volume rabbitmq-data)
|
||||
worker ×2 ◄─ consume, prefetch 2, ручной ack ─┘
|
||||
└─► s3: originals/<id>, variants/<id>/v<версия>/<имя>-<токен>.<ext>; postgres: фиксация результата
|
||||
reconciler (из lab4) ─► сверка БД ↔ S3 по originals/, staging/, variants/
|
||||
```
|
||||
|
||||
**Из lab4 перенесено без изменений**: весь API lab1–4, HAProxy с `retry-on conn-failure`, PostgreSQL, SeaweedFS с отдельными S3-identities, потоковый PNG/JPEG-валидатор (CRC, потоковая распаковка со сверкой объёма, лимит пикселей по заголовку), reconciler. Валидатор доработан по замечаниям к lab4 (как в lab4): PNG — тип фильтра каждой строки только 0–4 и длина PLTE; JPEG — заголовки и таблицы проверяются так же, как в libjpeg-turbo (8 бит, 1/3/4 компонента, прореживание, DQT/DHT для каждого скана, параметры SOS, непустой скан). Файлы с фильтром 5 и JPEG без DQT/DHT и данных скана → 415. **Изменено**: upload 201 → 202, байты сначала пишутся в `staging/`; добавлены брокер, outbox, worker, варианты, повторы и replay; reconciler расширен на `staging/` и `variants/`; исправлен порядок компенсации неудачной загрузки — сначала удаляется pending-строка, потом объект. Иначе при COMMIT с неизвестным исходом можно было удалить объект уже принятого вложения.
|
||||
|
||||
### Что сохранено в момент 202 (транзакционные границы)
|
||||
|
||||
1. **Строка** `attachments (pending)` с ключами `originals/<id>` и `staging/<id>`; filename в ключи не попадает.
|
||||
2. **Потоковая загрузка** тела в `staging/<id>` с проверкой изображения на лету. PUT в S3 подтверждён, и SHA-256 с размером посчитаны по тем же байтам.
|
||||
3. **Одна транзакция**: `pending → queued` с размером, sha256 и размерами изображения, `INSERT jobs` (`queued`, `pipeline_version` из `PIPELINE_VERSION`) и `INSERT outbox (attempt 1)`. После COMMIT работа не теряется ни при падении API, ни при недоступном брокере.
|
||||
4. **Ответ** 202 со снимком `status=queued`, `variants=[]`, затем `relay.kick()`. Публикацию делает relay асинхронно; в типичном случае через 15–100 мс после COMMIT.
|
||||
|
||||
Readiness API зависит только от PostgreSQL. Брокер не нужен синхронному пути: при его недоступности задания ждут в outbox. S3 нужен только загрузкам и скачиваниям, без него эти запросы получают 503.
|
||||
|
||||
### Состояния вложения
|
||||
|
||||
| Состояние | Видно в API | Кто ставит | Что дальше |
|
||||
| --- | --- | --- | --- |
|
||||
| `pending` | нет, 404 | API до COMMIT | `queued`; при ошибке строка удаляется, зависшую убирает reconciler (`stale_pending`) |
|
||||
| `queued` | да; content 409 | API (COMMIT), worker (повтор), sweeper (истёкшая аренда) | `processing` |
|
||||
| `processing` | да; content 409 | worker при захвате | `ready`, `queued` (временная ошибка), `failed` |
|
||||
| `ready` | да; варианты текущей версии | worker при фиксации | не откатывается; новая версия pipeline публикуется поверх |
|
||||
| `failed` | да, `error_code`; content и привязка 409 | worker или sweeper (`retry_exhausted`) | `queued` только явным `jobs replay` |
|
||||
| `lost` (из lab4) | да; content 409 | reconciler, объект оригинала пропал | `ready`, если объект вернулся |
|
||||
|
||||
У задания (`jobs`) свои состояния: `queued`, `processing`, `done`, `failed`, `superseded`. Пара `(attachment_id, pipeline_version)` уникальна, это одна логическая работа: `job_id` не меняется ни при redelivery, ни при повторе. Сообщение по `contracts/jobs.schema.json` содержит только идентификаторы, версию, номер попытки и время. Байтов, ключей S3, URL и credentials в нём нет, ключи worker берёт из БД. Публикация идёт с `persistent`, `mandatory` и `messageId = job_id:attempt`, outbox отмечается только после publisher confirm. Невозвращённое `mandatory`-сообщение логируется.
|
||||
|
||||
### Relay и sweeper (`src/jobs/relay.ts`, в каждой реплике API)
|
||||
|
||||
- **publishDue**: раз в 500 мс и по `kick`. Строки outbox с наступившим `available_at` берутся `FOR UPDATE SKIP LOCKED` (две реплики не публикуют одну строку одновременно), публикуются, `waitForConfirms` ждёт не больше 5 с, затем ставится `published_at` и COMMIT. Падение после confirm, но до COMMIT, даёт повторную публикацию, то есть дубль; его гасит worker.
|
||||
- **sweep**: раз в 5 с, одна реплика под `pg_try_advisory_xact_lock`.
|
||||
- Истёкшая аренда: job `processing` с `lease_until < now` становится `queued` с новой строкой outbox на `attempts + 1`, а если попытки исчерпаны — `failed retry_exhausted`.
|
||||
- Job `queued` без живой строки outbox дольше `JOB_REPUBLISH_SECONDS` (600 с) публикуется снова. Это закрывает потерю сообщения брокером или его отбрасывание по `x-delivery-limit`.
|
||||
- Источник истины о работе — PostgreSQL, а не очередь.
|
||||
|
||||
### Worker (`src/jobs/worker.ts`) — порядок одной попытки
|
||||
|
||||
1. **Захват** — одна транзакция: `UPDATE jobs SET processing, attempts+1, lease_token=<uuid>, lease_until=now()+JOB_TIMEOUT_SECONDS+15 WHERE attempts+1 = <attempt из сообщения> AND (queued OR истёкший processing)`.
|
||||
- Сообщение старой или будущей попытки, а также живая аренда другого worker дают no-op с ack.
|
||||
- Если опубликована эта или более новая версия, job становится `superseded`.
|
||||
2. **Исходник**: при первой обработке — из `staging/`, при переобработке — из `originals/`. Читается не больше `size_bytes` + 1 байт, сверяются размер и SHA-256 из БД (`source_missing`/`source_corrupted` — постоянные ошибки).
|
||||
3. **Рендер и запись**: три варианта под ключами с токеном попытки, затем копия `staging → originals/<id>` (тот же ключ при повторе).
|
||||
4. **Фиксация** — одна транзакция:
|
||||
- `jobs → done` только при совпадении `lease_token` (fencing);
|
||||
- `attachments → ready, pipeline_version = N` только при `pipeline_version IS NULL OR < N`, иначе job `superseded`, а её объекты удаляются;
|
||||
- `INSERT attachment_variants`, ключ эффекта — PK `(attachment_id, pipeline_version, name)`.
|
||||
5. Удаление staging (best-effort, остаток уберёт reconciler), затем **ack**.
|
||||
|
||||
Ack подтверждает устойчивую фиксацию (шаг 4), publisher confirm — приём брокером. Это разные границы. Неожиданная ошибка вне попытки (БД недоступна при захвате) даёт nack с requeue через 2 с. Потеря соединения или канала, в том числе по `consumer_timeout`, — выход процесса: Docker перезапустит worker, а брокер отдаст неподтверждённые сообщения снова. При старте worker ждёт брокер с backoff 1–15 с. SIGTERM: consumer отменяется, текущие задания получают до 10 с.
|
||||
|
||||
### Повторы, failed, replay
|
||||
|
||||
- **Постоянные ошибки** (свойство файла): `invalid_image`, `processing_timeout`, `source_missing`, `source_corrupted`, `unsupported_pipeline`. Вложение сразу переходит в `failed`, без повторов.
|
||||
- **Временные ошибки** (S3 или БД): у job сохраняется безопасный код причины (`storage_unavailable`/`database_unavailable`), а время следующей попытки — в `outbox.available_at`. Backoff: `JOB_RETRY_BASE_MS × 2^(n−1)`, не больше 60 с, с jitter ×[0.5; 1]. После `JOB_MAX_ATTEMPTS = 5` попыток — `failed retry_exhausted`.
|
||||
- **Реестр failed** (`jobs failed`) заменяет DLQ: job, вложение, код, число попыток, время.
|
||||
- **`jobs replay`** работает только для `failed` и при сохранённом staging. Он пишет аудит `job_replays`: прежняя ошибка и число попыток. Затем `attempts = 0`, outbox получает попытку 1, вложение возвращается в `queued`. Для `done`, `queued` или `processing` replay отвечает отказом, поэтому «повторить» не исполняет дубль успешной job.
|
||||
- **Контракт API**: `error_code` у вложения только для `failed`; у `ready` и `queued` — `null`.
|
||||
|
||||
### Варианты и лимиты (`src/jobs/render.ts`)
|
||||
|
||||
| Вариант | Формат | Правило | Параметры v1 / v2 |
|
||||
| --- | --- | --- | --- |
|
||||
| `thumbnail` | JPEG (mozjpeg) | вписан в 256×256 без увеличения, размеры округляются вниз, минимум 1 px; EXIF orientation применяется; alpha на белом. 320×200 → 256×160 | q82 / q90 + sharpen |
|
||||
| `crop` | JPEG | центрированный квадрат 128×128 (`cover`), маленький исходник увеличивается | q82 / q90 + sharpen |
|
||||
| `optimized` | WebP | вписан в 1280×1280 без увеличения | q80 effort 4 / q85 + sharpen |
|
||||
|
||||
Метаданные (EXIF, XMP, IPTC, ICC) не копируются: sharp по умолчанию приводит цвета к sRGB и отбрасывает их; orientation применяется до этого. Уменьшения размера каждого маленького файла не обещается.
|
||||
|
||||
Ограничения worker:
|
||||
- **байты**: принимает API, не больше 10 MiB; worker читает не больше `size_bytes`;
|
||||
- **пиксели**: API проверяет заголовок до распаковки, worker — `limitInputPixels = MAX_IMAGE_PIXELS` (40 Мп);
|
||||
- **время**: timeout libvips = `JOB_TIMEOUT_SECONDS`, превышение — `processing_timeout`;
|
||||
- **память**: `sharp.concurrency(1)`, `sharp.cache(false)`, `sequentialRead`, лимит контейнера 768 MiB и 1 CPU;
|
||||
- **конкуренция**: `WORKER_CONCURRENCY = prefetch = 2` задания на реплику, 2 реплики.
|
||||
|
||||
Замер — в разделе «Ресурсы worker».
|
||||
|
||||
### Брокер и безопасность
|
||||
|
||||
RabbitMQ 4.3, один узел, quorum-очередь: publisher confirm приходит после записи в Raft-лог на диск. Топология и пользователи импортируются из definitions при каждом старте узла (`infra/rabbitmq/rabbitmq.conf`, `load_definitions`):
|
||||
- vhost `messenger`, exchange `attachments` (direct), очередь `attachments.process` с `x-delivery-limit: 20`, binding `process`;
|
||||
- пользователь `api`: только `write` в exchange; пользователь `worker`: только `read` очереди; `configure` нет ни у кого;
|
||||
- `guest` не создаётся, в definitions лежат только солёные SHA-256-хеши паролей;
|
||||
- `consumer_timeout` 5 мин, `disk_free_limit` 256 MB.
|
||||
|
||||
Брокер, worker, API, PostgreSQL и S3-шлюз находятся во внутренней сети `backend`. На хост опубликованы только LB и статистика HAProxy. У worker своя S3-identity (Read/Write bucket, без List и Admin); RabbitMQ-пароли лежат только в `broker_url_api`/`broker_url_worker`.
|
||||
|
||||
### Очистка staging и reconciler
|
||||
|
||||
Worker удаляет staging сразу после фиксации результата. Reconciler (каждые 300 с, `--grace=900`) дочищает:
|
||||
|
||||
| Находка | Условие | Действие |
|
||||
| --- | --- | --- |
|
||||
| `stale_pending` | загрузка оборвалась до задания | удалить строку и staging |
|
||||
| `orphan_staging` | staging без строки старше grace | удалить объект |
|
||||
| `published_staging` | staging у `ready` старше grace (worker упал после фиксации) | удалить объект |
|
||||
| `expired_staging` | staging у `failed` старше `STAGING_RETENTION_SECONDS` (86400 с) | удалить объект и обнулить `staging_key`; replay после этого отвечает «исходник недоступен» |
|
||||
| `orphan_variant` | объект варианта без строки старше grace (проигравшая или упавшая попытка) | удалить объект |
|
||||
|
||||
Grace сильно больше аренды, поэтому текущая работа не удаляется.
|
||||
|
||||
### Конфигурация (`.env.example` → реальная)
|
||||
|
||||
| Переменная | Где и как используется |
|
||||
| --- | --- |
|
||||
| `BROKER_URL_FILE` | `/run/secrets/broker_url`: у api — secret `broker_url_api`, у worker — `broker_url_worker` |
|
||||
| `WORKER_CONCURRENCY` | prefetch и число одновременных заданий на реплику worker (2) |
|
||||
| `JOB_MAX_ATTEMPTS` | 5 попыток на серию; replay начинает новую серию |
|
||||
| `JOB_TIMEOUT_SECONDS` | timeout libvips; аренда = значение + 15 с |
|
||||
| `STAGING_RETENTION_SECONDS` | reconciler: сколько хранится staging failed-вложения для replay |
|
||||
| `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` | API (до чтения тела и по заголовку) и worker (`limitInputPixels`) |
|
||||
| `PIPELINE_VERSION`, `JOB_RETRY_BASE_MS`, `JOB_REPUBLISH_SECONDS` | версия новых заданий (1); база backoff (2000 мс); переопубликация queued без живого сообщения (600 с) |
|
||||
| `WORKER_REPLICAS`, `WORKER_CPUS`, `WORKER_MEMORY` | 2 реплики, 1 CPU, 768m |
|
||||
| `FAILPOINTS` | 0; 1 только на тестовом стенде (`src/failpoints.ts`) |
|
||||
| `LB_PORT`, `LB_STATS_PORT`, `DB_POOL_MAX`, `API_*`, `RECONCILE_*`, `SHUTDOWN_DRAIN_MS` | как в lab4 |
|
||||
|
||||
Остальное (`SESSION_*`, `S3_*`, `IDEMPOTENCY_TTL_SECONDS`, `CACHE_URL_FILE`) — как в lab3–4.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `make check`, `make validate`, `make test` | PASS lab5 public API scenario: 202, затем ready, SHA-256 оригинала, thumbnail 256×160 по байтам JPEG | `evidence/level3/public-checks.txt` |
|
||||
| 3: минимум lab4 сохранён, upload 201 → 202 | `attachments.py`, `idempotency_race.py`, `failures.py` | 43 случая загрузки, ни одного 5xx: 202 queued с `variants=[]`; 413, 415 (в том числе PNG с фильтром 5 и JPEG без таблиц), 400, 401 и 404 по лимитам и правам; PNG 40 Мп обработан worker. Гонка 32 POST с одним ключом через 2 реплики дала одно сообщение. S3 остановлен — 503 за ~1 с, завис — 503 за 8 с, текст и метаданные работают; `down` + `up` данные сохранил | `public-checks.txt`, `evidence/level4/s3-failures.txt` |
|
||||
| 3: 202 только после staging и задания; остановка API после ответа не теряет работу | `pipeline_faults.py` S1, S2; `worker_outage.py` | S1 — падение API после staging: клиент 502, задания нет, 202 не было. S2 — падение после COMMIT до publish: клиент 502, но работа дошла до ready. Рестарт обеих реплик API после 202 — ready | `evidence/track2/pipeline-faults.txt`, `evidence/level3/worker-outage.txt` |
|
||||
| 3: отдельные broker и worker; durable at-least-once; ack после эффекта; без worker API не делает resize | `compose.yaml`, `worker_outage.py` | Сервисы `rabbitmq` и `worker`×2. Worker остановлен: upload 202, content 409, сообщения 201. Ack только после COMMIT фиксации, дубли видны в логах worker (S3, S4) | `compose.yaml`, `worker-outage.txt` |
|
||||
| 3: состояния queued/processing/ready/failed, оригинал и thumbnail | smoke, `worker_outage.py`, S12, S13 | queued → ready; failed с `retry_exhausted` и `invalid_image`; оригинал побайтно равен загруженному; thumbnail JPEG 256×160, sha256 = метаданным | `worker-outage.txt`, `pipeline-faults.txt` |
|
||||
| 3: ограниченный retry, failed с безопасным кодом; повтор job без второго набора | S12, S4 | 5 попыток (`JOB_MAX_ATTEMPTS`) → `failed retry_exhausted`; три копии одной попытки → 1 обработка, 2 no-op, 3 варианта | `pipeline-faults.txt` |
|
||||
| 3: worker остановлен → upload → сообщение → рестарт API и брокера → worker → ready; задание переживает рестарт брокера | `worker_outage.py` | Очередь (messages, unacked, consumers) = (1, 0, 0) до и после `restart rabbitmq`; ready через 2.6 с после старта worker | `worker-outage.txt` |
|
||||
| 3: persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS. `StartedAt` всех 10 контейнеров изменился (api×2, worker×2, lb, reconciler, postgres, rabbitmq, seaweedfs, s3), токен прежний | `evidence/level3/persistence-before.txt`, `persistence-after.txt` |
|
||||
| 3: failover | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | PASS 5 раз: api-2 четыре раза, api-1 один раз. 0 неудачных записей, восстановление 3.0–5.4 с | `evidence/level3/failover.txt` |
|
||||
| 4: crop и optimized WebP | smoke, `attachments.py` | crop JPEG 128×128; optimized WebP вписан в 1280 (6400×6250 → 1280×1250, 320×200 без увеличения). EXIF/XMP/ICC не копируются | `public-checks.txt` |
|
||||
| 4: лимиты worker по байтам, пикселям, времени и памяти | `research/worker_limits.py` | Худшие допустимые входы (10.4 MB шума; 40 Мп 1 бит; 40 Мп RGBA 16 бит = 320 МБ данных): ready за 0.6–1.6 с, пик памяти worker 64–160 MiB из 768 MiB. Сверх лимитов вход не доходит до worker (413 до распаковки) | `evidence/level4/worker-limits.txt` |
|
||||
| 4: outbox; crash между COMMIT и publish | S2, S3, S14 | S2: ready без ручного создания задания. S3: падение relay после confirm — дубль погашен. S14: брокер остановлен — 3 × 202, 3 строки outbox ждут; брокер вернулся — ready | `pipeline-faults.txt` |
|
||||
| 4: backoff с jitter, постоянные и временные ошибки, реестр failed, replay | S12, S13 | Задержки попыток 2–5: 1.3; 3.4; 6.6; 8.2 с (2 с × 2^(n−1) × [0.5; 1]). `invalid_image` — failed с первой попытки. Job видна в `jobs failed`; replay с аудитом → ready; повторный replay — отказ «job в состоянии done» | `pipeline-faults.txt` |
|
||||
| 4: остановка worker после записи объекта до ack | S9, S10 | S9 — падение после записи S3 до COMMIT: попытка 2 после истечения аренды, варианты побайтно равны контрольным. S10 — падение после COMMIT до ack: redelivery дал no-op | `pipeline-faults.txt` |
|
||||
| 4: lease для зависшего processing, prefetch, очистка staging | S11, `compose.yaml`, reconciler | S11: пауза 35 с больше аренды 25 с → попытка 2 ready за 32 с, поздняя попытка 1 отброшена fencing-ом. prefetch = `WORKER_CONCURRENCY` = 2. Staging удаляется после фиксации, остаток S10 убрал reconciler (`published_staging`) | `pipeline-faults.txt` |
|
||||
| 4: права S3 и брокера (из lab4 плюс worker) | `scripts/check-s3-security.sh`, `rabbitmqctl list_users` | Анонимный доступ к S3 — 403, у api нет List, Admin только у s3-init. В брокере только `api` и `worker`, guest нет | `evidence/level4/s3-security.txt` |
|
||||
| 5, трек 2: versioned pipeline и автоматический fault-injection | `pipeline_faults.py`, `reprocess_v2.py` | 14 сценариев: дубль, reorder, падение до и после side effect, устаревшая job после новой версии. Все PASS, инварианты I1–I6 выполняются. Выкатка v2: 64 ready v1 переобработаны за 8.8 с, статус всё время `ready`, повторная команда поставила 0 | `evidence/track2/` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Стенд: Apple M3 Pro (11 ядер, 18 GiB), OrbStack. Одновременно работали Docker-стенды других лабораторных, поэтому времена ориентировочные. Лимиты: api 1 CPU/256 MiB, worker 1 CPU/768 MiB, rabbitmq 1 CPU/512 MiB, postgres 2 CPU/1 GiB.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Worker остановлен, upload | 202, content 409, остальной API работает | так и есть, сообщение ждёт в очереди | ready через 2.6 с после старта worker / нет |
|
||||
| Рестарт API ×2 и RabbitMQ при принятом задании | задание в quorum-очереди на диске | очередь (1, 0, 0) до и после | рестарт брокера ≈ 35 с / нет |
|
||||
| RabbitMQ остановлен (S14) | upload 202, задания в outbox, readiness 200 | 3 строки outbox без `published_at`; worker ждёт брокер с backoff | ready через 80 с после старта брокера (старт узла + переподключение worker) / нет |
|
||||
| S3 остановлен или завис (lab4 + worker) | 503 только у вложений; worker повторяет | 503 за 1 с (стоп) и 8 с (зависание); job — 5 попыток с backoff → failed; replay → ready | сразу после возврата S3 / нет; «воскресший» объект staging убрал reconciler |
|
||||
| API падает после staging (S1) | 202 не было, работы не обещано | клиент 502; строка pending без задания | reconciler `stale_pending` / нет (ничего не подтверждено) |
|
||||
| API падает после COMMIT до publish (S2) | outbox публикует другая реплика | клиент 502, ready, попыток 1 | ≈ 1 с / нет |
|
||||
| Relay падает после confirm до отметки (S3) | повторная публикация, дубль гасится | 2 доставки, 1 обработка | ≈ 1 с / нет |
|
||||
| Worker падает после захвата или после записи S3 (S8, S9) | redelivery no-op, затем аренда истекает → попытка 2 | ready, попыток 2, варианты = контрольным; 3 объекта попытки 1 убрал reconciler | 28–40 с при аренде 25 с (на рабочем стенде аренда 75 с) / нет |
|
||||
| Worker падает после COMMIT до ack (S10) | redelivery — no-op | ready, попыток 1; staging убрал reconciler | 1–12 с (перезапуск контейнера) / нет |
|
||||
| Worker завис на 35 с (S11) | аренда истекает, поздний результат отброшен | ready за 32 с, fencing «аренда потеряна» | ≈ аренда + такт sweeper / нет |
|
||||
| Невалидный для libvips PNG (S13) | постоянная ошибка без повторов | failed `invalid_image`, попыток 1 | — / файл не обработан, оригинал хранится до retention |
|
||||
|
||||
### Ресурсы worker
|
||||
|
||||
`research/worker_limits.py`, `evidence/level4/worker-limits.txt`. Перед каждым файлом worker перезапускается, чтобы сбросить `memory.peak` cgroup v2. Измеряются время от 202 до ready и пик памяти контейнеров worker, затем тот же render с timeout 1 с внутри контейнера.
|
||||
|
||||
| Вход (проходит лимиты API) | Файл | Пиксели | До ready | Пик памяти worker | Render с timeout 1 с |
|
||||
| --- | --- | --- | --- | --- | --- |
|
||||
| PNG RGB-шум 1860×1860, максимум по байтам | 10.38 MB | 3.5 М | 0.9 с | 102 MiB | ok, 367 мс |
|
||||
| PNG 1 бит 6400×6250 | 5 КБ | 40 М | 0.6 с | 64 MiB | ok, 363 мс |
|
||||
| PNG RGBA 16 бит 6400×6250, 320 МБ распакованных данных | 1.25 MB | 40 М | 1.6 с | 160 MiB | ok, 1308 мс на три варианта |
|
||||
|
||||
Вывод:
|
||||
- **Память.** Потоковое декодирование (`sequentialRead`), один поток libvips и выключенный кэш держат пик ниже 160 MiB. Даже при prefetch 2 это меньше трети лимита контейнера 768 MiB.
|
||||
- **Время.** Таймаут libvips действует на каждый из трёх вариантов отдельно. На допустимых входах ни один вариант не дольше 1 с, поэтому `processing_timeout` в замере не сработал: защита есть, но этими входами не доказана.
|
||||
- **Байты и пиксели.** Сверх лимита вход отклоняет API (413 по `Content-Length` и по заголовку изображения, `attachments.py`). Worker дополнительно проверяет `limitInputPixels` и читает не больше `size_bytes`.
|
||||
|
||||
## Трек 2. Доказанная идемпотентность pipeline
|
||||
|
||||
**Гипотеза.** При at-least-once доставке, при падениях и зависаниях процессов в любом окне отказа, при дублях и перестановке сообщений эффект pipeline идемпотентен:
|
||||
- каждая принятая работа доходит до конечного состояния;
|
||||
- у пары (вложение, версия) ровно один набор вариантов;
|
||||
- результат новой версии не перезаписывается старой;
|
||||
- повтор даёт побайтно тот же результат.
|
||||
|
||||
**Инварианты** (проверяются автоматически в конце `pipeline_faults.py` по всем вложениям тестового чата):
|
||||
- **I1** — нет потерянной работы: всё, для чего записано задание, в `ready` или `failed`;
|
||||
- **I2** — у каждой пары (вложение, версия) ровно 3 варианта;
|
||||
- **I3** — версия только растёт, варианты v2 не меняются после устаревших job;
|
||||
- **I4** — sha256 вариантов после сбоев равен sha256 контрольной обработки тех же байтов;
|
||||
- **I5** — через API скачиваются все оригиналы и варианты, размер и sha256 совпадают с метаданными;
|
||||
- **I6** — все job в `done`, `failed` или `superseded`, а reconciler находит только ожидаемые остатки сбоев, убирает их, и повторный обход пуст.
|
||||
|
||||
**Методика.**
|
||||
- **Точки отказа.** `src/failpoints.ts` включается только при `FAILPOINTS=1` и срабатывает, если имя файла `failpoint-<точка>[-<N>s].png`, ровно один раз на вложение (`failpoint_hits`). Действие — немедленный `process.exit(137)`: не выполняются ни finally, ни ack, ни ROLLBACK, соединения рвёт ядро. С суффиксом `-<N>s` — пауза N секунд. Точки покрывают все окна отказа из `attachment-states.md`: после staging; после COMMIT до publish; после publish до отметки; после захвата; после записи S3 до COMMIT; после COMMIT до ack.
|
||||
- **Дубли, reorder и устаревшие job** создаются строками outbox. Их публикует relay, то есть настоящий путь сообщений.
|
||||
- **Отказ хранилищ** — `docker compose stop` S3 и брокера.
|
||||
- **Окружение.** Скрипт сам пересоздаёт api и worker с `FAILPOINTS=1` и `JOB_TIMEOUT_SECONDS=10` (аренда 25 с), в конце возвращает конфигурацию из `.env` и проверяет её.
|
||||
- **Повторы.** Полностью PASS прошли последние два прогона: S0–S13 и S0–S14. Более ранние падали на ошибках самого теста, они исправлены (см. «Почему не сразу»).
|
||||
|
||||
**Результаты** (`evidence/track2/pipeline-faults.txt`):
|
||||
|
||||
| Сценарий | Внедрение | Результат |
|
||||
| --- | --- | --- |
|
||||
| S0 контроль | обычная загрузка | ready v1, эталонные sha256 вариантов |
|
||||
| S1 | API: падение после staging | клиент 502, строка pending без задания → `stale_pending` |
|
||||
| S2 | API: падение после COMMIT до publish | клиент 502; relay другой реплики опубликовал → ready |
|
||||
| S3 | relay: падение после confirm до отметки | 2 доставки, 1 обработка, 3 варианта |
|
||||
| S4 дубль | 3 копии попытки 1 одновременно двум worker | 1 обработка, 2 no-op, варианты = контрольным |
|
||||
| S5 reorder | job v2, сообщение попытки 2 раньше попытки 1 | попытка 2 → no-op, попытка 1 → done, версия 1 → 2 |
|
||||
| S6 устаревшая job | поздний дубль старой v1 и повторно поставленная v1 после публикации v2 | no-op и `superseded` при захвате; v2 не тронута |
|
||||
| S7 устаревшая job | v1 зависла после записи объектов, в это время опубликована v2 | v1 → `superseded` при фиксации, вариантов v1 в БД 0, её объекты удалены |
|
||||
| S8, S9 | worker: падение после захвата и после записи S3 | попытка 2 после истечения аренды, варианты побайтно = контрольным |
|
||||
| S10 | worker: падение после COMMIT до ack | redelivery → no-op, попыток 1 |
|
||||
| S11 | worker завис дольше аренды | попытка 2 ready, поздняя попытка 1 отброшена fencing-ом |
|
||||
| S12 | S3 недоступен | backoff 1.3 / 3.4 / 6.6 / 8.2 с → `retry_exhausted` → реестр failed → replay → ready; второй replay — отказ |
|
||||
| S13 | PNG с несуществующим фильтром строк | `invalid_image` с первой попытки |
|
||||
| S14 | брокер остановлен | 3 × 202, outbox копит; после возврата брокера ready |
|
||||
|
||||
Инварианты: 14 вложений с заданием в конечном состоянии; 14 наборов по 3 варианта; S5–S7 остались v2; у 11 ready v1 sha256 совпадает с контрольными; скачаны 13 оригиналов и 39 вариантов. Reconciler нашёл ровно ожидаемые остатки — `stale_pending` (S1), 3 `orphan_variant` попытки 1 в S9 и `published_staging` (S10), — после `--apply` повторный обход пуст.
|
||||
|
||||
**Выкатка v2** (`student-tests/reprocess_v2.py`, `evidence/track2/reprocess-v2.txt`). Порядок:
|
||||
1. worker уже поддерживает v1 и v2;
|
||||
2. api пересоздаётся с `PIPELINE_VERSION=2`: новые загрузки сразу получают v2;
|
||||
3. `jobs reprocess --version=2` переводит старые `ready`, повтор команды ничего не ставит.
|
||||
|
||||
Результат:
|
||||
- до выкатки: ready v1 — 64, v2 — 8 (вложения fault-injection);
|
||||
- новая загрузка сразу получила v2;
|
||||
- `reprocess` поставил 64 job, все done за 8.8 с (7.3 вложения/с на 2 worker × 2);
|
||||
- во время переобработки вложение оставалось `ready` и отдавало варианты;
|
||||
- повторная команда поставила 0;
|
||||
- итог: v2 — 73, jobs v2 done — 73, у всех пар (вложение, версия) по 3 варианта;
|
||||
- переобработанное старое вложение отдаёт thumbnail, побайтно равный свежей загрузке v2: pipeline детерминирован.
|
||||
|
||||
**Почему это не exactly-once доставка.**
|
||||
- Брокер не может знать, обработано ли сообщение. Потерянный confirm (S3) и потерянный ack (S10) неотличимы от недоставки, поэтому брокер обязан доставить снова; дубли реально приходят (S3 — 2 доставки, S4 — 3).
|
||||
- Exactly-once здесь — свойство эффекта внутри PostgreSQL. Его дают:
|
||||
- захват по номеру попытки;
|
||||
- fencing-токен аренды;
|
||||
- условная публикация `pipeline_version < N`;
|
||||
- PK `(attachment_id, pipeline_version, name)`.
|
||||
- Побочные эффекты в S3 не транзакционны. Попытка, которая не дошла до фиксации, оставляет объекты (3 штуки в S9). Они не видны пользователю, их со временем удаляет reconciler, то есть корректность достигается связкой «идемпотентная фиксация + очистка».
|
||||
|
||||
**Почему не сразу.** Три первых прогона выявили ошибки самого теста и окружения:
|
||||
- node в контейнере — PID 1, и `process.kill(self, SIGKILL)` игнорируется ядром: точки отказа «не роняли» процесс. Заменено на `process.exit(137)`;
|
||||
- `docker compose start worker` поднимает и S3 по цепочке `depends_on`. Заменено на `up --no-deps`;
|
||||
- проверку I6 искажали остатки прерванного прошлого прогона. Теперь находки считаются только по вложениям текущего прогона.
|
||||
|
||||
**Ограничения эксперимента.**
|
||||
- Один узел каждого хранилища, один host, синтетические входы (`sample.png` 320×200).
|
||||
- Время зависит от шумного общего host.
|
||||
- Точки отказа проверяют окна из контракта, а не произвольную инструкцию: падение посреди `INSERT` вариантов закрыто транзакцией, но отдельно не внедрялось.
|
||||
- Детерминизм вариантов показан для одной версии libvips: обновление libvips меняет байты, поэтому это новая версия pipeline, а не тот же результат.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- **Выдерживается**:
|
||||
- падение или зависание процесса API, relay или worker в любом окне отказа контракта;
|
||||
- рестарт брокера, PostgreSQL и S3 с volumes;
|
||||
- временная недоступность брокера: задания ждут в outbox;
|
||||
- временная недоступность S3: загрузки получают 503, у worker повторы, потом replay.
|
||||
- **Не выдерживается**:
|
||||
- отказ единственного узла RabbitMQ, PostgreSQL, SeaweedFS или Docker-host: всё в одном экземпляре. Quorum-очередь на одном узле даёт durability на диске, но не HA;
|
||||
- потеря диска с volume.
|
||||
- **Учебные упрощения**:
|
||||
- outbox опрашивается раз в 500 мс, без LISTEN/NOTIFY;
|
||||
- строки outbox и job_replays не чистятся;
|
||||
- аренда не продлевается heartbeat-ом. Обработка ограничена `JOB_TIMEOUT_SECONDS`, но запись в S3 после рендера может съесть запас в 15 с — тогда результат будет честно отброшен fencing-ом и повторён;
|
||||
- проверка PNG в API распаковывает весь поток: PNG на 40 Мп RGBA 16 бит (1.25 MB, 320 МБ данных) проверяется около 6.5 с при 1 CPU. При сильной конкуренции за CPU это может превысить 8-секундный таймаут сокета S3 у ещё открытого PUT — один раз наблюдался 503 для такого файла, повтор прошёл (202). Исправление — отвязать таймаут PUT от скорости распаковки или разбивать проверку;
|
||||
- `reprocess` берёт только `ready`: вложения, которые в момент команды в работе, остаются на старой версии до повторного запуска команды. Команда идемпотентна;
|
||||
- staging удаляется worker сразу после фиксации, поэтому конкурирующая первая обработка более новой версией, пришедшая позже, получает `source_missing`. В обычной работе такой гонки нет: job новой версии ставится только для `ready`.
|
||||
- **Дальше**: трассировка `traceparent` через сообщение (поле уже есть в схеме — lab6), метрики глубины очереди и возраста outbox, кластер RabbitMQ из 3 узлов, продление аренды для долгих заданий.
|
||||
|
||||
## Ответы на вопросы защиты
|
||||
|
||||
- **Чем publisher confirm отличается от consumer ack?** Confirm — от брокера к издателю: сообщение принято и записано в quorum-очередь на диск. Только после него relay отмечает строку outbox. Ack — от consumer к брокеру: обработка завершена и её результат устойчиво зафиксирован в PostgreSQL, сообщение можно удалить. Между ними работа может быть доставлена несколько раз. Confirm без ack означает «работа ждёт в очереди», ack без COMMIT у нас невозможен: ack идёт после фиксации.
|
||||
- **Что именно уже сохранено в момент 202?** Полный оригинал в `staging/<id>` (PUT подтверждён S3, SHA-256 и размер посчитаны по тем же байтам, формат проверен потоково) и одной транзакцией в PostgreSQL: вложение `queued` с метаданными, job и строка outbox. Публикации в брокер ещё может не быть — её гарантирует outbox (S2, S14). Остановка API после 202 работу не теряет: это проверено S2 и `worker_outage.py`.
|
||||
- **Почему повторная доставка нормальна и где ключ идемпотентности?** At-least-once неизбежна: падение между confirm и отметкой outbox, между фиксацией и ack, обрыв соединения — и брокер обязан доставить снова (S3, S4, S10). Защита стоит в эффекте, а не в доставке:
|
||||
- логическая работа — `job_id`, уникальный по `(attachment_id, pipeline_version)`;
|
||||
- попытку захватывает только сообщение с ожидаемым `attempt`;
|
||||
- эффект — PK `(attachment_id, pipeline_version, name)` в `attachment_variants` и условная публикация `pipeline_version < N`.
|
||||
|
||||
Повтор done-job — no-op с ack. Это не exactly-once delivery: дубли реально доставляются (видно в логах worker), но эффект ровно один.
|
||||
- **Как отличить зависший worker от долго работающего и не запустить два неконтролируемых дубля?** Работа ограничена: timeout libvips = `JOB_TIMEOUT_SECONDS`, S3 со своими таймаутами. Аренда (`lease_until`) больше этого предела на 15 с, поэтому живой worker либо успевает, либо сам получает ошибку. Если аренда истекла, worker считается зависшим: sweeper возвращает работу (новая попытка с новым `lease_token`). Поздний результат старой попытки отбрасывается fencing-ом: `UPDATE jobs ... WHERE lease_token = <свой>` не находит строку, объекты попытки удаляются (S11). Две попытки физически могут идти одновременно, но опубликовать результат может только владелец текущей аренды. Объекты пишутся под ключами с токеном попытки, поэтому проигравшая попытка не перезапишет объекты победителя.
|
||||
|
||||
+257
@@ -0,0 +1,257 @@
|
||||
# Клиент → lb (HAProxy) → api × N → postgres (метаданные, jobs, outbox) + s3 (SeaweedFS, staging/ оригинала).
|
||||
# api (relay outbox) → rabbitmq (quorum-очередь attachments.process) → worker × M → s3 (originals/, variants/) + postgres.
|
||||
# Запуск: scripts/init-secrets.sh && docker compose --env-file .env up -d --build (см. REPORT.md)
|
||||
name: messenger-lab5
|
||||
|
||||
x-app: &app
|
||||
build: .
|
||||
image: messenger-lab5-app:dev # уникальное имя: на общем Docker-host не перепутать с чужими стендами
|
||||
networks: [backend]
|
||||
|
||||
x-s3-env: &s3-env
|
||||
S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000}
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ACCESS_KEY_ID_FILE: /run/secrets/s3_access_key_id
|
||||
S3_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_secret_access_key
|
||||
|
||||
x-jobs-env: &jobs-env
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
BROKER_URL_FILE: /run/secrets/broker_url
|
||||
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
|
||||
PIPELINE_VERSION: ${PIPELINE_VERSION:-1}
|
||||
JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:-5}
|
||||
JOB_TIMEOUT_SECONDS: ${JOB_TIMEOUT_SECONDS:-60}
|
||||
JOB_RETRY_BASE_MS: ${JOB_RETRY_BASE_MS:-2000}
|
||||
JOB_REPUBLISH_SECONDS: ${JOB_REPUBLISH_SECONDS:-600}
|
||||
FAILPOINTS: ${FAILPOINTS:-0} # 1 только на тестовом стенде: файл failpoint-<точка>.png один раз роняет процесс
|
||||
|
||||
x-seaweedfs: &seaweedfs
|
||||
image: chrislusf/seaweedfs:4.48@sha256:4e61d15fd35994cb1e43e1e553dff106794841fd9a99ade2fc8c8bfce4d7872d
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 20s
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:18.6-alpine
|
||||
command: ["postgres", "-c", "max_connections=200", "-c", "shared_buffers=256MB"]
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets: [postgres_password]
|
||||
volumes: [pgdata:/var/lib/postgresql]
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 15
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "${DB_CPUS:-2}", memory: 1g }
|
||||
stop_grace_period: 30s
|
||||
restart: unless-stopped
|
||||
networks: [backend]
|
||||
|
||||
# Хранилище SeaweedFS: master + volume + filer, данные в volume s3data. Только во внутренней сети storage:
|
||||
# его HTTP-интерфейсы (master :9333, filer :8888, volume :8080) не требуют подписи S3 и недоступны даже из API.
|
||||
seaweedfs:
|
||||
<<: *seaweedfs
|
||||
command: ["server", "-dir=/data", "-ip=seaweedfs", "-ip.bind=0.0.0.0", "-filer", "-master.volumeSizeLimitMB=1024"]
|
||||
volumes: [s3data:/data]
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:8888/"]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 30
|
||||
start_period: 5s
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "1", memory: 512m }
|
||||
networks: [storage]
|
||||
|
||||
# S3-шлюз — единственный путь к байтам: проверяет SigV4 и права identities (secrets/s3_identities.json).
|
||||
# Встроенный IAM API, Iceberg и Lance выключены; порт не опубликован на хост.
|
||||
s3:
|
||||
<<: *seaweedfs
|
||||
# concurrentUploadLimitMB: шлюз буферизует чанки (4 MiB) каждой загрузки; сверх лимита новые загрузки ждут,
|
||||
# а не выводят шлюз за лимит памяти (эксперимент research/upload_memory.py: при 256m без лимита — OOM).
|
||||
command: ["s3", "-filer=seaweedfs:8888", "-port=9000", "-config=/run/secrets/s3_identities",
|
||||
"-iam=false", "-port.iceberg=0", "-port.lance=0", "-concurrentUploadLimitMB=256"]
|
||||
secrets: [s3_identities]
|
||||
depends_on:
|
||||
seaweedfs: { condition: service_healthy }
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:9000/healthz"]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 30
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "1", memory: 768m }
|
||||
networks: [storage, backend]
|
||||
|
||||
# Одноразовые сервисы до старта реплик: схема БД (advisory lock) и bucket (повторный запуск ничего не меняет).
|
||||
migrate:
|
||||
<<: *app
|
||||
command: ["node", "src/main.ts", "migrate"]
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
secrets: [database_url]
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "0.5", memory: 128m }
|
||||
depends_on:
|
||||
postgres: { condition: service_healthy }
|
||||
|
||||
s3-init:
|
||||
<<: *app
|
||||
command: ["node", "src/main.ts", "s3-init"]
|
||||
environment: *s3-env
|
||||
secrets:
|
||||
- { source: s3_admin_access_key_id, target: s3_access_key_id }
|
||||
- { source: s3_admin_secret_access_key, target: s3_secret_access_key }
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "0.5", memory: 128m }
|
||||
depends_on:
|
||||
s3: { condition: service_healthy }
|
||||
|
||||
# Брокер: RabbitMQ, quorum-очередь на диске (volume rabbitmq-data), publisher confirms, ручной ack.
|
||||
# hostname фиксирует имя узла rabbit@rabbitmq: данные в volume привязаны к нему и переживают пересоздание.
|
||||
rabbitmq:
|
||||
image: rabbitmq:4.3.6-alpine@sha256:6931816af1a943f471c038b278835d36692d55dec769232739296bb91b7de0f5
|
||||
hostname: rabbitmq
|
||||
volumes:
|
||||
- rabbitmq-data:/var/lib/rabbitmq
|
||||
- ./infra/rabbitmq/rabbitmq.conf:/etc/rabbitmq/conf.d/90-messenger.conf:ro
|
||||
secrets: [rabbitmq_definitions]
|
||||
healthcheck:
|
||||
test: ["CMD", "rabbitmq-diagnostics", "-q", "check_port_connectivity"]
|
||||
interval: 5s
|
||||
timeout: 10s
|
||||
retries: 30
|
||||
start_period: 20s
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "1", memory: 512m }
|
||||
stop_grace_period: 30s
|
||||
restart: unless-stopped
|
||||
networks: [backend]
|
||||
|
||||
api:
|
||||
<<: *app
|
||||
environment:
|
||||
<<: [*s3-env, *jobs-env]
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
DB_POOL_MAX: ${DB_POOL_MAX:-8}
|
||||
SHUTDOWN_DRAIN_MS: ${SHUTDOWN_DRAIN_MS:-2500}
|
||||
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
|
||||
secrets:
|
||||
- database_url
|
||||
- { source: broker_url_api, target: broker_url }
|
||||
- { source: s3_api_access_key_id, target: s3_access_key_id }
|
||||
- { source: s3_api_secret_access_key, target: s3_secret_access_key }
|
||||
# rabbitmq не в depends_on: API принимает загрузки и без брокера, задания ждут в outbox.
|
||||
depends_on:
|
||||
migrate: { condition: service_completed_successfully }
|
||||
s3-init: { condition: service_completed_successfully }
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-qO", "/dev/null", "http://127.0.0.1:8080/health/ready"]
|
||||
interval: 2s
|
||||
timeout: 2s
|
||||
retries: 3
|
||||
start_period: 10s
|
||||
deploy:
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
resources:
|
||||
limits: { cpus: "${API_CPUS:-1}", memory: "${API_MEMORY:-256m}" }
|
||||
stop_grace_period: 15s
|
||||
restart: unless-stopped # упавшая реплика поднимается сама; после `docker stop` остаётся остановленной
|
||||
|
||||
# Worker: отдельный процесс без HTTP, конкурирующие consumers одной очереди. WORKER_CONCURRENCY = prefetch =
|
||||
# одновременных заданий на реплику; память ограничена контейнером, libvips — один поток, без кэша.
|
||||
worker:
|
||||
<<: *app
|
||||
command: ["node", "src/main.ts", "worker"]
|
||||
environment:
|
||||
<<: [*s3-env, *jobs-env]
|
||||
WORKER_CONCURRENCY: ${WORKER_CONCURRENCY:-2}
|
||||
secrets:
|
||||
- database_url
|
||||
- { source: broker_url_worker, target: broker_url }
|
||||
- { source: s3_worker_access_key_id, target: s3_access_key_id }
|
||||
- { source: s3_worker_secret_access_key, target: s3_secret_access_key }
|
||||
depends_on:
|
||||
migrate: { condition: service_completed_successfully }
|
||||
s3-init: { condition: service_completed_successfully }
|
||||
rabbitmq: { condition: service_healthy }
|
||||
deploy:
|
||||
replicas: ${WORKER_REPLICAS:-2}
|
||||
resources:
|
||||
limits: { cpus: "${WORKER_CPUS:-1}", memory: "${WORKER_MEMORY:-768m}" }
|
||||
stop_grace_period: 15s # SIGTERM: consumer отменяется, текущие задания до 10 с, затем выход
|
||||
restart: unless-stopped
|
||||
|
||||
# Периодическая сверка БД ↔ S3 с grace period (src/reconcile.ts). Свои S3-ключи: объекты + листинг bucket.
|
||||
reconciler:
|
||||
<<: *app
|
||||
command: ["node", "src/main.ts", "reconcile", "--apply", "--every=${RECONCILE_INTERVAL_SECONDS:-300}"]
|
||||
environment:
|
||||
<<: *s3-env
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
RECONCILE_GRACE_SECONDS: ${RECONCILE_GRACE_SECONDS:-900}
|
||||
STAGING_RETENTION_SECONDS: ${STAGING_RETENTION_SECONDS:-86400}
|
||||
secrets:
|
||||
- database_url
|
||||
- { source: s3_reconciler_access_key_id, target: s3_access_key_id }
|
||||
- { source: s3_reconciler_secret_access_key, target: s3_secret_access_key }
|
||||
depends_on:
|
||||
migrate: { condition: service_completed_successfully }
|
||||
s3-init: { condition: service_completed_successfully }
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "0.5", memory: 128m }
|
||||
restart: unless-stopped
|
||||
|
||||
lb:
|
||||
image: haproxy:3.2.26-alpine
|
||||
volumes: ["./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro"]
|
||||
ports:
|
||||
- "127.0.0.1:${LB_PORT:-8080}:8080"
|
||||
- "127.0.0.1:${LB_STATS_PORT:-8404}:8404" # статистика HAProxy для оператора, это не API
|
||||
depends_on:
|
||||
api: { condition: service_healthy }
|
||||
deploy:
|
||||
resources:
|
||||
limits: { cpus: "${LB_CPUS:-1}", memory: 128m }
|
||||
restart: unless-stopped
|
||||
networks: [frontend, backend]
|
||||
|
||||
networks:
|
||||
frontend: {}
|
||||
backend: { internal: true } # api, worker, postgres, rabbitmq и s3-шлюз недоступны с хоста и не имеют выхода наружу
|
||||
storage: { internal: true } # внутренние компоненты SeaweedFS видит только s3-шлюз
|
||||
|
||||
volumes:
|
||||
pgdata: {}
|
||||
s3data: {}
|
||||
rabbitmq-data: {}
|
||||
|
||||
secrets:
|
||||
database_url: { file: ./secrets/database_url }
|
||||
postgres_password: { file: ./secrets/postgres_password }
|
||||
s3_identities: { file: ./secrets/s3_identities.json }
|
||||
s3_admin_access_key_id: { file: ./secrets/s3_admin_access_key_id }
|
||||
s3_admin_secret_access_key: { file: ./secrets/s3_admin_secret_access_key }
|
||||
s3_api_access_key_id: { file: ./secrets/s3_api_access_key_id }
|
||||
s3_api_secret_access_key: { file: ./secrets/s3_api_secret_access_key }
|
||||
s3_reconciler_access_key_id: { file: ./secrets/s3_reconciler_access_key_id }
|
||||
s3_reconciler_secret_access_key: { file: ./secrets/s3_reconciler_secret_access_key }
|
||||
s3_worker_access_key_id: { file: ./secrets/s3_worker_access_key_id }
|
||||
s3_worker_secret_access_key: { file: ./secrets/s3_worker_secret_access_key }
|
||||
rabbitmq_definitions: { file: ./secrets/rabbitmq_definitions.json }
|
||||
broker_url_api: { file: ./secrets/broker_url_api }
|
||||
broker_url_worker: { file: ./secrets/broker_url_worker }
|
||||
@@ -0,0 +1,20 @@
|
||||
run 1: stopped messenger-lab5-api-2
|
||||
{"observed_instances_before": 2, "successful_writes": 111, "failed_attempts": 0, "first_recovery_seconds": 5.353}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
run 2: stopped messenger-lab5-api-2
|
||||
{"observed_instances_before": 2, "successful_writes": 106, "failed_attempts": 0, "first_recovery_seconds": 3.299}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
run 3: stopped messenger-lab5-api-2
|
||||
{"observed_instances_before": 2, "successful_writes": 129, "failed_attempts": 0, "first_recovery_seconds": 2.968}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
run 4: stopped messenger-lab5-api-2
|
||||
{"observed_instances_before": 2, "successful_writes": 94, "failed_attempts": 0, "first_recovery_seconds": 4.836}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
replicas stopped: messenger-lab5-api-2
|
||||
run 5 (+1 request to shift round-robin): stopped messenger-lab5-api-1
|
||||
{"observed_instances_before": 2, "successful_writes": 133, "failed_attempts": 0, "first_recovery_seconds": 3.084}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
[WARNING] (7) : Server api/api2 is DOWN, reason: Layer4 connection problem, info: "Connection refused", check duration: 429ms. 1 active and 0 backup servers left. 0 sessions active, 0 requeued, 0 remaining in queue.
|
||||
Server api/api2 is DOWN, reason: Layer4 connection problem, info: "Connection refused", check duration: 429ms. 1 active and 0 backup servers left. 0 sessions active, 0 requeued, 0 remaining in queue.
|
||||
[WARNING] (7) : Server api/api2 is UP, reason: Layer7 check passed, code: 200, check duration: 2ms. 2 active and 0 backup servers online. 0 sessions requeued, 0 total in queue.
|
||||
Server api/api2 is UP, reason: Layer7 check passed, code: 200, check duration: 2ms. 2 active and 0 backup servers online. 0 sessions requeued, 0 total in queue.
|
||||
@@ -0,0 +1,21 @@
|
||||
messenger-lab5-api-1 Up 6 seconds (healthy) 5 minutes ago
|
||||
messenger-lab5-api-2 Up 7 seconds (healthy) 5 minutes ago
|
||||
messenger-lab5-lb-1 Up Less than a second 5 minutes ago
|
||||
messenger-lab5-postgres-1 Up 46 seconds (healthy) 5 minutes ago
|
||||
messenger-lab5-rabbitmq-1 Up 46 seconds (healthy) 5 minutes ago
|
||||
messenger-lab5-reconciler-1 Up 7 seconds 5 minutes ago
|
||||
messenger-lab5-s3-1 Up 12 seconds (healthy) 5 minutes ago
|
||||
messenger-lab5-seaweedfs-1 Up 28 seconds (healthy) 5 minutes ago
|
||||
messenger-lab5-worker-1 Up 6 seconds 5 minutes ago
|
||||
messenger-lab5-worker-2 Up 7 seconds 5 minutes ago
|
||||
|
||||
/messenger-lab5-api-1 started 2026-10-30T20:24:05.602965545Z
|
||||
/messenger-lab5-api-2 started 2026-10-30T20:24:04.785490599Z
|
||||
/messenger-lab5-lb-1 started 2026-10-30T20:24:11.582502053Z
|
||||
/messenger-lab5-postgres-1 started 2026-10-30T20:23:26.162988688Z
|
||||
/messenger-lab5-rabbitmq-1 started 2026-10-30T20:23:26.27834088Z
|
||||
/messenger-lab5-reconciler-1 started 2026-10-30T20:24:05.262334255Z
|
||||
/messenger-lab5-s3-1 started 2026-10-30T20:23:59.781004956Z
|
||||
/messenger-lab5-seaweedfs-1 started 2026-10-30T20:23:44.155816805Z
|
||||
/messenger-lab5-worker-1 started 2026-10-30T20:24:05.708003921Z
|
||||
/messenger-lab5-worker-2 started 2026-10-30T20:24:05.217974973Z
|
||||
@@ -0,0 +1,21 @@
|
||||
messenger-lab5-api-1 Up 4 minutes (healthy) 4 minutes ago
|
||||
messenger-lab5-api-2 Up 4 minutes (healthy) 4 minutes ago
|
||||
messenger-lab5-lb-1 Up 4 minutes 4 minutes ago
|
||||
messenger-lab5-postgres-1 Up 4 minutes (healthy) 4 minutes ago
|
||||
messenger-lab5-rabbitmq-1 Up 4 minutes (healthy) 4 minutes ago
|
||||
messenger-lab5-reconciler-1 Up 4 minutes 4 minutes ago
|
||||
messenger-lab5-s3-1 Up 4 minutes (healthy) 4 minutes ago
|
||||
messenger-lab5-seaweedfs-1 Up 4 minutes (healthy) 4 minutes ago
|
||||
messenger-lab5-worker-1 Up 4 minutes 4 minutes ago
|
||||
messenger-lab5-worker-2 Up 4 minutes 4 minutes ago
|
||||
|
||||
/messenger-lab5-api-1 started 2026-10-30T20:18:58.833645745Z
|
||||
/messenger-lab5-api-2 started 2026-10-30T20:18:58.318161341Z
|
||||
/messenger-lab5-lb-1 started 2026-10-30T20:19:04.772212162Z
|
||||
/messenger-lab5-postgres-1 started 2026-10-30T20:18:47.484742253Z
|
||||
/messenger-lab5-rabbitmq-1 started 2026-10-30T20:18:47.480438913Z
|
||||
/messenger-lab5-reconciler-1 started 2026-10-30T20:18:58.326505977Z
|
||||
/messenger-lab5-s3-1 started 2026-10-30T20:18:52.779709225Z
|
||||
/messenger-lab5-seaweedfs-1 started 2026-10-30T20:18:47.461227944Z
|
||||
/messenger-lab5-worker-1 started 2026-10-30T20:19:01.959070667Z
|
||||
/messenger-lab5-worker-2 started 2026-10-30T20:19:01.770281645Z
|
||||
@@ -0,0 +1,53 @@
|
||||
python3 scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
.venv/bin/python scripts/validate_openapi.py
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
python3 tests/smoke.py --base-url "http://localhost:8095"
|
||||
PASS: lab5 public API scenario; infrastructure and grading evidence remain separate.
|
||||
real JPEG + unicode filename 202 25 ms
|
||||
PNG 9.90 MiB (noise 1860x1860) 202 131 ms
|
||||
PNG ровно 40 000 000 px 202 29 ms
|
||||
PNG 10.33 MiB > 10 MiB 413 payload_too_large 10 ms
|
||||
10 MiB + 1 байт 413 payload_too_large 12 ms
|
||||
PNG 40 006 400 px 413 payload_too_large 15 ms
|
||||
pixel-bomb 30000x30000, файл 106 КБ 413 payload_too_large 24 ms
|
||||
JPEG SOF 10000x10000 413 payload_too_large 8 ms
|
||||
zip-bomb в IDAT (64 МБ при 100x100) 415 unsupported_media_type 62 ms
|
||||
PNG: байт IDAT испорчен (CRC) 415 unsupported_media_type 13 ms
|
||||
PNG: корректные CRC, мусор в zlib 415 unsupported_media_type 14 ms
|
||||
PNG: данных меньше, чем пикселей 415 unsupported_media_type 15 ms
|
||||
PNG обрезан 415 unsupported_media_type 15 ms
|
||||
PNG + данные после IEND 415 unsupported_media_type 31 ms
|
||||
PNG 1x1: фильтр строки 5 (допустимы 0–4) 415 unsupported_media_type 10 ms
|
||||
JPEG 27 байт: без DQT/DHT и скана 415 unsupported_media_type 17 ms
|
||||
JPEG без таблиц квантования DQT 415 unsupported_media_type 18 ms
|
||||
JPEG обрезан (нет EOI) 415 unsupported_media_type 25 ms
|
||||
PNG под видом image/jpeg 415 unsupported_media_type 15 ms
|
||||
JPEG под видом image/png 415 unsupported_media_type 11 ms
|
||||
GIF под видом image/png 415 unsupported_media_type 8 ms
|
||||
SVG под видом image/png 415 unsupported_media_type 8 ms
|
||||
Content-Type image/gif 415 unsupported_media_type 4 ms
|
||||
Content-Type octet-stream 415 unsupported_media_type 4 ms
|
||||
пустое тело 415 unsupported_media_type 5 ms
|
||||
filename '../etc/passwd' 400 invalid_request 3 ms
|
||||
filename 'a/b.png' 400 invalid_request 5 ms
|
||||
filename 'a\\b.png' 400 invalid_request 3 ms
|
||||
filename 'nul\x00.png' 400 invalid_request 3 ms
|
||||
filename 'tab\t.png' 400 invalid_request 3 ms
|
||||
filename 'line\n.png' 400 invalid_request 3 ms
|
||||
filename 'c1\x85.png' 400 invalid_request 4 ms
|
||||
filename '' 400 invalid_request 3 ms
|
||||
filename ' ' 400 invalid_request 3 ms
|
||||
filename 'xxxxxxxxxxxxxxxxxxxx' 400 invalid_request 6 ms
|
||||
без filename 400 invalid_request 3 ms
|
||||
chunked без Content-Length 400 invalid_request 2 ms
|
||||
без действительной сессии 401 unauthorized 2 ms
|
||||
посторонний грузит в чужой чат 404 not_found 3 ms
|
||||
несуществующий чат 404 not_found 3 ms
|
||||
chat_id не UUID 400 invalid_request 3 ms
|
||||
обычный PNG 202 23 ms
|
||||
PNG в другом чате 202 19 ms
|
||||
PASS: 43 upload cases, ACL and message linking; no 5xx
|
||||
{"parallel": 32, "replicas_hit": 2, "created_201": 16, "conflict_409": 16, "stored_messages": 1}
|
||||
PASS: concurrent same-key POSTs through different replicas created exactly one message
|
||||
exit 0
|
||||
@@ -0,0 +1,13 @@
|
||||
0.6 s docker compose stop worker
|
||||
0.8 s upload → 202 queued, attachment d57aee4e-8333-4123-8a58-f416d3e64f88
|
||||
0.9 s сообщение с queued-вложением → 201, message 5185cd23-b850-496c-8e94-fee9d9caead9
|
||||
0.9 s content и content?variant=thumbnail → 409 conflict
|
||||
0.9 s другие сообщения без worker: POST 201, история 200
|
||||
6.1 s job a8ea74d0-1487-41cc-96ad-8d06e38c7ebd queued attempts=0; outbox опубликован (publisher confirm); очередь (messages, unacked, consumers) = (1, 0, 0)
|
||||
11.2 s docker compose restart api (обе реплики, SIGTERM)
|
||||
46.4 s docker compose restart rabbitmq; после рестарта очередь = (1, 0, 0)
|
||||
46.5 s вложение после рестартов: queued (прежний токен)
|
||||
53.2 s docker compose start worker
|
||||
56.2 s ready через 2.6 s после старта worker; job: done attempts=1
|
||||
56.5 s thumbnail 256x160 JPEG (sha256 = метаданным), оригинал совпадает побайтно; варианты: crop 128x128, optimized 320x200, thumbnail 256x160
|
||||
PASS: job accepted while worker was down survived API + broker restart and reached ready
|
||||
@@ -0,0 +1,20 @@
|
||||
S3 stopped: /health/ready (S3 не критичен) 200 7 ms
|
||||
S3 stopped: upload #1 503 1096 ms
|
||||
S3 stopped: upload #2 503 1118 ms
|
||||
S3 stopped: upload #3 503 1024 ms
|
||||
S3 stopped: download 503 1013 ms
|
||||
S3 stopped: metadata (только БД) 200 7 ms
|
||||
S3 stopped: text message 201 7 ms
|
||||
S3 stopped: message with ready attachment 201 13 ms
|
||||
pending-строк после 3 неудачных загрузок: 0
|
||||
S3 started: download снова 200 через 0.8 s
|
||||
S3 paused: download (таймаут сокета S3 8 с) 503 8067 ms
|
||||
S3 paused: upload 503 8071 ms
|
||||
S3 paused: text message 201 50 ms
|
||||
S3 unpaused: download снова 200 через 0.0 s
|
||||
S3 back: upload 202 47 ms
|
||||
S3 back: download old attachment 200 11 ms
|
||||
reconcile dry-run --grace=0: {"orphan_staging": 1}
|
||||
reconcile --apply: applied=1; повтор: {}
|
||||
down + up -d: download with old token 200 153 ms
|
||||
PASS: S3 outage/hang degrade only attachments (503), compensation + reconciler clean up, full restart keeps data
|
||||
@@ -0,0 +1,29 @@
|
||||
PASS анонимный GET объекта: 403
|
||||
PASS анонимный LIST bucket: 403
|
||||
PASS анонимный PUT объекта: 403
|
||||
api GetObject own bucket: allowed
|
||||
api ListObjectsV2 own bucket: denied (403 AccessDenied)
|
||||
api CreateBucket other: denied (403 AccessDenied)
|
||||
api PutObject other bucket: denied (403 AccessDenied)
|
||||
api PutObject own bucket: allowed
|
||||
api DeleteObject own bucket: allowed
|
||||
reconciler GetObject own bucket: allowed
|
||||
reconciler ListObjectsV2 own bucket: allowed
|
||||
reconciler CreateBucket other: denied (403 AccessDenied)
|
||||
reconciler PutObject other bucket: denied (403 AccessDenied)
|
||||
reconciler PutObject own bucket: allowed
|
||||
reconciler DeleteObject own bucket: allowed
|
||||
PASS api GetObject: allowed
|
||||
PASS api ListObjectsV2 (не нужен API): denied
|
||||
PASS api CreateBucket: denied
|
||||
PASS api PutObject в чужой bucket: denied
|
||||
PASS reconciler ListObjectsV2: allowed
|
||||
PASS reconciler CreateBucket: denied
|
||||
PASS seaweedfs:8888 из контейнера api: unreachable
|
||||
PASS seaweedfs:9333 из контейнера api: unreachable
|
||||
PASS seaweedfs:8080 из контейнера api: unreachable
|
||||
PASS filer по IP 192.168.186.2:8888 из контейнера api: unreachable
|
||||
PASS сервисы с опубликованными портами: lb
|
||||
PASS повторный s3-init: bucket messenger-attachments: exists
|
||||
PASS: bucket приватен, права минимальны, внутренние порты закрыты
|
||||
exit 0
|
||||
@@ -0,0 +1,7 @@
|
||||
worker: лимит памяти контейнера 768 MiB, WORKER_CONCURRENCY=2, libvips concurrency 1, cache off
|
||||
вход файл пикс. до ready пик worker timeout 1 с
|
||||
PNG RGB-шум 1860×1860 (макс. байт) 10.38 MB 3 M 0.9 с 102 MiB ok (367 мс)
|
||||
PNG 1 бит 6400×6250 0.00 MB 40 M 0.6 с 64 MiB ok (363 мс)
|
||||
PNG RGBA 16 бит 6400×6250 1.25 MB 40 M 1.6 с 160 MiB ok (1308 мс)
|
||||
PASS: worst-case accepted images processed within worker limits
|
||||
exit 0
|
||||
@@ -0,0 +1,44 @@
|
||||
S0 контроль ready v1, варианты crop, optimized, thumbnail
|
||||
S1 API: crash после staging клиент получил 502; строка pending, заданий нет → stale_pending для reconciler
|
||||
S2 API: crash после COMMIT, до publish клиент 502; задание из outbox опубликовано → ready, попыток 1
|
||||
S3 relay: crash после confirm клиент 202; доставок worker: 2 (дубль), обработка 1, вариантов 3
|
||||
S4 дубль: 3 копии попытки 1 3 доставки → 1 обработка, 2 no-op; попыток 1, варианты = контрольным
|
||||
S5 reorder: попытка 2 раньше 1 (job v2) попытка 2 → no-op, попытка 1 → done; версия 1 → 2, вариантов v2: 3
|
||||
S6 устаревшая v1 после v2 (захват) дубль старого сообщения → no-op; повторно поставленная v1 → superseded; v2 не тронута
|
||||
S7 v1 фиксируется после v2 (фиксация) v2 ready; v1 при фиксации → superseded, вариантов v1 в БД 0, объекты удалены
|
||||
S8 worker: crash после захвата redelivery → no-op (аренда жива), аренда истекла → попытка 2; ready за 40 с, попыток 2, варианты = контрольным
|
||||
S9 worker: crash после записи S3 redelivery → no-op (аренда жива), аренда истекла → попытка 2; ready за 40 с, попыток 2, варианты = контрольным
|
||||
S10 worker: crash после COMMIT до ack redelivery → no-op (job done); ready за 12 с, попыток 1, варианты = контрольным
|
||||
S11 worker завис на 35 с (аренда 25 с) попытка 2 → ready за 32 с; попытка 1 проснулась → fencing: результат отброшен
|
||||
S12 S3 недоступен → retry_exhausted задержки попыток 2–5: 1.3, 3.4, 6.6, 8.2 с; failed в реестре, API: failed/409
|
||||
replay аудит (retry_exhausted, 5) → ready; повторный replay: job в состоянии done: повтор не нужен
|
||||
S13 постоянная ошибка (фильтр PNG = 9) failed invalid_image с первой попытки, без повторов
|
||||
S14 брокер остановлен 3 upload → 202, неопубликовано в outbox 3; брокер вернулся → все ready за 80 с
|
||||
|
||||
Инварианты:
|
||||
I1 нет потерянной работы: 14 вложений с заданием, все ready/failed; S1 (без 202) — pending до reconciler
|
||||
I2 один результат: 14 наборов (вложение, версия), в каждом ровно 3 варианта
|
||||
I3 v2 не перезаписана: S5–S7 остались v2, sha256 вариантов v2 не изменились после старых job
|
||||
I4 тот же результат: у 11 ready v1 после сбоев sha256 вариантов = контрольным
|
||||
I5 API согласован: 13 оригиналов и 39 вариантов скачаны, размер и sha256 = метаданным
|
||||
I6 job: {"superseded": "2", "failed": "1", "done": "13"}; reconciler: stale_pending S1, orphan_variant ×3 попытки 1 в S9, published_staging S10 — и только они; применено 5 (всего на стенде {"stale_pending": 1, "published_staging": 1, "orphan_variant": 3}), повторный обход: {}
|
||||
|
||||
Сводка:
|
||||
S0 контроль ready v1, варианты crop, optimized, thumbnail
|
||||
S1 API: crash после staging клиент получил 502; строка pending, заданий нет → stale_pending для reconciler
|
||||
S2 API: crash после COMMIT, до publish клиент 502; задание из outbox опубликовано → ready, попыток 1
|
||||
S3 relay: crash после confirm клиент 202; доставок worker: 2 (дубль), обработка 1, вариантов 3
|
||||
S4 дубль: 3 копии попытки 1 3 доставки → 1 обработка, 2 no-op; попыток 1, варианты = контрольным
|
||||
S5 reorder: попытка 2 раньше 1 (job v2) попытка 2 → no-op, попытка 1 → done; версия 1 → 2, вариантов v2: 3
|
||||
S6 устаревшая v1 после v2 (захват) дубль старого сообщения → no-op; повторно поставленная v1 → superseded; v2 не тронута
|
||||
S7 v1 фиксируется после v2 (фиксация) v2 ready; v1 при фиксации → superseded, вариантов v1 в БД 0, объекты удалены
|
||||
S8 worker: crash после захвата redelivery → no-op (аренда жива), аренда истекла → попытка 2; ready за 40 с, попыток 2, варианты = контрольным
|
||||
S9 worker: crash после записи S3 redelivery → no-op (аренда жива), аренда истекла → попытка 2; ready за 40 с, попыток 2, варианты = контрольным
|
||||
S10 worker: crash после COMMIT до ack redelivery → no-op (job done); ready за 12 с, попыток 1, варианты = контрольным
|
||||
S11 worker завис на 35 с (аренда 25 с) попытка 2 → ready за 32 с; попытка 1 проснулась → fencing: результат отброшен
|
||||
S12 S3 недоступен → retry_exhausted задержки попыток 2–5: 1.3, 3.4, 6.6, 8.2 с; failed в реестре, API: failed/409
|
||||
replay аудит (retry_exhausted, 5) → ready; повторный replay: job в состоянии done: повтор не нужен
|
||||
S13 постоянная ошибка (фильтр PNG = 9) failed invalid_image с первой попытки, без повторов
|
||||
S14 брокер остановлен 3 upload → 202, неопубликовано в outbox 3; брокер вернулся → все ready за 80 с
|
||||
PASS: 14 fault scenarios, invariants I1–I6 hold (at-least-once delivery + idempotent effect, not exactly-once)
|
||||
exit 0
|
||||
@@ -0,0 +1,7 @@
|
||||
до выкатки: ready по версиям — v1: 64, v2: 8; вложение c906be5c-6ba1-4a38-9a04-fdf624d467e6 v1
|
||||
api с PIPELINE_VERSION=2: новая загрузка dd05eb6c-4a55-43dc-94db-81d5def3ea62 сразу v2 (thumbnail отличается от v1)
|
||||
reprocess --version=2: поставлено 64, все done за 8.8 с (7.3 вложений/с); статус во время: ready; повтор: поставлено 0
|
||||
итог: ready по версиям — v2: 73; jobs v2: done 73; у всех пар (вложение, версия) по 3 варианта;
|
||||
c906be5c-6ba1-4a38-9a04-fdf624d467e6 после reprocess отдаёт v2, thumbnail побайтно равен свежей загрузке v2 (детерминизм pipeline)
|
||||
PASS: v2 rollout — new uploads v2, reprocess idempotent, no rollback of ready, deterministic result
|
||||
exit 0
|
||||
@@ -0,0 +1,56 @@
|
||||
# Единственная публичная точка входа. Реплики находятся через Docker DNS (имя сервиса "api"),
|
||||
# поэтому `docker compose up --scale api=N` не требует правки конфига (до 8 реплик).
|
||||
global
|
||||
log stdout format raw local0 info
|
||||
maxconn 4096
|
||||
|
||||
resolvers docker
|
||||
nameserver dns 127.0.0.11:53
|
||||
resolve_retries 2
|
||||
timeout resolve 1s
|
||||
timeout retry 500ms
|
||||
hold valid 1s
|
||||
hold other 1s
|
||||
hold refused 1s
|
||||
hold nx 1s
|
||||
hold timeout 1s
|
||||
hold obsolete 1s
|
||||
|
||||
defaults
|
||||
mode http
|
||||
log global
|
||||
option httplog
|
||||
option dontlog-normal # логируем только ошибки и смену состояния реплик
|
||||
timeout connect 1s
|
||||
timeout client 30s
|
||||
timeout server 10s
|
||||
timeout http-request 10s
|
||||
timeout http-keep-alive 10s
|
||||
timeout check 1s
|
||||
# Повторяется только запрос, не дошедший до реплики (отказ или таймаут соединения), последняя попытка —
|
||||
# на другой реплике. Уже отправленные запросы НЕ повторяются: POST /users и /chats не идемпотентны.
|
||||
retries 2
|
||||
retry-on conn-failure
|
||||
option redispatch 1
|
||||
|
||||
frontend public
|
||||
bind :8080
|
||||
default_backend api
|
||||
|
||||
backend api
|
||||
balance roundrobin
|
||||
option httpchk
|
||||
http-check send meth GET uri /health/ready
|
||||
http-check expect status 200
|
||||
# Активная проверка раз в 1 с (0.5 с при смене состояния): 2 неудачи → DOWN, 2 успеха → UP.
|
||||
# Отказ соединения на живом трафике сразу помечает реплику DOWN (observe layer4).
|
||||
default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 observe layer4 error-limit 1 on-error mark-down resolvers docker init-addr none
|
||||
server-template api 8 api:8080
|
||||
|
||||
# Для оператора (compose публикует только на 127.0.0.1): /stats и Prometheus /metrics.
|
||||
frontend stats
|
||||
bind :8404
|
||||
http-request use-service prometheus-exporter if { path /metrics }
|
||||
stats enable
|
||||
stats uri /stats
|
||||
stats refresh 2s
|
||||
@@ -0,0 +1,12 @@
|
||||
# Монтируется в /etc/rabbitmq/conf.d/90-messenger.conf: файлы conf.d читаются по алфавиту, этот — последним.
|
||||
# Пользователи, vhost messenger, exchange, quorum-очередь и binding — из definitions (scripts/init-secrets.sh),
|
||||
# импорт при каждом старте узла. При импорте definitions пользователь guest не создаётся.
|
||||
load_definitions = /run/secrets/rabbitmq_definitions
|
||||
# Образ разрешает guest из сети (10-defaults.conf); возвращаем безопасное значение на случай его появления.
|
||||
loopback_users.guest = true
|
||||
# Сообщение без ack дольше 5 минут: брокер закрывает канал consumer и отдаёт сообщение снова.
|
||||
# Это страховка брокера; зависшую попытку раньше (JOB_TIMEOUT_SECONDS + 15 с) обнаруживает аренда в БД.
|
||||
consumer_timeout = 300000
|
||||
# При нехватке диска брокер блокирует публикацию — API продолжает принимать файлы, задания ждут в outbox.
|
||||
disk_free_limit.absolute = 256MB
|
||||
log.console.level = info
|
||||
Generated
+1612
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"name": "messenger-lab5",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"engines": {
|
||||
"node": ">=24"
|
||||
},
|
||||
"scripts": {
|
||||
"start": "node src/main.ts",
|
||||
"migrate": "node src/main.ts migrate",
|
||||
"typecheck": "tsc"
|
||||
},
|
||||
"dependencies": {
|
||||
"@aws-sdk/client-s3": "3.1152.0",
|
||||
"amqplib": "2.2.0",
|
||||
"pg": "8.23.1",
|
||||
"sharp": "0.35.5"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "24.19.2",
|
||||
"@types/pg": "8.23.1",
|
||||
"typescript": "7.0.2"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,134 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Пик памяти API при N одновременных загрузках ~9.9 MiB (уровень 4).
|
||||
Гипотеза: загрузка идёт потоком с обратным давлением, поэтому рост памяти реплики ≪ N × размер файла.
|
||||
Перед каждым уровнем реплики перезапускаются (новая cgroup), затем прогрев и выборка memory.current каждые 50 мс
|
||||
во всех api и s3 контейнерах. Запуск: python3 research/upload_memory.py --base-url http://localhost:8080"""
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import statistics
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import zlib
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / 'tests'))
|
||||
from client import Client, arguments, check, run # noqa: E402
|
||||
|
||||
MiB = 1024 * 1024
|
||||
|
||||
|
||||
def noise_png(side):
|
||||
def chunk(kind, data):
|
||||
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
|
||||
raw = b''.join(b'\0' + os.urandom(side * 3) for _ in range(side))
|
||||
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', side, side, 8, 2, 0, 0, 0))
|
||||
+ chunk(b'IDAT', zlib.compress(raw, 1)) + chunk(b'IEND', b''))
|
||||
|
||||
|
||||
def containers(service):
|
||||
out = subprocess.run(['docker', 'compose', 'ps', '-q', service], cwd=ROOT, capture_output=True, text=True, check=True).stdout
|
||||
return out.split()
|
||||
|
||||
|
||||
def cgroup(cid, name):
|
||||
return int(subprocess.run(['docker', 'exec', cid, 'cat', '/sys/fs/cgroup/' + name], capture_output=True, text=True, check=True).stdout)
|
||||
|
||||
|
||||
class Sampler(threading.Thread):
|
||||
"""Максимум memory.current контейнера, опрос каждые 50 мс одним долгим docker exec."""
|
||||
def __init__(self, cid):
|
||||
super().__init__(daemon=True)
|
||||
self.max = 0
|
||||
self.proc = subprocess.Popen(['docker', 'exec', cid, 'sh', '-c', 'while :; do cat /sys/fs/cgroup/memory.current; sleep 0.05; done'],
|
||||
stdout=subprocess.PIPE, text=True)
|
||||
|
||||
def run(self):
|
||||
for line in self.proc.stdout:
|
||||
self.max = max(self.max, int(line))
|
||||
|
||||
def stop(self):
|
||||
self.proc.terminate()
|
||||
return self.max
|
||||
|
||||
|
||||
def restart_api(c):
|
||||
subprocess.run(['docker', 'compose', 'restart', 'api'], cwd=ROOT, check=True, capture_output=True)
|
||||
seen, deadline = set(), time.monotonic() + 60
|
||||
while len(seen) < 2:
|
||||
check(time.monotonic() < deadline, 'replicas not ready')
|
||||
try:
|
||||
r = c.call('GET', '/health/ready', [200, 503])
|
||||
if r['status'] == 200:
|
||||
seen.add(r['headers']['X-Instance-Id'])
|
||||
except AssertionError:
|
||||
pass
|
||||
time.sleep(0.2)
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Concurrent upload memory experiment', lambda p: p.add_argument('--levels', default='1,10,20,40'))
|
||||
c = Client(args.base_url, args.ca_file, timeout=120)
|
||||
data = noise_png(1860)
|
||||
small = (ROOT / 'tests/fixtures/sample.png').read_bytes()
|
||||
results = []
|
||||
for n in [int(x) for x in args.levels.split(',')]:
|
||||
restart_api(c)
|
||||
alice, _, _, chat = c.bootstrap()
|
||||
path = '/api/v1/chats/' + chat['id'] + '/attachments?filename=load.png'
|
||||
for _ in range(4): # прогрев: модули SDK, пул соединений, JIT
|
||||
c.call('POST', path, 201, actor=alice, raw=small, headers={'Content-Type': 'image/png'})
|
||||
api = containers('api')
|
||||
watched = {('api', cid): None for cid in api} | {('s3', cid): None for cid in containers('s3')}
|
||||
base = {k: cgroup(k[1], 'memory.current') for k in watched}
|
||||
samplers = {k: Sampler(k[1]) for k in watched}
|
||||
for s in samplers.values():
|
||||
s.start()
|
||||
time.sleep(0.5)
|
||||
barrier = threading.Barrier(n)
|
||||
done = []
|
||||
|
||||
def upload():
|
||||
local = Client(args.base_url, args.ca_file, timeout=120)
|
||||
barrier.wait()
|
||||
r = local.call('POST', path, [201, 503], actor=alice, raw=data, headers={'Content-Type': 'image/png'})
|
||||
done.append((r['status'], r['elapsed'], r['headers'].get('X-Instance-Id')))
|
||||
|
||||
start = time.monotonic()
|
||||
threads = [threading.Thread(target=upload) for _ in range(n)]
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
wall = time.monotonic() - start
|
||||
time.sleep(0.5)
|
||||
peak = {k: s.stop() for k, s in samplers.items()}
|
||||
lat = sorted(e for _, e, _ in done)
|
||||
row = {
|
||||
'concurrency': n, 'file_mib': round(len(data) / MiB, 2), 'ok': sum(s == 201 for s, _, _ in done), 'errors': sum(s != 201 for s, _, _ in done),
|
||||
'wall_s': round(wall, 2), 'throughput_mib_s': round(n * len(data) / MiB / wall, 1),
|
||||
'latency_p50_s': round(statistics.median(lat), 2), 'latency_max_s': round(lat[-1], 2),
|
||||
'per_replica': sorted(sum(1 for *_, i in done if i == cid[:12]) for cid in api),
|
||||
'api_baseline_mib': [round(base[('api', cid)] / MiB, 1) for cid in api],
|
||||
'api_peak_mib': [round(peak[('api', cid)] / MiB, 1) for cid in api],
|
||||
'api_cgroup_peak_mib': [round(cgroup(cid, 'memory.peak') / MiB, 1) for cid in api],
|
||||
's3_baseline_mib': [round(base[k] / MiB, 1) for k in watched if k[0] == 's3'],
|
||||
's3_peak_mib': [round(peak[k] / MiB, 1) for k in watched if k[0] == 's3'],
|
||||
}
|
||||
row['api_max_growth_mib'] = round(max(p - b for p, b in zip(row['api_peak_mib'], row['api_baseline_mib'])), 1)
|
||||
results.append(row)
|
||||
print(json.dumps(row, ensure_ascii=False))
|
||||
print('\n| N | OK/ошибки | время, с | MiB/s | p50 / max, с | загрузок на реплику | API до → пик, MiB | рост max, MiB | S3-шлюз до → пик, MiB |')
|
||||
print('| --- | --- | --- | --- | --- | --- | --- | --- | --- |')
|
||||
for r in results:
|
||||
print('| %d | %d/%d | %.2f | %.1f | %.2f / %.2f | %s | %s → %s | %.1f | %s → %s |' % (
|
||||
r['concurrency'], r['ok'], r['errors'], r['wall_s'], r['throughput_mib_s'], r['latency_p50_s'], r['latency_max_s'],
|
||||
r['per_replica'], r['api_baseline_mib'], r['api_peak_mib'], r['api_max_growth_mib'], r['s3_baseline_mib'], r['s3_peak_mib']))
|
||||
check(all(r['errors'] == 0 for r in results), 'some uploads failed')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
@@ -0,0 +1,77 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Уровень 4: ресурсы worker на худших допустимых входах (не больше MAX_UPLOAD_BYTES и MAX_IMAGE_PIXELS).
|
||||
Методика: перед каждым файлом worker перезапускается (сбрасывается memory.peak cgroup v2 контейнера), файл грузится
|
||||
через API, измеряются время от 202 до ready и пик памяти контейнеров worker. Затем тот же render внутри контейнера
|
||||
worker с timeout 1 с (как при JOB_TIMEOUT_SECONDS=1) должен закончиться постоянной ошибкой processing_timeout.
|
||||
Запуск: python3 research/worker_limits.py --base-url http://localhost:8080"""
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import zlib
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'student-tests'))
|
||||
from attachments import chunk, gray1, noise_png # noqa: E402
|
||||
from failures import ROOT, compose # noqa: E402
|
||||
from client import Client, arguments, check, run # noqa: E402
|
||||
|
||||
MiB = 1024 * 1024
|
||||
RENDER = """
|
||||
import { render } from './src/jobs/render.ts';
|
||||
const chunks = []; for await (const c of process.stdin) chunks.push(c);
|
||||
const t = performance.now();
|
||||
try { await render(Buffer.concat(chunks), 1, 40000000, Number(process.argv[1])); console.log('ok', Math.round(performance.now() - t)); }
|
||||
catch (e) { console.log(e.code, Math.round(performance.now() - t)); }
|
||||
"""
|
||||
|
||||
|
||||
def rgba16(width, height):
|
||||
"""RGBA 16 бит: 8 байт на пиксель, 40 Мп = 320 МБ распакованных данных; повторяющиеся строки сжимаются до ~1 МБ."""
|
||||
row = b'\0' + bytes(range(256)) * (width * 8 // 256)
|
||||
z = zlib.compressobj(9)
|
||||
data = b''.join(z.compress(row) for _ in range(height)) + z.flush()
|
||||
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', width, height, 16, 6, 0, 0, 0))
|
||||
+ chunk(b'IDAT', data) + chunk(b'IEND', b''))
|
||||
|
||||
|
||||
def workers():
|
||||
return compose('ps', '-q', 'worker', capture=True).split()
|
||||
|
||||
|
||||
def cgroup(container, name):
|
||||
r = subprocess.run(['docker', 'exec', container, 'cat', '/sys/fs/cgroup/' + name], capture_output=True, text=True)
|
||||
check(r.returncode == 0, 'cgroup v2 %s unavailable' % name)
|
||||
return int(r.stdout) / MiB
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Worker resource limits on worst-case accepted images')
|
||||
c = Client(args.base_url, args.ca_file, timeout=60)
|
||||
alice, bob, _, chat = c.bootstrap()
|
||||
limit = compose('exec', '-T', 'worker', 'sh', '-c', 'cat /sys/fs/cgroup/memory.max', capture=True).strip()
|
||||
print('worker: лимит памяти контейнера %d MiB, WORKER_CONCURRENCY=2, libvips concurrency 1, cache off' % (int(limit) / MiB))
|
||||
print('%-34s %9s %8s %10s %13s %13s' % ('вход', 'файл', 'пикс.', 'до ready', 'пик worker', 'timeout 1 с'))
|
||||
for label, data, pixels in (('PNG RGB-шум 1860×1860 (макс. байт)', noise_png(1860), 1860 * 1860),
|
||||
('PNG 1 бит 6400×6250', gray1(6400, 6250), 40_000_000),
|
||||
('PNG RGBA 16 бит 6400×6250', rgba16(6400, 6250), 40_000_000)):
|
||||
check(len(data) <= 10 * MiB, 'input over upload limit')
|
||||
compose('restart', 'worker')
|
||||
time.sleep(3)
|
||||
att = c.call('POST', '/api/v1/chats/%s/attachments?filename=limits.png' % chat['id'], 202, actor=alice, raw=data,
|
||||
headers={'Content-Type': 'image/png'}, schema='Attachment')['json']
|
||||
start = time.monotonic()
|
||||
ready = c.wait_ready(bob, att, 120)
|
||||
took = time.monotonic() - start
|
||||
check(len(ready['variants']) == 3, 'variants')
|
||||
peak = max(cgroup(w, 'memory.peak') for w in workers())
|
||||
r = subprocess.run(['docker', 'compose', 'exec', '-T', 'worker', 'node', '--input-type=module', '-e', RENDER, '1'],
|
||||
cwd=ROOT, input=data, capture_output=True)
|
||||
code, ms = r.stdout.decode().split()
|
||||
print('%-34s %7.2f MB %6.0f M %8.1f с %9.0f MiB %13s' % (label, len(data) / 1e6, pixels / 1e6, took, peak,
|
||||
'%s (%s мс)' % (code, ms)))
|
||||
print('PASS: worst-case accepted images processed within worker limits')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
Executable
+51
@@ -0,0 +1,51 @@
|
||||
#!/bin/sh
|
||||
# Проверка приватности bucket и минимальных прав вне API (уровень 4). Ничего не меняет, кроме
|
||||
# временного объекта probe/* (создаётся и сразу удаляется ключом api) — и повторного запуска s3-init.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
fail=0
|
||||
expect() { # описание, ожидаемое, фактическое
|
||||
if [ "$2" = "$3" ]; then echo "PASS $1: $3"; else echo "FAIL $1: ожидалось $2, получено $3"; fail=1; fi
|
||||
}
|
||||
key=$(docker compose exec -T postgres psql -U messenger -d messenger -tAc "SELECT object_key FROM attachments WHERE state = 'ready' LIMIT 1")
|
||||
[ -n "$key" ] || { echo "нужно хотя бы одно вложение: сначала make test"; exit 2; }
|
||||
bucket=$(docker compose exec -T api printenv S3_BUCKET)
|
||||
|
||||
# 1. Анонимный доступ напрямую к S3-шлюзу из сети backend (минуя API): без подписи — 403.
|
||||
anon() { docker compose exec -T api node -e 'fetch(process.argv[1], { method: process.argv[2], body: process.argv[2] === "PUT" ? "x" : undefined }).then((r) => console.log(r.status), () => console.log("error"))' "$@"; }
|
||||
expect "анонимный GET объекта" 403 "$(anon "http://s3:9000/$bucket/$key" GET)"
|
||||
expect "анонимный LIST bucket" 403 "$(anon "http://s3:9000/$bucket?list-type=2" GET)"
|
||||
expect "анонимный PUT объекта" 403 "$(anon "http://s3:9000/$bucket/originals/anonymous" PUT)"
|
||||
|
||||
# 2. Ключи api и reconciler: только свой bucket и только нужные действия.
|
||||
for svc in api reconciler; do
|
||||
docker compose exec -T "$svc" node --input-type=module - "$key" < student-tests/s3_probe.mjs | while read -r line; do echo " $svc $line"; done
|
||||
done
|
||||
probe() { docker compose exec -T "$1" node --input-type=module - "$key" < student-tests/s3_probe.mjs | awk -v op="$2: " 'index($0, op) == 1 {split(substr($0, length(op) + 1), w, " "); print w[1]}'; }
|
||||
expect "api GetObject" allowed "$(probe api 'GetObject own bucket')"
|
||||
expect "api ListObjectsV2 (не нужен API)" denied "$(probe api 'ListObjectsV2 own bucket')"
|
||||
expect "api CreateBucket" denied "$(probe api 'CreateBucket other')"
|
||||
expect "api PutObject в чужой bucket" denied "$(probe api 'PutObject other bucket')"
|
||||
expect "reconciler ListObjectsV2" allowed "$(probe reconciler 'ListObjectsV2 own bucket')"
|
||||
expect "reconciler CreateBucket" denied "$(probe reconciler 'CreateBucket other')"
|
||||
|
||||
# 3. Внутренние интерфейсы SeaweedFS (filer/master/volume без подписи S3) недоступны из API: другая сеть.
|
||||
for port in 8888 9333 8080; do
|
||||
if docker compose exec -T api wget -T 2 -q -O /dev/null "http://seaweedfs:$port/" 2>/dev/null; then r=reachable; else r=unreachable; fi
|
||||
expect "seaweedfs:$port из контейнера api" unreachable "$r"
|
||||
done
|
||||
# Не только DNS: и по IP в сети storage маршрута из backend нет.
|
||||
ip=$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$(docker compose ps -q seaweedfs)")
|
||||
if docker compose exec -T api wget -T 2 -q -O /dev/null "http://$ip:8888/" 2>/dev/null; then r=reachable; else r=unreachable; fi
|
||||
expect "filer по IP $ip:8888 из контейнера api" unreachable "$r"
|
||||
|
||||
# 4. На хост опубликован только LB (API и статистика HAProxy на 127.0.0.1); S3 и консоли — нет.
|
||||
published=$(for id in $(docker compose ps -q); do
|
||||
[ -n "$(docker port "$id")" ] && docker inspect -f '{{index .Config.Labels "com.docker.compose.service"}}' "$id"
|
||||
done | sort -u | tr '\n' ' ')
|
||||
expect "сервисы с опубликованными портами" "lb " "$published"
|
||||
|
||||
# 5. Bootstrap идемпотентен: повторный s3-init не создаёт и не ломает bucket.
|
||||
expect "повторный s3-init" "bucket $bucket: exists" "$(docker compose run --rm -T s3-init 2>/dev/null | tail -1)"
|
||||
|
||||
[ "$fail" = 0 ] && echo "PASS: bucket приватен, права минимальны, внутренние порты закрыты" || exit 1
|
||||
Executable
+76
@@ -0,0 +1,76 @@
|
||||
#!/bin/sh
|
||||
# Создаёт локальные учебные секреты и .env (вне Git). Существующие ключи не перезаписывает: они уже записаны
|
||||
# в volume pgdata и используются SeaweedFS. Повторный запуск только добавляет недостающее.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
[ -f .env ] || cp .env.example .env
|
||||
mkdir -p secrets
|
||||
chmod 700 secrets
|
||||
put() {
|
||||
[ -f "secrets/$1" ] && return 0
|
||||
printf '%s' "$2" > "secrets/$1"
|
||||
chmod 644 "secrets/$1" # читают пользователи контейнеров; сам каталог остаётся 700
|
||||
echo "created secrets/$1"
|
||||
}
|
||||
if [ ! -f secrets/postgres_password ]; then
|
||||
password=$(openssl rand -hex 24)
|
||||
put postgres_password "$password"
|
||||
put database_url "postgres://messenger:$password@postgres:5432/messenger"
|
||||
fi
|
||||
# Отдельные S3-ключи: admin — только bootstrap bucket (s3-init), api и worker — объекты, reconciler — объекты + листинг.
|
||||
for who in admin api worker reconciler; do
|
||||
put "s3_${who}_access_key_id" "$who$(openssl rand -hex 8)"
|
||||
put "s3_${who}_secret_access_key" "$(openssl rand -hex 24)"
|
||||
done
|
||||
|
||||
# Identities SeaweedFS выводятся из ключей и bucket, поэтому файл пересобирается при каждом запуске.
|
||||
# Действие с суффиксом :bucket разрешено только в этом bucket; Admin (создание/удаление bucket) — только у admin.
|
||||
# Анонимной identity нет: запрос без подписи получает 403.
|
||||
bucket=$(sed -n 's/^S3_BUCKET=//p' .env)
|
||||
bucket=${bucket:-messenger-attachments}
|
||||
identity() {
|
||||
printf '{"name":"%s","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":[%s]}' \
|
||||
"$1" "$(cat "secrets/s3_$1_access_key_id")" "$(cat "secrets/s3_$1_secret_access_key")" "$2"
|
||||
}
|
||||
umask 022
|
||||
printf '{"identities":[%s,%s,%s,%s]}\n' \
|
||||
"$(identity admin '"Admin","Read","List","Write"')" \
|
||||
"$(identity api "\"Read:$bucket\",\"Write:$bucket\"")" \
|
||||
"$(identity worker "\"Read:$bucket\",\"Write:$bucket\"")" \
|
||||
"$(identity reconciler "\"Read:$bucket\",\"Write:$bucket\",\"List:$bucket\"")" > secrets/s3_identities.json
|
||||
|
||||
# RabbitMQ: отдельные пользователи api (только публикация в exchange attachments) и worker (только чтение
|
||||
# очереди attachments.process), configure ни у кого — топология объявлена здесь и импортируется при старте узла.
|
||||
# В definitions лежат только солёные хеши SHA-256 (формат rabbit_password_hashing_sha256), пароли — в broker_url_*.
|
||||
for who in api worker; do
|
||||
put "rabbitmq_${who}_password" "$(openssl rand -hex 24)"
|
||||
put "broker_url_$who" "amqp://$who:$(cat "secrets/rabbitmq_${who}_password")@rabbitmq:5672/messenger?heartbeat=10"
|
||||
done
|
||||
python3 - > secrets/rabbitmq_definitions.json <<'PY'
|
||||
import base64, hashlib, json, os
|
||||
def user(name):
|
||||
salt = os.urandom(4)
|
||||
with open(f'secrets/rabbitmq_{name}_password', 'rb') as f:
|
||||
digest = hashlib.sha256(salt + f.read()).digest()
|
||||
return {'name': name, 'password_hash': base64.b64encode(salt + digest).decode(),
|
||||
'hashing_algorithm': 'rabbit_password_hashing_sha256', 'tags': []}
|
||||
vh = 'messenger'
|
||||
print(json.dumps({
|
||||
'users': [user('api'), user('worker')],
|
||||
'vhosts': [{'name': vh}],
|
||||
'permissions': [
|
||||
{'user': 'api', 'vhost': vh, 'configure': '^$', 'write': '^attachments$', 'read': '^$'},
|
||||
{'user': 'worker', 'vhost': vh, 'configure': '^$', 'write': '^$', 'read': '^attachments\\.process$'},
|
||||
],
|
||||
'exchanges': [{'name': 'attachments', 'vhost': vh, 'type': 'direct', 'durable': True, 'auto_delete': False,
|
||||
'internal': False, 'arguments': {}}],
|
||||
# Quorum-очередь: сообщение подтверждается publisher confirm после записи на диск (Raft-лог).
|
||||
# delivery-limit: сообщение, которое worker 20 раз вернул без ack, отбрасывается; задание при этом остаётся в БД
|
||||
# и будет опубликовано снова sweeper-ом (relay.ts) — источник истины о работе PostgreSQL, а не очередь.
|
||||
'queues': [{'name': 'attachments.process', 'vhost': vh, 'durable': True, 'auto_delete': False,
|
||||
'arguments': {'x-queue-type': 'quorum', 'x-delivery-limit': 20}}],
|
||||
'bindings': [{'source': 'attachments', 'vhost': vh, 'destination': 'attachments.process',
|
||||
'destination_type': 'queue', 'routing_key': 'process', 'arguments': {}}],
|
||||
}, indent=2))
|
||||
PY
|
||||
echo "secrets/ and .env are ready (bucket $bucket)"
|
||||
Executable
+10
@@ -0,0 +1,10 @@
|
||||
#!/bin/sh
|
||||
# Перезапускает LB, все API-реплики, worker, reconciler, PostgreSQL, RabbitMQ и SeaweedFS (хранилище + S3-шлюз).
|
||||
# Volumes pgdata, s3data и rabbitmq-data, схема, bucket и очередь сохраняются; migrate и s3-init ничего не меняют.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose stop lb api worker reconciler # штатный SIGTERM, реплики сначала завершают запросы
|
||||
docker compose stop s3
|
||||
docker compose restart postgres seaweedfs rabbitmq # те же контейнеры и те же volumes
|
||||
docker compose start s3
|
||||
docker compose start api worker reconciler lb
|
||||
Executable
+14
@@ -0,0 +1,14 @@
|
||||
#!/bin/sh
|
||||
# Останавливает ровно ту API-реплику, чей X-Instance-Id передан в TARGET_INSTANCE_ID, и оставляет её остановленной.
|
||||
# X-Instance-Id = hostname контейнера = первые 12 hex-символов ID контейнера.
|
||||
# Восстановление после теста: docker compose start api
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
cd "$(dirname "$0")/.."
|
||||
case "$TARGET_INSTANCE_ID" in
|
||||
*[!0-9a-f]* | "") echo "unexpected instance id" >&2; exit 2 ;;
|
||||
esac
|
||||
ids=$(docker compose ps -q api | grep "^$TARGET_INSTANCE_ID" || true)
|
||||
[ "$(printf '%s\n' "$ids" | grep -c .)" -eq 1 ] || { echo "no single running api container for $TARGET_INSTANCE_ID" >&2; exit 1; }
|
||||
docker stop "$ids" >/dev/null # SIGTERM → readiness 503 → drain → выход (около 3 с)
|
||||
echo "stopped $(docker inspect -f '{{.Name}}' "$ids") ($TARGET_INSTANCE_ID)"
|
||||
+93
@@ -0,0 +1,93 @@
|
||||
// HTTP-приложение: таблица маршрутов, health-проверки и общая обработка каждого запроса.
|
||||
import { randomUUID } from 'node:crypto';
|
||||
import type { IncomingMessage, OutgoingHttpHeaders, ServerResponse } from 'node:http';
|
||||
import { Readable } from 'node:stream';
|
||||
import { pipeline } from 'node:stream/promises';
|
||||
import type { Pool } from 'pg';
|
||||
import type { Config } from './config.ts';
|
||||
import type { Handler, Result } from './http/context.ts';
|
||||
import { notFound, toHttpError, unavailable } from './http/errors.ts';
|
||||
import { downloadAttachment, getAttachment, uploadAttachment } from './modules/attachments.ts';
|
||||
import { createChat, getChat, listChats } from './modules/chats.ts';
|
||||
import { listMessages, sendMessage } from './modules/messages.ts';
|
||||
import { createSession, deleteSession } from './modules/sessions.ts';
|
||||
import { createUser, me } from './modules/users.ts';
|
||||
import type { Storage } from './storage/s3.ts';
|
||||
|
||||
function send(res: ServerResponse, status: number, body?: unknown, headers?: OutgoingHttpHeaders) {
|
||||
if (body instanceof Readable) {
|
||||
// Байты вложения потоком из S3. Обрыв с любой стороны закрывает соединение: клиент увидит
|
||||
// несовпадение с Content-Length, а не «успешно» обрезанный файл.
|
||||
res.writeHead(status, headers);
|
||||
pipeline(body, res).catch((err) => console.error(`передача вложения прервана: ${err.message}`));
|
||||
return;
|
||||
}
|
||||
if (body === undefined) {
|
||||
res.writeHead(status).end();
|
||||
return;
|
||||
}
|
||||
const data = JSON.stringify(body);
|
||||
res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) }).end(data);
|
||||
}
|
||||
|
||||
export function createApp(db: Pool, s3: Storage, config: Config, relay: { kick(): void }) {
|
||||
// ready = false с момента SIGTERM: балансировщик по readiness выводит реплику из ротации.
|
||||
const state = { ready: true };
|
||||
|
||||
// Готовность: процесс не завершается и PostgreSQL отвечает. Это единственная критичная зависимость:
|
||||
// при недоступном S3 реплика остаётся в ротации, текстовые сообщения работают, вложения отвечают 503;
|
||||
// при недоступном брокере загрузки принимаются (задания ждут в outbox), worker не нужен для приёма.
|
||||
const readiness: Handler = async () => {
|
||||
if (!state.ready) throw unavailable('Реплика завершает работу');
|
||||
try {
|
||||
await db.query('SELECT 1');
|
||||
} catch {
|
||||
throw unavailable('База данных недоступна');
|
||||
}
|
||||
return [200, { status: 'ok' }];
|
||||
};
|
||||
|
||||
const routes: [method: string, path: RegExp, handler: Handler][] = [
|
||||
['GET', /^\/health\/live$/, async () => [200, { status: 'ok' }]],
|
||||
['GET', /^\/health\/ready$/, readiness],
|
||||
['POST', /^\/api\/v1\/users$/, createUser],
|
||||
['GET', /^\/api\/v1\/users\/me$/, me],
|
||||
['POST', /^\/api\/v1\/auth\/sessions$/, createSession],
|
||||
['DELETE', /^\/api\/v1\/auth\/sessions\/current$/, deleteSession],
|
||||
['POST', /^\/api\/v1\/chats$/, createChat],
|
||||
['GET', /^\/api\/v1\/chats$/, listChats],
|
||||
['GET', /^\/api\/v1\/chats\/([^/]+)$/, getChat],
|
||||
['POST', /^\/api\/v1\/chats\/([^/]+)\/messages$/, sendMessage],
|
||||
['GET', /^\/api\/v1\/chats\/([^/]+)\/messages$/, listMessages],
|
||||
['POST', /^\/api\/v1\/chats\/([^/]+)\/attachments$/, uploadAttachment],
|
||||
['GET', /^\/api\/v1\/attachments\/([^/]+)$/, getAttachment],
|
||||
['GET', /^\/api\/v1\/attachments\/([^/]+)\/content$/, downloadAttachment],
|
||||
];
|
||||
|
||||
async function dispatch(req: IncomingMessage): Promise<Result> {
|
||||
const url = new URL(req.url ?? '/', 'http://api');
|
||||
for (const [method, pattern, handler] of routes) {
|
||||
const m = pattern.exec(url.pathname);
|
||||
if (m && req.method === method) return handler({ req, url, params: m.slice(1), db, s3, config, relay });
|
||||
}
|
||||
throw notFound(); // неизвестный путь или метод — тоже JSON-ошибка контракта
|
||||
}
|
||||
|
||||
// Каждый ответ, включая ошибки и health, несёт X-Request-Id и X-Instance-Id.
|
||||
function handle(req: IncomingMessage, res: ServerResponse) {
|
||||
const requestId = randomUUID();
|
||||
res.setHeader('X-Request-Id', requestId);
|
||||
res.setHeader('X-Instance-Id', config.instanceId);
|
||||
if (!state.ready) res.setHeader('Connection', 'close'); // при остановке LB не переиспользует соединение
|
||||
dispatch(req).then(([status, body, headers]) => send(res, status, body, headers), (err) => {
|
||||
const e = toHttpError(err, requestId);
|
||||
if (e.status === 401) {
|
||||
// Basic только на входе, на остальных эндпоинтах — Bearer.
|
||||
res.setHeader('WWW-Authenticate', req.url === '/api/v1/auth/sessions' ? 'Basic realm="messenger", charset="UTF-8"' : 'Bearer realm="messenger"');
|
||||
}
|
||||
send(res, e.status, { error: { code: e.code, message: e.message, request_id: requestId } });
|
||||
});
|
||||
}
|
||||
|
||||
return { state, handle };
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
// Конфигурация процесса из переменных окружения. Читается один раз при старте.
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { hostname } from 'node:os';
|
||||
|
||||
export type S3Config = {
|
||||
endpoint: string;
|
||||
region: string;
|
||||
bucket: string;
|
||||
accessKeyId: string;
|
||||
secretAccessKey: string;
|
||||
};
|
||||
|
||||
export type Config = {
|
||||
host: string;
|
||||
port: number;
|
||||
databaseUrl: string;
|
||||
dbPoolMax: number;
|
||||
sessionTtlSeconds: number;
|
||||
shutdownDrainMs: number;
|
||||
instanceId: string;
|
||||
s3: S3Config;
|
||||
maxUploadBytes: number;
|
||||
maxImagePixels: number;
|
||||
brokerUrl: string;
|
||||
jobs: JobsConfig;
|
||||
};
|
||||
|
||||
// Общие параметры заданий для API (relay, sweeper) и worker.
|
||||
export type JobsConfig = {
|
||||
pipelineVersion: number; // версия pipeline для новых загрузок
|
||||
maxAttempts: number; // попыток на job, затем failed retry_exhausted
|
||||
timeoutSeconds: number; // предел одной попытки; аренда = timeout + 15 с
|
||||
retryBaseMs: number; // backoff повтора: base × 2^(n−1), cap 60 с, jitter 50–100 %
|
||||
republishSeconds: number; // queued без живого сообщения дольше этого — опубликовать заново
|
||||
};
|
||||
|
||||
function env(name: string, def: string): string {
|
||||
return process.env[name] || def;
|
||||
}
|
||||
|
||||
export function envInt(name: string, def: number): number {
|
||||
const n = Number(env(name, String(def)));
|
||||
if (!Number.isInteger(n) || n <= 0) throw new Error(`${name} должен быть положительным целым`);
|
||||
return n;
|
||||
}
|
||||
|
||||
// Секрет берётся из файла NAME_FILE (Docker secret), иначе из NAME. Значение никогда не логируется.
|
||||
export function secret(name: string): string {
|
||||
const file = process.env[name + '_FILE'];
|
||||
const value = file ? readFileSync(file, 'utf8').trim() : process.env[name];
|
||||
if (!value) throw new Error(`нужна переменная ${name} или ${name}_FILE`);
|
||||
return value;
|
||||
}
|
||||
|
||||
// Ключи у каждого сервиса свои (api, reconciler, s3-init), compose монтирует их под одинаковыми именами.
|
||||
export function s3Config(): S3Config {
|
||||
return {
|
||||
endpoint: env('S3_ENDPOINT', 'http://s3:9000'),
|
||||
region: env('S3_REGION', 'us-east-1'),
|
||||
bucket: env('S3_BUCKET', 'messenger-attachments'),
|
||||
accessKeyId: secret('S3_ACCESS_KEY_ID'),
|
||||
secretAccessKey: secret('S3_SECRET_ACCESS_KEY'),
|
||||
};
|
||||
}
|
||||
|
||||
export function jobsConfig(): JobsConfig {
|
||||
return {
|
||||
pipelineVersion: envInt('PIPELINE_VERSION', 1),
|
||||
maxAttempts: envInt('JOB_MAX_ATTEMPTS', 5),
|
||||
timeoutSeconds: envInt('JOB_TIMEOUT_SECONDS', 60),
|
||||
retryBaseMs: envInt('JOB_RETRY_BASE_MS', 2000),
|
||||
republishSeconds: envInt('JOB_REPUBLISH_SECONDS', 600),
|
||||
};
|
||||
}
|
||||
|
||||
export function loadConfig(): Config {
|
||||
return {
|
||||
host: env('APP_HOST', '0.0.0.0'),
|
||||
port: envInt('APP_PORT', 8080),
|
||||
databaseUrl: secret('DATABASE_URL'),
|
||||
dbPoolMax: envInt('DB_POOL_MAX', 8),
|
||||
sessionTtlSeconds: envInt('SESSION_TTL_SECONDS', 3600),
|
||||
// Пауза между отказом readiness и закрытием сервера: должна быть больше времени обнаружения LB (fall × inter).
|
||||
shutdownDrainMs: envInt('SHUTDOWN_DRAIN_MS', 2500),
|
||||
// X-Instance-Id = hostname контейнера (12 символов ID), по нему scripts/stop-one.sh находит реплику.
|
||||
instanceId: env('INSTANCE_ID', hostname()),
|
||||
s3: s3Config(),
|
||||
maxUploadBytes: envInt('MAX_UPLOAD_BYTES', 10485760),
|
||||
maxImagePixels: envInt('MAX_IMAGE_PIXELS', 40000000),
|
||||
brokerUrl: secret('BROKER_URL'),
|
||||
jobs: jobsConfig(),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
// Доступ к PostgreSQL: пул соединений для API и однократный прогон миграций.
|
||||
import { readFileSync, readdirSync } from 'node:fs';
|
||||
import pg from 'pg';
|
||||
|
||||
export function createPool(databaseUrl: string, max: number): pg.Pool {
|
||||
const pool = new pg.Pool({
|
||||
connectionString: databaseUrl,
|
||||
max,
|
||||
connectionTimeoutMillis: 2000, // пул исчерпан или БД недоступна → 503, а не зависший запрос
|
||||
statement_timeout: 5000,
|
||||
});
|
||||
// Ошибка простаивающего соединения (например, рестарт PostgreSQL) не должна ронять процесс.
|
||||
pool.on('error', (err) => console.error('ошибка соединения с БД:', err.message));
|
||||
return pool;
|
||||
}
|
||||
|
||||
// Применяет src/migrations/*.sql по порядку, каждую в своей транзакции и ровно один раз.
|
||||
// Advisory lock не даёт двум запускам выполнить DDL одновременно.
|
||||
export async function migrate(databaseUrl: string): Promise<void> {
|
||||
const client = new pg.Client({ connectionString: databaseUrl });
|
||||
await client.connect();
|
||||
try {
|
||||
await client.query('SELECT pg_advisory_lock(3003)');
|
||||
await client.query('CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())');
|
||||
const dir = new URL('./migrations/', import.meta.url);
|
||||
for (const file of readdirSync(dir).filter((f) => f.endsWith('.sql')).sort()) {
|
||||
const done = await client.query('SELECT 1 FROM schema_migrations WHERE version = $1', [file]);
|
||||
if (done.rowCount) continue;
|
||||
await client.query('BEGIN');
|
||||
try {
|
||||
await client.query(readFileSync(new URL(file, dir), 'utf8'));
|
||||
await client.query('INSERT INTO schema_migrations (version) VALUES ($1)', [file]);
|
||||
await client.query('COMMIT');
|
||||
} catch (err) {
|
||||
await client.query('ROLLBACK');
|
||||
throw err;
|
||||
}
|
||||
console.log(`применена миграция ${file}`);
|
||||
}
|
||||
console.log('схема актуальна');
|
||||
} finally {
|
||||
await client.end();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Точки внедрения отказов для тестов (трек 2 и уровень 4). Выключены, пока FAILPOINTS не равно 1.
|
||||
// Срабатывает только для вложения с именем файла failpoint-<точка>[-<N>s].png и ровно один раз на вложение
|
||||
// (отметка в failpoint_hits), поэтому перезапущенный процесс доделывает работу, а не падает по кругу.
|
||||
// failpoint-<точка>.png — немедленный выход с кодом 137: ни finally, ни ack, ни ROLLBACK — соединения с БД
|
||||
// и брокером рвёт ядро, как при реальном падении. Не SIGKILL себе: node в контейнере —
|
||||
// PID 1, а сигналы без обработчика, посланные init изнутри его namespace, ядро игнорирует;
|
||||
// failpoint-<точка>-<N>s.png — пауза N секунд: процесс жив, но «завис» (проверка аренды и fencing).
|
||||
// Точки: api_after_staging, api_after_commit, relay_after_publish, worker_after_claim, worker_after_side_effect,
|
||||
// worker_after_commit.
|
||||
import { setTimeout as sleep } from 'node:timers/promises';
|
||||
import type { Pool } from 'pg';
|
||||
|
||||
const enabled = process.env.FAILPOINTS === '1';
|
||||
|
||||
export async function failpoint(db: Pool, name: string, attachmentId: string, filename: string): Promise<void> {
|
||||
const m = enabled ? /^failpoint-([a-z_]+)(?:-(\d+)s)?\.png$/.exec(filename) : null;
|
||||
if (!m || m[1] !== name) return;
|
||||
const hit = await db.query('INSERT INTO failpoint_hits (name, attachment_id) VALUES ($1, $2) ON CONFLICT DO NOTHING', [name, attachmentId]);
|
||||
if (!hit.rowCount) return;
|
||||
if (m[2]) {
|
||||
console.error(`failpoint ${name}: пауза ${m[2]} с`);
|
||||
await sleep(Number(m[2]) * 1000);
|
||||
return;
|
||||
}
|
||||
console.error(`failpoint ${name}: аварийное завершение процесса`);
|
||||
process.exit(137);
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
// Общие типы обработчиков: контекст запроса и результат.
|
||||
import type { IncomingMessage, OutgoingHttpHeaders } from 'node:http';
|
||||
import type { Pool } from 'pg';
|
||||
import type { Config } from '../config.ts';
|
||||
import type { Storage } from '../storage/s3.ts';
|
||||
|
||||
export type Ctx = {
|
||||
req: IncomingMessage;
|
||||
url: URL;
|
||||
params: string[]; // группы из шаблона маршрута, например chat_id
|
||||
db: Pool;
|
||||
s3: Storage;
|
||||
config: Config;
|
||||
relay: { kick(): void }; // разбудить публикацию outbox сразу после COMMIT
|
||||
};
|
||||
|
||||
// [HTTP-статус, JSON-тело или поток байтов, заголовки потока]; без тела — ответ без содержимого (204).
|
||||
export type Result = [status: number, body?: unknown, headers?: OutgoingHttpHeaders];
|
||||
|
||||
export type Handler = (c: Ctx) => Promise<Result>;
|
||||
@@ -0,0 +1,31 @@
|
||||
// Ошибки API в формате контракта: {"error":{"code","message","request_id"}}.
|
||||
|
||||
export class HttpError extends Error {
|
||||
status: number;
|
||||
code: string;
|
||||
constructor(status: number, code: string, message: string) {
|
||||
super(message);
|
||||
this.status = status;
|
||||
this.code = code;
|
||||
}
|
||||
}
|
||||
|
||||
export const badRequest = (message: string) => new HttpError(400, 'invalid_request', message);
|
||||
export const unauthorized = () => new HttpError(401, 'unauthorized', 'Требуется действительная сессия');
|
||||
// 404 и для отсутствующего, и для чужого объекта: не раскрываем факт существования.
|
||||
export const notFound = () => new HttpError(404, 'not_found', 'Объект не найден');
|
||||
export const conflict = (message: string) => new HttpError(409, 'conflict', message);
|
||||
export const unavailable = (message: string) => new HttpError(503, 'unavailable', message);
|
||||
export const tooLarge = (message: string) => new HttpError(413, 'payload_too_large', message);
|
||||
export const unsupported = (message: string) => new HttpError(415, 'unsupported_media_type', message);
|
||||
|
||||
// Неизвестную ошибку переводим в ответ без внутренних деталей.
|
||||
// Ошибка SQL — наш баг (500). Потеря соединения, таймаут пула, рестарт или отмена в PostgreSQL —
|
||||
// временная недоступность зависимости (503): клиент может повторить запрос.
|
||||
export function toHttpError(err: unknown, requestId: string): HttpError {
|
||||
if (err instanceof HttpError) return err;
|
||||
const { code = '', message = '' } = err as { code?: string; message?: string };
|
||||
console.error(`запрос ${requestId}: ${code} ${message}`);
|
||||
const transient = /^(08|53|57)/.test(code) || /^E[A-Z]+$/.test(code) || /connect|terminated|timeout/i.test(message);
|
||||
return transient ? unavailable('Сервис временно недоступен') : new HttpError(500, 'internal_error', 'Внутренняя ошибка');
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
// Keyset-пагинация по (created_at, id) по возрастанию.
|
||||
// Cursor непрозрачен для клиента: base64url("вид|область|created_at|id").
|
||||
// Область привязывает cursor к конкретному чату (или пользователю для списка чатов): чужой cursor → 400.
|
||||
import { badRequest } from './errors.ts';
|
||||
import { UUID } from './request.ts';
|
||||
|
||||
const TIMESTAMP = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{6}Z$/;
|
||||
|
||||
type Keyed = { created_at: string; id: string };
|
||||
|
||||
export function limitOf(url: URL): number {
|
||||
const q = url.searchParams.get('limit');
|
||||
if (q === null) return 50;
|
||||
const n = Number(q);
|
||||
if (!/^\d+$/.test(q) || n < 1 || n > 100) throw badRequest('limit должен быть целым 1–100');
|
||||
return n;
|
||||
}
|
||||
|
||||
// Позиция, после которой продолжать чтение. Без cursor — начало истории.
|
||||
export function afterCursor(url: URL, kind: string, scope: string): [createdAt: string, id: string] {
|
||||
const raw = url.searchParams.get('cursor');
|
||||
if (raw === null) return ['-infinity', '00000000-0000-0000-0000-000000000000'];
|
||||
const [k, s, ts, id, ...rest] = Buffer.from(raw, 'base64url').toString().split('|');
|
||||
if (k !== kind || s !== scope || !isTimestamp(ts) || !UUID.test(id ?? '') || rest.length) {
|
||||
throw badRequest('Некорректный cursor');
|
||||
}
|
||||
return [ts, id];
|
||||
}
|
||||
|
||||
// Форма RFC 3339 и реальная дата: 2026-13-01 или 2026-02-30 иначе дошли бы до PostgreSQL и дали 500.
|
||||
// Проверка круговым преобразованием: JS-дата без микросекунд должна совпасть с исходной строкой.
|
||||
function isTimestamp(ts: string | undefined): ts is string {
|
||||
if (!ts || !TIMESTAMP.test(ts)) return false;
|
||||
const ms = Date.parse(ts.slice(0, 23) + 'Z');
|
||||
return !Number.isNaN(ms) && new Date(ms).toISOString().slice(0, 23) === ts.slice(0, 23);
|
||||
}
|
||||
|
||||
// Запрос выбирает limit + 1 строк: лишняя строка означает, что следующая страница есть.
|
||||
export function page<T extends Keyed>(rows: T[], limit: number, kind: string, scope: string) {
|
||||
const items = rows.slice(0, limit);
|
||||
const last = items[limit - 1];
|
||||
const next = rows.length > limit ? Buffer.from([kind, scope, last.created_at, last.id].join('|')).toString('base64url') : null;
|
||||
return { items, next_cursor: next };
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
// Разбор и проверка входных данных запроса.
|
||||
import type { IncomingMessage } from 'node:http';
|
||||
import { badRequest, tooLarge, unsupported } from './errors.ts';
|
||||
|
||||
const BODY_LIMIT = 1 << 20; // 1 MiB: с запасом для 4000 символов в худшем JSON-экранировании
|
||||
export const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
|
||||
|
||||
// Тело запроса как JSON: только application/json, строгий UTF-8, ограничение размера.
|
||||
export async function readJson(req: IncomingMessage): Promise<unknown> {
|
||||
if (mediaType(req) !== 'application/json') throw unsupported('Ожидается application/json');
|
||||
const chunks: Buffer[] = [];
|
||||
let size = 0;
|
||||
for await (const chunk of req) {
|
||||
size += chunk.length;
|
||||
if (size > BODY_LIMIT) throw tooLarge('Слишком большое тело запроса');
|
||||
chunks.push(chunk);
|
||||
}
|
||||
try {
|
||||
return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
|
||||
} catch {
|
||||
throw badRequest('Некорректный JSON');
|
||||
}
|
||||
}
|
||||
|
||||
// Тип тела без параметров (charset и т.п.), в нижнем регистре.
|
||||
export function mediaType(req: IncomingMessage): string {
|
||||
return (req.headers['content-type'] ?? '').split(';')[0].trim().toLowerCase();
|
||||
}
|
||||
|
||||
// Для эндпоинтов без тела: любое непустое тело — 400, а не молча игнорируется.
|
||||
export async function requireEmptyBody(req: IncomingMessage): Promise<void> {
|
||||
let size = 0;
|
||||
for await (const chunk of req) {
|
||||
size += chunk.length;
|
||||
if (size > BODY_LIMIT) break;
|
||||
}
|
||||
if (size > 0) throw badRequest('Тело запроса не допускается');
|
||||
}
|
||||
|
||||
// JSON-объект только с разрешёнными ключами: лишние поля по контракту дают 400.
|
||||
export function jsonObject(value: unknown, keys: string[]): Record<string, unknown> {
|
||||
if (typeof value !== 'object' || value === null || Array.isArray(value) || Object.keys(value).some((k) => !keys.includes(k))) {
|
||||
throw badRequest('Ожидается JSON-объект без лишних полей');
|
||||
}
|
||||
return value as Record<string, unknown>;
|
||||
}
|
||||
|
||||
// Обязательная строка: не только пробелы, длина в Unicode code points (эмодзи = 1 символ).
|
||||
export function isText(v: unknown, min: number, max: number): v is string {
|
||||
if (typeof v !== 'string' || v.trim() === '') return false;
|
||||
const n = [...v].length;
|
||||
return n >= min && n <= max;
|
||||
}
|
||||
|
||||
// UUID из пути в каноническом нижнем регистре.
|
||||
export function uuidParam(c: { params: string[] }, name: string): string {
|
||||
const value = c.params[0];
|
||||
if (!UUID.test(value)) throw badRequest(`Некорректный ${name}`);
|
||||
return value.toLowerCase();
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
// Операторские команды над заданиями (выполняются в контейнере api: docker compose exec api node src/main.ts …).
|
||||
// failed — реестр failed (аналог DLQ): job, вложение, код ошибки, попытки
|
||||
// replay <attachment_id> — failed → queued: новая попытка той же логической job с аудитом;
|
||||
// для done/queued/processing — отказ (повтор не дублирует успешную работу)
|
||||
// reprocess --version=N — поставить job версии N для ready-вложений с более старой версией (трек 5);
|
||||
// вложения в работе не затрагиваются — после разбора очереди команду повторяют
|
||||
// show <attachment_id> — вложение, его jobs, попытки в outbox (время следующей), replay-аудит, варианты
|
||||
import type { Pool } from 'pg';
|
||||
import { UUID } from '../http/request.ts';
|
||||
|
||||
export async function adminCommand(db: Pool, args: string[]): Promise<void> {
|
||||
const [cmd, arg] = args;
|
||||
if (cmd === 'failed') {
|
||||
const r = await db.query(`SELECT j.job_id, j.attachment_id, j.pipeline_version, j.attempts, j.error_code, rfc3339(j.updated_at) AS failed_at
|
||||
FROM jobs j WHERE j.state = 'failed' ORDER BY j.updated_at`);
|
||||
for (const row of r.rows) console.log(JSON.stringify(row));
|
||||
console.log(JSON.stringify({ failed: r.rowCount }));
|
||||
} else if (cmd === 'replay') {
|
||||
if (!UUID.test(arg ?? '')) throw new Error('replay <attachment_id>');
|
||||
console.log(JSON.stringify(await replay(db, arg.toLowerCase())));
|
||||
} else if (cmd === 'reprocess') {
|
||||
const version = Number(args.find((a) => a.startsWith('--version='))?.split('=')[1]);
|
||||
if (!Number.isInteger(version) || version < 1) throw new Error('reprocess --version=N');
|
||||
const r = await db.query(`WITH j AS (
|
||||
INSERT INTO jobs (job_id, attachment_id, pipeline_version)
|
||||
SELECT gen_random_uuid(), a.id, $1 FROM attachments a WHERE a.state = 'ready' AND a.pipeline_version < $1
|
||||
ON CONFLICT (attachment_id, pipeline_version) DO NOTHING RETURNING job_id)
|
||||
INSERT INTO outbox (job_id, attempt) SELECT job_id, 1 FROM j`, [version]);
|
||||
console.log(JSON.stringify({ reprocess_version: version, enqueued: r.rowCount }));
|
||||
} else if (cmd === 'show') {
|
||||
if (!UUID.test(arg ?? '')) throw new Error('show <attachment_id>');
|
||||
const q = async (sql: string) => (await db.query(sql, [arg.toLowerCase()])).rows;
|
||||
console.log(JSON.stringify({
|
||||
attachment: (await q(`SELECT id, state, pipeline_version, error_code, staging_key IS NOT NULL AS has_staging
|
||||
FROM attachments WHERE id = $1`))[0] ?? null,
|
||||
jobs: await q(`SELECT job_id, pipeline_version, state, attempts, error_code, rfc3339(lease_until) AS lease_until
|
||||
FROM jobs WHERE attachment_id = $1 ORDER BY pipeline_version`),
|
||||
outbox: await q(`SELECT j.pipeline_version, o.attempt, rfc3339(o.available_at) AS available_at, rfc3339(o.published_at) AS published_at
|
||||
FROM outbox o JOIN jobs j ON j.job_id = o.job_id WHERE j.attachment_id = $1 ORDER BY o.id`),
|
||||
replays: await q(`SELECT r.previous_error, r.previous_attempts, rfc3339(r.replayed_at) AS replayed_at
|
||||
FROM job_replays r JOIN jobs j ON j.job_id = r.job_id WHERE j.attachment_id = $1 ORDER BY r.replayed_at`),
|
||||
variants: await q(`SELECT pipeline_version, name, width, height, size_bytes, left(sha256, 12) AS sha256
|
||||
FROM attachment_variants WHERE attachment_id = $1 ORDER BY pipeline_version, name`),
|
||||
}));
|
||||
} else {
|
||||
throw new Error('jobs failed | replay <attachment_id> | reprocess --version=N | show <attachment_id>');
|
||||
}
|
||||
}
|
||||
|
||||
async function replay(db: Pool, attachmentId: string) {
|
||||
const client = await db.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
const j = (await client.query(`SELECT j.job_id, j.state, j.attempts, j.error_code, a.pipeline_version IS NULL AS initial
|
||||
FROM jobs j JOIN attachments a ON a.id = j.attachment_id
|
||||
WHERE j.attachment_id = $1 ORDER BY j.pipeline_version DESC LIMIT 1 FOR UPDATE OF j`, [attachmentId])).rows[0];
|
||||
if (!j) throw new Error('у вложения нет заданий');
|
||||
if (j.state !== 'failed') {
|
||||
await client.query('ROLLBACK');
|
||||
return { replayed: false, reason: `job в состоянии ${j.state}: повтор не нужен` };
|
||||
}
|
||||
// Staging failed-вложения хранится STAGING_RETENTION_SECONDS; после очистки повторять нечего.
|
||||
if (j.initial) {
|
||||
const s = await client.query(`SELECT 1 FROM attachments WHERE id = $1 AND staging_key IS NOT NULL`, [attachmentId]);
|
||||
if (!s.rowCount) throw new Error('исходник недоступен');
|
||||
}
|
||||
await client.query('INSERT INTO job_replays (job_id, previous_error, previous_attempts) VALUES ($1, $2, $3)', [j.job_id, j.error_code, j.attempts]);
|
||||
// Новая серия попыток той же логической job: прежний эффект защищён ключом (attachment_id, version, name).
|
||||
await client.query(`UPDATE jobs SET state = 'queued', attempts = 0, error_code = NULL, updated_at = clock_timestamp() WHERE job_id = $1`, [j.job_id]);
|
||||
await client.query('INSERT INTO outbox (job_id, attempt) VALUES ($1, 1)', [j.job_id]);
|
||||
if (j.initial) {
|
||||
await client.query(`UPDATE attachments SET state = 'queued', error_code = NULL, updated_at = clock_timestamp() WHERE id = $1 AND state = 'failed'`, [attachmentId]);
|
||||
}
|
||||
await client.query('COMMIT');
|
||||
return { replayed: true, job_id: j.job_id, previous_error: j.error_code, previous_attempts: j.attempts };
|
||||
} catch (err) {
|
||||
await client.query('ROLLBACK').catch(() => {});
|
||||
throw err;
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
// RabbitMQ: формат сообщения job (contracts/jobs.schema.json), публикация с publisher confirm.
|
||||
// Топология (exchange attachments → quorum-очередь attachments.process) и пользователи создаются из
|
||||
// definitions при старте брокера (scripts/init-secrets.sh); у API право только писать в exchange.
|
||||
import amqp, { type ChannelModel, type ConfirmChannel } from 'amqplib';
|
||||
import { UUID } from '../http/request.ts';
|
||||
|
||||
export const EXCHANGE = 'attachments';
|
||||
export const ROUTING_KEY = 'process';
|
||||
export const QUEUE = 'attachments.process';
|
||||
|
||||
// В сообщении только идентификаторы: ни байтов, ни ключей S3, ни credentials. Worker берёт данные из БД.
|
||||
export type Job = {
|
||||
schema_version: 1;
|
||||
job_id: string;
|
||||
type: 'attachment.process.v1';
|
||||
attachment_id: string;
|
||||
pipeline_version: number;
|
||||
attempt: number;
|
||||
created_at: string;
|
||||
};
|
||||
|
||||
// Проверка входящего сообщения по jobs.schema.json; null — сообщение не по контракту.
|
||||
export function parseJob(content: Buffer): Job | null {
|
||||
let j: Record<string, unknown>;
|
||||
try {
|
||||
j = JSON.parse(content.toString('utf8'));
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
const keys = ['schema_version', 'job_id', 'type', 'attachment_id', 'pipeline_version', 'attempt', 'created_at', 'traceparent', 'tracestate'];
|
||||
const ok = typeof j === 'object' && j !== null && Object.keys(j).every((k) => keys.includes(k))
|
||||
&& j.schema_version === 1 && j.type === 'attachment.process.v1'
|
||||
&& typeof j.job_id === 'string' && UUID.test(j.job_id) && typeof j.attachment_id === 'string' && UUID.test(j.attachment_id)
|
||||
&& Number.isInteger(j.pipeline_version) && (j.pipeline_version as number) >= 1
|
||||
&& Number.isInteger(j.attempt) && (j.attempt as number) >= 1
|
||||
&& typeof j.created_at === 'string' && !Number.isNaN(Date.parse(j.created_at));
|
||||
return ok ? (j as unknown as Job) : null;
|
||||
}
|
||||
|
||||
export type Publisher = { publish(jobs: Job[]): Promise<void> };
|
||||
|
||||
// Ленивое соединение: брокер может быть недоступен — тогда publish бросает ошибку, а задания остаются в outbox.
|
||||
export function createPublisher(url: string): Publisher {
|
||||
let channel: Promise<ConfirmChannel> | null = null;
|
||||
let conn: ChannelModel | null = null;
|
||||
const open = async () => {
|
||||
conn = await amqp.connect(url, { timeout: 2000 });
|
||||
const reset = () => { channel = null; };
|
||||
conn.on('error', reset);
|
||||
conn.on('close', reset);
|
||||
const ch = await conn.createConfirmChannel();
|
||||
ch.on('error', reset);
|
||||
ch.on('close', reset);
|
||||
// mandatory + return: сообщение без маршрута (сломана топология) не исчезает молча.
|
||||
ch.on('return', (m) => console.error(`брокер вернул неотмаршрутизированное сообщение ${m.properties.messageId}`));
|
||||
return ch;
|
||||
};
|
||||
return {
|
||||
async publish(jobs) {
|
||||
channel ??= open().catch((err) => { channel = null; throw err; });
|
||||
const ch = await channel;
|
||||
for (const job of jobs) {
|
||||
ch.publish(EXCHANGE, ROUTING_KEY, Buffer.from(JSON.stringify(job)), {
|
||||
persistent: true, mandatory: true, contentType: 'application/json', messageId: `${job.job_id}:${job.attempt}`,
|
||||
});
|
||||
}
|
||||
// Publisher confirm: брокер записал сообщения в quorum-очередь (на диск). Только после этого outbox отмечается.
|
||||
// Зависший брокер не держит транзакцию relay вечно: через 5 с соединение закрывается, строки остаются в outbox.
|
||||
let timer: NodeJS.Timeout | undefined;
|
||||
const timeout = new Promise<never>((_, reject) => {
|
||||
timer = setTimeout(() => {
|
||||
channel = null;
|
||||
conn?.close().catch(() => {});
|
||||
reject(new Error('нет publisher confirm за 5 с'));
|
||||
}, 5000);
|
||||
});
|
||||
try {
|
||||
await Promise.race([ch.waitForConfirms(), timeout]);
|
||||
} finally {
|
||||
clearTimeout(timer);
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
// Relay transactional outbox → RabbitMQ и восстановление зависшей работы. Работает в каждой реплике API.
|
||||
// publishDue: строки outbox, у которых наступил available_at, блокируются FOR UPDATE SKIP LOCKED (две реплики
|
||||
// не публикуют одну строку одновременно), публикуются с publisher confirm и только потом отмечаются.
|
||||
// Падение после confirm, но до отметки → повторная публикация → дубль, который worker распознаёт по job.
|
||||
// sweep: истёкшая аренда (worker умер/завис) → новая попытка или failed retry_exhausted; queued без живого
|
||||
// сообщения (потеряно брокером, отброшено delivery-limit) → публикуется снова. Источник истины — БД.
|
||||
import type { Pool, PoolClient } from 'pg';
|
||||
import type { JobsConfig } from '../config.ts';
|
||||
import { failpoint } from '../failpoints.ts';
|
||||
import type { Job, Publisher } from './broker.ts';
|
||||
|
||||
const BATCH = 100;
|
||||
|
||||
export function startRelay(db: Pool, publisher: Publisher, cfg: JobsConfig) {
|
||||
let busy = false;
|
||||
let again = false;
|
||||
let failing = false; // лог ошибки брокера один раз на серию, а не каждые 500 мс
|
||||
|
||||
async function publishBatch(client: PoolClient): Promise<number> {
|
||||
const r = await client.query(`SELECT o.id, o.attempt, rfc3339(o.created_at) AS created_at, j.job_id, j.attachment_id, j.pipeline_version, a.filename
|
||||
FROM outbox o JOIN jobs j ON j.job_id = o.job_id JOIN attachments a ON a.id = j.attachment_id
|
||||
WHERE o.published_at IS NULL AND o.available_at <= clock_timestamp()
|
||||
ORDER BY o.id LIMIT ${BATCH} FOR UPDATE OF o SKIP LOCKED`);
|
||||
if (!r.rowCount) return 0;
|
||||
const jobs: Job[] = r.rows.map((row) => ({
|
||||
schema_version: 1, job_id: row.job_id, type: 'attachment.process.v1', attachment_id: row.attachment_id,
|
||||
pipeline_version: row.pipeline_version, attempt: row.attempt, created_at: row.created_at,
|
||||
}));
|
||||
await publisher.publish(jobs);
|
||||
for (const row of r.rows) await failpoint(db, 'relay_after_publish', row.attachment_id, row.filename);
|
||||
await client.query('UPDATE outbox SET published_at = clock_timestamp() WHERE id = ANY($1::bigint[])', [r.rows.map((row) => row.id)]);
|
||||
return r.rows.length;
|
||||
}
|
||||
|
||||
async function publishDue(): Promise<void> {
|
||||
if (busy) {
|
||||
again = true;
|
||||
return;
|
||||
}
|
||||
busy = true;
|
||||
try {
|
||||
do {
|
||||
again = false;
|
||||
const client = await db.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
const n = await publishBatch(client);
|
||||
await client.query('COMMIT');
|
||||
if (failing) console.log('relay: публикация восстановлена');
|
||||
failing = false;
|
||||
if (n === BATCH) again = true;
|
||||
} catch (err) {
|
||||
await client.query('ROLLBACK').catch(() => {});
|
||||
if (!failing) console.error(`relay: публикация отложена, задания ждут в outbox: ${(err as Error).message}`);
|
||||
failing = true;
|
||||
again = false;
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
} while (again);
|
||||
} catch (err) {
|
||||
if (!failing) console.error(`relay: нет соединения с БД: ${(err as Error).message}`);
|
||||
failing = true;
|
||||
} finally {
|
||||
busy = false;
|
||||
}
|
||||
}
|
||||
|
||||
async function sweep(): Promise<void> {
|
||||
let client: PoolClient | undefined;
|
||||
try {
|
||||
client = await db.connect();
|
||||
await client.query('BEGIN');
|
||||
// Одна реплика за раз: остальные пропускают такт.
|
||||
if ((await client.query('SELECT pg_try_advisory_xact_lock(5005) AS ok')).rows[0].ok) {
|
||||
const r = await client.query(`WITH e AS (
|
||||
UPDATE jobs SET state = CASE WHEN attempts >= $1 THEN 'failed' ELSE 'queued' END,
|
||||
error_code = CASE WHEN attempts >= $1 THEN 'retry_exhausted' END,
|
||||
lease_token = NULL, lease_until = NULL, updated_at = clock_timestamp()
|
||||
WHERE state = 'processing' AND lease_until < clock_timestamp()
|
||||
RETURNING job_id, attachment_id, state, attempts, error_code),
|
||||
s AS (UPDATE attachments a SET state = e.state, error_code = e.error_code, updated_at = clock_timestamp() FROM e
|
||||
WHERE a.id = e.attachment_id AND a.pipeline_version IS NULL AND a.state IN ('queued', 'processing')),
|
||||
o AS (INSERT INTO outbox (job_id, attempt) SELECT job_id, attempts + 1 FROM e WHERE state = 'queued')
|
||||
SELECT count(*) FILTER (WHERE state = 'queued')::int AS requeued, count(*) FILTER (WHERE state = 'failed')::int AS failed FROM e`,
|
||||
[cfg.maxAttempts]);
|
||||
const stale = await client.query(`INSERT INTO outbox (job_id, attempt)
|
||||
SELECT j.job_id, j.attempts + 1 FROM jobs j
|
||||
WHERE j.state = 'queued' AND NOT EXISTS (SELECT 1 FROM outbox o WHERE o.job_id = j.job_id
|
||||
AND (o.published_at IS NULL OR o.published_at > clock_timestamp() - make_interval(secs => $1)))`, [cfg.republishSeconds]);
|
||||
const { requeued, failed } = r.rows[0];
|
||||
if (requeued || failed || stale.rowCount) {
|
||||
console.log(`sweeper: аренда истекла — повтор ${requeued}, failed ${failed}; переопубликовано queued ${stale.rowCount}`);
|
||||
}
|
||||
}
|
||||
await client.query('COMMIT');
|
||||
} catch (err) {
|
||||
await client?.query('ROLLBACK').catch(() => {});
|
||||
console.error(`sweeper: ${(err as Error).message}`);
|
||||
} finally {
|
||||
client?.release();
|
||||
}
|
||||
if (!failing) void publishDue();
|
||||
}
|
||||
|
||||
const timers = [setInterval(publishDue, 500), setInterval(sweep, 5000)];
|
||||
return {
|
||||
kick: () => void publishDue(),
|
||||
stop: () => timers.forEach(clearInterval),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
// Варианты изображения (libvips через sharp). Параметры зависят от версии pipeline; результат версии N
|
||||
// всегда один и тот же набор: thumbnail, crop, optimized.
|
||||
// thumbnail — JPEG, вписан в 256×256 без увеличения, EXIF orientation применяется, alpha на белом,
|
||||
// размеры округляются вниз (не меньше 1 px): 320×200 → 256×160;
|
||||
// crop — JPEG, центрированный квадрат 128×128 (маленький исходник увеличивается);
|
||||
// optimized — WebP, вписан в 1280×1280 без увеличения; метаданные (EXIF/XMP/ICC) не копируются — sharp
|
||||
// по умолчанию их отбрасывает, цвета приводятся к sRGB.
|
||||
// Ограничения: пиксели проверяются по заголовку до декодирования (limitInputPixels), время — timeout libvips,
|
||||
// память — один поток libvips на процесс, без кэша операций, и лимит памяти контейнера worker.
|
||||
import { createHash } from 'node:crypto';
|
||||
import sharp, { type Sharp } from 'sharp';
|
||||
|
||||
sharp.cache(false);
|
||||
sharp.concurrency(1);
|
||||
|
||||
export class PermanentError extends Error {
|
||||
code: string;
|
||||
constructor(code: string, message: string) {
|
||||
super(message);
|
||||
this.code = code;
|
||||
}
|
||||
}
|
||||
|
||||
// Версия 2 (трек 5): другое качество и лёгкая резкость — заметно иной результат той же логической работы.
|
||||
const PIPELINES: Record<number, { jpeg: number; webp: number; sharpen: boolean }> = {
|
||||
1: { jpeg: 82, webp: 80, sharpen: false },
|
||||
2: { jpeg: 90, webp: 85, sharpen: true },
|
||||
};
|
||||
export const SUPPORTED_VERSIONS = Object.keys(PIPELINES).map(Number);
|
||||
|
||||
export type Rendered = {
|
||||
name: 'thumbnail' | 'crop' | 'optimized';
|
||||
content_type: 'image/jpeg' | 'image/webp';
|
||||
ext: string;
|
||||
data: Buffer;
|
||||
width: number;
|
||||
height: number;
|
||||
size_bytes: number;
|
||||
sha256: string;
|
||||
};
|
||||
|
||||
export async function render(source: Buffer, version: number, maxPixels: number, timeoutSeconds: number): Promise<Rendered[]> {
|
||||
const p = PIPELINES[version];
|
||||
if (!p) throw new PermanentError('unsupported_pipeline', `pipeline v${version} не поддерживается`);
|
||||
const input = () => sharp(source, { limitInputPixels: maxPixels, sequentialRead: true }).timeout({ seconds: timeoutSeconds });
|
||||
try {
|
||||
const meta = await input().metadata();
|
||||
if (!meta.width || !meta.height || !['png', 'jpeg'].includes(meta.format ?? '')) throw new PermanentError('invalid_image', 'не PNG/JPEG');
|
||||
const turned = (meta.orientation ?? 1) >= 5; // EXIF 5–8: после поворота ширина и высота меняются местами
|
||||
const width = turned ? meta.height : meta.width;
|
||||
const height = turned ? meta.width : meta.height;
|
||||
const inside = (box: number) => {
|
||||
const k = Math.min(box / width, box / height, 1);
|
||||
return [Math.max(1, Math.floor(width * k)), Math.max(1, Math.floor(height * k))];
|
||||
};
|
||||
const [tw, th] = inside(256);
|
||||
const [ow, oh] = inside(1280);
|
||||
const oriented = () => {
|
||||
const img = input().autoOrient();
|
||||
return p.sharpen ? img.sharpen() : img;
|
||||
};
|
||||
return [
|
||||
await output('thumbnail', oriented().flatten({ background: '#ffffff' }).resize(tw, th, { fit: 'fill' }).jpeg({ quality: p.jpeg, mozjpeg: true })),
|
||||
await output('crop', oriented().flatten({ background: '#ffffff' }).resize(128, 128, { fit: 'cover', position: 'centre' }).jpeg({ quality: p.jpeg, mozjpeg: true })),
|
||||
await output('optimized', oriented().resize(ow, oh, { fit: 'fill' }).webp({ quality: p.webp, effort: 4 })),
|
||||
];
|
||||
} catch (err) {
|
||||
if (err instanceof PermanentError) throw err;
|
||||
const message = (err as Error).message ?? '';
|
||||
// Ошибки libvips — свойство входного файла: повтор не поможет.
|
||||
throw /timeout/i.test(message)
|
||||
? new PermanentError('processing_timeout', 'обработка дольше лимита')
|
||||
: new PermanentError('invalid_image', message.split('\n')[0].slice(0, 200));
|
||||
}
|
||||
}
|
||||
|
||||
async function output(name: Rendered['name'], img: Sharp): Promise<Rendered> {
|
||||
const { data, info } = await img.toBuffer({ resolveWithObject: true });
|
||||
const webp = info.format === 'webp';
|
||||
return {
|
||||
name, content_type: webp ? 'image/webp' : 'image/jpeg', ext: webp ? 'webp' : 'jpg', data,
|
||||
width: info.width, height: info.height, size_bytes: data.length, sha256: createHash('sha256').update(data).digest('hex'),
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,270 @@
|
||||
// Worker: отдельный процесс, читает quorum-очередь attachments.process (at least once, ручной ack).
|
||||
// Порядок одной попытки — каждое окно отказа безопасно:
|
||||
// 1. захват: jobs queued → processing, attempts+1, аренда с fencing-токеном (одна транзакция);
|
||||
// 2. исходник из S3 (ключ — из БД, не из сообщения), сверка размера и SHA-256 с метаданными;
|
||||
// 3. рендер вариантов; запись объектов под ключами с токеном попытки; копия оригинала staging → originals;
|
||||
// 4. фиксация (одна транзакция): job done только у владельца аренды, вложение ready только если более новая
|
||||
// версия ещё не опубликована, строки вариантов по ключу эффекта (attachment_id, pipeline_version, name);
|
||||
// 5. удаление staging, затем ack.
|
||||
// Падение до 4 — аренда истечёт, sweeper (relay) вернёт работу в очередь; чужие объекты попытки уберёт
|
||||
// reconciler. Падение после 4 — redelivery видит job done и подтверждает без повторной работы.
|
||||
import { createHash, randomUUID } from 'node:crypto';
|
||||
import { setTimeout as sleep } from 'node:timers/promises';
|
||||
import amqp from 'amqplib';
|
||||
import type { Pool } from 'pg';
|
||||
import { envInt, jobsConfig, s3Config, secret } from '../config.ts';
|
||||
import { createPool } from '../db.ts';
|
||||
import { failpoint } from '../failpoints.ts';
|
||||
import { createStorage, type Storage } from '../storage/s3.ts';
|
||||
import { QUEUE, parseJob, type Job } from './broker.ts';
|
||||
import { PermanentError, render } from './render.ts';
|
||||
|
||||
type Claim = {
|
||||
job: Job;
|
||||
token: string;
|
||||
attempts: number;
|
||||
version: number;
|
||||
initial: boolean; // первая обработка (вложение ещё не ready): публикуем оригинал, синхронизируем статус
|
||||
a: { id: string; filename: string; staging_key: string; object_key: string; size_bytes: number; sha256: string };
|
||||
};
|
||||
|
||||
export async function runWorker(): Promise<void> {
|
||||
const cfg = jobsConfig();
|
||||
const concurrency = envInt('WORKER_CONCURRENCY', 2);
|
||||
const maxPixels = envInt('MAX_IMAGE_PIXELS', 40000000);
|
||||
const db = createPool(secret('DATABASE_URL'), concurrency + 2);
|
||||
const s3 = createStorage(s3Config());
|
||||
const conn = await connect(secret('BROKER_URL'));
|
||||
let stopping = false;
|
||||
// Потеря соединения или канала (в том числе consumer_timeout брокера) — выход; Docker перезапустит процесс,
|
||||
// неподтверждённые сообщения брокер отдаст снова.
|
||||
const lost = (what: string) => () => {
|
||||
if (stopping) return;
|
||||
console.error(`${what} с брокером закрыт(о)`);
|
||||
process.exit(1);
|
||||
};
|
||||
conn.on('close', lost('соединение'));
|
||||
conn.on('error', (err) => console.error(`брокер: ${err.message}`));
|
||||
const ch = await conn.createChannel();
|
||||
ch.on('close', lost('канал'));
|
||||
ch.on('error', (err) => console.error(`канал: ${err.message}`));
|
||||
await ch.prefetch(concurrency); // не больше concurrency неподтверждённых сообщений на worker
|
||||
const leaseSeconds = cfg.timeoutSeconds + 15;
|
||||
let inflight = 0;
|
||||
|
||||
const processJob = (content: Buffer) => handle(db, s3, content, { cfg, maxPixels, leaseSeconds });
|
||||
const { consumerTag } = await ch.consume(QUEUE, (msg) => {
|
||||
if (!msg) return; // очередь удалена или consumer отменён брокером
|
||||
inflight++;
|
||||
processJob(msg.content)
|
||||
.then(() => ch.ack(msg), async (err) => {
|
||||
// Сюда попадают только сбои БД/брокера вне попытки (например, БД недоступна при захвате): вернуть позже.
|
||||
console.error(`job не обработан, вернётся в очередь: ${(err as Error).message}`);
|
||||
await sleep(2000);
|
||||
ch.nack(msg, false, true);
|
||||
})
|
||||
.finally(() => { inflight--; });
|
||||
}, { noAck: false });
|
||||
console.log(`worker: очередь ${QUEUE}, prefetch ${concurrency}, попыток ${cfg.maxAttempts}, таймаут ${cfg.timeoutSeconds} с`);
|
||||
|
||||
const stop = async () => {
|
||||
console.log('SIGTERM: новые сообщения не принимаются, дожидаюсь текущих');
|
||||
await ch.cancel(consumerTag).catch(() => {});
|
||||
for (let i = 0; inflight && i < 100; i++) await sleep(100);
|
||||
stopping = true;
|
||||
await conn.close().catch(() => {});
|
||||
process.exit(0);
|
||||
};
|
||||
process.on('SIGTERM', stop);
|
||||
process.on('SIGINT', stop);
|
||||
}
|
||||
|
||||
// Брокер недоступен при старте (рестарт брокера, worker поднят раньше) — ждать с backoff, а не падать в цикле.
|
||||
async function connect(url: string) {
|
||||
for (let delay = 1000; ; delay = Math.min(delay * 2, 15000)) {
|
||||
try {
|
||||
return await amqp.connect(url, { timeout: 5000 });
|
||||
} catch (err) {
|
||||
console.error(`брокер недоступен (${(err as Error).message}), повтор через ${delay} мс`);
|
||||
await sleep(delay);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type Opts = { cfg: ReturnType<typeof jobsConfig>; maxPixels: number; leaseSeconds: number };
|
||||
|
||||
// Ошибка бизнес-уровня здесь не бросается: она переводит job в retry/failed, сообщение подтверждается.
|
||||
async function handle(db: Pool, s3: Storage, content: Buffer, o: Opts): Promise<void> {
|
||||
const job = parseJob(content);
|
||||
if (!job) {
|
||||
console.error('сообщение не по jobs.schema.json отброшено');
|
||||
return;
|
||||
}
|
||||
const claim = await claimJob(db, job, o.leaseSeconds);
|
||||
if (!claim) return;
|
||||
const written: string[] = [];
|
||||
let reason = 'storage_unavailable'; // безопасная причина временной ошибки (в jobs.error_code, без текста исключения)
|
||||
try {
|
||||
await failpoint(db, 'worker_after_claim', claim.a.id, claim.a.filename); // до любого side effect
|
||||
const source = await readSource(s3, claim);
|
||||
const variants = await render(source, claim.version, o.maxPixels, o.cfg.timeoutSeconds);
|
||||
for (const v of variants) {
|
||||
// Токен попытки в ключе: проигравшая аренду попытка не перезапишет объекты победителя.
|
||||
const key = `variants/${claim.a.id}/v${claim.version}/${v.name}-${claim.token.slice(0, 8)}.${v.ext}`;
|
||||
await s3.putBuffer(key, v.data, v.content_type);
|
||||
written.push(key);
|
||||
}
|
||||
if (claim.initial) await s3.copy(claim.a.staging_key, claim.a.object_key); // тот же ключ при повторе
|
||||
await failpoint(db, 'worker_after_side_effect', claim.a.id, claim.a.filename);
|
||||
reason = 'database_unavailable';
|
||||
const published = await commit(db, claim, variants.map((v, i) => ({ ...v, key: written[i] })));
|
||||
if (!published) {
|
||||
await removeAll(s3, written);
|
||||
return;
|
||||
}
|
||||
await failpoint(db, 'worker_after_commit', claim.a.id, claim.a.filename); // результат зафиксирован, ack ещё нет
|
||||
// Staging больше не нужен; если удаление не удалось, остаток уберёт reconciler.
|
||||
if (claim.initial) await s3.remove(claim.a.staging_key).catch((err) => console.error(`staging не удалён: ${err.message}`));
|
||||
console.log(`job ${job.job_id} v${claim.version} попытка ${claim.attempts}: ready`);
|
||||
} catch (err) {
|
||||
await removeAll(s3, written);
|
||||
await failOrRetry(db, claim, err, o.cfg, reason);
|
||||
}
|
||||
}
|
||||
|
||||
async function claimJob(db: Pool, job: Job, leaseSeconds: number): Promise<Claim | null> {
|
||||
const client = await db.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
const token = randomUUID();
|
||||
// Захват только ожидаемой попытки: сообщение старой попытки (redelivery после падения) — no-op,
|
||||
// живую аренду другого worker не трогаем — при его смерти работу вернёт sweeper.
|
||||
const r = await client.query(`UPDATE jobs SET state = 'processing', attempts = attempts + 1, lease_token = $2,
|
||||
lease_until = clock_timestamp() + make_interval(secs => $3), updated_at = clock_timestamp()
|
||||
WHERE job_id = $1 AND attempts + 1 = $4
|
||||
AND (state = 'queued' OR (state = 'processing' AND lease_until < clock_timestamp()))
|
||||
RETURNING attachment_id, pipeline_version, attempts`, [job.job_id, token, leaseSeconds, job.attempt]);
|
||||
if (!r.rowCount) {
|
||||
await client.query('COMMIT');
|
||||
const s = await db.query('SELECT state, attempts FROM jobs WHERE job_id = $1', [job.job_id]);
|
||||
console.log(`job ${job.job_id} попытка ${job.attempt}: no-op (${s.rows[0] ? `${s.rows[0].state}, попыток ${s.rows[0].attempts}` : 'неизвестная job'})`);
|
||||
return null;
|
||||
}
|
||||
const { attachment_id, pipeline_version, attempts } = r.rows[0];
|
||||
const a = (await client.query(`SELECT id, filename, staging_key, object_key, size_bytes, sha256, state, pipeline_version
|
||||
FROM attachments WHERE id = $1 FOR UPDATE`, [attachment_id])).rows[0];
|
||||
// Результат этой или более новой версии уже опубликован: старая job не должна ничего перезаписать.
|
||||
if (a.pipeline_version !== null && a.pipeline_version >= pipeline_version) {
|
||||
await client.query(`UPDATE jobs SET state = 'superseded', lease_token = NULL, lease_until = NULL, updated_at = clock_timestamp()
|
||||
WHERE job_id = $1`, [job.job_id]);
|
||||
await client.query('COMMIT');
|
||||
console.log(`job ${job.job_id} v${pipeline_version}: superseded (опубликована v${a.pipeline_version})`);
|
||||
return null;
|
||||
}
|
||||
const initial = a.pipeline_version === null;
|
||||
if (initial) await client.query(`UPDATE attachments SET state = 'processing', updated_at = clock_timestamp() WHERE id = $1 AND state = 'queued'`, [a.id]);
|
||||
await client.query('COMMIT');
|
||||
return { job, token, attempts, version: pipeline_version, initial, a };
|
||||
} catch (err) {
|
||||
await client.query('ROLLBACK').catch(() => {});
|
||||
throw err;
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
|
||||
// Исходник: при первой обработке — staging, при переобработке новой версией — опубликованный оригинал.
|
||||
// Читается не больше size_bytes + 1 байт и сверяется с доверенными метаданными из БД.
|
||||
async function readSource(s3: Storage, claim: Claim): Promise<Buffer> {
|
||||
const body = await s3.get(claim.initial ? claim.a.staging_key : claim.a.object_key);
|
||||
if (!body) throw new PermanentError('source_missing', 'исходник отсутствует в S3');
|
||||
const chunks: Buffer[] = [];
|
||||
let size = 0;
|
||||
for await (const chunk of body) {
|
||||
size += chunk.length;
|
||||
if (size > claim.a.size_bytes) {
|
||||
body.destroy();
|
||||
break;
|
||||
}
|
||||
chunks.push(chunk);
|
||||
}
|
||||
const data = Buffer.concat(chunks);
|
||||
if (size !== claim.a.size_bytes || createHash('sha256').update(data).digest('hex') !== claim.a.sha256) {
|
||||
throw new PermanentError('source_corrupted', 'исходник не совпадает с метаданными');
|
||||
}
|
||||
return data;
|
||||
}
|
||||
|
||||
type Stored = { name: string; content_type: string; size_bytes: number; width: number; height: number; sha256: string; key: string };
|
||||
|
||||
async function commit(db: Pool, claim: Claim, variants: Stored[]): Promise<boolean> {
|
||||
const client = await db.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
// Fencing: если аренда истекла и работу забрал другой worker, токен уже не совпадает.
|
||||
const done = await client.query(`UPDATE jobs SET state = 'done', lease_token = NULL, lease_until = NULL, error_code = NULL,
|
||||
updated_at = clock_timestamp() WHERE job_id = $1 AND lease_token = $2 AND state = 'processing'`, [claim.job.job_id, claim.token]);
|
||||
if (!done.rowCount) {
|
||||
await client.query('ROLLBACK');
|
||||
console.log(`job ${claim.job.job_id} попытка ${claim.attempts}: аренда потеряна, результат отброшен`);
|
||||
return false;
|
||||
}
|
||||
const ready = await client.query(`UPDATE attachments SET state = 'ready', pipeline_version = $2, error_code = NULL, updated_at = clock_timestamp()
|
||||
WHERE id = $1 AND (pipeline_version IS NULL OR pipeline_version < $2)`, [claim.a.id, claim.version]);
|
||||
if (!ready.rowCount) {
|
||||
await client.query(`UPDATE jobs SET state = 'superseded' WHERE job_id = $1`, [claim.job.job_id]);
|
||||
await client.query('COMMIT');
|
||||
console.log(`job ${claim.job.job_id} v${claim.version}: superseded при фиксации`);
|
||||
return false;
|
||||
}
|
||||
for (const v of variants) {
|
||||
await client.query(`INSERT INTO attachment_variants (attachment_id, pipeline_version, name, object_key, content_type, size_bytes, width, height, sha256)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`, [claim.a.id, claim.version, v.name, v.key, v.content_type, v.size_bytes, v.width, v.height, v.sha256]);
|
||||
}
|
||||
await client.query('COMMIT');
|
||||
return true;
|
||||
} catch (err) {
|
||||
await client.query('ROLLBACK').catch(() => {});
|
||||
throw err;
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
|
||||
// Постоянная ошибка (свойство файла) → failed сразу. Временная → новая попытка через outbox с backoff и jitter,
|
||||
// пока attempts < JOB_MAX_ATTEMPTS, затем failed retry_exhausted. Всё — только у владельца аренды.
|
||||
// У job в error_code — последняя причина (и для queued), у вложения — только финальный код failed.
|
||||
async function failOrRetry(db: Pool, claim: Claim, err: unknown, cfg: Opts['cfg'], reason: string): Promise<void> {
|
||||
const permanent = err instanceof PermanentError ? err.code : null;
|
||||
const exhausted = !permanent && claim.attempts >= cfg.maxAttempts;
|
||||
const state = permanent || exhausted ? 'failed' : 'queued';
|
||||
const code = permanent ?? (exhausted ? 'retry_exhausted' : null);
|
||||
const delayMs = Math.min(60000, cfg.retryBaseMs * 2 ** (claim.attempts - 1)) * (0.5 + Math.random() / 2);
|
||||
console.error(`job ${claim.job.job_id} попытка ${claim.attempts}: ${(err as Error).message} → ${state}${code ? ` ${code}` : `, повтор через ${Math.round(delayMs)} мс`}`);
|
||||
const client = await db.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
const r = await client.query(`UPDATE jobs SET state = $3, error_code = $4, lease_token = NULL, lease_until = NULL, updated_at = clock_timestamp()
|
||||
WHERE job_id = $1 AND lease_token = $2`, [claim.job.job_id, claim.token, state, code ?? reason]);
|
||||
if (r.rowCount) {
|
||||
if (state === 'queued') {
|
||||
await client.query(`INSERT INTO outbox (job_id, attempt, available_at) VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3))`,
|
||||
[claim.job.job_id, claim.attempts + 1, delayMs / 1000]);
|
||||
}
|
||||
if (claim.initial) {
|
||||
await client.query(`UPDATE attachments SET state = $2, error_code = $3, updated_at = clock_timestamp()
|
||||
WHERE id = $1 AND pipeline_version IS NULL AND state IN ('queued', 'processing')`, [claim.a.id, state, code]);
|
||||
}
|
||||
}
|
||||
await client.query('COMMIT');
|
||||
} catch (e) {
|
||||
await client.query('ROLLBACK').catch(() => {});
|
||||
throw e; // job останется processing: аренда истечёт и sweeper вернёт её
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
|
||||
async function removeAll(s3: Storage, keys: string[]): Promise<void> {
|
||||
for (const key of keys) await s3.remove(key).catch(() => {}); // остаток уберёт reconciler
|
||||
}
|
||||
+84
@@ -0,0 +1,84 @@
|
||||
// Точка входа мессенджера (лабораторная 5).
|
||||
// Реплика не хранит состояния: пользователи, сессии, чаты, сообщения, ключи идемпотентности, метаданные
|
||||
// вложений и задания (jobs, outbox) — в PostgreSQL, байты — в S3, поэтому запрос может обслужить любая реплика.
|
||||
// node src/main.ts — HTTP-сервер + relay outbox → RabbitMQ (src/jobs/relay.ts)
|
||||
// node src/main.ts worker — обработка изображений из очереди (src/jobs/worker.ts, сервис worker)
|
||||
// node src/main.ts jobs … — операторские команды: failed | replay <id> | reprocess --version=N
|
||||
// node src/main.ts migrate — однократный прогон миграций (сервис migrate)
|
||||
// node src/main.ts s3-init — идемпотентное создание приватного bucket ключом администратора (сервис s3-init)
|
||||
// node src/main.ts reconcile — сверка БД ↔ S3, параметры в src/reconcile.ts (сервис reconciler)
|
||||
import { createServer } from 'node:http';
|
||||
import { setTimeout as sleep } from 'node:timers/promises';
|
||||
import { createApp } from './app.ts';
|
||||
import { envInt, loadConfig, s3Config, secret } from './config.ts';
|
||||
import { createPool, migrate } from './db.ts';
|
||||
import { adminCommand } from './jobs/admin.ts';
|
||||
import { createPublisher } from './jobs/broker.ts';
|
||||
import { startRelay } from './jobs/relay.ts';
|
||||
import { runWorker } from './jobs/worker.ts';
|
||||
import { reconcileCommand } from './reconcile.ts';
|
||||
import { createStorage } from './storage/s3.ts';
|
||||
|
||||
async function serve(): Promise<void> {
|
||||
const config = loadConfig();
|
||||
const db = createPool(config.databaseUrl, config.dbPoolMax);
|
||||
const relay = startRelay(db, createPublisher(config.brokerUrl), config.jobs);
|
||||
const app = createApp(db, createStorage(config.s3), config, relay);
|
||||
const server = createServer(app.handle);
|
||||
server.headersTimeout = 5000;
|
||||
server.requestTimeout = 60000; // 10 MiB на медленном канале; grace reconciler-а (15 мин) заведомо больше
|
||||
server.keepAliveTimeout = 60000;
|
||||
server.listen(config.port, config.host, () =>
|
||||
console.log(`реплика ${config.instanceId} слушает :${config.port}, пул БД ${config.dbPoolMax}`));
|
||||
|
||||
// Graceful shutdown: сначала readiness → 503 и пауза drain, пока LB не исключит реплику (fall × inter),
|
||||
// при этом запросы ещё обслуживаются; затем перестаём принимать соединения и дожидаемся текущих запросов.
|
||||
const stop = (signal: string) => {
|
||||
if (!app.state.ready) return;
|
||||
console.log(`${signal}: readiness=503, drain ${config.shutdownDrainMs} мс`);
|
||||
app.state.ready = false;
|
||||
relay.stop();
|
||||
setTimeout(() => {
|
||||
server.close(async () => {
|
||||
await db.end();
|
||||
console.log('остановлена');
|
||||
process.exit(0);
|
||||
});
|
||||
server.closeIdleConnections();
|
||||
setTimeout(() => process.exit(1), 10000).unref(); // страховка от зависшего запроса
|
||||
}, config.shutdownDrainMs);
|
||||
};
|
||||
process.on('SIGTERM', () => stop('SIGTERM'));
|
||||
process.on('SIGINT', () => stop('SIGINT'));
|
||||
}
|
||||
|
||||
// S3 может стартовать позже: повторяем до 30 с. Повторный запуск на готовом bucket ничего не меняет.
|
||||
async function s3Init(): Promise<void> {
|
||||
const storage = createStorage(s3Config());
|
||||
for (let attempt = 1; ; attempt++) {
|
||||
try {
|
||||
console.log(`bucket ${storage.bucket}: ${await storage.createBucket()}`);
|
||||
return;
|
||||
} catch (err) {
|
||||
if (attempt >= 30) throw err;
|
||||
await sleep(1000);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const command = process.argv[2];
|
||||
if (command === 'migrate') {
|
||||
await migrate(secret('DATABASE_URL'));
|
||||
} else if (command === 's3-init') {
|
||||
await s3Init();
|
||||
} else if (command === 'worker') {
|
||||
await runWorker();
|
||||
} else if (command === 'jobs') {
|
||||
const db = createPool(secret('DATABASE_URL'), 2);
|
||||
await adminCommand(db, process.argv.slice(3));
|
||||
await db.end();
|
||||
} else if (command === 'reconcile') {
|
||||
await reconcileCommand(process.argv.slice(3), envInt('RECONCILE_GRACE_SECONDS', 900), envInt('STAGING_RETENTION_SECONDS', 86400));
|
||||
} else {
|
||||
await serve();
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
-- Начальная схема мессенджера. Источник истины для всех реплик API.
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
username text NOT NULL UNIQUE,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
-- Хранится только sha256(токена): дамп БД не содержит рабочих Bearer-токенов.
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
expires_at timestamptz NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
position int NOT NULL,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
-- Ключи идемпотентности: область = пользователь + метод + путь + ключ.
|
||||
-- Строка вставляется тем же SQL-оператором, что и сообщение (атомарно).
|
||||
-- ponytail: ключи не удаляются (контракт требует >= 24 ч); при росте таблицы добавить периодический DELETE.
|
||||
CREATE TABLE idempotency_keys (
|
||||
user_id uuid NOT NULL,
|
||||
method text NOT NULL,
|
||||
path text NOT NULL,
|
||||
key text NOT NULL,
|
||||
request_hash bytea NOT NULL,
|
||||
message_id uuid NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
PRIMARY KEY (user_id, method, path, key)
|
||||
);
|
||||
|
||||
-- RFC 3339 UTC с микросекундами: формат ответа API и точная позиция keyset-cursor.
|
||||
CREATE FUNCTION rfc3339(timestamptz) RETURNS text LANGUAGE sql STABLE AS
|
||||
$$ SELECT to_char($1 AT TIME ZONE 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.US"Z"') $$;
|
||||
@@ -0,0 +1,38 @@
|
||||
-- Вложения (lab4). Только добавление схемы: версия lab3 продолжает работать на этой схеме.
|
||||
-- Метаданные — здесь, байты — в приватном S3-bucket под ключом object_key, который назначает сервер.
|
||||
-- pending — запись-намерение: создаётся ДО загрузки байтов, поэтому у любого объекта в S3 сначала есть строка;
|
||||
-- ready — объект загружен и проверен, метаданные описывают оригинал;
|
||||
-- lost — reconciler не нашёл объект или он не совпал по размеру/SHA-256: вложение скрыто из API (404),
|
||||
-- ссылки в сообщениях сохраняются, при возврате правильного объекта reconciler вернёт ready.
|
||||
CREATE TABLE attachments (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
owner_id uuid NOT NULL REFERENCES users (id),
|
||||
filename text NOT NULL,
|
||||
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')),
|
||||
-- Побайтовая сортировка совпадает с порядком ListObjectsV2: reconciler сливает два отсортированных потока.
|
||||
object_key text COLLATE "C" NOT NULL UNIQUE,
|
||||
state text NOT NULL DEFAULT 'pending' CHECK (state IN ('pending', 'ready', 'lost')),
|
||||
size_bytes integer CHECK (size_bytes > 0),
|
||||
sha256 text CHECK (sha256 ~ '^[0-9a-f]{64}$'),
|
||||
width integer,
|
||||
height integer,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
UNIQUE (chat_id, id), -- цель составного FK из message_attachments
|
||||
CHECK (state = 'pending' OR (size_bytes IS NOT NULL AND sha256 IS NOT NULL))
|
||||
);
|
||||
-- Поиск зависших загрузок reconciler-ом.
|
||||
CREATE INDEX attachments_pending_idx ON attachments (created_at) WHERE state = 'pending';
|
||||
|
||||
-- Вложения сообщения. FK (chat_id, attachment_id) → attachments (chat_id, id): БД не даст прикрепить вложение
|
||||
-- чужого чата и не даст удалить метаданные вложения, на которое ссылается сообщение (NO ACTION).
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL REFERENCES messages (id),
|
||||
chat_id uuid NOT NULL,
|
||||
attachment_id uuid NOT NULL,
|
||||
position int NOT NULL,
|
||||
PRIMARY KEY (message_id, attachment_id),
|
||||
FOREIGN KEY (chat_id, attachment_id) REFERENCES attachments (chat_id, id)
|
||||
);
|
||||
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id, chat_id);
|
||||
@@ -0,0 +1,74 @@
|
||||
-- Фоновая обработка вложений (lab5). Только добавление: версия lab4 продолжает работать на этой схеме.
|
||||
-- Состояния вложения: pending (байты ещё принимаются) → queued (оригинал устойчиво в staging, задание
|
||||
-- сохранено) → processing → ready | failed; lost — карантин reconciler (объект пропал или повреждён).
|
||||
ALTER TABLE attachments DROP CONSTRAINT attachments_state_check;
|
||||
ALTER TABLE attachments ADD CONSTRAINT attachments_state_check
|
||||
CHECK (state IN ('pending', 'queued', 'processing', 'ready', 'failed', 'lost'));
|
||||
ALTER TABLE attachments
|
||||
ADD COLUMN staging_key text COLLATE "C" UNIQUE, -- staging/<id>: принятый оригинал до публикации worker-ом
|
||||
ADD COLUMN pipeline_version int, -- версия pipeline опубликованного результата (ready)
|
||||
ADD COLUMN error_code text; -- машинный код failed, без деталей
|
||||
|
||||
-- Логическая работа: одна на (вложение, версия pipeline). job_id не меняется при повторах и redelivery.
|
||||
CREATE TABLE jobs (
|
||||
job_id uuid PRIMARY KEY,
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
pipeline_version int NOT NULL,
|
||||
state text NOT NULL DEFAULT 'queued'
|
||||
CHECK (state IN ('queued', 'processing', 'done', 'failed', 'superseded')),
|
||||
attempts int NOT NULL DEFAULT 0, -- начатые попытки (успешные захваты аренды)
|
||||
lease_token uuid, -- fencing: результат фиксирует только владелец аренды
|
||||
lease_until timestamptz,
|
||||
error_code text,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
updated_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
UNIQUE (attachment_id, pipeline_version)
|
||||
);
|
||||
CREATE INDEX jobs_lease_idx ON jobs (lease_until) WHERE state = 'processing';
|
||||
CREATE INDEX jobs_queued_idx ON jobs (updated_at) WHERE state = 'queued';
|
||||
|
||||
-- Transactional outbox: строка пишется в одной транзакции с изменением состояния, relay публикует её
|
||||
-- в брокер после COMMIT и только после publisher confirm отмечает published_at.
|
||||
CREATE TABLE outbox (
|
||||
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
|
||||
job_id uuid NOT NULL REFERENCES jobs (job_id),
|
||||
attempt int NOT NULL,
|
||||
available_at timestamptz NOT NULL DEFAULT clock_timestamp(), -- момент после backoff повтора
|
||||
published_at timestamptz,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
CREATE INDEX outbox_due_idx ON outbox (available_at) WHERE published_at IS NULL;
|
||||
CREATE INDEX outbox_job_idx ON outbox (job_id, created_at);
|
||||
|
||||
-- Результат обработки. Ключ эффекта (attachment_id, pipeline_version, name): повтор той же job
|
||||
-- не может создать второй набор вариантов.
|
||||
CREATE TABLE attachment_variants (
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
pipeline_version int NOT NULL,
|
||||
name text NOT NULL CHECK (name IN ('thumbnail', 'crop', 'optimized')),
|
||||
object_key text COLLATE "C" NOT NULL UNIQUE,
|
||||
content_type text NOT NULL,
|
||||
size_bytes int NOT NULL,
|
||||
width int NOT NULL,
|
||||
height int NOT NULL,
|
||||
sha256 text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
PRIMARY KEY (attachment_id, pipeline_version, name)
|
||||
);
|
||||
|
||||
-- Аудит операторского replay failed → queued.
|
||||
CREATE TABLE job_replays (
|
||||
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
|
||||
job_id uuid NOT NULL REFERENCES jobs (job_id),
|
||||
previous_error text,
|
||||
previous_attempts int NOT NULL,
|
||||
replayed_at timestamptz NOT NULL DEFAULT clock_timestamp()
|
||||
);
|
||||
|
||||
-- Учебный fault-injection (src/failpoints.ts): точка срабатывает один раз на вложение. Пусто, если FAILPOINTS выключены.
|
||||
CREATE TABLE failpoint_hits (
|
||||
name text NOT NULL,
|
||||
attachment_id uuid NOT NULL,
|
||||
hit_at timestamptz NOT NULL DEFAULT clock_timestamp(),
|
||||
PRIMARY KEY (name, attachment_id)
|
||||
);
|
||||
@@ -0,0 +1,179 @@
|
||||
// Вложения: приём PNG/JPEG в устойчивый staging, фоновая обработка worker-ом, скачивание только через API.
|
||||
//
|
||||
// Приём (lab5): ответ 202 означает, что устойчиво сохранено всё, что нужно для завершения работы без клиента:
|
||||
// 1. INSERT строки pending (запись-намерение с ключами staging и оригинала) — COMMIT;
|
||||
// 2. поток байтов: клиент → проверка формата + SHA-256 → S3 staging/<id>;
|
||||
// 3. одна транзакция: pending → queued, job и строка outbox (transactional outbox) — COMMIT → 202.
|
||||
// Брокер в этот момент не нужен: relay (src/jobs/relay.ts) опубликует задание после COMMIT, даже если брокер
|
||||
// поднимется позже. Ошибка на шагах 2–3 → компенсация; падение процесса → pending-строку уберёт reconciler.
|
||||
import { createHash, randomUUID } from 'node:crypto';
|
||||
import { Transform } from 'node:stream';
|
||||
import { failpoint } from '../failpoints.ts';
|
||||
import type { Ctx, Result } from '../http/context.ts';
|
||||
import { badRequest, conflict, notFound, tooLarge, unavailable, unsupported } from '../http/errors.ts';
|
||||
import { isText, mediaType, uuidParam } from '../http/request.ts';
|
||||
import { requireMember } from './chats.ts';
|
||||
import { imageValidator, type Dimensions } from './images.ts';
|
||||
import type { User } from './model.ts';
|
||||
import { authenticate } from './sessions.ts';
|
||||
|
||||
const FORBIDDEN_IN_FILENAME = /[/\\\p{Cc}]/u; // разделители путей, NUL и управляющие символы C0/C1
|
||||
const VARIANTS = ['thumbnail', 'crop', 'optimized'];
|
||||
// Варианты — опубликованной версии pipeline; у queued/processing/failed их нет.
|
||||
const columns = `a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, a.state AS status, a.error_code,
|
||||
rfc3339(a.created_at) AS created_at, rfc3339(a.updated_at) AS updated_at,
|
||||
COALESCE((SELECT json_agg(json_build_object('name', v.name, 'content_type', v.content_type, 'size_bytes', v.size_bytes,
|
||||
'width', v.width, 'height', v.height, 'sha256', v.sha256) ORDER BY v.name)
|
||||
FROM attachment_variants v WHERE v.attachment_id = a.id AND v.pipeline_version = a.pipeline_version), '[]') AS variants`;
|
||||
const VISIBLE = `('queued', 'processing', 'ready', 'failed')`; // pending ещё не принято, lost — в карантине
|
||||
|
||||
type Row = Record<string, unknown> & { object_key?: string; pipeline_version?: number | null };
|
||||
|
||||
// Ключи объектов и внутренняя версия pipeline наружу не отдаются.
|
||||
const view = ({ object_key: _, pipeline_version: __, ...row }: Row) => row;
|
||||
|
||||
// POST /api/v1/chats/{chat_id}/attachments?filename=… — сырые байты одного PNG/JPEG → 202 queued.
|
||||
// Все лимиты проверяются до чтения тела; тело не буферизуется целиком ни в памяти, ни на диске API.
|
||||
export async function uploadAttachment(c: Ctx): Promise<Result> {
|
||||
const user = await authenticate(c);
|
||||
const chatId = await requireMember(c, user);
|
||||
const filename = c.url.searchParams.get('filename');
|
||||
if (!isText(filename, 1, 255) || FORBIDDEN_IN_FILENAME.test(filename)) {
|
||||
throw badRequest('filename: 1–255 символов, без / \\ и управляющих символов');
|
||||
}
|
||||
const type = mediaType(c.req);
|
||||
if (type !== 'image/png' && type !== 'image/jpeg') throw unsupported('Ожидается image/png или image/jpeg');
|
||||
const declared = c.req.headers['content-length'];
|
||||
if (declared === undefined || !/^\d+$/.test(declared)) throw badRequest('Нужен Content-Length: файл передаётся потоком в S3');
|
||||
const length = Number(declared);
|
||||
if (length > c.config.maxUploadBytes) throw tooLarge(`Файл больше ${c.config.maxUploadBytes} байт`);
|
||||
if (length === 0) throw unsupported('Пустое тело не является изображением');
|
||||
|
||||
const id = randomUUID();
|
||||
const staging = `staging/${id}`; // filename только для отображения и в ключи не попадает
|
||||
await c.db.query(`INSERT INTO attachments (id, chat_id, owner_id, filename, content_type, object_key, staging_key)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7)`, [id, chatId, user.id, filename, type, `originals/${id}`, staging]);
|
||||
let row: Row;
|
||||
try {
|
||||
const dims = await store(c, staging, type, length);
|
||||
await failpoint(c.db, 'api_after_staging', id, filename); // байты в staging, задания ещё нет
|
||||
row = await accept(c, id, length, dims);
|
||||
} catch (err) {
|
||||
void discard(c, id, staging); // в фоне: при зависшем S3 клиент не ждёт ещё и DELETE
|
||||
throw err;
|
||||
}
|
||||
await failpoint(c.db, 'api_after_commit', id, filename); // задание в outbox, публикации ещё не было
|
||||
c.relay.kick();
|
||||
return [202, view(row)];
|
||||
}
|
||||
|
||||
// pending → queued + job + outbox одной транзакцией: после COMMIT работа не теряется при падении API.
|
||||
async function accept(c: Ctx, id: string, length: number, dims: { sha256: string; width: number; height: number }): Promise<Row> {
|
||||
const client = await c.db.connect();
|
||||
try {
|
||||
await client.query('BEGIN');
|
||||
const r = await client.query(`UPDATE attachments AS a SET state = 'queued', size_bytes = $2, sha256 = $3, width = $4, height = $5,
|
||||
updated_at = clock_timestamp() WHERE a.id = $1 AND a.state = 'pending' RETURNING ${columns}`, [id, length, dims.sha256, dims.width, dims.height]);
|
||||
if (!r.rowCount) throw unavailable('Загрузка не завершилась вовремя'); // строку уже убрал reconciler
|
||||
await client.query(`WITH j AS (INSERT INTO jobs (job_id, attachment_id, pipeline_version) VALUES (gen_random_uuid(), $1, $2) RETURNING job_id)
|
||||
INSERT INTO outbox (job_id, attempt) SELECT job_id, 1 FROM j`, [id, c.config.jobs.pipelineVersion]);
|
||||
await client.query('COMMIT');
|
||||
return r.rows[0];
|
||||
} catch (err) {
|
||||
await client.query('ROLLBACK').catch(() => {});
|
||||
throw err;
|
||||
} finally {
|
||||
client.release();
|
||||
}
|
||||
}
|
||||
|
||||
// Клиент → проверка + SHA-256 → S3. Обратное давление: пока S3 не принял кусок, следующий не читается из сокета,
|
||||
// поэтому память на загрузку не зависит от размера файла. Последний кусок уходит в S3 только после полной
|
||||
// проверки файла: S3 не получит все Content-Length байт невалидного изображения, и объект не создастся.
|
||||
async function store(c: Ctx, key: string, type: 'image/png' | 'image/jpeg', length: number) {
|
||||
const check = imageValidator(type, c.config.maxImagePixels);
|
||||
const hash = createHash('sha256');
|
||||
const abort = new AbortController();
|
||||
let received = 0;
|
||||
let dims: Dimensions | undefined;
|
||||
let failure: unknown;
|
||||
const fail = (err: unknown) => {
|
||||
failure ??= err;
|
||||
abort.abort();
|
||||
};
|
||||
const body = new Transform({
|
||||
transform(chunk: Buffer, _encoding, done) {
|
||||
received += chunk.length;
|
||||
hash.update(chunk);
|
||||
check.write(chunk)
|
||||
.then(async () => { if (received === length) dims = await check.end(); })
|
||||
.then(() => done(null, chunk), done);
|
||||
},
|
||||
});
|
||||
body.on('error', fail);
|
||||
c.req.on('close', () => { if (!c.req.complete) fail(badRequest('Загрузка прервана клиентом')); });
|
||||
c.req.pipe(body);
|
||||
try {
|
||||
await c.s3.put(key, body, length, type, abort.signal);
|
||||
if (failure) throw failure;
|
||||
if (!dims) throw new Error('S3 принял объект до конца проверки');
|
||||
return { sha256: hash.digest('hex'), ...dims };
|
||||
} catch (err) {
|
||||
// Остаток тела читаем и выбрасываем: иначе ответ с ошибкой не дойдёт до клиента, который ещё отправляет файл.
|
||||
c.req.unpipe(body);
|
||||
c.req.resume();
|
||||
body.destroy();
|
||||
check.close();
|
||||
throw failure ?? err;
|
||||
}
|
||||
}
|
||||
|
||||
// Компенсация неудачной загрузки. Объект удаляется, только если строка точно не стала queued: при
|
||||
// неоднозначной ошибке COMMIT (соединение оборвалось) строка могла зафиксироваться, и байты нужны worker-у.
|
||||
// Сбой здесь не теряет учёт: останется pending-строка с ключом staging, её подберёт reconciler.
|
||||
async function discard(c: Ctx, id: string, key: string): Promise<void> {
|
||||
try {
|
||||
const deleted = await c.db.query(`DELETE FROM attachments WHERE id = $1 AND state = 'pending'`, [id]);
|
||||
if (!deleted.rowCount && (await c.db.query('SELECT 1 FROM attachments WHERE id = $1', [id])).rowCount) return;
|
||||
await c.s3.remove(key);
|
||||
} catch (err) {
|
||||
console.error(`компенсация вложения ${id} не завершена, остаток уберёт reconciler: ${(err as Error).message}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Вложение доступно только участникам его чата; постороннему — тот же 404, что и для несуществующего.
|
||||
async function findVisible(c: Ctx, user: User): Promise<Row & { object_key: string }> {
|
||||
const r = await c.db.query(`SELECT ${columns}, a.object_key, a.pipeline_version FROM attachments a
|
||||
JOIN chat_members m ON m.chat_id = a.chat_id AND m.user_id = $2
|
||||
WHERE a.id = $1 AND a.state IN ${VISIBLE}`, [uuidParam(c, 'attachment_id'), user.id]);
|
||||
if (!r.rowCount) throw notFound();
|
||||
return r.rows[0];
|
||||
}
|
||||
|
||||
// GET /api/v1/attachments/{attachment_id} — снимок статуса; клиент опрашивает до ready/failed.
|
||||
export async function getAttachment(c: Ctx): Promise<Result> {
|
||||
return [200, view(await findVisible(c, await authenticate(c)))];
|
||||
}
|
||||
|
||||
// GET /api/v1/attachments/{attachment_id}/content[?variant=original|thumbnail|crop|optimized] — байты потоком из S3.
|
||||
// queued/processing/failed — 409; отсутствующий вариант ready-объекта — 404; без redirect.
|
||||
export async function downloadAttachment(c: Ctx): Promise<Result> {
|
||||
const user = await authenticate(c);
|
||||
const variant = c.url.searchParams.get('variant') ?? 'original';
|
||||
if (variant !== 'original' && !VARIANTS.includes(variant)) throw badRequest('Неизвестный variant');
|
||||
const row = await findVisible(c, user);
|
||||
if (row.status !== 'ready') throw conflict(row.status === 'failed' ? 'Обработка вложения завершилась ошибкой' : 'Вложение ещё обрабатывается');
|
||||
let target = { key: row.object_key, type: row.content_type as string, size: row.size_bytes as number };
|
||||
if (variant !== 'original') {
|
||||
const v = await c.db.query(`SELECT object_key, content_type, size_bytes FROM attachment_variants
|
||||
WHERE attachment_id = $1 AND pipeline_version = $2 AND name = $3`, [row.id, row.pipeline_version, variant]);
|
||||
if (!v.rowCount) throw notFound();
|
||||
target = { key: v.rows[0].object_key, type: v.rows[0].content_type, size: v.rows[0].size_bytes };
|
||||
}
|
||||
const body = await c.s3.get(target.key);
|
||||
if (!body) {
|
||||
console.error(`объект ${variant} вложения ${row.id} отсутствует в S3`); // reconciler пометит оригинал lost
|
||||
throw notFound();
|
||||
}
|
||||
return [200, body, { 'Content-Type': target.type, 'Content-Length': target.size, 'X-Content-Type-Options': 'nosniff' }];
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
// Чаты: создание, список чатов пользователя, один чат, проверка членства.
|
||||
import type { Ctx, Result } from '../http/context.ts';
|
||||
import { badRequest, notFound } from '../http/errors.ts';
|
||||
import { afterCursor, limitOf, page } from '../http/pagination.ts';
|
||||
import { UUID, isText, jsonObject, readJson, uuidParam } from '../http/request.ts';
|
||||
import { authenticate } from './sessions.ts';
|
||||
import type { User } from './model.ts';
|
||||
|
||||
// Чаты, где состоит пользователь $1; member_ids в порядке, заданном при создании.
|
||||
const chatSelect = `SELECT c.id, c.title, rfc3339(c.created_at) AS created_at,
|
||||
(SELECT array_agg(m.user_id::text ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids
|
||||
FROM chats c JOIN chat_members me ON me.chat_id = c.id AND me.user_id = $1 `;
|
||||
|
||||
// chat_id из пути, если пользователь — участник. Постороннему тот же 404, что и для несуществующего чата.
|
||||
export async function requireMember(c: Ctx, user: User): Promise<string> {
|
||||
const chatId = uuidParam(c, 'chat_id');
|
||||
const r = await c.db.query({
|
||||
name: 'member',
|
||||
text: 'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2',
|
||||
values: [chatId, user.id],
|
||||
});
|
||||
if (!r.rowCount) throw notFound();
|
||||
return chatId;
|
||||
}
|
||||
|
||||
// POST /api/v1/chats: участники фиксируются при создании и обязательно включают создателя.
|
||||
export async function createChat(c: Ctx): Promise<Result> {
|
||||
const user = await authenticate(c);
|
||||
const b = jsonObject(await readJson(c.req), ['title', 'member_ids']);
|
||||
const ids = b.member_ids;
|
||||
if (!isText(b.title, 1, 100) || !Array.isArray(ids) || ids.length < 1 || ids.length > 100
|
||||
|| !ids.every((id) => typeof id === 'string' && UUID.test(id))) {
|
||||
throw badRequest('Неверные title или member_ids');
|
||||
}
|
||||
const members = ids.map((id: string) => id.toLowerCase());
|
||||
if (new Set(members).size !== members.length || !members.includes(user.id)) {
|
||||
throw badRequest('member_ids должны быть уникальны и включать создателя');
|
||||
}
|
||||
try {
|
||||
// Один оператор = одна транзакция: при неизвестном участнике сработает FK и не создастся ничего.
|
||||
const r = await c.db.query(`WITH c AS (INSERT INTO chats (title) VALUES ($1) RETURNING id, title, created_at),
|
||||
m AS (INSERT INTO chat_members (chat_id, user_id, position)
|
||||
SELECT c.id, t.u::uuid, t.o FROM c, unnest($2::text[]) WITH ORDINALITY AS t(u, o))
|
||||
SELECT id, title, rfc3339(created_at) AS created_at FROM c`, [b.title, members]);
|
||||
return [201, { ...r.rows[0], member_ids: members }];
|
||||
} catch (err) {
|
||||
if ((err as { code?: string }).code === '23503') throw badRequest('Неизвестный участник'); // foreign_key_violation
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
// GET /api/v1/chats: только чаты текущего пользователя, cursor привязан к пользователю.
|
||||
export async function listChats(c: Ctx): Promise<Result> {
|
||||
const user = await authenticate(c);
|
||||
const limit = limitOf(c.url);
|
||||
const [ts, id] = afterCursor(c.url, 'c', user.id);
|
||||
const r = await c.db.query(chatSelect + 'WHERE (c.created_at, c.id) > ($2, $3::uuid) ORDER BY c.created_at, c.id LIMIT $4',
|
||||
[user.id, ts, id, limit + 1]);
|
||||
return [200, page(r.rows, limit, 'c', user.id)];
|
||||
}
|
||||
|
||||
// GET /api/v1/chats/{chat_id}
|
||||
export async function getChat(c: Ctx): Promise<Result> {
|
||||
const user = await authenticate(c);
|
||||
const r = await c.db.query(chatSelect + 'WHERE c.id = $2', [user.id, uuidParam(c, 'chat_id')]);
|
||||
if (!r.rowCount) throw notFound();
|
||||
return [200, r.rows[0]];
|
||||
}
|
||||
@@ -0,0 +1,411 @@
|
||||
// Потоковая проверка PNG/JPEG по содержимому: без декодирования пикселей и без буферизации файла.
|
||||
// Размеры берутся из заголовка (IHDR / SOF) и проверяются ДО распаковки данных, поэтому «бомба» отсекается сразу.
|
||||
// PNG: сигнатура, порядок chunk-ов, CRC каждого chunk, длина PLTE; поток zlib распаковывается с подсчётом байтов
|
||||
// (вывод выбрасывается, смотрится только байт фильтра 0–4 в начале каждой строки) и сверяется с объёмом,
|
||||
// который следует из размеров и формата пикселя.
|
||||
// JPEG: структура маркеров, ровно один SOF до первого SOS, обязательный EOI и те же проверки заголовков, на которых
|
||||
// останавливается libjpeg-turbo (декодер Pillow и браузеров): 8 бит, 1/3/4 компонента, прореживание, таблицы
|
||||
// DQT/DHT для каждого скана, параметры SOS; скан не пустой. Энтропийные данные не декодируются — битый
|
||||
// Huffman-код libjpeg тоже считает лишь предупреждением.
|
||||
// Обработанный кусок можно сразу передавать дальше: состояние проверки — несколько чисел и ≤ 13 байт хвоста
|
||||
// (у JPEG ещё сегмент заголовка, ≤ 64 KiB).
|
||||
import { finished } from 'node:stream/promises';
|
||||
import { createInflate, crc32 } from 'node:zlib';
|
||||
import { tooLarge, unsupported } from '../http/errors.ts';
|
||||
|
||||
export type Dimensions = { width: number; height: number };
|
||||
|
||||
export type ImageValidator = {
|
||||
write(chunk: Buffer): Promise<void>;
|
||||
end(): Promise<Dimensions>; // весь файл получен; бросает 415, если он обрезан
|
||||
close(): void; // освободить ресурсы при обрыве загрузки
|
||||
};
|
||||
|
||||
const broken = (why: string) => unsupported(`Содержимое не является корректным изображением: ${why}`);
|
||||
|
||||
export function imageValidator(type: 'image/png' | 'image/jpeg', maxPixels: number): ImageValidator {
|
||||
return type === 'image/png' ? png(maxPixels) : jpeg(maxPixels);
|
||||
}
|
||||
|
||||
function checkPixels(width: number, height: number, maxPixels: number): void {
|
||||
if (width * height > maxPixels) throw tooLarge(`Изображение больше ${maxPixels} пикселей`);
|
||||
}
|
||||
|
||||
const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
|
||||
const CHANNELS: Record<number, number> = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
|
||||
const DEPTHS: Record<number, number[]> = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
|
||||
const ADAM7 = [[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]];
|
||||
|
||||
// Строки распакованных данных PNG как [число строк, байт в строке]: байт фильтра + пиксели;
|
||||
// при interlace — по одной паре на каждый непустой проход Adam7.
|
||||
function rowLayout(width: number, height: number, bits: number, interlaced: boolean): [number, number][] {
|
||||
const row = (w: number) => 1 + Math.ceil((w * bits) / 8);
|
||||
if (!interlaced) return [[height, row(width)]];
|
||||
const passes: [number, number][] = [];
|
||||
for (const [x0, y0, dx, dy] of ADAM7) {
|
||||
const w = Math.ceil((width - x0) / dx);
|
||||
const h = Math.ceil((height - y0) / dy);
|
||||
if (w > 0 && h > 0) passes.push([h, row(w)]);
|
||||
}
|
||||
return passes;
|
||||
}
|
||||
|
||||
function png(maxPixels: number): ImageValidator {
|
||||
let carry = Buffer.alloc(0);
|
||||
let state: 'signature' | 'header' | 'data' | 'crc' | 'done' = 'signature';
|
||||
let type = '';
|
||||
let left = 0;
|
||||
let crc = 0;
|
||||
let ihdr = Buffer.alloc(0);
|
||||
let dims: Dimensions | null = null;
|
||||
let color = 0;
|
||||
let palette = false;
|
||||
let idat: 'none' | 'open' | 'closed' = 'none';
|
||||
let expected = 0;
|
||||
let inflated = 0;
|
||||
let rows: [number, number][] = [];
|
||||
let pass = 0; // текущий проход Adam7 (без interlace — единственный)
|
||||
let rowsLeft = 0; // строк до конца прохода
|
||||
let inRow = 0; // позиция внутри текущей строки
|
||||
let badFilter = false;
|
||||
|
||||
const inflate = createInflate();
|
||||
let zerr: Error | null = null;
|
||||
let wake: (() => void) | null = null;
|
||||
inflate.on('data', (d: Buffer) => {
|
||||
inflated += d.length;
|
||||
// Первый байт каждой строки — тип фильтра, допустимы только 0–4 (ISO/IEC 15948, 9.2).
|
||||
for (let i = 0; i < d.length && pass < rows.length;) {
|
||||
const len = rows[pass][1];
|
||||
if (inRow === 0 && d[i] > 4) badFilter = true;
|
||||
const step = Math.min(len - inRow, d.length - i);
|
||||
i += step;
|
||||
inRow += step;
|
||||
if (inRow === len) {
|
||||
inRow = 0;
|
||||
if (--rowsLeft === 0 && ++pass < rows.length) rowsLeft = rows[pass][0];
|
||||
}
|
||||
}
|
||||
});
|
||||
// При ошибке zlib callback write не вызывается: будим ожидающего вручную.
|
||||
inflate.on('error', (e) => { zerr = e; wake?.(); });
|
||||
const feed = (data: Buffer) => zerr ? Promise.resolve() : new Promise<void>((resolve) => {
|
||||
wake = resolve;
|
||||
inflate.write(data, () => resolve());
|
||||
});
|
||||
|
||||
function startChunk(len: number) {
|
||||
if (!/^[A-Za-z]{4}$/.test(type) || len > 0x7fffffff) throw broken('неверный заголовок chunk');
|
||||
if (!dims && type !== 'IHDR') throw broken('первым должен быть IHDR');
|
||||
if (dims && type === 'IHDR') throw broken('повторный IHDR');
|
||||
if (type === 'IHDR' && len !== 13) throw broken('неверная длина IHDR');
|
||||
// Неизвестный критический chunk (заглавная первая буква) декодер обязан отвергнуть.
|
||||
if (/^[A-Z]/.test(type) && !['IHDR', 'PLTE', 'IDAT', 'IEND'].includes(type)) throw broken(`неизвестный chunk ${type}`);
|
||||
if (type === 'IDAT') {
|
||||
if (idat === 'closed') throw broken('IDAT идут не подряд');
|
||||
if (color === 3 && !palette) throw broken('нет палитры PLTE');
|
||||
idat = 'open';
|
||||
} else if (idat === 'open') {
|
||||
idat = 'closed';
|
||||
}
|
||||
if (type === 'PLTE') {
|
||||
if (palette || !len || len > 256 * 3 || len % 3) throw broken('неверная палитра PLTE');
|
||||
palette = true;
|
||||
}
|
||||
if (type === 'IEND' && (len !== 0 || idat === 'none')) throw broken('неверный IEND');
|
||||
}
|
||||
|
||||
function endChunk() {
|
||||
if (type === 'IHDR') {
|
||||
const width = ihdr.readUInt32BE(0);
|
||||
const height = ihdr.readUInt32BE(4);
|
||||
const depth = ihdr[8];
|
||||
color = ihdr[9];
|
||||
if (!width || !height || width > 0x7fffffff || height > 0x7fffffff) throw broken('неверные размеры');
|
||||
if (!DEPTHS[color]?.includes(depth) || ihdr[10] !== 0 || ihdr[11] !== 0 || ihdr[12] > 1) throw broken('неверные параметры IHDR');
|
||||
checkPixels(width, height, maxPixels); // до первого байта IDAT
|
||||
dims = { width, height };
|
||||
rows = rowLayout(width, height, CHANNELS[color] * depth, ihdr[12] === 1);
|
||||
expected = rows.reduce((sum, [h, len]) => sum + h * len, 0);
|
||||
rowsLeft = rows[0][0];
|
||||
}
|
||||
state = type === 'IEND' ? 'done' : 'header';
|
||||
}
|
||||
|
||||
async function write(chunk: Buffer) {
|
||||
const buf = carry.length ? Buffer.concat([carry, chunk]) : chunk;
|
||||
let pos = 0;
|
||||
while (pos < buf.length) {
|
||||
const avail = buf.length - pos;
|
||||
if (state === 'signature') {
|
||||
if (avail < 8) break;
|
||||
if (!buf.subarray(pos, pos + 8).equals(SIGNATURE)) throw broken('нет сигнатуры PNG');
|
||||
pos += 8;
|
||||
state = 'header';
|
||||
} else if (state === 'header') {
|
||||
if (avail < 8) break;
|
||||
left = buf.readUInt32BE(pos);
|
||||
type = buf.toString('latin1', pos + 4, pos + 8);
|
||||
startChunk(left);
|
||||
crc = crc32(buf.subarray(pos + 4, pos + 8));
|
||||
pos += 8;
|
||||
state = left ? 'data' : 'crc';
|
||||
} else if (state === 'data') {
|
||||
const part = buf.subarray(pos, pos + Math.min(left, avail));
|
||||
crc = crc32(part, crc);
|
||||
if (type === 'IHDR') ihdr = Buffer.concat([ihdr, part]);
|
||||
if (type === 'IDAT') {
|
||||
await feed(part);
|
||||
if (zerr) throw broken('повреждён поток zlib');
|
||||
if (badFilter) throw broken('неверный тип фильтра строки');
|
||||
if (inflated > expected) throw broken('данных больше, чем пикселей');
|
||||
}
|
||||
left -= part.length;
|
||||
pos += part.length;
|
||||
if (!left) state = 'crc';
|
||||
} else if (state === 'crc') {
|
||||
if (avail < 4) break;
|
||||
if (buf.readUInt32BE(pos) !== crc) throw broken(`неверная CRC chunk ${type}`);
|
||||
pos += 4;
|
||||
endChunk();
|
||||
} else {
|
||||
throw broken('данные после IEND');
|
||||
}
|
||||
}
|
||||
carry = Buffer.from(buf.subarray(pos));
|
||||
}
|
||||
|
||||
return {
|
||||
async write(chunk) {
|
||||
try {
|
||||
await write(chunk);
|
||||
} catch (err) {
|
||||
inflate.destroy();
|
||||
throw err;
|
||||
}
|
||||
},
|
||||
async end() {
|
||||
if (state !== 'done') throw broken('файл обрезан');
|
||||
inflate.end();
|
||||
try {
|
||||
await finished(inflate);
|
||||
} catch {
|
||||
throw broken('поток zlib не завершён');
|
||||
}
|
||||
if (badFilter) throw broken('неверный тип фильтра строки');
|
||||
if (inflated !== expected) throw broken('объём данных не совпадает с размерами');
|
||||
return dims!;
|
||||
},
|
||||
close: () => inflate.destroy(),
|
||||
};
|
||||
}
|
||||
|
||||
// SOF0–SOF15 кроме DHT (C4), JPG (C8), DAC (CC): в них ширина и высота кадра.
|
||||
const SOF = new Set([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]);
|
||||
// Принимается то, что декодирует libjpeg-turbo через обычный 8-битный API: baseline, extended, progressive
|
||||
// с Huffman- или arithmetic-кодированием. Lossless и hierarchical (C3, C5–C7, CB, CD–CF) отвергаются.
|
||||
const SUPPORTED_SOF = new Set([0xc0, 0xc1, 0xc2, 0xc9, 0xca]);
|
||||
const DHT = 0xc4;
|
||||
const SOS = 0xda;
|
||||
const DQT = 0xdb;
|
||||
const DRI = 0xdd;
|
||||
const PARSED = new Set([...SUPPORTED_SOF, DHT, SOS, DQT]);
|
||||
|
||||
type Component = { h: number; v: number; tq: number };
|
||||
|
||||
function jpeg(maxPixels: number): ImageValidator {
|
||||
let carry = Buffer.alloc(0);
|
||||
let state: 'soi' | 'marker' | 'length' | 'payload' | 'scan' | 'done' = 'soi';
|
||||
let marker = 0;
|
||||
let left = 0;
|
||||
let seg = Buffer.alloc(0); // payload разбираемого сегмента (SOF, DHT, DQT, SOS)
|
||||
let dims: Dimensions | null = null;
|
||||
let progressive = false;
|
||||
let arithmetic = false;
|
||||
let scanned = false;
|
||||
let scanData = 0; // байт энтропийных данных в текущем скане
|
||||
const components = new Map<number, Component>();
|
||||
const quant = new Set<number>(); // номера определённых таблиц DQT
|
||||
const huff = new Set<number>(); // таблицы DHT: класс << 2 | номер
|
||||
|
||||
function frame() {
|
||||
const [precision, n] = [seg[0], seg[5]];
|
||||
const height = seg.readUInt16BE(1);
|
||||
const width = seg.readUInt16BE(3);
|
||||
if (!width || !height) throw broken('нулевые размеры');
|
||||
if (precision !== 8) throw broken('поддерживается только 8 бит на канал');
|
||||
if (![1, 3, 4].includes(n) || seg.length !== 6 + 3 * n) throw broken('неверный SOF');
|
||||
for (let i = 6; i < seg.length; i += 3) {
|
||||
const [id, h, v, tq] = [seg[i], seg[i + 1] >> 4, seg[i + 1] & 15, seg[i + 2]];
|
||||
if (components.has(id) || h < 1 || h > 4 || v < 1 || v > 4 || tq > 3) throw broken('неверные компоненты SOF');
|
||||
components.set(id, { h, v, tq });
|
||||
}
|
||||
// libjpeg восстанавливает цвет только при целом отношении прореживания к максимальному.
|
||||
const all = [...components.values()];
|
||||
const [maxH, maxV] = [Math.max(...all.map((c) => c.h)), Math.max(...all.map((c) => c.v))];
|
||||
if (all.some((c) => maxH % c.h || maxV % c.v)) throw broken('неподдерживаемое прореживание цвета');
|
||||
checkPixels(width, height, maxPixels); // до энтропийных данных
|
||||
dims = { width, height };
|
||||
progressive = marker === 0xc2 || marker === 0xca;
|
||||
arithmetic = marker >= 0xc9;
|
||||
}
|
||||
|
||||
function quantTables() {
|
||||
for (let i = 0; i < seg.length;) {
|
||||
const [pq, tq] = [seg[i] >> 4, seg[i] & 15];
|
||||
const size = 1 + 64 * (pq + 1);
|
||||
if (pq > 1 || tq > 3 || i + size > seg.length) throw broken('неверная таблица DQT');
|
||||
quant.add(tq);
|
||||
i += size;
|
||||
}
|
||||
}
|
||||
|
||||
function huffmanTables() {
|
||||
for (let i = 0; i < seg.length;) {
|
||||
if (i + 17 > seg.length) throw broken('неверная таблица DHT');
|
||||
const [tc, th] = [seg[i] >> 4, seg[i] & 15];
|
||||
let total = 0;
|
||||
let code = 0;
|
||||
for (let len = 1; len <= 16; len++) {
|
||||
total += seg[i + len];
|
||||
code += seg[i + len];
|
||||
// Как jpeg_make_d_derived_tbl: коды длины len не должны занять всё пространство (код из одних 1 зарезервирован).
|
||||
if (code >= 1 << len) throw broken('неверная таблица DHT');
|
||||
code <<= 1;
|
||||
}
|
||||
const symbols = seg.subarray(i + 17, i + 17 + total);
|
||||
if (tc > 1 || th > 3 || total > 256 || symbols.length !== total) throw broken('неверная таблица DHT');
|
||||
if (tc === 0 && symbols.some((s) => s > 15)) throw broken('неверная таблица DHT');
|
||||
huff.add((tc << 2) | th);
|
||||
i += 17 + total;
|
||||
}
|
||||
}
|
||||
|
||||
function scan() {
|
||||
const n = seg[0];
|
||||
if (n < 1 || n > 4 || seg.length !== 4 + 2 * n) throw broken('неверный SOS');
|
||||
const [ss, se, ah, al] = [seg[1 + 2 * n], seg[2 + 2 * n], seg[3 + 2 * n] >> 4, seg[3 + 2 * n] & 15];
|
||||
if (progressive && (ss === 0 ? se !== 0 : ss > se || se > 63 || n !== 1)) throw broken('неверные параметры скана');
|
||||
if (progressive && ((ah && al !== ah - 1) || al > 13)) throw broken('неверные параметры скана');
|
||||
const seen = new Set<number>();
|
||||
let blocks = 0;
|
||||
for (let i = 1; i < 1 + 2 * n; i += 2) {
|
||||
const comp = components.get(seg[i]);
|
||||
if (!comp || seen.has(seg[i])) throw broken('SOS ссылается на неизвестный компонент');
|
||||
seen.add(seg[i]);
|
||||
blocks += comp.h * comp.v;
|
||||
if (!quant.has(comp.tq)) throw broken('нет таблицы квантования DQT');
|
||||
// Отсутствующие таблицы Хаффмана 0 и 1 libjpeg-turbo заменяет стандартными (Motion JPEG); 2 и 3 — нет.
|
||||
// У arithmetic-кодирования таблицы условий (DAC) необязательны, проверяется только номер.
|
||||
const [td, ta] = [seg[i + 1] >> 4, seg[i + 1] & 15];
|
||||
const missing = (cls: number, t: number) => t > 3 || (!arithmetic && t > 1 && !huff.has((cls << 2) | t));
|
||||
const needDC = !progressive || (ss === 0 && ah === 0);
|
||||
const needAC = !progressive || ss > 0;
|
||||
if ((needDC && missing(0, td)) || (needAC && missing(1, ta))) throw broken('нет таблицы энтропийного кодирования');
|
||||
}
|
||||
if (n > 1 && blocks > 10) throw broken('слишком большой MCU');
|
||||
scanned = true;
|
||||
scanData = 0;
|
||||
}
|
||||
|
||||
function write(chunk: Buffer) {
|
||||
const buf = carry.length ? Buffer.concat([carry, chunk]) : chunk;
|
||||
let pos = 0;
|
||||
loop: while (pos < buf.length) {
|
||||
const avail = buf.length - pos;
|
||||
switch (state) {
|
||||
case 'soi':
|
||||
if (avail < 2) break loop;
|
||||
if (buf[pos] !== 0xff || buf[pos + 1] !== 0xd8) throw broken('нет сигнатуры JPEG');
|
||||
pos += 2;
|
||||
state = 'marker';
|
||||
break;
|
||||
case 'marker': {
|
||||
if (avail < 2) break loop;
|
||||
if (buf[pos] !== 0xff) throw broken('ожидался маркер');
|
||||
const code = buf[pos + 1];
|
||||
if (code === 0xff) { // байты-заполнители 0xFF перед маркером
|
||||
pos += 1;
|
||||
break;
|
||||
}
|
||||
pos += 2;
|
||||
if (code === 0xd9) {
|
||||
if (!scanned) throw broken('EOI до данных изображения');
|
||||
state = 'done';
|
||||
} else if (code === 0x00 || code === 0xd8 || (code >= 0xd0 && code <= 0xd7)) {
|
||||
throw broken('неожиданный маркер');
|
||||
} else if (code !== 0x01) { // TEM не имеет длины
|
||||
marker = code;
|
||||
state = 'length';
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'length': {
|
||||
if (avail < 2) break loop;
|
||||
left = buf.readUInt16BE(pos) - 2;
|
||||
pos += 2;
|
||||
if (left < 0) throw broken('неверная длина сегмента');
|
||||
if (SOF.has(marker) && !SUPPORTED_SOF.has(marker)) throw broken('неподдерживаемый вид JPEG (lossless, hierarchical)');
|
||||
if (SOF.has(marker) && (dims || left < 6)) throw broken('неверный SOF');
|
||||
if (marker === SOS && !dims) throw broken('SOS до SOF');
|
||||
if (marker === DRI && left !== 2) throw broken('неверный DRI');
|
||||
seg = Buffer.alloc(0);
|
||||
state = 'payload';
|
||||
break;
|
||||
}
|
||||
case 'payload': {
|
||||
const n = Math.min(left, avail);
|
||||
if (PARSED.has(marker)) seg = Buffer.concat([seg, buf.subarray(pos, pos + n)]);
|
||||
pos += n;
|
||||
left -= n;
|
||||
if (left) break;
|
||||
if (SUPPORTED_SOF.has(marker)) frame();
|
||||
else if (marker === DQT) quantTables();
|
||||
else if (marker === DHT) huffmanTables();
|
||||
else if (marker === SOS) scan();
|
||||
state = marker === SOS ? 'scan' : 'marker';
|
||||
break;
|
||||
}
|
||||
case 'scan': {
|
||||
// Внутри энтропийных данных 0xFF допустим только как FF00 (stuffing) и RSTn; иначе начинается маркер.
|
||||
const ff = buf.indexOf(0xff, pos);
|
||||
scanData += (ff < 0 ? buf.length : ff) - pos;
|
||||
if (ff < 0) {
|
||||
pos = buf.length;
|
||||
} else if (ff + 1 >= buf.length) {
|
||||
pos = ff;
|
||||
break loop;
|
||||
} else {
|
||||
const next = buf[ff + 1];
|
||||
if (next === 0x00) {
|
||||
pos = ff + 2;
|
||||
scanData += 1;
|
||||
} else if (next >= 0xd0 && next <= 0xd7) {
|
||||
pos = ff + 2;
|
||||
} else if (next === 0xff) {
|
||||
pos = ff + 1; // заполнитель перед маркером
|
||||
} else {
|
||||
if (!scanData) throw broken('скан без данных');
|
||||
pos = ff;
|
||||
state = 'marker';
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'done': // данные после EOI (MPF, «живые» фото) — нормальная практика камер
|
||||
pos = buf.length;
|
||||
break;
|
||||
}
|
||||
}
|
||||
carry = Buffer.from(buf.subarray(pos));
|
||||
}
|
||||
|
||||
return {
|
||||
write: async (chunk) => write(chunk),
|
||||
async end() {
|
||||
if (state !== 'done') throw broken('нет EOI: файл обрезан');
|
||||
return dims!;
|
||||
},
|
||||
close: () => {},
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
// Сообщения: идемпотентная отправка и история чата.
|
||||
import type { Ctx, Result } from '../http/context.ts';
|
||||
import { badRequest, conflict, notFound } from '../http/errors.ts';
|
||||
import { afterCursor, limitOf, page } from '../http/pagination.ts';
|
||||
import { UUID, isText, jsonObject, readJson } from '../http/request.ts';
|
||||
import { requireMember } from './chats.ts';
|
||||
import { authenticate, sha256 } from './sessions.ts';
|
||||
|
||||
const IDEMPOTENCY_KEY = /^[A-Za-z0-9._:-]{1,128}$/;
|
||||
// attachment_ids в порядке, заданном отправителем; text[] драйвер pg возвращает как массив строк.
|
||||
const attachmentIds = (m: string) =>
|
||||
`ARRAY(SELECT ma.attachment_id::text FROM message_attachments ma WHERE ma.message_id = ${m}.id ORDER BY ma.position) AS attachment_ids`;
|
||||
const messageColumns = `id, chat_id, sender_id, text, rfc3339(created_at) AS created_at, ${attachmentIds('messages')}`;
|
||||
|
||||
// POST /api/v1/chats/{chat_id}/messages с обязательным Idempotency-Key.
|
||||
// Область ключа: пользователь + метод + путь чата + ключ.
|
||||
// Ключ и сообщение вставляются ОДНИМ оператором, поэтому фиксируются атомарно: при ошибке БД нет ни того,
|
||||
// ни другого, и клиент может безопасно повторить запрос с тем же ключом.
|
||||
// Одновременный дубль (с любой реплики) ждёт на первичном ключе idempotency_keys, пока первая транзакция
|
||||
// не зафиксируется, затем получает ON CONFLICT DO NOTHING и отдаёт сохранённый результат.
|
||||
export async function sendMessage(c: Ctx): Promise<Result> {
|
||||
const user = await authenticate(c);
|
||||
const chatId = await requireMember(c, user); // повтор тоже заново проверяет сессию и доступ
|
||||
const key = c.req.headers['idempotency-key'];
|
||||
if (typeof key !== 'string' || !IDEMPOTENCY_KEY.test(key)) throw badRequest('Нужен Idempotency-Key [A-Za-z0-9._:-]{1,128}');
|
||||
// sender_id в теле не принимается: отправитель — из сессии.
|
||||
const b = jsonObject(await readJson(c.req), ['text', 'attachment_ids']);
|
||||
const ids = attachmentList(b.attachment_ids);
|
||||
const text = b.text;
|
||||
// С вложениями текст может быть пустым; без вложений — 1–4000 символов, не только пробелы.
|
||||
if (typeof text !== 'string' || [...text].length > 4000 || (!ids.length && !isText(text, 1, 4000))) {
|
||||
throw badRequest('text: до 4000 символов; пустой текст допустим только с вложениями');
|
||||
}
|
||||
if (ids.length) await requireAttachments(c, chatId, ids);
|
||||
|
||||
const path = `/api/v1/chats/${chatId}/messages`;
|
||||
// Каноническое тело: порядок ключей JSON не важен, отсутствующий attachment_ids = [].
|
||||
// Без вложений hash тот же, что в lab3 (32 байта); с вложениями 64 байта — с текстовым не совпадёт.
|
||||
const hash = ids.length ? Buffer.concat([sha256(text), sha256(ids.join(','))]) : sha256(text);
|
||||
let inserted;
|
||||
try {
|
||||
inserted = await c.db.query({
|
||||
name: 'send',
|
||||
text: `WITH k AS (
|
||||
INSERT INTO idempotency_keys (user_id, method, path, key, request_hash, message_id)
|
||||
VALUES ($1, 'POST', $2, $3, $4, gen_random_uuid()) ON CONFLICT DO NOTHING RETURNING message_id),
|
||||
m AS (INSERT INTO messages (id, chat_id, sender_id, text) SELECT message_id, $5, $1, $6 FROM k
|
||||
RETURNING id, chat_id, sender_id, text, rfc3339(created_at) AS created_at),
|
||||
a AS (INSERT INTO message_attachments (message_id, chat_id, attachment_id, position)
|
||||
SELECT m.id, m.chat_id, t.id, t.ord FROM m, unnest($7::uuid[]) WITH ORDINALITY AS t(id, ord))
|
||||
SELECT * FROM m`,
|
||||
values: [user.id, path, key, hash, chatId, text, ids],
|
||||
});
|
||||
} catch (err) {
|
||||
// Составной FK (chat_id, attachment_id): вложение другого чата не прикрепить даже в обход проверки выше.
|
||||
if ((err as { code?: string }).code === '23503') throw notFound();
|
||||
throw err;
|
||||
}
|
||||
if (inserted.rowCount) return [201, { ...inserted.rows[0], attachment_ids: ids }];
|
||||
|
||||
// Ключ уже использован: тот же body → тот же 201 и то же сообщение, другой body → 409.
|
||||
const stored = await c.db.query(`SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, rfc3339(m.created_at) AS created_at,
|
||||
${attachmentIds('m')}
|
||||
FROM idempotency_keys k JOIN messages m ON m.id = k.message_id
|
||||
WHERE k.user_id = $1 AND k.method = 'POST' AND k.path = $2 AND k.key = $3`, [user.id, path, key]);
|
||||
const { request_hash, ...message } = stored.rows[0];
|
||||
if (!hash.equals(request_hash)) throw conflict('Idempotency-Key уже использован с другим телом');
|
||||
return [201, message];
|
||||
}
|
||||
|
||||
// GET /api/v1/chats/{chat_id}/messages: история по возрастанию (created_at, id), limit 1–100.
|
||||
export async function listMessages(c: Ctx): Promise<Result> {
|
||||
const user = await authenticate(c);
|
||||
const chatId = await requireMember(c, user);
|
||||
const limit = limitOf(c.url);
|
||||
const [ts, id] = afterCursor(c.url, 'm', chatId);
|
||||
const r = await c.db.query({
|
||||
name: 'history',
|
||||
text: `SELECT ${messageColumns} FROM messages WHERE chat_id = $1 AND (created_at, id) > ($2, $3::uuid)
|
||||
ORDER BY created_at, id LIMIT $4`,
|
||||
values: [chatId, ts, id, limit + 1],
|
||||
});
|
||||
return [200, page(r.rows, limit, 'm', chatId)];
|
||||
}
|
||||
|
||||
// attachment_ids: 0–10 уникальных UUID (в нижнем регистре), по умолчанию [].
|
||||
function attachmentList(value: unknown): string[] {
|
||||
if (value === undefined) return [];
|
||||
if (!Array.isArray(value) || value.length > 10 || !value.every((id) => typeof id === 'string' && UUID.test(id))) {
|
||||
throw badRequest('attachment_ids: до 10 UUID');
|
||||
}
|
||||
const ids = value.map((id: string) => id.toLowerCase());
|
||||
if (new Set(ids).size !== ids.length) throw badRequest('attachment_ids должны быть уникальны');
|
||||
return ids;
|
||||
}
|
||||
|
||||
// Все вложения из этого чата и приняты (queued/processing/ready). Чужое или неизвестное — 404, как и чужой чат;
|
||||
// failed — 409: прикреплять нечего, но объект виден участнику.
|
||||
async function requireAttachments(c: Ctx, chatId: string, ids: string[]): Promise<void> {
|
||||
const r = await c.db.query(`SELECT count(*)::int AS visible, count(*) FILTER (WHERE state = 'failed')::int AS failed
|
||||
FROM attachments WHERE id = ANY($1::uuid[]) AND chat_id = $2 AND state IN ('queued', 'processing', 'ready', 'failed')`, [ids, chatId]);
|
||||
if (r.rows[0].visible !== ids.length) throw notFound();
|
||||
if (r.rows[0].failed) throw conflict('Вложение не обработано (failed), прикрепить нельзя');
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
// Общая модель пользователя для модулей users и sessions.
|
||||
|
||||
export type User = { id: string; username: string; display_name: string; created_at: string };
|
||||
|
||||
export const USERNAME = /^[a-z0-9_]{3,32}$/;
|
||||
|
||||
// Время форматирует PostgreSQL: Date в JS потерял бы микросекунды, на которых держится cursor.
|
||||
export const userColumns = 'u.id, u.username, u.display_name, rfc3339(u.created_at) AS created_at';
|
||||
@@ -0,0 +1,29 @@
|
||||
// Хеширование паролей: scrypt из node:crypto (N=2^14, r=8, p=1, 16 MiB на хеш).
|
||||
// Формат хранения: scrypt$N$r$p$соль$хеш (base64), параметры читаются из записи при проверке.
|
||||
import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
|
||||
|
||||
const N = 16384;
|
||||
const R = 8;
|
||||
const P = 1;
|
||||
|
||||
function scryptKey(password: string, salt: Buffer, n: number, r: number, p: number): Promise<Buffer> {
|
||||
return new Promise((resolve, reject) =>
|
||||
scrypt(password, salt, 32, { N: n, r, p, maxmem: 64 << 20 }, (err, key) => (err ? reject(err) : resolve(key))));
|
||||
}
|
||||
|
||||
export async function hashPassword(password: string): Promise<string> {
|
||||
const salt = randomBytes(16);
|
||||
const key = await scryptKey(password, salt, N, R, P);
|
||||
return ['scrypt', N, R, P, salt.toString('base64'), key.toString('base64')].join('$');
|
||||
}
|
||||
|
||||
export async function checkPassword(password: string, encoded: string): Promise<boolean> {
|
||||
const [alg, n, r, p, salt, hash] = encoded.split('$');
|
||||
if (alg !== 'scrypt') return false;
|
||||
const got = await scryptKey(password, Buffer.from(salt, 'base64'), Number(n), Number(r), Number(p));
|
||||
return timingSafeEqual(got, Buffer.from(hash, 'base64'));
|
||||
}
|
||||
|
||||
// Хеш-пустышка: вход несуществующего пользователя стоит столько же, сколько неверный пароль,
|
||||
// поэтому по времени ответа нельзя узнать, существует ли username.
|
||||
export const dummyHash = hashPassword('dummy-password-for-timing');
|
||||
@@ -0,0 +1,62 @@
|
||||
// Сессии: вход по Basic, выход, проверка Bearer-токена.
|
||||
// В БД хранится только sha256(токена): дамп базы не даёт рабочих токенов.
|
||||
import { createHash, randomBytes } from 'node:crypto';
|
||||
import type { Ctx, Result } from '../http/context.ts';
|
||||
import { HttpError, unauthorized } from '../http/errors.ts';
|
||||
import { isText, requireEmptyBody } from '../http/request.ts';
|
||||
import { checkPassword, dummyHash } from './passwords.ts';
|
||||
import { USERNAME, userColumns, type User } from './model.ts';
|
||||
|
||||
export const sha256 = (s: string) => createHash('sha256').update(s).digest();
|
||||
|
||||
function bearerToken(c: Ctx): string | null {
|
||||
return /^Bearer +(\S+)$/i.exec(c.req.headers.authorization ?? '')?.[1] ?? null;
|
||||
}
|
||||
|
||||
// Текущий пользователь по Bearer-сессии. Basic и X-User-Id на бизнес-эндпоинтах не аутентифицируют.
|
||||
// Запрос именованный: pg готовит его один раз на соединение (улучшение из трека 1).
|
||||
export async function authenticate(c: Ctx): Promise<User> {
|
||||
const token = bearerToken(c);
|
||||
if (!token) throw unauthorized();
|
||||
const r = await c.db.query<User>({
|
||||
name: 'auth',
|
||||
text: `SELECT ${userColumns} FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = $1 AND s.expires_at > now()`,
|
||||
values: [sha256(token)],
|
||||
});
|
||||
if (!r.rowCount) throw unauthorized();
|
||||
return r.rows[0];
|
||||
}
|
||||
|
||||
// POST /api/v1/auth/sessions: Basic username:password → новый Bearer-токен.
|
||||
export async function createSession(c: Ctx): Promise<Result> {
|
||||
await requireEmptyBody(c.req); // контракт: только заголовок Basic, без JSON-тела
|
||||
const deny = new HttpError(401, 'unauthorized', 'Неверные учётные данные'); // одинаковый ответ на любую ошибку входа
|
||||
const m = /^Basic +([A-Za-z0-9+/]+=*)$/i.exec(c.req.headers.authorization ?? '');
|
||||
if (!m) throw deny;
|
||||
const decoded = Buffer.from(m[1], 'base64').toString('utf8');
|
||||
const colon = decoded.indexOf(':'); // в username двоеточия нет, в пароле может быть
|
||||
const username = decoded.slice(0, colon);
|
||||
const password = decoded.slice(colon + 1);
|
||||
if (colon < 0 || !USERNAME.test(username)) throw deny;
|
||||
|
||||
const r = await c.db.query<User & { password_hash: string }>(
|
||||
`SELECT ${userColumns}, u.password_hash FROM users u WHERE u.username = $1`, [username]);
|
||||
const row = r.rows[0];
|
||||
const valid = await checkPassword(password, row?.password_hash ?? await dummyHash);
|
||||
if (!row || !valid || !isText(password, 12, 128)) throw deny;
|
||||
|
||||
const token = randomBytes(32).toString('base64url'); // 256 бит энтропии
|
||||
const s = await c.db.query(
|
||||
`INSERT INTO sessions (token_hash, user_id, expires_at) VALUES ($1, $2, now() + make_interval(secs => $3))
|
||||
RETURNING rfc3339(expires_at) AS expires_at`, [sha256(token), row.id, c.config.sessionTtlSeconds]);
|
||||
const { password_hash: _, ...user } = row;
|
||||
return [201, { token, token_type: 'Bearer', expires_at: s.rows[0].expires_at, user }];
|
||||
}
|
||||
|
||||
// DELETE /api/v1/auth/sessions/current: отзыв текущего токена.
|
||||
export async function deleteSession(c: Ctx): Promise<Result> {
|
||||
await authenticate(c);
|
||||
await c.db.query('DELETE FROM sessions WHERE token_hash = $1', [sha256(bearerToken(c)!)]);
|
||||
return [204];
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
// Пользователи: регистрация и профиль текущего пользователя.
|
||||
import type { Ctx, Result } from '../http/context.ts';
|
||||
import { badRequest, conflict } from '../http/errors.ts';
|
||||
import { isText, jsonObject, readJson } from '../http/request.ts';
|
||||
import { hashPassword } from './passwords.ts';
|
||||
import { USERNAME, userColumns, type User } from './model.ts';
|
||||
import { authenticate } from './sessions.ts';
|
||||
|
||||
// POST /api/v1/users: публичная регистрация. Пароль и его хеш в ответ не попадают.
|
||||
export async function createUser(c: Ctx): Promise<Result> {
|
||||
const b = jsonObject(await readJson(c.req), ['username', 'display_name', 'password']);
|
||||
if (typeof b.username !== 'string' || !USERNAME.test(b.username) || !isText(b.display_name, 1, 100) || !isText(b.password, 12, 128)) {
|
||||
throw badRequest('Неверные username, display_name или password');
|
||||
}
|
||||
try {
|
||||
const r = await c.db.query<User>(
|
||||
`INSERT INTO users AS u (username, display_name, password_hash) VALUES ($1, $2, $3) RETURNING ${userColumns}`,
|
||||
[b.username, b.display_name, await hashPassword(b.password)]);
|
||||
return [201, r.rows[0]];
|
||||
} catch (err) {
|
||||
if ((err as { code?: string }).code === '23505') throw conflict('Username уже занят'); // unique_violation
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
|
||||
// GET /api/v1/users/me
|
||||
export async function me(c: Ctx): Promise<Result> {
|
||||
return [200, await authenticate(c)];
|
||||
}
|
||||
@@ -0,0 +1,260 @@
|
||||
// Сверка PostgreSQL ↔ S3: очистка после сбоев загрузки (уровень 4) и исправление расхождений (трек 2).
|
||||
// node src/main.ts reconcile — dry-run: только отчёт, ничего не меняет
|
||||
// ... reconcile --apply — выполнить исправления
|
||||
// --verify дополнительно скачать ready-объекты и сверить SHA-256 (читает все байты bucket)
|
||||
// --grace=N pending-строки и объекты без строки моложе N секунд не трогаются (RECONCILE_GRACE_SECONDS, 900)
|
||||
// --retention=N staging failed-вложений хранится N секунд для replay (STAGING_RETENTION_SECONDS, 86400)
|
||||
// --every=N повторять каждые N секунд (так работает сервис reconciler)
|
||||
//
|
||||
// Правила. Строки ready/lost не удаляются никогда, используемые сообщениями дополнительно защищены FK.
|
||||
// stale_pending pending старше grace: запрос загрузки давно завершён (таймаут API 60 с ≪ grace)
|
||||
// → удалить строку, затем объект (если упадём между ними — останется orphan_object)
|
||||
// orphan_object объект без строки старше grace → удалить объект. Строка создаётся раньше объекта,
|
||||
// ключ случайный, поэтому строка для такого объекта уже не появится
|
||||
// missing_object ready без объекта (повторно проверено HEAD) → lost: скрыть из API, ссылки сохранить
|
||||
// size_mismatch ready, размер объекта ≠ size_bytes → lost
|
||||
// checksum_mismatch ready, SHA-256 объекта ≠ sha256 (только --verify) → lost
|
||||
// restored lost, объект на месте и SHA-256 совпал → снова ready (карантин обратим)
|
||||
// Lab5, префиксы staging/ и variants/ (объект нужен, пока на него ссылается БД):
|
||||
// orphan_staging staging без строки старше grace → удалить
|
||||
// published_staging staging ready-вложения старше grace (worker не успел удалить после фиксации) → удалить
|
||||
// expired_staging staging failed-вложения старше STAGING_RETENTION_SECONDS → удалить (replay после этого невозможен)
|
||||
// orphan_variant объект варианта без строки attachment_variants старше grace (попытка проиграла аренду
|
||||
// или упала до фиксации; grace ≫ JOB_TIMEOUT_SECONDS) → удалить
|
||||
//
|
||||
// Обход: ListObjectsV2 и строки БД, оба отсортированы по ключу побайтово, сливаются как два потока
|
||||
// (merge join) — память O(страница), запросов O(N / 1000). Конкурентные загрузки: строки, изменённые после
|
||||
// начала обхода (updated_at ≥ t0), не проверяются; их объекты моложе grace и тоже не трогаются.
|
||||
import { createHash } from 'node:crypto';
|
||||
import type { Readable } from 'node:stream';
|
||||
import { setTimeout as sleep } from 'node:timers/promises';
|
||||
import type pg from 'pg';
|
||||
import { s3Config, secret } from './config.ts';
|
||||
import { createPool } from './db.ts';
|
||||
import { createStorage, type Storage } from './storage/s3.ts';
|
||||
|
||||
const PREFIX = 'originals/';
|
||||
const PAGE = 1000;
|
||||
const PRINT_LIMIT = 20; // находки сверх лимита только считаются
|
||||
|
||||
type Options = { apply: boolean; verify: boolean; grace: number; retention: number };
|
||||
type Obj = { key: string; size: number; modified: Date };
|
||||
type Row = { id: string; object_key: string; state: string; size_bytes: number | null; sha256: string | null; settled: boolean };
|
||||
|
||||
export async function reconcileCommand(args: string[], defaultGrace: number, defaultRetention: number): Promise<void> {
|
||||
const flag = (name: string) => args.find((a) => a.startsWith(`--${name}=`))?.split('=')[1];
|
||||
const opts: Options = { apply: args.includes('--apply'), verify: args.includes('--verify'), grace: Number(flag('grace') ?? defaultGrace),
|
||||
retention: Number(flag('retention') ?? defaultRetention) };
|
||||
const every = Number(flag('every') ?? 0);
|
||||
if (!Number.isInteger(opts.grace) || opts.grace < 0 || !Number.isInteger(every) || every < 0) throw new Error('--grace/--every: целые секунды');
|
||||
const db = createPool(secret('DATABASE_URL'), 2);
|
||||
const s3 = createStorage(s3Config());
|
||||
process.on('SIGTERM', () => process.exit(0)); // прерванный обход безопасен: каждое действие атомарно
|
||||
for (;;) {
|
||||
try {
|
||||
console.log(JSON.stringify(await reconcile(db, s3, opts)));
|
||||
} catch (err) {
|
||||
console.error(`сверка не выполнена: ${(err as Error).message}`);
|
||||
if (!every) process.exitCode = 1;
|
||||
}
|
||||
if (!every) break;
|
||||
await sleep(every * 1000);
|
||||
}
|
||||
await db.end();
|
||||
}
|
||||
|
||||
export async function reconcile(db: pg.Pool, s3: Storage, opts: Options) {
|
||||
const started = performance.now();
|
||||
const lock = await db.connect();
|
||||
try {
|
||||
// Два reconciler-а одновременно не работают: второй сразу выходит.
|
||||
if (!(await lock.query('SELECT pg_try_advisory_lock(4004) AS ok')).rows[0].ok) return { skipped: 'другая сверка уже идёт' };
|
||||
try {
|
||||
return await run(db, s3, opts, started);
|
||||
} finally {
|
||||
await lock.query('SELECT pg_advisory_unlock(4004)');
|
||||
}
|
||||
} finally {
|
||||
lock.release();
|
||||
}
|
||||
}
|
||||
|
||||
async function run(db: pg.Pool, s3: Storage, { apply, verify, grace, retention }: Options, started: number) {
|
||||
const stats = { mode: apply ? 'apply' : 'dry-run', verify, grace_seconds: grace, objects: 0, rows: 0, fresh_skipped: 0,
|
||||
s3_list: 0, s3_head: 0, s3_get_bytes: 0, db_queries: 0, findings: {} as Record<string, number>, applied: 0 };
|
||||
const t0: Date = (await db.query('SELECT now() AS t0')).rows[0].t0;
|
||||
stats.db_queries++;
|
||||
const cutoff = t0.getTime() - grace * 1000;
|
||||
|
||||
const found = async (kind: string, detail: Record<string, unknown>, fix: () => Promise<boolean>) => {
|
||||
const n = stats.findings[kind] = (stats.findings[kind] ?? 0) + 1;
|
||||
const done = apply && await fix();
|
||||
if (done) stats.applied++;
|
||||
if (n <= PRINT_LIMIT) console.log(JSON.stringify({ finding: kind, ...detail, action: apply ? (done ? 'fixed' : 'changed meanwhile, skipped') : 'would fix' }));
|
||||
};
|
||||
const setState = async (id: string, from: string, to: string) => {
|
||||
stats.db_queries++;
|
||||
return Boolean((await db.query('UPDATE attachments SET state = $3, updated_at = clock_timestamp() WHERE id = $1 AND state = $2',
|
||||
[id, from, to])).rowCount);
|
||||
};
|
||||
const sha256Of = async (key: string) => {
|
||||
const body = await s3.get(key);
|
||||
if (!body) return null;
|
||||
const hash = createHash('sha256');
|
||||
for await (const chunk of body as Readable) {
|
||||
hash.update(chunk);
|
||||
stats.s3_get_bytes += chunk.length;
|
||||
}
|
||||
return hash.digest('hex');
|
||||
};
|
||||
|
||||
// 1. Зависшие загрузки. Условие повторяется в DELETE: если строка успела измениться, её не трогаем.
|
||||
const stale = await db.query(`SELECT id, COALESCE(staging_key, object_key) AS object_key FROM attachments
|
||||
WHERE state = 'pending' AND created_at < $1::timestamptz - make_interval(secs => $2)`, [t0, grace]);
|
||||
stats.db_queries++;
|
||||
for (const r of stale.rows) {
|
||||
await found('stale_pending', { id: r.id, key: r.object_key }, async () => {
|
||||
stats.db_queries++;
|
||||
const d = await db.query(`DELETE FROM attachments WHERE id = $1 AND state = 'pending'
|
||||
AND created_at < $2::timestamptz - make_interval(secs => $3)`, [r.id, t0, grace]);
|
||||
if (!d.rowCount) return false;
|
||||
await s3.remove(r.object_key);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
// 2. Слияние отсортированных потоков объектов и строк.
|
||||
const onlyObject = async (o: Obj) => {
|
||||
if (o.modified.getTime() > cutoff) {
|
||||
stats.fresh_skipped++;
|
||||
return;
|
||||
}
|
||||
await found('orphan_object', { key: o.key, size: o.size, modified: o.modified }, async () => {
|
||||
await s3.remove(o.key);
|
||||
return true;
|
||||
});
|
||||
};
|
||||
const onlyRow = async (r: Row) => {
|
||||
// pending — этап 1; lost — уже в карантине; не settled — строка изменилась после начала обхода.
|
||||
if (r.state !== 'ready' || !r.settled) return;
|
||||
stats.s3_head++;
|
||||
if (await s3.exists(r.object_key)) return; // объект не попал в листинг, но существует — не трогаем
|
||||
await found('missing_object', { id: r.id, key: r.object_key }, () => setState(r.id, 'ready', 'lost'));
|
||||
};
|
||||
const both = async (o: Obj, r: Row) => {
|
||||
// Оригинал до фиксации ready (processing/queued) может уже лежать в originals/: его не проверяем.
|
||||
if ((r.state !== 'ready' && r.state !== 'lost') || !r.settled) return;
|
||||
if (o.size !== r.size_bytes) {
|
||||
if (r.state === 'ready') await found('size_mismatch', { id: r.id, key: r.object_key, expected: r.size_bytes, actual: o.size }, () => setState(r.id, 'ready', 'lost'));
|
||||
return;
|
||||
}
|
||||
if (r.state === 'ready' && !verify) return;
|
||||
const actual = await sha256Of(o.key);
|
||||
if (r.state === 'ready' && actual !== r.sha256) {
|
||||
await found('checksum_mismatch', { id: r.id, key: r.object_key }, () => setState(r.id, 'ready', 'lost'));
|
||||
} else if (r.state === 'lost' && actual === r.sha256) {
|
||||
await found('restored', { id: r.id, key: r.object_key }, () => setState(r.id, 'lost', 'ready'));
|
||||
}
|
||||
};
|
||||
|
||||
const objs = objects(s3, stats);
|
||||
const rows = dbRows(db, t0, stats);
|
||||
let o = (await objs.next()).value;
|
||||
let r = (await rows.next()).value;
|
||||
while (o || r) {
|
||||
if (o && (!r || o.key < r.object_key)) {
|
||||
stats.objects++;
|
||||
await onlyObject(o);
|
||||
o = (await objs.next()).value;
|
||||
} else if (r && (!o || r.object_key < o.key)) {
|
||||
stats.rows++;
|
||||
await onlyRow(r);
|
||||
r = (await rows.next()).value;
|
||||
} else {
|
||||
stats.objects++;
|
||||
stats.rows++;
|
||||
await both(o!, r!);
|
||||
o = (await objs.next()).value;
|
||||
r = (await rows.next()).value;
|
||||
}
|
||||
}
|
||||
|
||||
// 3. staging/ и variants/: постраничный поиск ключей в БД.
|
||||
const remove = (key: string) => async () => {
|
||||
await s3.remove(key);
|
||||
return true;
|
||||
};
|
||||
for await (const page of pages(s3, 'staging/', stats)) {
|
||||
const r = await db.query(`SELECT staging_key AS key, state, updated_at < $2::timestamptz - make_interval(secs => $3) AS expired
|
||||
FROM attachments WHERE staging_key = ANY($1)`, [page.map((o) => o.key), t0, retention]);
|
||||
stats.db_queries++;
|
||||
const rows = new Map(r.rows.map((row) => [row.key, row]));
|
||||
for (const o of page) {
|
||||
stats.objects++;
|
||||
const row = rows.get(o.key);
|
||||
const old = o.modified.getTime() <= cutoff;
|
||||
if (!row && !old) stats.fresh_skipped++;
|
||||
else if (!row) await found('orphan_staging', { key: o.key }, remove(o.key));
|
||||
else if (row.state === 'ready' && old) await found('published_staging', { key: o.key }, remove(o.key));
|
||||
else if (row.state === 'failed' && row.expired) {
|
||||
await found('expired_staging', { key: o.key }, async () => {
|
||||
await s3.remove(o.key);
|
||||
await db.query(`UPDATE attachments SET staging_key = NULL WHERE staging_key = $1 AND state = 'failed'`, [o.key]);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
for await (const page of pages(s3, 'variants/', stats)) {
|
||||
const r = await db.query('SELECT object_key FROM attachment_variants WHERE object_key = ANY($1)', [page.map((o) => o.key)]);
|
||||
stats.db_queries++;
|
||||
const known = new Set(r.rows.map((row) => row.object_key));
|
||||
for (const o of page) {
|
||||
stats.objects++;
|
||||
if (known.has(o.key)) continue;
|
||||
if (o.modified.getTime() > cutoff) stats.fresh_skipped++;
|
||||
else await found('orphan_variant', { key: o.key }, remove(o.key));
|
||||
}
|
||||
}
|
||||
return { ...stats, duration_ms: Math.round(performance.now() - started), max_rss_mb: Math.round(process.resourceUsage().maxRSS / 1024) };
|
||||
}
|
||||
|
||||
async function* pages(s3: Storage, prefix: string, stats: { s3_list: number }): AsyncGenerator<Obj[], undefined> {
|
||||
let token: string | undefined;
|
||||
do {
|
||||
const page = await s3.list(prefix, token);
|
||||
stats.s3_list++;
|
||||
yield (page.Contents ?? []).map((item) => ({ key: item.Key!, size: item.Size ?? 0, modified: item.LastModified! }));
|
||||
token = page.IsTruncated ? page.NextContinuationToken : undefined;
|
||||
} while (token);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
async function* objects(s3: Storage, stats: { s3_list: number }): AsyncGenerator<Obj, undefined> {
|
||||
let token: string | undefined;
|
||||
let last = '';
|
||||
do {
|
||||
const page = await s3.list(PREFIX, token);
|
||||
stats.s3_list++;
|
||||
for (const item of page.Contents ?? []) {
|
||||
// Слияние корректно только на отсортированных потоках: иначе остановиться, а не удалить лишнее.
|
||||
if (item.Key! <= last) throw new Error('S3 вернул ключи не по порядку');
|
||||
last = item.Key!;
|
||||
yield { key: item.Key!, size: item.Size ?? 0, modified: item.LastModified! };
|
||||
}
|
||||
token = page.IsTruncated ? page.NextContinuationToken : undefined;
|
||||
} while (token);
|
||||
return undefined;
|
||||
}
|
||||
|
||||
async function* dbRows(db: pg.Pool, t0: Date, stats: { db_queries: number }): AsyncGenerator<Row, undefined> {
|
||||
let last = '';
|
||||
for (;;) {
|
||||
const r = await db.query<Row>(`SELECT id, object_key, state, size_bytes, sha256, updated_at < $2 AS settled
|
||||
FROM attachments WHERE object_key > $1 ORDER BY object_key LIMIT ${PAGE}`, [last, t0]);
|
||||
stats.db_queries++;
|
||||
yield* r.rows;
|
||||
if (r.rows.length < PAGE) return undefined;
|
||||
last = r.rows[r.rows.length - 1].object_key;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
// S3-совместимое хранилище байтов вложений (SeaweedFS). Один приватный bucket, ключи объектов назначает сервер.
|
||||
// Ошибки переводятся в ответы контракта: недоступность хранилища — 503, ошибка конфигурации/прав — 500.
|
||||
import {
|
||||
CopyObjectCommand,
|
||||
CreateBucketCommand,
|
||||
DeleteObjectCommand,
|
||||
GetObjectCommand,
|
||||
HeadObjectCommand,
|
||||
ListObjectsV2Command,
|
||||
PutObjectCommand,
|
||||
S3Client,
|
||||
} from '@aws-sdk/client-s3';
|
||||
import type { Readable } from 'node:stream';
|
||||
import type { S3Config } from '../config.ts';
|
||||
import { HttpError, unavailable } from '../http/errors.ts';
|
||||
|
||||
export type Storage = ReturnType<typeof createStorage>;
|
||||
|
||||
export function createStorage(cfg: S3Config) {
|
||||
const client = new S3Client({
|
||||
endpoint: cfg.endpoint,
|
||||
region: cfg.region,
|
||||
forcePathStyle: true,
|
||||
credentials: { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey },
|
||||
// Тело PUT уходит как есть с Content-Length, без aws-chunked/trailer: SHA-256 считает сам API.
|
||||
requestChecksumCalculation: 'WHEN_REQUIRED',
|
||||
responseChecksumValidation: 'WHEN_REQUIRED',
|
||||
// Потоковое тело PUT нельзя отправить повторно; повтор — решение клиента API (он получит 503).
|
||||
maxAttempts: 1,
|
||||
// Недоступный S3 — быстрый отказ (1 с); requestTimeout — простой сокета, а не длительность всей загрузки.
|
||||
// requestTimeout < timeout server HAProxy (10 с): при зависшем S3 ответит API (503), а не LB (504).
|
||||
requestHandler: { connectionTimeout: 1000, requestTimeout: 8000, throwOnRequestTimeout: true },
|
||||
});
|
||||
const Bucket = cfg.bucket;
|
||||
const send = async <T>(p: Promise<T>): Promise<T> => {
|
||||
try {
|
||||
return await p;
|
||||
} catch (err) {
|
||||
throw storageError(err);
|
||||
}
|
||||
};
|
||||
|
||||
return {
|
||||
bucket: Bucket,
|
||||
put: (key: string, body: Readable, length: number, type: string, signal: AbortSignal) =>
|
||||
send(client.send(new PutObjectCommand({ Bucket, Key: key, Body: body, ContentLength: length, ContentType: type }), { abortSignal: signal })),
|
||||
putBuffer: (key: string, body: Buffer, type: string) =>
|
||||
send(client.send(new PutObjectCommand({ Bucket, Key: key, Body: body, ContentType: type }))),
|
||||
// Копия на стороне S3 (байты не идут через процесс): публикация оригинала из staging в конечный prefix.
|
||||
copy: (from: string, to: string) =>
|
||||
send(client.send(new CopyObjectCommand({ Bucket, CopySource: `${Bucket}/${from}`, Key: to }))),
|
||||
// null — объекта нет.
|
||||
async get(key: string): Promise<Readable | null> {
|
||||
try {
|
||||
return (await client.send(new GetObjectCommand({ Bucket, Key: key }))).Body as Readable;
|
||||
} catch (err) {
|
||||
if (isMissing(err)) return null;
|
||||
throw storageError(err);
|
||||
}
|
||||
},
|
||||
async exists(key: string): Promise<boolean> {
|
||||
try {
|
||||
await client.send(new HeadObjectCommand({ Bucket, Key: key }));
|
||||
return true;
|
||||
} catch (err) {
|
||||
if (isMissing(err)) return false;
|
||||
throw storageError(err);
|
||||
}
|
||||
},
|
||||
remove: (key: string) => send(client.send(new DeleteObjectCommand({ Bucket, Key: key }))),
|
||||
list: (prefix: string, token?: string) =>
|
||||
send(client.send(new ListObjectsV2Command({ Bucket, Prefix: prefix, ContinuationToken: token, MaxKeys: 1000 }))),
|
||||
// Идемпотентный bootstrap: существующий bucket этого владельца — не ошибка.
|
||||
async createBucket(): Promise<'created' | 'exists'> {
|
||||
try {
|
||||
await client.send(new CreateBucketCommand({ Bucket }));
|
||||
return 'created';
|
||||
} catch (err) {
|
||||
if ((err as Error).name === 'BucketAlreadyOwnedByYou') return 'exists';
|
||||
throw err;
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function isMissing(err: unknown): boolean {
|
||||
const e = err as { name?: string; $metadata?: { httpStatusCode?: number } };
|
||||
return e.name === 'NoSuchKey' || e.name === 'NotFound' || e.$metadata?.httpStatusCode === 404;
|
||||
}
|
||||
|
||||
// 4xx от S3 (AccessDenied, неверный bucket) — ошибка конфигурации: 500. Сеть, таймаут, 5xx — 503, клиент может повторить.
|
||||
function storageError(err: unknown): Error {
|
||||
if (err instanceof HttpError) return err;
|
||||
const e = err as { name?: string; message?: string; $metadata?: { httpStatusCode?: number } };
|
||||
if (e.name === 'AbortError') return err as Error; // загрузку прервал сам API, причину знает вызывающий
|
||||
console.error(`S3: ${e.name} ${e.message}`);
|
||||
const status = e.$metadata?.httpStatusCode ?? 0;
|
||||
return status >= 400 && status < 500 ? new HttpError(500, 'internal_error', 'Внутренняя ошибка') : unavailable('Хранилище файлов недоступно');
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Негативные и граничные сценарии вложений (уровень 4) через LB: ни один из них не должен дать 500.
|
||||
Lab5: принятый файл — 202 queued, байты и варианты доступны после ready (worker).
|
||||
Изображения генерируются кодом (PNG — zlib/struct), JPEG — синтетический fixtures/sample.jpg (sips из sample.png).
|
||||
Запуск: python3 student-tests/attachments.py --base-url http://localhost:8080"""
|
||||
import hashlib
|
||||
import http.client
|
||||
import os
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import sys
|
||||
import time
|
||||
import urllib.parse
|
||||
import uuid
|
||||
import zlib
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
|
||||
from client import Client, ROOT, arguments, check, run # noqa: E402
|
||||
|
||||
MiB = 1024 * 1024
|
||||
SAMPLE_PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
|
||||
SAMPLE_JPG = (Path(__file__).parent / 'fixtures/sample.jpg').read_bytes()
|
||||
|
||||
|
||||
def chunk(kind, data):
|
||||
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
|
||||
|
||||
|
||||
def png(width, height, raw, depth=8, color=2, level=1):
|
||||
"""PNG из готовых распакованных строк raw (байт фильтра + пиксели)."""
|
||||
ihdr = struct.pack('>IIBBBBB', width, height, depth, color, 0, 0, 0)
|
||||
return b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', ihdr) + chunk(b'IDAT', zlib.compress(raw, level)) + chunk(b'IEND', b'')
|
||||
|
||||
|
||||
def noise_png(side):
|
||||
"""RGB-шум не сжимается: размер файла ≈ side² × 3 байт."""
|
||||
row = 1 + side * 3
|
||||
return png(side, side, b''.join(b'\0' + os.urandom(row - 1) for _ in range(side)))
|
||||
|
||||
|
||||
def gray1(width, height):
|
||||
"""1-битный серый PNG из нулей: 40 Мпикс занимают несколько килобайт файла."""
|
||||
return png(width, height, bytes(height * (1 + (width + 7) // 8)), depth=1, color=0, level=9)
|
||||
|
||||
|
||||
def jpeg_with_size(data, width, height):
|
||||
"""Подменить размеры в SOF0 существующего JPEG."""
|
||||
i = data.index(b'\xff\xc0')
|
||||
return data[:i + 5] + struct.pack('>HH', height, width) + data[i + 9:]
|
||||
|
||||
|
||||
def jpeg_without(data, marker):
|
||||
"""Вырезать из JPEG все сегменты с маркером marker, стоящие до SOS."""
|
||||
out, i = data[:2], 2
|
||||
while data[i + 1] != 0xda:
|
||||
size = 2 + struct.unpack('>H', data[i + 2:i + 4])[0]
|
||||
if data[i + 1] != marker:
|
||||
out += data[i:i + size]
|
||||
i += size
|
||||
return out + data[i:]
|
||||
|
||||
|
||||
def bare_jpeg():
|
||||
"""27 байт: SOI, SOF0 1x1, SOS, EOI — без таблиц DQT/DHT и без данных скана."""
|
||||
return (b'\xff\xd8' + b'\xff\xc0' + struct.pack('>HBHHB', 11, 8, 1, 1, 1) + b'\x01\x11\x00'
|
||||
+ b'\xff\xda' + struct.pack('>HB', 8, 1) + b'\x01\x00\x00\x3f\x00' + b'\xff\xd9')
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Attachment negative suite')
|
||||
c = Client(args.base_url, args.ca_file, timeout=30)
|
||||
alice, bob, eve, chat = c.bootstrap()
|
||||
other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой чат', 'member_ids': [alice['id']]}, schema='Chat')['json']
|
||||
results = []
|
||||
|
||||
def upload(data, expected, ctype='image/png', name='file.png', actor=alice, target=chat, label=None):
|
||||
path = '/api/v1/chats/' + target['id'] + '/attachments?filename=' + urllib.parse.quote(name, safe='')
|
||||
r = c.call('POST', path, expected, actor=actor, raw=data, headers={'Content-Type': ctype}, schema='Attachment' if expected == 202 else None)
|
||||
results.append((label or name, r['status'], (r['json'] or {}).get('error', {}).get('code', ''), round(r['elapsed'] * 1000)))
|
||||
if expected == 202:
|
||||
att = r['json']
|
||||
check(att['sha256'] == hashlib.sha256(data).hexdigest() and att['size_bytes'] == len(data), label + ': checksum/size')
|
||||
check(att['content_type'] == ctype and att['filename'] == name, label + ': metadata')
|
||||
check(att['status'] == 'queued' and att['variants'] == [] and att['error_code'] is None, label + ': 202 snapshot')
|
||||
return att
|
||||
return r['json']
|
||||
|
||||
def download(att, actor=bob, expect=None):
|
||||
att = c.wait_ready(actor, att, 120)
|
||||
r = c.call('GET', '/api/v1/attachments/' + att['id'] + '/content', actor=actor)
|
||||
check(r['bytes'] == expect and hashlib.sha256(r['bytes']).hexdigest() == att['sha256'], 'download differs')
|
||||
check(r['headers'].get_content_type() == att['content_type'], 'download content type')
|
||||
check(r['headers'].get('X-Content-Type-Options') == 'nosniff', 'missing nosniff')
|
||||
check(not r['headers'].get('Location'), 'download must not redirect')
|
||||
|
||||
# Принимаются реальные PNG/JPEG, граница по размеру и по пикселям.
|
||||
jpg = upload(SAMPLE_JPG, 202, 'image/jpeg', 'фото 📷 2026.jpg', label='real JPEG + unicode filename')
|
||||
download(jpg, expect=SAMPLE_JPG)
|
||||
big = noise_png(1860)
|
||||
check(9 * MiB < len(big) <= 10 * MiB, 'big fixture size %d' % len(big))
|
||||
big_att = upload(big, 202, label='PNG %.2f MiB (noise 1860x1860)' % (len(big) / MiB))
|
||||
download(big_att, expect=big)
|
||||
huge = upload(gray1(6400, 6250), 202, label='PNG ровно 40 000 000 px')
|
||||
huge = c.wait_ready(bob, huge, 120) # worker обрабатывает предельный по пикселям файл в своих лимитах
|
||||
dims = {v['name']: (v['width'], v['height']) for v in huge['variants']}
|
||||
check(dims == {'thumbnail': (256, 250), 'crop': (128, 128), 'optimized': (1280, 1250)}, 'variants of 6400x6250: %s' % dims)
|
||||
|
||||
# Лимиты: до чтения тела (Content-Length) и по заголовку изображения до распаковки.
|
||||
upload(noise_png(1900), 413, label='PNG 10.33 MiB > 10 MiB')
|
||||
upload(os.urandom(10 * MiB + 1), 413, label='10 MiB + 1 байт')
|
||||
upload(gray1(6400, 6251), 413, label='PNG 40 006 400 px')
|
||||
bomb = gray1(30000, 30000)
|
||||
upload(bomb, 413, label='pixel-bomb 30000x30000, файл %d КБ' % (len(bomb) // 1024))
|
||||
upload(jpeg_with_size(SAMPLE_JPG, 10000, 10000), 413, 'image/jpeg', 'bomb.jpg', label='JPEG SOF 10000x10000')
|
||||
# IHDR обещает 100x100, а IDAT распаковывается в 64 МБ нулей: распаковка останавливается на лишних данных.
|
||||
upload(png(100, 100, bytes(64 * MiB), level=9), 415, label='zip-bomb в IDAT (64 МБ при 100x100)')
|
||||
|
||||
# Повреждённые файлы и подмена типа.
|
||||
bad_crc = bytearray(SAMPLE_PNG)
|
||||
bad_crc[1000] ^= 0xFF
|
||||
upload(bytes(bad_crc), 415, label='PNG: байт IDAT испорчен (CRC)')
|
||||
upload(png(320, 200, os.urandom(1000)), 415, label='PNG: корректные CRC, мусор в zlib')
|
||||
upload(png(320, 200, bytes(100)), 415, label='PNG: данных меньше, чем пикселей')
|
||||
upload(SAMPLE_PNG[:-200], 415, label='PNG обрезан')
|
||||
upload(SAMPLE_PNG + b'<html>', 415, label='PNG + данные после IEND')
|
||||
upload(png(1, 1, b'\x05\0\0\0'), 415, label='PNG 1x1: фильтр строки 5 (допустимы 0–4)')
|
||||
upload(bare_jpeg(), 415, 'image/jpeg', 'bare.jpg', label='JPEG 27 байт: без DQT/DHT и скана')
|
||||
upload(jpeg_without(SAMPLE_JPG, 0xdb), 415, 'image/jpeg', 'nodqt.jpg', label='JPEG без таблиц квантования DQT')
|
||||
upload(SAMPLE_JPG[:-500], 415, 'image/jpeg', 'cut.jpg', label='JPEG обрезан (нет EOI)')
|
||||
upload(SAMPLE_PNG, 415, 'image/jpeg', 'spoof.jpg', label='PNG под видом image/jpeg')
|
||||
upload(SAMPLE_JPG, 415, 'image/png', 'spoof.png', label='JPEG под видом image/png')
|
||||
upload(b'GIF89a' + os.urandom(100), 415, label='GIF под видом image/png')
|
||||
upload(b'<svg xmlns="http://www.w3.org/2000/svg"/>', 415, label='SVG под видом image/png')
|
||||
upload(SAMPLE_PNG, 415, 'image/gif', 'x.gif', label='Content-Type image/gif')
|
||||
upload(SAMPLE_PNG, 415, 'application/octet-stream', 'x.png', label='Content-Type octet-stream')
|
||||
upload(b'', 415, label='пустое тело')
|
||||
|
||||
# Опасные и некорректные filename: 400 до чтения тела.
|
||||
for name in ['../etc/passwd', 'a/b.png', 'a\\b.png', 'nul\x00.png', 'tab\t.png', 'line\n.png', 'c1\x85.png', '', ' ', 'x' * 256]:
|
||||
upload(SAMPLE_PNG, 400, name=name, label='filename %r' % name[:20])
|
||||
r = c.call('POST', '/api/v1/chats/' + chat['id'] + '/attachments', 400, actor=alice, raw=SAMPLE_PNG, headers={'Content-Type': 'image/png'})
|
||||
results.append(('без filename', r['status'], r['json']['error']['code'], round(r['elapsed'] * 1000)))
|
||||
results.append(('chunked без Content-Length',) + chunked_upload(c, alice, chat))
|
||||
|
||||
# Доступ: без сессии, посторонний, чужое вложение.
|
||||
upload(SAMPLE_PNG, 401, actor={'id': '', 'token': 'bad'}, label='без действительной сессии')
|
||||
upload(SAMPLE_PNG, 404, actor=eve, label='посторонний грузит в чужой чат')
|
||||
upload(SAMPLE_PNG, 404, target={'id': str(uuid.uuid4())}, label='несуществующий чат')
|
||||
upload(SAMPLE_PNG, 400, target={'id': 'not-a-uuid'}, label='chat_id не UUID')
|
||||
own = upload(SAMPLE_PNG, 202, label='обычный PNG')
|
||||
foreign = upload(SAMPLE_PNG, 202, target=other, label='PNG в другом чате')
|
||||
for suffix in ('', '/content'):
|
||||
c.call('GET', '/api/v1/attachments/' + own['id'] + suffix, 404, actor=eve)
|
||||
c.call('GET', '/api/v1/attachments/' + foreign['id'] + suffix, 404, actor=bob)
|
||||
c.call('GET', '/api/v1/attachments/' + str(uuid.uuid4()) + suffix, 404, actor=bob)
|
||||
c.call('GET', '/api/v1/attachments/xyz' + suffix, 400, actor=bob)
|
||||
c.call('GET', '/api/v1/attachments/' + own['id'] + suffix, 401)
|
||||
content = '/api/v1/attachments/' + own['id'] + '/content'
|
||||
c.wait_ready(bob, own)
|
||||
check(c.call('GET', content + '?variant=thumbnail', actor=bob)['headers'].get_content_type() == 'image/jpeg', 'thumbnail type')
|
||||
check(c.call('GET', content + '?variant=optimized', actor=bob)['headers'].get_content_type() == 'image/webp', 'optimized type')
|
||||
c.call('GET', content + '?variant=bogus', 400, actor=bob)
|
||||
check(c.call('GET', content + '?variant=original', actor=bob)['bytes'] == SAMPLE_PNG, 'variant=original')
|
||||
|
||||
# Привязка к сообщению: только вложения этого чата, 0–10 уникальных UUID.
|
||||
send = '/api/v1/chats/' + chat['id'] + '/messages'
|
||||
|
||||
def post(body, expected, key=None):
|
||||
return c.call('POST', send, expected, actor=alice, body=body, headers={'Idempotency-Key': key or uuid.uuid4().hex},
|
||||
schema='Message' if expected == 201 else None)['json']
|
||||
|
||||
post({'text': 'чужое', 'attachment_ids': [foreign['id']]}, 404)
|
||||
post({'text': 'смесь', 'attachment_ids': [own['id'], foreign['id']]}, 404)
|
||||
post({'text': 'нет такого', 'attachment_ids': [str(uuid.uuid4())]}, 404)
|
||||
post({'text': 'дубль', 'attachment_ids': [own['id'], own['id'].upper()]}, 400)
|
||||
post({'text': 'много', 'attachment_ids': [str(uuid.uuid4()) for _ in range(11)]}, 400)
|
||||
post({'text': 'не uuid', 'attachment_ids': ['x']}, 400)
|
||||
post({'text': 'не массив', 'attachment_ids': own['id']}, 400)
|
||||
post({'text': ' '}, 400)
|
||||
post({'text': '', 'attachment_ids': []}, 400)
|
||||
c.call('POST', '/api/v1/chats/' + other['id'] + '/messages', 404, actor=bob, body={'text': 'x', 'attachment_ids': [foreign['id']]},
|
||||
headers={'Idempotency-Key': uuid.uuid4().hex})
|
||||
key = uuid.uuid4().hex
|
||||
m = post({'text': '', 'attachment_ids': [own['id'], jpg['id']]}, 201, key)
|
||||
check(m['attachment_ids'] == [own['id'], jpg['id']] and m['text'] == '', 'attachment order/text')
|
||||
check(post({'attachment_ids': [own['id'], jpg['id']], 'text': ''}, 201, key) == m, 'replay with attachments differs')
|
||||
post({'text': '', 'attachment_ids': [jpg['id'], own['id']]}, 409, key)
|
||||
post({'text': '', 'attachment_ids': [own['id']]}, 409, key)
|
||||
key = uuid.uuid4().hex
|
||||
t = post({'text': 'без вложений'}, 201, key)
|
||||
check(post({'text': 'без вложений', 'attachment_ids': []}, 201, key) == t and t['attachment_ids'] == [], 'missing attachment_ids != []')
|
||||
history = c.call('GET', send + '?limit=100', actor=bob, schema='MessagePage')['json']['items']
|
||||
check([x for x in history if x['id'] == m['id']] == [m], 'history lost attachment_ids')
|
||||
|
||||
width = max(len(r[0]) for r in results)
|
||||
for label, status, code, ms in results:
|
||||
print('%-*s %d %-24s %5d ms' % (width, label, status, code, ms))
|
||||
check(all(status < 500 for _, status, _, _ in results), 'server error in negative suite')
|
||||
print('PASS: %d upload cases, ACL and message linking; no 5xx' % len(results))
|
||||
|
||||
|
||||
def chunked_upload(c, actor, chat):
|
||||
"""Тело без Content-Length (Transfer-Encoding: chunked): потоковая запись в S3 требует длину — 400."""
|
||||
url = urllib.parse.urlsplit(c.base)
|
||||
conn = http.client.HTTPConnection(url.hostname, url.port, timeout=10)
|
||||
conn.putrequest('POST', '/api/v1/chats/' + chat['id'] + '/attachments?filename=c.png')
|
||||
conn.putheader('Authorization', 'Bearer ' + actor['token'])
|
||||
conn.putheader('Content-Type', 'image/png')
|
||||
conn.putheader('Transfer-Encoding', 'chunked')
|
||||
conn.endheaders()
|
||||
start = time.monotonic()
|
||||
conn.send(b'%x\r\n%s\r\n0\r\n\r\n' % (len(SAMPLE_PNG), SAMPLE_PNG))
|
||||
r = conn.getresponse()
|
||||
body = r.read()
|
||||
check(r.status == 400 and b'invalid_request' in body, 'chunked upload: %d' % r.status)
|
||||
return r.status, 'invalid_request', round((time.monotonic() - start) * 1000)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
@@ -0,0 +1,139 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Отказы вокруг S3 и перезапуск всего стенда (уровни 3–4). Управляет Docker Compose этого каталога:
|
||||
1. S3 остановлен: upload/download → 503 быстро, метаданные и текст работают, readiness = 200;
|
||||
2. S3 «завис» (docker pause): ответ 503 по таймауту API раньше таймаута LB;
|
||||
3. после возврата S3 всё работает; неудачные загрузки не оставили строк (lab5: компенсация сначала удаляет строку),
|
||||
«воскресший» после pause объект staging убирает reconciler (orphan_staging);
|
||||
4. docker compose down (без -v) + up: метаданные, оригинал и прежний токен сохранены.
|
||||
Запуск: python3 student-tests/failures.py --base-url http://localhost:8080"""
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
|
||||
from client import Client, ROOT, arguments, check, run # noqa: E402
|
||||
|
||||
PNG = (ROOT / 'tests/fixtures/sample.png').read_bytes()
|
||||
|
||||
|
||||
def compose(*args, capture=False):
|
||||
r = subprocess.run(['docker', 'compose', *args], cwd=ROOT, text=True, capture_output=True)
|
||||
check(r.returncode == 0, 'docker compose %s: %s' % (args[0], r.stderr.strip().splitlines()[-1:]))
|
||||
return r.stdout if capture else None
|
||||
|
||||
|
||||
def sql(query):
|
||||
return compose('exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-tAc', query, capture=True).strip()
|
||||
|
||||
|
||||
def reconcile(*flags):
|
||||
out = compose('run', '--rm', '--no-deps', '-T', 'reconciler', 'node', 'src/main.ts', 'reconcile', *flags, capture=True)
|
||||
return json.loads(out.strip().splitlines()[-1])
|
||||
|
||||
|
||||
def wait_ready(c, seconds=90):
|
||||
deadline = time.monotonic() + seconds
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
if c.call('GET', '/health/ready', [200, 503])['status'] == 200:
|
||||
return
|
||||
except AssertionError:
|
||||
pass
|
||||
time.sleep(1)
|
||||
raise AssertionError('stand not ready')
|
||||
|
||||
|
||||
def recover(c, path, actor, seconds=60):
|
||||
"""Время до первого успешного скачивания после возврата S3."""
|
||||
start = time.monotonic()
|
||||
while c.call('GET', path, [200, 503], actor=actor)['status'] != 200:
|
||||
check(time.monotonic() - start < seconds, 'S3 path did not recover')
|
||||
time.sleep(0.5)
|
||||
return time.monotonic() - start
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('S3 outage, S3 hang and full stand restart')
|
||||
c = Client(args.base_url, args.ca_file, timeout=30)
|
||||
alice, bob, _, chat = c.bootstrap()
|
||||
up = '/api/v1/chats/' + chat['id'] + '/attachments?filename=outage.png'
|
||||
send = '/api/v1/chats/' + chat['id'] + '/messages'
|
||||
hdr = {'Content-Type': 'image/png'}
|
||||
att = c.call('POST', up, 202, actor=alice, raw=PNG, headers=hdr, schema='Attachment')['json']
|
||||
att = c.wait_ready(bob, att) # lab5: байты доступны после обработки worker
|
||||
content = '/api/v1/attachments/' + att['id'] + '/content'
|
||||
pending_before = int(sql("SELECT count(*) FROM attachments WHERE state = 'pending'"))
|
||||
log = []
|
||||
|
||||
def step(name, r):
|
||||
log.append('%-52s %d %5d ms' % (name, r['status'], r['elapsed'] * 1000))
|
||||
|
||||
# 1. S3 остановлен.
|
||||
compose('stop', 's3')
|
||||
try:
|
||||
step('S3 stopped: /health/ready (S3 не критичен)', c.call('GET', '/health/ready', 200))
|
||||
for i in range(3):
|
||||
step('S3 stopped: upload #%d' % (i + 1), c.call('POST', up, 503, actor=alice, raw=PNG, headers=hdr))
|
||||
step('S3 stopped: download', c.call('GET', content, 503, actor=bob))
|
||||
step('S3 stopped: metadata (только БД)', c.call('GET', '/api/v1/attachments/' + att['id'], 200, actor=bob, schema='Attachment'))
|
||||
step('S3 stopped: text message', c.call('POST', send, 201, actor=alice, body={'text': 'S3 недоступен'},
|
||||
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message'))
|
||||
step('S3 stopped: message with ready attachment', c.call('POST', send, 201, actor=alice, body={'text': '', 'attachment_ids': [att['id']]},
|
||||
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message'))
|
||||
finally:
|
||||
compose('start', 's3')
|
||||
# Компенсация сначала удаляет pending-строку (БД доступна), объектов при остановленном S3 не появилось.
|
||||
leftover = int(sql("SELECT count(*) FROM attachments WHERE state = 'pending'")) - pending_before
|
||||
log.append('pending-строк после 3 неудачных загрузок: %d' % leftover)
|
||||
check(leftover == 0, 'failed uploads left pending rows')
|
||||
|
||||
log.append('S3 started: download снова 200 через %.1f s' % recover(c, content, bob))
|
||||
|
||||
# 2. S3 завис: TCP-соединения не отвечают.
|
||||
c.call('GET', content, 200, actor=bob) # прогреть keep-alive соединения API → S3
|
||||
compose('pause', 's3')
|
||||
try:
|
||||
step('S3 paused: download (таймаут сокета S3 8 с)', c.call('GET', content, 503, actor=bob))
|
||||
step('S3 paused: upload', c.call('POST', up, 503, actor=alice, raw=PNG, headers=hdr))
|
||||
step('S3 paused: text message', c.call('POST', send, 201, actor=alice, body={'text': 'S3 завис'},
|
||||
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message'))
|
||||
finally:
|
||||
compose('unpause', 's3')
|
||||
|
||||
# 3. S3 вернулся.
|
||||
log.append('S3 unpaused: download снова 200 через %.1f s' % recover(c, content, bob))
|
||||
r = c.call('POST', up, 202, actor=alice, raw=PNG, headers=hdr, schema='Attachment')
|
||||
step('S3 back: upload', r)
|
||||
c.wait_ready(bob, r['json']) # reconcile --grace=0 ниже не должен застать работу в процессе
|
||||
r = c.call('GET', content, 200, actor=bob)
|
||||
check(r['bytes'] == PNG, 'original changed')
|
||||
step('S3 back: download old attachment', r)
|
||||
# Возможен orphan_staging — PUT, который S3 буферизовал во время pause и выполнил после того, как API сдался
|
||||
# и компенсационный DELETE уже прошёл (объект «воскрес»). Других расхождений быть не должно.
|
||||
dry = reconcile('--grace=0')
|
||||
log.append('reconcile dry-run --grace=0: %s' % json.dumps(dry['findings'], ensure_ascii=False))
|
||||
check(set(dry['findings']) <= {'orphan_staging'}, 'unexpected findings')
|
||||
fixed = reconcile('--grace=0', '--apply')
|
||||
again = reconcile('--grace=0')
|
||||
log.append('reconcile --apply: applied=%d; повтор: %s' % (fixed['applied'], json.dumps(again['findings'])))
|
||||
check(not again['findings'], 'reconciler left inconsistencies')
|
||||
|
||||
# 4. Полный перезапуск стенда с сохранением volumes: down удаляет контейнеры и сети, не volumes.
|
||||
compose('down')
|
||||
compose('up', '-d', '--wait')
|
||||
wait_ready(c)
|
||||
r = c.call('GET', content, 200, actor=bob) # прежний токен
|
||||
check(r['bytes'] == PNG and hashlib.sha256(r['bytes']).hexdigest() == att['sha256'], 'original lost after down/up')
|
||||
step('down + up -d: download with old token', r)
|
||||
meta = c.call('GET', '/api/v1/attachments/' + att['id'], 200, actor=bob, schema='Attachment')['json']
|
||||
check(meta == att, 'metadata changed after restart')
|
||||
print('\n'.join(log))
|
||||
print('PASS: S3 outage/hang degrade only attachments (503), compensation + reconciler clean up, full restart keeps data')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 10 KiB |
Executable
+59
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Один Idempotency-Key, N параллельных запросов через LB (то есть через разные реплики).
|
||||
Половина запросов с телом A, половина с телом B: должно появиться ровно одно сообщение, каждый 201 возвращает его,
|
||||
другое тело получает 409. Запуск: python3 student-tests/idempotency_race.py --base-url http://localhost:8080"""
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sys
|
||||
import threading
|
||||
import uuid
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests'))
|
||||
from client import Client, arguments, check, run # noqa: E402
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Parallel same-key POST race', lambda p: p.add_argument('--parallel', type=int, default=32))
|
||||
c = Client(args.base_url, args.ca_file)
|
||||
alice, bob, _, chat = c.bootstrap()
|
||||
path = '/api/v1/chats/' + chat['id'] + '/messages'
|
||||
key = 'race-' + uuid.uuid4().hex
|
||||
texts = ['гонка A ' + key, 'гонка B ' + key]
|
||||
barrier = threading.Barrier(args.parallel)
|
||||
|
||||
def send(i):
|
||||
local = Client(args.base_url, args.ca_file)
|
||||
barrier.wait()
|
||||
r = local.call('POST', path, [201, 409], actor=alice, body={'text': texts[i % 2]}, headers={'Idempotency-Key': key}, schema='Message')
|
||||
return r['status'], r['json'], r['headers']['X-Instance-Id']
|
||||
|
||||
with ThreadPoolExecutor(args.parallel) as pool:
|
||||
results = list(pool.map(send, range(args.parallel)))
|
||||
|
||||
created = [body for status, body, _ in results if status == 201]
|
||||
check(created, 'no request succeeded')
|
||||
winner = created[0]
|
||||
check(all(body == winner for body in created), 'replicas returned different messages for one key')
|
||||
check(all(body['error']['code'] == 'conflict' for status, body, _ in results if status == 409), '409 without conflict code')
|
||||
statuses = {texts[i % 2]: set() for i in range(2)}
|
||||
for i, (status, _, _) in enumerate(results):
|
||||
statuses[texts[i % 2]].add(status)
|
||||
check(statuses[winner['text']] == {201}, 'winning body must always get 201')
|
||||
check(statuses[next(t for t in texts if t != winner['text'])] == {409}, 'other body must always get 409')
|
||||
instances = {inst for _, _, inst in results}
|
||||
check(len(instances) >= 2, 'race did not reach two replicas')
|
||||
|
||||
history = c.call('GET', path + '?limit=100', actor=bob, schema='MessagePage')['json']['items']
|
||||
stored = [m for m in history if key in m['text']]
|
||||
check(stored == [winner], 'expected exactly one stored message equal to the replayed one')
|
||||
# Тот же ключ у другого пользователя независим.
|
||||
other = c.message(bob, chat, texts[0], key=key)['json']
|
||||
check(other['id'] != winner['id'] and other['sender_id'] == bob['id'], 'key scope leaked across users')
|
||||
print(json.dumps({'parallel': args.parallel, 'replicas_hit': len(instances), 'created_201': len(created),
|
||||
'conflict_409': args.parallel - len(created), 'stored_messages': len(stored)}, ensure_ascii=False))
|
||||
print('PASS: concurrent same-key POSTs through different replicas created exactly one message')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
@@ -0,0 +1,354 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Уровень 4 и трек 2: автоматический fault-injection pipeline вложений и проверка инвариантов.
|
||||
|
||||
На время теста api и worker пересоздаются с FAILPOINTS=1 и JOB_TIMEOUT_SECONDS=10 (аренда 25 с), в конце —
|
||||
снова с конфигурацией из .env. Отказы настоящие: аварийный выход процесса в точке (src/failpoints.ts), пауза процесса,
|
||||
дубли и перестановка сообщений через outbox, остановка S3 и брокера, устаревшая job после новой версии pipeline.
|
||||
|
||||
Инварианты (проверяются в конце по всем вложениям тестового чата):
|
||||
I1 нет потерянной работы: каждое вложение, для которого записано задание, в конечном состоянии ready/failed;
|
||||
I2 один результат: у пары (вложение, версия) ровно 3 варианта, лишние объекты попыток убирает reconciler;
|
||||
I3 новый результат не перезаписан старым: версия только растёт, варианты v2 не меняются после старых job;
|
||||
I4 повтор даёт тот же результат: sha256 вариантов после сбоев = sha256 контрольной обработки тех же байтов;
|
||||
I5 API согласован: каждый вариант и оригинал скачиваются, размер и sha256 совпадают с метаданными;
|
||||
I6 все job в конечном состоянии (done/failed/superseded), reconciler после очистки ничего не находит.
|
||||
Запуск: python3 student-tests/pipeline_faults.py --base-url http://localhost:8080"""
|
||||
import hashlib
|
||||
import http.client
|
||||
import json
|
||||
import os
|
||||
import struct
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.parse
|
||||
import uuid
|
||||
import zlib
|
||||
|
||||
from failures import PNG, ROOT, sql, wait_ready
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
TEST_ENV = {'FAILPOINTS': '1', 'JOB_TIMEOUT_SECONDS': '10'} # аренда = таймаут + 15 с
|
||||
LEASE = 25
|
||||
|
||||
|
||||
def compose(*args, env=None):
|
||||
r = subprocess.run(['docker', 'compose', *args], cwd=ROOT, text=True, capture_output=True, env={**os.environ, **(env or {})})
|
||||
check(r.returncode == 0, 'docker compose %s: %s' % (args[0], r.stderr.strip().splitlines()[-1:]))
|
||||
return r.stdout
|
||||
|
||||
|
||||
def jobs(*args):
|
||||
out = compose('exec', '-T', 'api', 'node', 'src/main.ts', 'jobs', *args)
|
||||
return [json.loads(line) for line in out.splitlines() if line.startswith('{')]
|
||||
|
||||
|
||||
def reconcile(*flags):
|
||||
"""Находки reconciler (по одной JSON-строке) и итоговая сводка."""
|
||||
out = compose('run', '--rm', '--no-deps', '-T', 'reconciler', 'node', 'src/main.ts', 'reconcile', *flags)
|
||||
lines = [json.loads(line) for line in out.splitlines() if line.startswith('{')]
|
||||
return [x for x in lines if 'finding' in x], lines[-1]
|
||||
|
||||
|
||||
def rows(query):
|
||||
out = sql(query)
|
||||
return [line.split('|') for line in out.splitlines()] if out else []
|
||||
|
||||
|
||||
def wait_for(what, fn, seconds):
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
value = fn()
|
||||
if value:
|
||||
return value
|
||||
check(time.monotonic() < deadline, 'timeout: ' + what)
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def healthy(service):
|
||||
"""Все реплики сервиса healthy (после crash Docker перезапускает контейнер)."""
|
||||
out = compose('ps', '-a', service, '--format', '{{.State}} {{.Health}}').split('\n')
|
||||
return all(line == 'running healthy' for line in out if line)
|
||||
|
||||
|
||||
def bad_filter_png():
|
||||
"""Структура PNG верна (CRC, объём данных), но байт фильтра строк 9 не существует: API принимает, libvips — нет."""
|
||||
def chunk(kind, data):
|
||||
return struct.pack('>I', len(data)) + kind + data + struct.pack('>I', zlib.crc32(kind + data))
|
||||
raw = b''.join(b'\x09' + bytes(64 * 3) for _ in range(64))
|
||||
return (b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('>IIBBBBB', 64, 64, 8, 2, 0, 0, 0))
|
||||
+ chunk(b'IDAT', zlib.compress(raw)) + chunk(b'IEND', b''))
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Pipeline fault injection with invariant checks')
|
||||
c = Client(args.base_url, args.ca_file, timeout=30)
|
||||
since = time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
|
||||
compose('up', '-d', '--no-deps', 'api', 'worker', env=TEST_ENV)
|
||||
wait_for('api healthy with FAILPOINTS=1', lambda: healthy('api'), 90)
|
||||
for service in ('api', 'worker'):
|
||||
ids = compose('ps', '-q', service).split()
|
||||
check(len(ids) == 2 and all(subprocess.run(['docker', 'exec', i, 'printenv', 'FAILPOINTS'], capture_output=True, text=True)
|
||||
.stdout.strip() == '1' for i in ids), '%s replicas without FAILPOINTS=1' % service)
|
||||
wait_ready(c)
|
||||
alice, bob, _, chat = c.bootstrap()
|
||||
report = []
|
||||
|
||||
def record(name, text):
|
||||
report.append('%-44s %s' % (name, text))
|
||||
print(report[-1], flush=True)
|
||||
|
||||
def upload(name, data=PNG):
|
||||
path = '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], urllib.parse.quote(name))
|
||||
return c.call('POST', path, 202, actor=alice, raw=data, headers={'Content-Type': 'image/png'}, schema='Attachment')['json']['id']
|
||||
|
||||
def raw_upload(name):
|
||||
"""Upload, при котором API может погибнуть посреди запроса: статус без проверок клиента (0 — обрыв)."""
|
||||
url = urllib.parse.urlsplit(c.base)
|
||||
conn = http.client.HTTPConnection(url.hostname, url.port, timeout=30)
|
||||
try:
|
||||
conn.request('POST', '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], name), body=PNG,
|
||||
headers={'Authorization': 'Bearer ' + alice['token'], 'Content-Type': 'image/png'})
|
||||
return conn.getresponse().status
|
||||
except OSError:
|
||||
return 0
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
def find(name):
|
||||
return sql("SELECT id FROM attachments WHERE chat_id = '%s' AND filename = '%s'" % (chat['id'], name))
|
||||
|
||||
def state(aid):
|
||||
return rows("SELECT state, coalesce(pipeline_version, 0), coalesce(error_code, '') FROM attachments WHERE id = '%s'" % aid)[0]
|
||||
|
||||
def job(aid, version=1):
|
||||
r = rows("SELECT job_id, state, attempts, coalesce(error_code, '') FROM jobs WHERE attachment_id = '%s' AND pipeline_version = %d"
|
||||
% (aid, version))
|
||||
return r[0] if r else None
|
||||
|
||||
def variants(aid, version):
|
||||
return {name: sha for name, sha in rows("SELECT name, sha256 FROM attachment_variants WHERE attachment_id = '%s' "
|
||||
"AND pipeline_version = %d" % (aid, version))}
|
||||
|
||||
def settle(aid, seconds=90, version=1):
|
||||
"""Дождаться конечного состояния вложения и его job нужной версии."""
|
||||
return wait_for('attachment %s final' % aid, lambda: state(aid)[0] in ('ready', 'failed')
|
||||
and (job(aid, version) or ['', ''])[1] in ('done', 'failed', 'superseded') and state(aid), seconds)
|
||||
|
||||
def deliveries(job_id):
|
||||
log = compose('logs', '--no-log-prefix', '--since', since, 'worker')
|
||||
return [line for line in log.splitlines() if job_id in line]
|
||||
|
||||
try:
|
||||
# S0. Контроль: эталонные sha256 вариантов v1 для тех же байтов.
|
||||
control = upload('control.png')
|
||||
settle(control)
|
||||
ref = variants(control, 1)
|
||||
check(len(ref) == 3, 'control variants')
|
||||
record('S0 контроль', 'ready v1, варианты %s' % ', '.join(sorted(ref)))
|
||||
|
||||
# S1. API падает после записи staging, до транзакции задания: 202 не было — работы не обещано.
|
||||
status = raw_upload('failpoint-api_after_staging.png')
|
||||
s1 = find('failpoint-api_after_staging.png')
|
||||
check(status != 202 and state(s1)[0] == 'pending' and job(s1) is None, 'S1: %s %s' % (status, state(s1)))
|
||||
wait_for('api restarted', lambda: healthy('api'), 90)
|
||||
record('S1 API: crash после staging', 'клиент получил %d; строка pending, заданий нет → stale_pending для reconciler' % status)
|
||||
|
||||
# S2. API падает после COMMIT задания+outbox, до publish и ответа: публикует relay другой реплики.
|
||||
status = raw_upload('failpoint-api_after_commit.png')
|
||||
s2 = find('failpoint-api_after_commit.png')
|
||||
st = settle(s2)
|
||||
j = job(s2)
|
||||
check(status != 202 and st[0] == 'ready' and j[1:3] == ['done', '1'], 'S2: %s %s %s' % (status, st, j))
|
||||
wait_for('api restarted', lambda: healthy('api'), 90)
|
||||
record('S2 API: crash после COMMIT, до publish', 'клиент %d; задание из outbox опубликовано → ready, попыток 1' % status)
|
||||
|
||||
# S3. Relay падает после publisher confirm, до отметки published_at: строку публикует снова — дубль.
|
||||
status = raw_upload('failpoint-relay_after_publish.png')
|
||||
s3 = find('failpoint-relay_after_publish.png')
|
||||
st = settle(s3)
|
||||
j = job(s3)
|
||||
seen = wait_for('duplicate delivered', lambda: len(deliveries(j[0])) >= 2 and deliveries(j[0]), 20)
|
||||
check(st[0] == 'ready' and j[1:3] == ['done', '1'] and len(seen) >= 2 and len(variants(s3, 1)) == 3, 'S3: %s %s %s' % (st, j, seen))
|
||||
wait_for('api restarted', lambda: healthy('api'), 90)
|
||||
record('S3 relay: crash после confirm', 'клиент %d; доставок worker: %d (дубль), обработка 1, вариантов 3' % (status, len(seen)))
|
||||
|
||||
# S4. Тройная доставка одной попытки одновременно двум worker.
|
||||
compose('stop', 'worker')
|
||||
s4 = upload('duplicate.png')
|
||||
j4 = job(s4)[0]
|
||||
sql("INSERT INTO outbox (job_id, attempt) VALUES ('%s', 1), ('%s', 1)" % (j4, j4))
|
||||
wait_for('duplicates published', lambda: sql("SELECT count(*) FROM outbox WHERE job_id = '%s' AND published_at IS NOT NULL" % j4) == '3', 20)
|
||||
compose('start', 'worker')
|
||||
st = settle(s4)
|
||||
seen = wait_for('all copies delivered', lambda: len(deliveries(j4)) >= 3 and deliveries(j4), 20)
|
||||
noop = [line for line in seen if 'no-op' in line]
|
||||
check(st[0] == 'ready' and job(s4)[2] == '1' and len(seen) == 3 and len(noop) == 2 and variants(s4, 1) == ref, 'S4: %s' % seen)
|
||||
record('S4 дубль: 3 копии попытки 1', '3 доставки → 1 обработка, 2 no-op; попыток 1, варианты = контрольным')
|
||||
|
||||
# S5. Reorder в новой версии: сообщение попытки 2 опубликовано раньше попытки 1 (job v2 для ready v1).
|
||||
j5 = str(uuid.uuid4())
|
||||
sql("INSERT INTO jobs (job_id, attachment_id, pipeline_version) VALUES ('%s', '%s', 2); "
|
||||
"INSERT INTO outbox (job_id, attempt) VALUES ('%s', 2), ('%s', 1)" % (j5, s4, j5, j5))
|
||||
st = settle(s4, version=2)
|
||||
v2 = variants(s4, 2)
|
||||
seen = wait_for('attempt 2 no-op', lambda: any('попытка 2: no-op' in line for line in deliveries(j5)) and deliveries(j5), 20)
|
||||
check(st[:2] == ['ready', '2'] and job(s4, 2)[1:3] == ['done', '1'] and len(v2) == 3 and v2['thumbnail'] != ref['thumbnail']
|
||||
and any('попытка 2: no-op' in line for line in seen), 'S5: %s %s' % (st, seen))
|
||||
record('S5 reorder: попытка 2 раньше 1 (job v2)', 'попытка 2 → no-op, попытка 1 → done; версия 1 → 2, вариантов v2: 3')
|
||||
|
||||
# S6. Устаревшая job v1 после публикации v2: поздний дубль старого сообщения и повторно поставленная v1.
|
||||
j1 = job(s4)[0]
|
||||
before = len(deliveries(j1))
|
||||
sql("INSERT INTO outbox (job_id, attempt) VALUES ('%s', 1)" % j1)
|
||||
wait_for('late duplicate handled', lambda: len(deliveries(j1)) > before, 20)
|
||||
sql("UPDATE jobs SET state = 'queued' WHERE job_id = '%s'; "
|
||||
"INSERT INTO outbox (job_id, attempt) SELECT job_id, attempts + 1 FROM jobs WHERE job_id = '%s'" % (j1, j1))
|
||||
wait_for('stale v1 superseded', lambda: job(s4)[1] == 'superseded', 30)
|
||||
check(state(s4)[:2] == ['ready', '2'] and variants(s4, 2) == v2, 'S6: v2 changed')
|
||||
record('S6 устаревшая v1 после v2 (захват)', 'дубль старого сообщения → no-op; повторно поставленная v1 → superseded; v2 не тронута')
|
||||
|
||||
# S7. v1 фиксируется после v2: v1 «зависла» 10 с после записи объектов, тем временем v2 опубликована.
|
||||
name = 'failpoint-worker_after_side_effect-10s.png'
|
||||
s7 = upload(name)
|
||||
wait_for('v1 stalled after side effects', lambda: sql("SELECT count(*) FROM failpoint_hits WHERE attachment_id = '%s'" % s7) == '1', 30)
|
||||
j7 = str(uuid.uuid4())
|
||||
sql("INSERT INTO jobs (job_id, attachment_id, pipeline_version) VALUES ('%s', '%s', 2); "
|
||||
"INSERT INTO outbox (job_id, attempt) VALUES ('%s', 1)" % (j7, s7, j7))
|
||||
wait_for('v2 done', lambda: (job(s7, 2) or ['', ''])[1] == 'done', 30)
|
||||
v2_7 = variants(s7, 2)
|
||||
wait_for('v1 superseded at commit', lambda: job(s7)[1] == 'superseded', 30)
|
||||
check(state(s7)[:2] == ['ready', '2'] and variants(s7, 1) == {} and variants(s7, 2) == v2_7, 'S7: %s' % state(s7))
|
||||
record('S7 v1 фиксируется после v2 (фиксация)', 'v2 ready; v1 при фиксации → superseded, вариантов v1 в БД 0, объекты удалены')
|
||||
|
||||
# S8–S10. Worker crash до side effect, после side effect, после COMMIT (до ack).
|
||||
crashed = {}
|
||||
for label, point, attempts in (('S8 worker: crash после захвата', 'worker_after_claim', '2'),
|
||||
('S9 worker: crash после записи S3', 'worker_after_side_effect', '2'),
|
||||
('S10 worker: crash после COMMIT до ack', 'worker_after_commit', '1')):
|
||||
started = time.monotonic()
|
||||
aid = crashed[point] = upload('failpoint-%s.png' % point)
|
||||
st = settle(aid, LEASE * 3)
|
||||
j = job(aid)
|
||||
check(st[0] == 'ready' and j[1:3] == ['done', attempts] and variants(aid, 1) == ref, '%s: %s %s' % (point, st, j))
|
||||
wait_for('worker restarted', lambda: set(compose('ps', '-a', 'worker', '--format', '{{.State}}').split()) == {'running'}, 30)
|
||||
how = 'redelivery → no-op (аренда жива), аренда истекла → попытка 2' if attempts == '2' else 'redelivery → no-op (job done)'
|
||||
record(label, '%s; ready за %.0f с, попыток %s, варианты = контрольным' % (how, time.monotonic() - started, attempts))
|
||||
|
||||
# S11. Зависший worker: пауза 35 с > аренды 25 с. Работу забирает другая попытка, поздний результат отброшен.
|
||||
started = time.monotonic()
|
||||
s11 = upload('failpoint-worker_after_side_effect-35s.png')
|
||||
st = settle(s11, 90)
|
||||
j = job(s11)
|
||||
ready_after = time.monotonic() - started
|
||||
wait_for('stale attempt fenced', lambda: any('аренда потеряна' in line for line in deliveries(j[0])), 60)
|
||||
check(st[0] == 'ready' and j[1:3] == ['done', '2'] and variants(s11, 1) == ref, 'S11: %s %s' % (st, j))
|
||||
record('S11 worker завис на 35 с (аренда 25 с)', 'попытка 2 → ready за %.0f с; попытка 1 проснулась → fencing: результат отброшен' % ready_after)
|
||||
|
||||
# S12. S3 недоступен для worker: backoff с jitter → retry_exhausted → реестр failed → replay.
|
||||
compose('stop', 'worker')
|
||||
s12 = upload('transient.png')
|
||||
compose('stop', 's3')
|
||||
try:
|
||||
compose('up', '-d', '--no-deps', 'worker', env=TEST_ENV) # start поднял бы и S3 по цепочке depends_on
|
||||
st = wait_for('retry exhausted', lambda: state(s12)[0] == 'failed' and state(s12), 120)
|
||||
j = job(s12)
|
||||
delays = rows("SELECT attempt, round(extract(epoch FROM available_at - created_at)::numeric, 1) FROM outbox "
|
||||
"WHERE job_id = '%s' AND attempt > 1 ORDER BY attempt" % j[0])
|
||||
registry = [r for r in jobs('failed') if r.get('attachment_id') == s12]
|
||||
meta = c.call('GET', '/api/v1/attachments/' + s12, 200, actor=bob, schema='Attachment')['json']
|
||||
c.call('GET', '/api/v1/attachments/' + s12 + '/content', 409, actor=bob)
|
||||
c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice, body={'text': '', 'attachment_ids': [s12]},
|
||||
headers={'Idempotency-Key': uuid.uuid4().hex})
|
||||
check(st[2] == 'retry_exhausted' and j[1:3] == ['failed', '5'] and len(registry) == 1
|
||||
and meta['status'] == 'failed' and meta['error_code'] == 'retry_exhausted', 'S12: %s %s' % (st, j))
|
||||
finally:
|
||||
compose('start', 's3')
|
||||
wait_for('s3 healthy', lambda: healthy('s3'), 60)
|
||||
replay = jobs('replay', s12)[-1]
|
||||
st = settle(s12)
|
||||
audit = rows("SELECT previous_error, previous_attempts FROM job_replays WHERE job_id = '%s'" % j[0])
|
||||
again = jobs('replay', s12)[-1]
|
||||
check(replay['replayed'] and st[0] == 'ready' and audit == [['retry_exhausted', '5']] and not again['replayed']
|
||||
and variants(s12, 1) == ref, 'S12 replay: %s %s %s' % (replay, st, again))
|
||||
record('S12 S3 недоступен → retry_exhausted', 'задержки попыток 2–5: %s с; failed в реестре, API: failed/409'
|
||||
% ', '.join(d for _, d in delays))
|
||||
record(' replay', 'аудит (retry_exhausted, 5) → ready; повторный replay: %s' % again['reason'])
|
||||
|
||||
# S13. Постоянная ошибка: файл проходит приём, но не декодируется — failed сразу, без повторов.
|
||||
s13 = upload('bad-filter.png', bad_filter_png())
|
||||
st = wait_for('permanent failure', lambda: state(s13)[0] == 'failed' and state(s13), 60)
|
||||
check(st[2] == 'invalid_image' and job(s13)[1:3] == ['failed', '1'], 'S13: %s' % st)
|
||||
record('S13 постоянная ошибка (фильтр PNG = 9)', 'failed invalid_image с первой попытки, без повторов')
|
||||
|
||||
# S14. Брокер остановлен: API принимает файлы (202), задания ждут в outbox; брокер вернулся — ready.
|
||||
compose('stop', 'rabbitmq')
|
||||
try:
|
||||
s14 = [upload('broker-down-%d.png' % i) for i in range(3)]
|
||||
c.call('GET', '/health/ready', 200) # readiness API не зависит от брокера
|
||||
unpublished = sql("SELECT count(*) FROM outbox o JOIN jobs j ON j.job_id = o.job_id WHERE o.published_at IS NULL "
|
||||
"AND j.attachment_id IN ('%s')" % "', '".join(s14))
|
||||
check(unpublished == '3', 'S14: unpublished %s' % unpublished)
|
||||
finally:
|
||||
compose('start', 'rabbitmq')
|
||||
started = time.monotonic()
|
||||
for aid in s14:
|
||||
check(settle(aid, 180)[0] == 'ready' and variants(aid, 1) == ref, 'S14: %s' % aid)
|
||||
record('S14 брокер остановлен', '3 upload → 202, неопубликовано в outbox 3; брокер вернулся → все ready за %.0f с'
|
||||
% (time.monotonic() - started))
|
||||
|
||||
# Инварианты по всем вложениям тестового чата.
|
||||
print('\nИнварианты:')
|
||||
atts = rows("SELECT id, state, coalesce(pipeline_version, 0), filename FROM attachments WHERE chat_id = '%s'" % chat['id'])
|
||||
open_work = [a for a in atts if a[1] not in ('ready', 'failed') and a[0] != s1]
|
||||
check(not open_work, 'I1: %s' % open_work)
|
||||
print(' I1 нет потерянной работы: %d вложений с заданием, все ready/failed; S1 (без 202) — pending до reconciler' % (len(atts) - 1))
|
||||
counts = rows("SELECT v.attachment_id, v.pipeline_version, count(*) FROM attachment_variants v JOIN attachments a ON a.id = v.attachment_id "
|
||||
"WHERE a.chat_id = '%s' GROUP BY 1, 2" % chat['id'])
|
||||
check(all(n == '3' for _, _, n in counts), 'I2: %s' % counts)
|
||||
ready = [a for a in atts if a[1] == 'ready']
|
||||
check(all(any(aid == a[0] and ver == a[2] for aid, ver, _ in counts) for a in ready), 'I2: ready without variants')
|
||||
print(' I2 один результат: %d наборов (вложение, версия), в каждом ровно 3 варианта' % len(counts))
|
||||
check(state(s4)[:2] == ['ready', '2'] and variants(s4, 2) == v2 and state(s7)[:2] == ['ready', '2'] and variants(s7, 2) == v2_7, 'I3')
|
||||
print(' I3 v2 не перезаписана: S5–S7 остались v2, sha256 вариантов v2 не изменились после старых job')
|
||||
same = [a for a in ready if a[2] == '1']
|
||||
check(all(variants(a[0], 1) == ref for a in same) and variants(s4, 1) == ref, 'I4')
|
||||
print(' I4 тот же результат: у %d ready v1 после сбоев sha256 вариантов = контрольным' % len(same))
|
||||
downloads = 0
|
||||
for a in ready:
|
||||
meta = c.call('GET', '/api/v1/attachments/' + a[0], 200, actor=bob, schema='Attachment')['json']
|
||||
check(c.call('GET', '/api/v1/attachments/' + a[0] + '/content', 200, actor=bob)['bytes'] == PNG, 'I5 original')
|
||||
for v in meta['variants']:
|
||||
body = c.call('GET', '/api/v1/attachments/%s/content?variant=%s' % (a[0], v['name']), 200, actor=bob)['bytes']
|
||||
check(len(body) == v['size_bytes'] and hashlib.sha256(body).hexdigest() == v['sha256'], 'I5 %s' % v['name'])
|
||||
downloads += 1
|
||||
print(' I5 API согласован: %d оригиналов и %d вариантов скачаны, размер и sha256 = метаданным' % (len(ready), downloads))
|
||||
states = dict((s, n) for s, n in rows("SELECT j.state, count(*) FROM jobs j JOIN attachments a ON a.id = j.attachment_id "
|
||||
"WHERE a.chat_id = '%s' GROUP BY 1" % chat['id']))
|
||||
check(set(states) <= {'done', 'failed', 'superseded'}, 'I6 jobs: %s' % states)
|
||||
# Остатки ожидаются ровно от трёх сценариев; находки по чужим вложениям (прерванные прошлые прогоны) не считаем.
|
||||
found, summary = reconcile('--grace=0')
|
||||
ids = {a[0] for a in atts}
|
||||
mine = {}
|
||||
for f in found:
|
||||
owner = f.get('id') or f['key'].split('/')[1]
|
||||
if owner in ids:
|
||||
mine.setdefault(f['finding'], set()).add(owner)
|
||||
check(mine == {'stale_pending': {s1}, 'orphan_variant': {crashed['worker_after_side_effect']},
|
||||
'published_staging': {crashed['worker_after_commit']}}, 'I6 reconcile: %s' % mine)
|
||||
n_variants = sum(1 for f in found if f['finding'] == 'orphan_variant' and f['key'].split('/')[1] in ids)
|
||||
fixed = reconcile('--grace=0', '--apply')[1]
|
||||
after = reconcile('--grace=0')[1]['findings']
|
||||
check(not after and n_variants == 3, 'I6 after cleanup: %s, orphan variants %d' % (after, n_variants))
|
||||
print(' I6 job: %s; reconciler: stale_pending S1, orphan_variant ×%d попытки 1 в S9, published_staging S10 — и только они;'
|
||||
' применено %d (всего на стенде %s), повторный обход: {}' % (json.dumps(states), n_variants, fixed['applied'],
|
||||
json.dumps(summary['findings'])))
|
||||
finally:
|
||||
compose('start', 's3', 'worker')
|
||||
compose('up', '-d', '--no-deps', 'api', 'worker') # FAILPOINTS и таймаут — снова из .env
|
||||
wait_for('api healthy', lambda: healthy('api'), 90)
|
||||
print('\n'.join(['', 'Сводка:'] + report))
|
||||
print('PASS: 14 fault scenarios, invariants I1–I6 hold (at-least-once delivery + idempotent effect, not exactly-once)')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
@@ -0,0 +1,79 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Трек 2, versioned pipeline: выкатка pipeline v2 без потери работы и без перезаписи.
|
||||
1. Новые загрузки сразу получают v2: api пересоздаётся с PIPELINE_VERSION=2 (worker уже поддерживает v1 и v2).
|
||||
2. Старые ready-вложения: `jobs reprocess --version=2`; повтор команды ничего не ставит (ключ attachment_id + версия).
|
||||
3. Пока идёт переобработка, вложение остаётся ready и отдаёт прежние варианты: в processing не откатывается.
|
||||
4. Итог: у всех ready версия 2; для одинаковых байтов v2 детерминирована (sha256 совпадает с новой загрузкой);
|
||||
у каждой пары (вложение, версия) ровно 3 варианта, варианты v1 остаются историей и не отдаются.
|
||||
В конце api возвращается к PIPELINE_VERSION из .env. Запуск: python3 student-tests/reprocess_v2.py --base-url http://localhost:8080"""
|
||||
import hashlib
|
||||
import time
|
||||
|
||||
from failures import PNG, sql
|
||||
from pipeline_faults import compose, healthy, jobs, rows, wait_for
|
||||
from client import Client, arguments, check, run
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Pipeline v1 -> v2 rollout and reprocess')
|
||||
c = Client(args.base_url, args.ca_file, timeout=30)
|
||||
alice, bob, _, chat = c.bootstrap()
|
||||
|
||||
def upload(name):
|
||||
att = c.call('POST', '/api/v1/chats/%s/attachments?filename=%s' % (chat['id'], name), 202, actor=alice, raw=PNG,
|
||||
headers={'Content-Type': 'image/png'}, schema='Attachment')['json']
|
||||
return c.wait_ready(bob, att)
|
||||
|
||||
def thumbnail(att):
|
||||
return hashlib.sha256(c.call('GET', '/api/v1/attachments/%s/content?variant=thumbnail' % att['id'], 200, actor=bob)['bytes']).hexdigest()
|
||||
|
||||
def version(att):
|
||||
return sql("SELECT pipeline_version FROM attachments WHERE id = '%s'" % att['id'])
|
||||
|
||||
def by_version():
|
||||
return ', '.join('v%s: %s' % tuple(r) for r in rows("SELECT pipeline_version, count(*) FROM attachments WHERE state = 'ready' GROUP BY 1 ORDER BY 1"))
|
||||
|
||||
old = upload('before-v2.png')
|
||||
old_thumb = thumbnail(old)
|
||||
check(version(old) == '1', 'expected v1 before rollout')
|
||||
print('до выкатки: ready по версиям — %s; вложение %s v1' % (by_version(), old['id']))
|
||||
try:
|
||||
compose('up', '-d', '--no-deps', 'api', env={'PIPELINE_VERSION': '2'})
|
||||
wait_for('api healthy with PIPELINE_VERSION=2', lambda: healthy('api'), 90)
|
||||
new = upload('after-v2.png')
|
||||
check(version(new) == '2' and thumbnail(new) != old_thumb, 'new upload is not v2')
|
||||
print('api с PIPELINE_VERSION=2: новая загрузка %s сразу v2 (thumbnail отличается от v1)' % new['id'])
|
||||
|
||||
started = time.monotonic()
|
||||
first = jobs('reprocess', '--version=2')[-1]
|
||||
states = set()
|
||||
while True:
|
||||
states.add(c.call('GET', '/api/v1/attachments/' + old['id'], 200, actor=bob, schema='Attachment')['json']['status'])
|
||||
thumbnail(old) # во время переобработки вариант доступен
|
||||
if not int(sql("SELECT count(*) FROM jobs WHERE pipeline_version = 2 AND state IN ('queued', 'processing')")):
|
||||
break
|
||||
check(time.monotonic() - started < 600, 'reprocess did not finish')
|
||||
time.sleep(0.5)
|
||||
elapsed = time.monotonic() - started
|
||||
second = jobs('reprocess', '--version=2')[-1]
|
||||
check(states == {'ready'}, 'attachment left ready during reprocess: %s' % states)
|
||||
check(second['enqueued'] == 0, 'second reprocess enqueued %s' % second)
|
||||
print('reprocess --version=2: поставлено %d, все done за %.1f с (%.1f вложений/с); статус во время: %s; повтор: поставлено %d'
|
||||
% (first['enqueued'], elapsed, first['enqueued'] / max(elapsed, 0.001), ', '.join(sorted(states)), second['enqueued']))
|
||||
left = rows("SELECT id FROM attachments WHERE state = 'ready' AND pipeline_version < 2")
|
||||
check(not left, 'ready attachments still below v2: %d' % len(left))
|
||||
bad = rows("SELECT attachment_id, pipeline_version, count(*) FROM attachment_variants GROUP BY 1, 2 HAVING count(*) <> 3")
|
||||
check(not bad, 'variant sets with count != 3: %s' % bad)
|
||||
failed = rows("SELECT state, count(*) FROM jobs WHERE pipeline_version = 2 GROUP BY 1")
|
||||
check(version(old) == '2' and thumbnail(old) == thumbnail(new) != old_thumb, 'reprocessed result differs from fresh v2')
|
||||
print('итог: ready по версиям — %s; jobs v2: %s; у всех пар (вложение, версия) по 3 варианта;'
|
||||
% (by_version(), ', '.join('%s %s' % tuple(r) for r in failed)))
|
||||
print(' %s после reprocess отдаёт v2, thumbnail побайтно равен свежей загрузке v2 (детерминизм pipeline)' % old['id'])
|
||||
finally:
|
||||
compose('up', '-d', '--no-deps', 'api')
|
||||
wait_for('api healthy', lambda: healthy('api'), 90)
|
||||
print('PASS: v2 rollout — new uploads v2, reprocess idempotent, no rollback of ready, deterministic result')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
@@ -0,0 +1,31 @@
|
||||
// Проба прав S3 изнутри контейнера сервиса (его же ключами из /run/secrets).
|
||||
// Запуск: docker compose exec -T api node --input-type=module - <key> < student-tests/s3_probe.mjs
|
||||
// Печатает по строке «операция: результат»; ключи и секреты не выводятся.
|
||||
import { readFileSync } from 'node:fs';
|
||||
import { CreateBucketCommand, GetObjectCommand, ListObjectsV2Command, PutObjectCommand, DeleteObjectCommand, S3Client } from '@aws-sdk/client-s3';
|
||||
|
||||
const key = process.argv[2];
|
||||
const bucket = process.env.S3_BUCKET;
|
||||
const s3 = new S3Client({
|
||||
endpoint: process.env.S3_ENDPOINT, region: process.env.S3_REGION, forcePathStyle: true, maxAttempts: 1,
|
||||
credentials: {
|
||||
accessKeyId: readFileSync('/run/secrets/s3_access_key_id', 'utf8').trim(),
|
||||
secretAccessKey: readFileSync('/run/secrets/s3_secret_access_key', 'utf8').trim(),
|
||||
},
|
||||
});
|
||||
const probe = async (name, command) => {
|
||||
try {
|
||||
await s3.send(command);
|
||||
console.log(`${name}: allowed`);
|
||||
} catch (err) {
|
||||
console.log(`${name}: denied (${err.$metadata?.httpStatusCode} ${err.name})`);
|
||||
}
|
||||
};
|
||||
const scratch = `probe/${Date.now()}`;
|
||||
await probe('GetObject own bucket', new GetObjectCommand({ Bucket: bucket, Key: key }));
|
||||
await probe('ListObjectsV2 own bucket', new ListObjectsV2Command({ Bucket: bucket, MaxKeys: 1 }));
|
||||
await probe('CreateBucket other', new CreateBucketCommand({ Bucket: `probe-${Date.now()}` }));
|
||||
await probe('PutObject other bucket', new PutObjectCommand({ Bucket: 'other-bucket', Key: 'x', Body: 'x' }));
|
||||
await probe('PutObject own bucket', new PutObjectCommand({ Bucket: bucket, Key: scratch, Body: 'x' }));
|
||||
await probe('DeleteObject own bucket', new DeleteObjectCommand({ Bucket: bucket, Key: scratch }));
|
||||
s3.destroy(); // keep-alive сокеты иначе держат процесс до idle-таймаута S3
|
||||
@@ -0,0 +1,97 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Уровень 3, сценарий защиты 2–3: worker остановлен → upload 202 → сообщение с вложением → content 409, другие
|
||||
сообщения работают → перезапуск API и брокера с сохранением volumes → worker запущен → то же вложение ready,
|
||||
thumbnail скачивается. Печатает порядок действий, ID и состояние очереди (без токенов).
|
||||
Управляет Docker Compose этого каталога. Запуск: python3 student-tests/worker_outage.py --base-url http://localhost:8080"""
|
||||
import hashlib
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from failures import PNG, compose, sql, wait_ready
|
||||
from client import Client, arguments, check, run
|
||||
from image_probe import jpeg_size
|
||||
|
||||
|
||||
def queue():
|
||||
"""Глубина quorum-очереди: (сообщений всего, без ack, consumers); None — брокер ещё не готов."""
|
||||
try:
|
||||
out = compose('exec', '-T', 'rabbitmq', 'rabbitmqctl', '-q', 'list_queues', '-p', 'messenger',
|
||||
'name', 'messages', 'messages_unacknowledged', 'consumers', capture=True)
|
||||
except AssertionError:
|
||||
return None
|
||||
for line in out.splitlines():
|
||||
f = line.split()
|
||||
if f and f[0] == 'attachments.process':
|
||||
return tuple(map(int, f[1:4]))
|
||||
return None
|
||||
|
||||
|
||||
def main():
|
||||
args = arguments('Worker outage: accepted job survives API and broker restart')
|
||||
c = Client(args.base_url, args.ca_file, timeout=30)
|
||||
alice, bob, _, chat = c.bootstrap()
|
||||
t0 = time.monotonic()
|
||||
|
||||
def step(text):
|
||||
print('%6.1f s %s' % (time.monotonic() - t0, text))
|
||||
|
||||
compose('stop', 'worker')
|
||||
step('docker compose stop worker')
|
||||
try:
|
||||
att = c.call('POST', '/api/v1/chats/' + chat['id'] + '/attachments?filename=outage.png', 202, actor=alice, raw=PNG,
|
||||
headers={'Content-Type': 'image/png'}, schema='Attachment')['json']
|
||||
check(att['status'] == 'queued' and att['variants'] == [], 'upload snapshot is not queued')
|
||||
step('upload → 202 queued, attachment %s' % att['id'])
|
||||
m = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=alice, schema='Message',
|
||||
body={'text': 'файл ещё в очереди', 'attachment_ids': [att['id']]}, headers={'Idempotency-Key': uuid.uuid4().hex})['json']
|
||||
step('сообщение с queued-вложением → 201, message %s' % m['id'])
|
||||
content = '/api/v1/attachments/' + att['id'] + '/content'
|
||||
for variant in ('', '?variant=thumbnail'):
|
||||
check(c.call('GET', content + variant, 409, actor=bob)['json']['error']['code'] == 'conflict', 'content must be 409')
|
||||
step('content и content?variant=thumbnail → 409 conflict')
|
||||
c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=bob, body={'text': 'обычное сообщение'},
|
||||
headers={'Idempotency-Key': uuid.uuid4().hex}, schema='Message')
|
||||
c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=10', 200, actor=bob, schema='MessagePage')
|
||||
step('другие сообщения без worker: POST 201, история 200')
|
||||
deadline = time.monotonic() + 10
|
||||
while sql("SELECT count(*) FROM outbox o JOIN jobs j ON j.job_id = o.job_id WHERE j.attachment_id = '%s' "
|
||||
"AND o.published_at IS NOT NULL" % att['id']) != '1':
|
||||
check(time.monotonic() < deadline, 'outbox row was not published')
|
||||
time.sleep(0.3)
|
||||
job = sql("SELECT job_id || ' ' || state || ' attempts=' || attempts FROM jobs WHERE attachment_id = '%s'" % att['id'])
|
||||
step('job %s; outbox опубликован (publisher confirm); очередь (messages, unacked, consumers) = %s' % (job, queue()))
|
||||
|
||||
compose('restart', 'api')
|
||||
step('docker compose restart api (обе реплики, SIGTERM)')
|
||||
compose('restart', 'rabbitmq')
|
||||
deadline = time.monotonic() + 90
|
||||
while (q := queue()) is None:
|
||||
check(time.monotonic() < deadline, 'broker did not come back')
|
||||
time.sleep(1)
|
||||
wait_ready(c)
|
||||
step('docker compose restart rabbitmq; после рестарта очередь = %s' % (q,))
|
||||
check(q[0] >= 1, 'accepted job disappeared from the durable queue')
|
||||
same = c.call('GET', '/api/v1/attachments/' + att['id'], 200, actor=bob, schema='Attachment')['json']
|
||||
check(same['status'] == 'queued', 'attachment state lost after restart')
|
||||
step('вложение после рестартов: %s (прежний токен)' % same['status'])
|
||||
finally:
|
||||
compose('start', 'worker')
|
||||
started = time.monotonic()
|
||||
step('docker compose start worker')
|
||||
ready = c.wait_ready(bob, att, 90)
|
||||
step('ready через %.1f s после старта worker; job: %s' % (time.monotonic() - started,
|
||||
sql("SELECT state || ' attempts=' || attempts FROM jobs WHERE attachment_id = '%s'" % att['id'])))
|
||||
thumb = [v for v in ready['variants'] if v['name'] == 'thumbnail']
|
||||
check(len(thumb) == 1, 'expected exactly one thumbnail')
|
||||
r = c.call('GET', content + '?variant=thumbnail', 200, actor=bob)
|
||||
check(r['headers'].get_content_type() == 'image/jpeg' and jpeg_size(r['bytes']) == (256, 160), 'thumbnail is not 256x160 JPEG')
|
||||
check(hashlib.sha256(r['bytes']).hexdigest() == thumb[0]['sha256'], 'thumbnail checksum mismatch')
|
||||
original = c.call('GET', content, 200, actor=bob)['bytes']
|
||||
check(original == PNG and hashlib.sha256(original).hexdigest() == ready['sha256'], 'original changed')
|
||||
step('thumbnail 256x160 JPEG (sha256 = метаданным), оригинал совпадает побайтно; варианты: %s'
|
||||
% ', '.join('%s %dx%d' % (v['name'], v['width'], v['height']) for v in ready['variants']))
|
||||
print('PASS: job accepted while worker was down survived API + broker restart and reached ready')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
run(main)
|
||||
@@ -0,0 +1,15 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "esnext",
|
||||
"module": "nodenext",
|
||||
"moduleResolution": "nodenext",
|
||||
"noEmit": true,
|
||||
"strict": true,
|
||||
"allowImportingTsExtensions": true,
|
||||
"erasableSyntaxOnly": true,
|
||||
"verbatimModuleSyntax": true,
|
||||
"skipLibCheck": true,
|
||||
"types": ["node"]
|
||||
},
|
||||
"include": ["src"]
|
||||
}
|
||||
Reference in New Issue
Block a user