Files
mtusi2026lab4/REPORT.md
T
celis 04458025fb Реализовать лабораторную 4: вложения в S3 и согласованность с БД
- приватный bucket SeaweedFS за S3-шлюзом, отдельные identities
  admin/api/reconciler, анонимный доступ запрещён
- потоковый upload с проверкой PNG/JPEG (CRC, распаковка со сверкой
  объёма, лимит пикселей до распаковки) без буферизации тела
- скачивание через авторизованный API; компенсация неудачной загрузки:
  сначала pending-строка, затем объект
- reconciler БД ↔ S3 с grace period: stale_pending, orphan_object,
  missing_object, size/checksum mismatch, обратимый карантин lost
- сценарии отказов S3, замер памяти загрузок, трек 2, evidence и REPORT.md
2026-10-31 00:31:54 +03:00

42 KiB
Raw Blame History

Отчёт — лабораторная 4

  • Автор, группа: Морару С. С., БПИ2303
  • Целевая оценка: 5, трек 2 «Согласованность двух хранилищ»
  • Commit/PR: ветка solution/bpi2303-moraru (fork s.s.moraru/mtusi2026lab4 и PR — при публикации)
  • Источники: Node.js 24 (node:http, node:crypto, node:zlib, node:stream), pg 8.23.1, @aws-sdk/client-s3 3.1152.0, SeaweedFS 4.48, HAProxy 3.2, PostgreSQL 18; спецификации PNG (ISO/IEC 15948) и JPEG (ITU-T T.81) — для потокового валидатора; документация S3 PutObject/ListObjectsV2.

Запуск из чистого clone

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.

scripts/init-secrets.sh                               # .env из .env.example; secrets/ (вне Git): пароль БД, 3 пары S3-ключей, s3_identities.json
docker compose --env-file .env up -d --build --wait   # postgres, seaweedfs → s3 → migrate + s3-init (one-shot) → api ×2, reconciler → lb
make test                                             # 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                              # вернуть остановленную реплику; для другой цели — повторить тест
docker compose stop                                   # безопасная остановка, данные остаются в volumes
docker compose down -v                                # намеренное удаление учебных данных (volumes pgdata и s3data)

На стенде автора порты 8080 и 8090 заняты другими стендами, поэтому в .env: LB_PORT=8094, LB_STATS_PORT=8414, и все команды с BASE_URL=http://localhost:8094 (--base-url у скриптов). Типы: npm ci && npm run typecheck (Node 24 исполняет .ts напрямую, сборки нет). Полная схема: python3 -m venv .venv && .venv/bin/python -m pip install -r requirements-dev.txt && make validate PYTHON=.venv/bin/python.

Собственные проверки (Python stdlib; скрипты с Docker управляют только compose-проектом этого каталога):

python3 student-tests/attachments.py --base-url http://localhost:8094      # 40 негативных/граничных загрузок, ACL, привязка к сообщениям
python3 student-tests/failures.py --base-url http://localhost:8094         # обрыв загрузки, S3 stop/pause, down + up
scripts/check-s3-security.sh                                                # приватный bucket, права ключей, закрытые порты, повтор s3-init
python3 student-tests/idempotency_race.py --base-url http://localhost:8094 # из lab3
python3 research/upload_memory.py --base-url http://localhost:8094         # 1/10/20/40 одновременных загрузок по 9.9 MiB
python3 research/reconcile_faults.py --base-url http://localhost:8094      # трек 2: матрица внедрённых ошибок
python3 research/reconcile_concurrency.py --base-url http://localhost:8094 # трек 2: reconciler во время загрузок
python3 research/reconcile_cost.py --base-url http://localhost:8094        # трек 2: стоимость обхода 1k/10k/50k

Reconciler (сервис reconciler выполняет --apply каждые RECONCILE_INTERVAL_SECONDS=300 с при RECONCILE_GRACE_SECONDS=900 с); вручную:

docker compose run --rm --no-deps reconciler node src/main.ts reconcile                      # dry-run: только отчёт
docker compose run --rm --no-deps reconciler node src/main.ts reconcile --apply              # исправить
docker compose run --rm --no-deps reconciler node src/main.ts reconcile --apply --verify     # + сверить SHA-256 всех объектов

