Author SHA1 Message Date
celis d922b5b0d9 Проверять фильтры строк PNG и таблицы JPEG при загрузке
PNG: тип фильтра каждой строки (с учётом Adam7) только 0–4, длина PLTE
кратна 3 и не больше 256 цветов. JPEG: заголовки и таблицы проверяются
так же, как в libjpeg-turbo — вид SOF, 8 бит, 1/3/4 компонента,
прореживание, DQT/DHT для каждого скана, параметры SOS, непустой скан.
Файлы из замечаний (PNG 1x1 с фильтром 5, JPEG 27 байт без таблиц и
данных скана) теперь получают 415; добавлены тесты.
2026-10-31 10:30:56 +03:00
celis a4a7b9d41a Реализовать лабораторную 5: очередь RabbitMQ, worker и outbox
- upload возвращает 202 после записи оригинала в staging/ и одной
  транзакции attachments + jobs + outbox
- relay outbox → RabbitMQ (quorum-очередь, publisher confirms) в каждой
  реплике API; sweeper возвращает работу с истёкшей арендой
- worker: аренда с fencing-токеном, варианты thumbnail/crop/optimized
  (sharp), retry с backoff и jitter, реестр failed, replay с аудитом,
  reprocess новой версией pipeline
- reconciler дочищает staging/ и variants/
- сценарии уровней 3–4, fault-injection трека 2 (14 сценариев,
  инварианты I1–I6), evidence и REPORT.md
2026-10-31 00:31:54 +03:00
61 changed files with 6449 additions and 15 deletions
+3
View File
@@ -18,3 +18,6 @@ __pycache__
node_modules
evidence
.DS_Store
research
student-tests
tests
+20
View File
@@ -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
View File
@@ -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"]
+318 -15
View File
@@ -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
View File
@@ -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 }
+20
View File
@@ -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.
+21
View File
@@ -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
+21
View File
@@ -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
+53
View File
@@ -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
+13
View File
@@ -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
+20
View File
@@ -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
+29
View File
@@ -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
+7
View File
@@ -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
+44
View File
@@ -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
+7
View File
@@ -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
+56
View File
@@ -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
+12
View File
@@ -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
+1612
View File
File diff suppressed because it is too large Load Diff
+24
View File
@@ -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"
}
}
+134
View File
@@ -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)
+77
View File
@@ -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)
+51
View File
@@ -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
+76
View File
@@ -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)"
+10
View File
@@ -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
+14
View File
@@ -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
View File
@@ -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 };
}
+93
View File
@@ -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(),
};
}
+44
View File
@@ -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();
}
}
+27
View File
@@ -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);
}
+20
View File
@@ -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>;
+31
View File
@@ -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', 'Внутренняя ошибка');
}
+44
View File
@@ -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 };
}
+60
View File
@@ -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();
}
+82
View File
@@ -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();
}
}
+84
View File
@@ -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);
}
},
};
}
+111
View File
@@ -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),
};
}
+84
View File
@@ -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'),
};
}
+270
View File
@@ -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
View File
@@ -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();
}
+57
View File
@@ -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"') $$;
+38
View File
@@ -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);
+74
View File
@@ -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)
);
+179
View File
@@ -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' }];
}
+68
View File
@@ -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]];
}
+411
View File
@@ -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: () => {},
};
}
+104
View File
@@ -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), прикрепить нельзя');
}
+8
View File
@@ -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';
+29
View File
@@ -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');
+62
View File
@@ -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];
}
+29
View File
@@ -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)];
}
+260
View File
@@ -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;
}
}
+99
View File
@@ -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('Хранилище файлов недоступно');
}
+220
View File
@@ -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)
+139
View File
@@ -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

+59
View File
@@ -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)
+354
View File
@@ -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)
+79
View File
@@ -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)
+31
View File
@@ -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
+97
View File
@@ -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)
+15
View File
@@ -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"]
}