Оператору: никаких ручных действий, кроме init-secrets.sh. Ключи и пароль не печатаются ни скриптами, ни тестами.

Архитектура и решения

клиент ─► lb (HAProxy, 127.0.0.1:LB_PORT) ─► api × 2 ─┬─► postgres   (пользователи, сессии, чаты, сообщения, метаданные вложений)
                                                      └─► s3 :9000   (S3-шлюз SeaweedFS: подпись SigV4, права identities)
                                                              └─► seaweedfs (master + volume + filer, volume s3data)
          reconciler (раз в 5 мин) ─► postgres + s3       migrate, s3-init — one-shot до старта реплик
сети: frontend (lb) │ backend internal (lb, api, postgres, s3, one-shot, reconciler) │ storage internal (s3, seaweedfs)
Роль Сервис Образ Health / readiness Volume Сеть, порт Credentials (Docker secrets)
LB lb haproxy:3.2.26-alpine проверяет /health/ready реплик раз в 1 с — frontend + backend; 127.0.0.1:LB_PORT, stats 127.0.0.1:LB_STATS_PORT —
API × 2 api messenger-lab4-app:dev (из исходников) /health/ready = процесс + SELECT 1 нет; корневая ФС read_only backend, 8080 не опубликован database_url, s3_api_*
PostgreSQL postgres postgres:18.6-alpine pg_isready pgdata backend postgres_password
S3-шлюз s3 seaweedfs 4.48 @digest GET /healthz :9000 — storage + backend, :9000 не опубликован s3_identities.json (только у него)
Хранилище S3 seaweedfs seaweedfs 4.48 @digest filer :8888 s3data только storage —
Схема БД migrate app, one-shot exit 0 — backend database_url
Bucket s3-init app, one-shot exit 0 — backend s3_admin_*
Сверка reconciler app JSON-итог каждого прохода в логе — backend database_url, s3_reconciler_*
  • Выбор S3. MinIO не воспроизводится из чистого clone: репозитории minio/minio и minio/mc удалены с Docker Hub (API registry отвечает object not found) и с quay.io. Взят SeaweedFS 4.48 (релиз 2026-09-28), закреплён по digest. RustFS 1.0.x тоже доступен, но пользователи и политики у него создаются клиентом rc неясной зрелости; у SeaweedFS identities задаются декларативным JSON, который генерирует init-secrets.sh.

  • Изоляция. HTTP-интерфейсы SeaweedFS (filer :8888, master :9333, volume :8080) не проверяют подпись S3. Поэтому seaweedfs живёт только в internal-сети storage, куда подключён один s3-шлюз. Из контейнера API они недоступны ни по имени, ни по IP. Наружу опубликован только LB, консоли не опубликованы.

  • Права S3 — три identity:

    • admin: Admin/Read/List/Write; ключ есть только у s3-init;
    • api: только Read: и Write:messenger-attachments; без листинга, без создания bucket, без доступа к другим bucket;
    • reconciler: то же, плюс List.

    Анонимной identity нет: запрос без подписи получает 403. В контейнере ключи всегда лежат в /run/secrets/s3_access_key_id и /run/secrets/s3_secret_access_key; compose монтирует туда пару своего сервиса (secrets: target).

  • Bootstrap. s3-init выполняет CreateBucket; ответ BucketAlreadyOwnedByYou значит «exists», поэтому повтор безопасен. Повторный запуск migrate/s3-init из restart.sh и up ничего не меняет. Миграции работают как в lab3: schema_migrations + advisory lock.

  • Схема 002_attachments.sql только добавляет объекты, версия lab3 на ней продолжает работать.

    • Таблица attachments: state ∈ pending/ready/lost, object_key text COLLATE "C" UNIQUE, size_bytes, sha256, width, height.
    • Таблица message_attachments с составным FK (chat_id, attachment_id) → attachments(chat_id, id). БД сама не даёт прикрепить вложение другого чата и удалить строку вложения, на которое ссылается сообщение.
  • Загрузка и транзакционные границы (src/modules/attachments.ts):

    1. До чтения тела проверяются: сессия → участник (иначе 404) → filename (400) → Content-Type (415) → Content-Length (обязателен, иначе 400; больше 10 MiB → 413).
    2. INSERT … pending с ключом originals/<uuid>, COMMIT. Это запись-намерение.
    3. Поток запрос → валидатор + SHA-256 → S3 PUT с ContentLength. Обратное давление: следующий кусок не читается из сокета, пока S3 не принял предыдущий. Последний кусок уходит в S3 только после полной проверки файла, поэтому невалидный файл не становится объектом.
    4. UPDATE pending → ready → 201.

    Ошибка на шагах 3–4 сразу даёт 4xx/503, а компенсация идёт в фоне, чтобы клиент не ждал зависший S3: сначала DELETE pending-строки, затем объекта. Если строка уже ready (COMMIT прошёл, а до API дошла ошибка), объект принадлежит готовому вложению и не удаляется. Если процесс умер или компенсация не удалась, остаётся pending-строка с ключом или объект без строки, их убирает reconciler. Инвариант: строка всегда создаётся раньше объекта, поэтому объект без строки — всегда мусор.

  • Потоковый валидатор (src/modules/images.ts), только stdlib.

    • PNG: сигнатура; порядок chunk; CRC32 каждого chunk (zlib.crc32); неизвестные критические chunk; PLTE для палитры; IDAT подряд; IEND последний и без хвоста. Поток zlib из IDAT распаковывается со счётчиком, вывод выбрасывается, а объём сверяется с вычисленным из IHDR (с учётом Adam7). Это ловит повреждения, усечение и zip-бомбы.
    • JPEG: SOI; цепочка сегментов; ровно один SOF (C0–CF кроме C4/C8/CC) до SOS; энтропийные данные со stuffing и RSTn; обязательный EOI. Хвост после EOI допустим (MPF, «живые» фото).
    • Лимит 40 млн пикселей проверяется по IHDR/SOF до распаковки (413). Состояние валидатора — несколько чисел и до 13 байт хвоста, файл целиком нигде не хранится.
  • Скачивание. Доступ проверяется через JOIN chat_members: посторонний получает 404. Байты идут потоком из S3, без redirect, с Content-Type из метаданных, Content-Length и X-Content-Type-Options: nosniff. variant=original по умолчанию; thumbnail/crop/optimized → 404, иное значение → 400.

  • Сообщения.

    • attachment_ids: 0–10 уникальных UUID, все ready и из этого чата, иначе 404. Пустой text допустим только с вложениями.
    • Hash идемпотентности: без вложений тот же, что в lab3; с вложениями — 64 байта (sha(text) ‖ sha(ids)), поэтому отсутствие поля = [].
    • Ключ, сообщение и связи вставляются одним SQL-оператором. История и повтор возвращают attachment_ids в исходном порядке.
  • Readiness зависит только от PostgreSQL. Если бы S3 входил в readiness, его отказ вывел бы из LB все реплики и остановил текстовый чат. Сейчас при недоступном S3 вложения отвечают 503, остальное работает (см. «Отказы»).

  • Таймауты.

    • S3: подключение 1 с; простой сокета 8 с (throwOnRequestTimeout), это меньше timeout server HAProxy (10 с). При зависшем S3 клиент получает 503 от API, а не 504 от LB.
    • maxAttempts: 1: потоковое тело нельзя отправить повторно.
    • Node: requestTimeout 60 с (10 MiB на медленном канале), заголовки — 5 с.
  • Лимиты ресурсов: api 1 CPU / 256 MiB; s3 1 CPU / 768 MiB и -concurrentUploadLimitMB=256 (по результату эксперимента памяти); seaweedfs 1 CPU / 512 MiB; postgres 2 CPU / 1 GiB; reconciler и one-shot 0.5 CPU / 128 MiB.

  • Нет локального оригинала на API. Корневая ФС контейнеров приложения read_only, volumes у api нет, тело не буферизуется ни в памяти, ни на диске.

  • Перенесено из lab3:

    • весь API: пользователи, scrypt, сессии в PostgreSQL, чаты, keyset-пагинация, идемпотентность;
    • HAProxy-конфиг, graceful drain, stop-one.sh, idempotency_race.py.
  • Изменено по сравнению с lab3:

    • Ctx получил s3 и config, Result может быть потоком байтов;
    • createPool(url, max); mediaType(); ошибки tooLarge/unsupported;
    • история возвращает attachment_ids;
    • restart.sh перезапускает и SeaweedFS (s3, seaweedfs), init-secrets.sh дописывает S3-ключи к существующим секретам;
    • образ назван messenger-lab4-app:dev: на общем Docker-host чужой стенд уже собирал образ с тегом messenger-api:lab4.
  • Переменные .env.example.

    • Используются как есть: APP_HOST, APP_PORT, SESSION_TTL_SECONDS, DATABASE_URL_FILE, API_REPLICAS, S3_ENDPOINT, S3_REGION, S3_BUCKET, S3_ACCESS_KEY_ID_FILE, S3_SECRET_ACCESS_KEY_FILE, MAX_UPLOAD_BYTES, MAX_IMAGE_PIXELS.
    • SESSION_STORE=postgres. CACHE_URL_FILE не используется: Redis нет. APP_ENV не используется.
    • IDEMPOTENCY_TTL_SECONDS: ключи хранятся бессрочно, требование ≥ 24 ч выполнено, очистка — в ограничениях.
    • Ручки реализации: LB_PORT, LB_STATS_PORT, DB_POOL_MAX, API_CPUS, API_MEMORY, DB_CPUS, SHUTDOWN_DRAIN_MS, RECONCILE_GRACE_SECONDS, RECONCILE_INTERVAL_SECONDS.

Доказательства критериев

Все прогоны: 2026-10-30–31, Apple M3 Pro (11 ядер, 18 GiB), OrbStack, BASE_URL=http://localhost:8094.

Критерий README Команда / сценарий Наблюдаемый результат Файл
Публичный smoke make check, make validate, make test PASS lab4 public API scenario: 201 ready, SHA-256 оригинала, download вторым участником, 404 постороннему для метаданных и байтов evidence/level3/public-checks.txt
3: возможности lab3 сохранены make test (сценарий lab1–3), idempotency_race.py --parallel 64, failover PASS; 64 параллельных POST с одним ключом через обе реплики: 32 × 201 с одним и тем же сообщением, 32 × 409, в истории одно сообщение evidence/level3/public-checks.txt, idempotency-race.txt
3: S3 в стенде, метаданные в PostgreSQL, байты в приватном bucket, не в БД/API compose.yaml, check-s3-security.sh анонимные GET/LIST/PUT к S3 → 403; у api нет volumes, корневая ФС read-only evidence/level4/s3-security.txt
3: реальные PNG/JPEG ≤ 10 MiB и ≤ 40 Мпикс, MIME по содержимому, опасные filename, лимиты до чтения student-tests/attachments.py JPEG и PNG 9.9 MiB → 201; ровно 40 000 000 px → 201; 40 006 400 px, 10 MiB + 1 байт → 413; подмена MIME → 415; ../, /, \, NUL, управляющие → 400; 0 ответов 5xx evidence/level4/attachments.txt
3: upload → остановка обслужившей реплики → download через другую make test-failover: цель api-2, затем api-1, затем снова api-2 PASS все 3 прогона, 0 неудачных записей, восстановление 3.9–6.2 с; файл скачан через оставшуюся реплику; в логе lb Server api/apiN is DOWN evidence/level3/public-checks.txt
3: restart с volumes сохраняет метаданные и оригинал make test-persistence (hook 53 с); failures.py (down + up) PASS с прежним токеном; StartedAt изменился у всех 9 контейнеров; после down/up метаданные равны, sha256 совпал evidence/level3/persistence-*.txt, evidence/level4/failures.txt
4: тесты большого, повреждённого, подменённого файла, чужого attachment_id, вложения другого чата; не 500 student-tests/attachments.py 40 случаев upload + ACL + привязка: чужое/смешанное/несуществующее → 404, дубль/11 шт/не UUID → 400; 5xx нет evidence/level4/attachments.txt
4: прерывание и отказ между S3 и БД не оставляют вечных объектов; компенсация + сверка с grace failures.py (обрыв клиента, S3 stop/pause), reconcile_faults.py (COMMIT упал; COMMIT прошёл, ответ потерян; реплика убита между PUT и COMMIT) обрыв и S3 stop: компенсация удалила строки, объектов нет, сверка пуста; pause: буферизованный PUT «воскрес» → orphan_object, убран reconciler-ом, повтор пуст; COMMIT прошёл, ответ потерян → объект ready-вложения цел evidence/level4/failures.txt, evidence/track2/faults.txt
4: потоковая обработка, лимиты/таймауты, ≥ 10 одновременных загрузок с пиком памяти research/upload_memory.py 40 × 9.9 MiB: 40/40 201, пик реплики 63 MiB при лимите 256 MiB (+23 MiB к фону) evidence/level4/upload-memory.txt
4: идемпотентный bootstrap, отдельные ограниченные ключи, консоль закрыта, private bucket вне API scripts/check-s3-security.sh повторный s3-init → exists; api: List/CreateBucket/чужой bucket → 403; filer/master/volume недоступны из API; опубликован только lb evidence/level4/s3-security.txt
5, трек 2: внедрение ошибок с обеих сторон, обнаружение, dry-run, безопасное исправление, повтор research/reconcile_faults.py 9 внедрённых расхождений найдены точно; dry-run не меняет БД и S3; --apply --verify исправил 9; повтор — 0 evidence/track2/faults.txt
5, трек 2: свежие и используемые вложения не удаляются reconcile_faults.py, reconcile_concurrency.py свежие P3/O2 целы до истечения grace; используемые B/D/F → lost, ссылки целы, DELETE отклонён FK; 4674 загрузки под 19 проходами --apply (grace 1 с) целы evidence/track2/faults.txt, concurrency.txt
5, трек 2: стоимость обхода research/reconcile_cost.py см. таблицу в разделе трека evidence/track2/cost.md, cost.jsonl

Эксперименты и отказы

Память при одновременных загрузках

Гипотеза: загрузка идёт потоком с обратным давлением, поэтому память реплики растёт много меньше, чем N × размер файла. При буферизации 20 файлов по 10 MiB на реплику понадобилось бы ≥ 200 MiB при лимите 256 MiB.

Методика (research/upload_memory.py):

  • перед каждым уровнем реплики перезапускаются (новая cgroup), затем прогрев — 4 малые загрузки;
  • N потоков по барьеру загружают один и тот же PNG 9.9 MiB из шума (не сжимается) через LB;
  • memory.current всех api и s3 контейнеров опрашивается каждые 50 мс;
  • один прогон на уровень.
N OK / ошибки время, с MiB/s p50 / max, с загрузок на реплику API до → пик, MiB рост max, MiB S3-шлюз до → пик, MiB
1 1/0 0.21 46.9 0.20 / 0.20 0 / 1 39 / 37 → 47 / 38 8.0 98 → 139
10 10/0 3.49 28.4 3.44 / 3.46 5 / 5 41 / 39 → 58 / 53 16.6 138 → 382
20 20/0 5.46 36.2 5.38 / 5.40 10 / 10 38 / 37 → 64 / 61 25.8 385 → 699
40 40/0 6.78 58.5 4.60 / 6.66 20 / 20 38 / 40 → 60 / 63 22.9 701 → 768
  • Гипотеза подтверждена для API: при 20 одновременных загрузках по 9.9 MiB на реплику (≈ 198 MiB данных) пик вырос на ≤ 26 MiB и почти не зависит от N. Остаток — буферы сокетов и zlib, пул соединений к S3, V8.
  • Найденное узкое место — S3-шлюз. В первом прогоне (s3 256 MiB, без ограничений) шлюз упирался в лимит: при N = 10 одна загрузка получила 503, при 20 и 40 — все 503, контейнер перезапустился (evidence/level4/upload-memory-s3-256m-oom.txt). SeaweedFS буферизует чанки по 4 MiB на каждую загрузку. Исправление: лимит 768 MiB и -concurrentUploadLimitMB=256, т.е. сверх 256 MB данных в работе новые загрузки ждут. После этого все 71 загрузка успешны. Компенсация в том прогоне (тогда она удаляла сначала объект, потом строку) не могла достучаться до S3, и остались 60 pending-строк. Их нашла и убрала первая же сверка следующего эксперимента (stale_pending: 60). Так механизм уровня 4 сработал на непредусмотренном отказе.
  • Ограничения: один прогон на уровень; клиент, LB, API и S3 на одной машине; memory.current включает page cache контейнера; нет пропускной способности на медленных клиентах.

Отказы

Воздействие Что ожидаем Что наблюдали Восстановление / потеря данных
Клиент рвёт соединение на половине тела строка pending удалена компенсацией, объекта нет строк abort.png 0, сверка с grace 0 пуста мгновенно / нет
docker compose stop s3 вложения 503, текст и метаданные работают, readiness 200 upload 503 за 1.0–1.2 с (таймаут подключения), download 503, текст 201, метаданные 200, readiness 200; pending-строк 0 — компенсация удалила их сразу, объектов нет download снова 200 через 0.8 с после start s3 / нет
docker compose pause s3 (TCP висит) 503 от API раньше 504 от LB download и upload 503 за 8.1–8.2 с, текст 201 сразу после unpause; PUT, буферизованный ядром во время паузы, выполнился после ответа клиенту → orphan_object, убран reconciler-ом
COMMIT в PostgreSQL падает после S3 PUT (триггер, ERRCODE 08006), процесс жив 503, фоновая компенсация удаляет строку и объект 503, строк 0, сверка не нашла лишних объектов мгновенно / нет
COMMIT прошёл, а API получил ошибку (триггер: строка становится ready, UPDATE API затрагивает 0 строк) 503; компенсация видит ready-строку и объект не трогает 503; строка ready, объект 111 817 байт на месте, скачивается с исходным sha256. До исправления порядка компенсации объект удалялся (evidence/track2/ack-lost-before-fix.txt) — / нет
Реплика убита docker kill во время COMMIT после S3 PUT клиент получает ошибку, остаются pending + объект, reconciler убирает 502 от LB, строка pending, объект 111 817 байт; stale_pending → строка и объект удалены через grace (900 с в стенде; 30 с в тесте) / нет
make test-failover (SIGTERM одной реплики) запись продолжается, файл доступен через другую 0 ошибок, восстановление 3.9–6.2 с 4–6 с (drain 2.5 с) / нет
scripts/restart.sh (lb, api, reconciler, postgres, seaweedfs, s3) и docker compose down + up данные и токен сохранены PASS; sha256 оригинала совпал 53 с на hook (около 20 с из них — остановка SeaweedFS) / нет

Трек 2. Согласованность двух хранилищ

Гипотеза. Ниже два инварианта: «строка создаётся раньше объекта» и «строки ready/lost не удаляются, только помечаются». При них повторяемый reconciler с grace period обнаружит любое расхождение БД ↔ S3, никогда не удалит используемое или свежее вложение, а стоимость его обхода растёт линейно по числу объектов при постоянной памяти.

Reconciler (src/reconcile.ts):

  • режимы: по умолчанию dry-run; --apply исправляет; --verify дополнительно скачивает объекты и сверяет SHA-256;
  • pg_try_advisory_lock: две сверки одновременно не идут;
  • момент начала t0 берётся из часов БД;
  • объекты листинга S3 (originals/) и строки БД, оба отсортированных побайтово (COLLATE "C"), сливаются merge join страницами по 1000. Если S3 нарушит порядок ключей, обход останавливается, а не удаляет лишнее.
Находка Условие Действие --apply Почему безопасно
stale_pending pending старше grace DELETE строки (с повтором условия), затем объекта grace 900 с ≫ таймаут загрузки 60 с; поздний UPDATE не найдёт строку → 503 и компенсация
orphan_object объект без строки старше grace удалить объект строка всегда раньше объекта; ключ случайный — строка для него уже не появится
missing_object ready без объекта (повторно проверено HEAD) ready → lost метаданные и ссылки сохраняются; API отвечает 404
size_mismatch размер объекта ≠ size_bytes ready → lost то же; объект не трогаем, он может понадобиться для расследования
checksum_mismatch --verify: SHA-256 ≠ sha256 ready → lost то же
restored lost, объект на месте и SHA-256 совпал lost → ready карантин обратим

Строки, изменённые после t0, и объекты моложе grace не проверяются. Конкурентная загрузка не может быть принята за потерю или мусор.

Методика и результаты.

  1. Матрица ошибок (research/reconcile_faults.py, grace 30 с, фоновый reconciler остановлен). Сначала база очищается до 0 находок. Вложения A, B, D, F используются сообщениями, C и E — нет. Внедрено:

    • на стороне S3 (ключом reconciler в обход API): объект B удалён; C подменён другим размером; D подменён тем же размером; F удалён (с резервной копией вне originals/); добавлен O1 — объект без строки;
    • на стороне БД: строка E удалена; P1 и P2 — pending «час назад», у P2 есть объект;
    • настоящие отказы через триггер: COMMIT падает после S3 PUT; COMMIT прошёл, но API получил ошибку (ack-lost: вложенный UPDATE делает строку ready, а UPDATE API затрагивает 0 строк); реплика убита docker kill во время COMMIT (CR).

    Результат:

    • dry-run нашёл ровно 8 ожидаемых находок (stale_pending P1/P2/CR, orphan_object E/O1, missing_object B/F, size_mismatch C);
    • --verify добавил checksum_mismatch D;
    • отпечаток всех строк (count + md5) и число объектов после dry-run не изменились;
    • --apply --verify исправил 9, повторный --verify — 0;
    • A скачивается с тем же sha256; B, C, D, F → lost (API 404), ссылки сообщений на B/D/F на месте, DELETE строки B отклонён FK;
    • объект F вернули — restored, F снова скачивается;
    • свежие P3/O2 пережили --apply (fresh_skipped=1) и были убраны после истечения grace;
    • ack-lost: API ответил 503, строка ready, объект на месте и скачивается с исходным sha256, находок по нему нет.

    Случай ack-lost добавлен после ревью кода. Компенсация удаляла сначала объект и только потом pending-строку, поэтому при потерянном ответе на COMMIT готовое вложение теряло оригинал, а reconciler затем помечал его lost. На старом коде матрица падает ровно на этом шаге (evidence/track2/ack-lost-before-fix.txt). Исправление в discard(): сначала DELETE … WHERE state = 'pending'; объект удаляется, только если строка удалена или её нет.

  2. Конкурентность (research/reconcile_concurrency.py). 25 с: 4 потока загружают через API (каждое 5-е вложение сразу прикрепляется к сообщению), параллельно reconcile --apply --grace=1 --every=1.

    Результат: 4674 загрузки, все 201; 19 проходов сверки. Каждое подтверждённое вложение после теста ready и скачивается с исходным sha256, итоговая сверка пуста. Единственная находка за время гонки — заведомо медленная загрузка (~4 с > grace): reconciler убрал её pending-строку, клиент получил 503, ни строки, ни объекта не осталось. Это граница метода: grace обязан превышать максимальную длительность загрузки (в стенде 900 с против 60 с).

  3. Стоимость обхода (research/reconcile_cost.py). К текущему набору (~3 000 реальных объектов) добавлялись синтетические ready-вложения по 1 KiB (строка + объект) до 1k / 10k / 50k. На каждом уровне — 3 dry-run (медиана) и --verify для 1k/10k.

синтетики объектов / строк dry-run, мс (медиана из 3) ListObjectsV2 запросов к БД max RSS, MiB --verify, мс прочитано, MiB
0 3002 / 3007 471 4 6 119 19 516 1 123
1 000 4002 / 4007 801 5 7 123 21 926 1 124
10 000 13 002 / 13 007 1 165 14 16 123 39 813 1 133
50 000 53 002 / 53 007 3 032 54 56 116 — —
  • Число запросов строго линейно: ListObjectsV2 = ⌈N/1000⌉, к БД — страницы + 2.
  • Время dry-run растёт примерно на 47 мкс на объект (13k → 53k: +1.9 с). Экстраполяция на 1 млн объектов — около 1 мин.
  • Память постоянна: 116–123 MiB на всех уровнях — это фон Node + SDK. Merge join держит по одной странице с каждой стороны. Гипотеза о линейной стоимости при постоянной памяти подтверждена.
  • --verify стоит по байтам и запросам: 1.1 GiB за 19.5 с, а 10 000 мелких объектов добавили 20 с (≈ 2 мс на GET). Поэтому периодический проход сравнивает только наличие и размер, а полную сверку SHA-256 запускают редко и вручную.
  • Подробности и сырьё: evidence/track2/cost.md, cost.jsonl.

Ограничения.

  • Один host и одна машина для клиента и стенда; для каждого уровня стоимости 3 прогона, для --verify — один.
  • Глубокий режим читает все байты bucket. Lost-объекты того же размера перехешируются на каждом проходе.
  • Поддерживается только префикс originals/.
  • Часы S3 и БД — одного host; при разных часах grace надо увеличивать на расхождение.
  • missing_object для строки, ставшей ready ровно между листингом и HEAD, отсекается проверкой settled (updated_at < t0).

Ограничения и следующие шаги

  • Выдерживается:
    • отказ одного процесса API;
    • недоступность или зависание S3: деградируют только вложения;
    • обрыв загрузки, отказ COMMIT после PUT, потерянный ответ на COMMIT, гибель процесса между PUT и COMMIT.
  • Не выдерживается:
    • отказ LB, PostgreSQL, SeaweedFS как единственного экземпляра (без репликации, один volume server);
    • отказ host.
  • Потерянный объект нельзя восстановить, если нет копии. Reconciler только помечает его lost.
  • Загрузка требует Content-Length: chunked → 400. Поток в S3 PUT без длины потребовал бы multipart.
  • Валидатор JPEG не декодирует энтропийные данные: битые коэффициенты при целой структуре пройдут. Полное декодирование — в worker lab5.
  • Ключи идемпотентности не удаляются (из lab3).
  • Дальше:
    • presigned upload (трек 1) поверх тех же pending/reconciler;
    • inventory-отчёты S3 вместо полного листинга при миллионах объектов;
    • кэш результата --verify по ETag/LastModified;
    • версионирование bucket для отката ошибочных удалений.

Ответы на вопросы защиты

  • Почему файл в Docker volume одной API-реплики не равен объектному хранилищу? Volume привязан к одному контейнеру и host. Другая реплика его не видит, при остановке реплики файл недоступен (failover-тест скачивает через другую реплику), у volume нет API с правами доступа и учёта. S3 — общий сервис с собственной долговечностью и ACL.
  • Когда можно честно вернуть 201? Только когда весь файл проверен, S3 подтвердил PUT (объект полностью записан) и COMMIT перевёл строку в ready. Здесь 201 возвращается после UPDATE … RETURNING, а последний кусок уходит в S3 только после полной проверки формата.
  • Что произойдёт, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет? Клиент получает 503 (или 502, если процесс умер), строка остаётся pending. Если процесс жив, фоновая компенсация удаляет pending-строку, затем объект. Если нет, reconciler через grace удалит строку и объект (stale_pending). Обратный случай — COMMIT прошёл, но ответ до API не дошёл: строка уже ready, компенсация это видит и объект не трогает. Все три случая воспроизведены в reconcile_faults.py.
  • Почему случайный object key и приватный bucket не заменяют ACL приложения? Ключ — не секрет: он попадает в логи, бэкапы, ответы, его знают все, у кого есть доступ к хранилищу. Приватный bucket защищает только от анонимного доступа к S3, но не отличает участника чата от постороннего пользователя API. Право видеть файл решается в приложении (членство в чате, 404 постороннему), а ключ наружу не выдаётся вообще.