Files
mtusi2026lab5/openspec/changes/pipeline-reliability/design.md
T

99 KiB
Raw Blame History

Design

Context

Мотивация — proposal.md, раздел Why. Требования — specs/. Контракт — contracts/README.md («Фоновая обработка (с lab5)»), contracts/attachment-states.md, contracts/jobs.schema.json, рубрика — README.md, уровень «4» (она главнее любого списка здесь). Основа — design архива 2026-10-31-async-attachments: его схема уже содержит published_at, next_attempt_at, lease_expires_at, значения вариантов crop и optimized.

Код

Состояние — 7f38948 (архив async-attachments, ветка feat/pipeline-reliability):

  • AttachmentService._store: staging → queued с заданием (tx2) → публикация с подтверждением → published_at (tx3) → 202. Отказ брокера — условная отмена, 503;
  • AttachmentProcessingService: claim по redelivered и сроку, декодирование в потоке (anyio.to_thread + CapacityLimiter(concurrency)), retry_delay_seconds — пауза в месте конкуренции, сообщение следующей попытки публикует сам worker;
  • src/worker/main.py: prefetch_count = concurrency; сумма сроков остановки 8 + 5 × 0,5 = 10,5 с при обещании «меньше 10» (замечание S5);
  • AttachmentCleanupService убирает только pending; у worker права удаления нет, у уборщика есть;
  • сверка видит только <база>/attachments/, класс orphan_object покрывает варианты с любым именем (parse_variant_key читает все значения enum);
  • bench/: брокер запускает только профиль загрузок; паспорт пишет .Image.

Пробы (2026-10-31, scratchpad, проект compose plprobe)

Образы — пины рабочего стенда и образ mtusi-messenger:lab5 (arm64, Docker 29.9.2, контейнер 1 CPU / 1 ГБ как у worker); данные — tmpfs, volumes не создавались. Рабочий стенд не затронут. После проб контейнеры и сеть удалены, ничего не осталось.

Проверка Результат
Pillow 13.0.0 в образе features.check('webp') — да, libwebp 1.6.0, libjpeg-turbo 3.2.0: новой зависимости не нужно
Три варианта из одного декодирования, 40 Мпкс, новый процесс: CPU и VmPeak PNG RGBA 0,36–0,55 с, 370 МиБ; RGB 0,46 с, 217 МиБ; палитра с tRNS 0,39 с, 408 МиБ; серый 16 бит 0,25 с, 417 МиБ; 1 бит 0,17 с, 133 МиБ; JPEG с draft: baseline 0,18 с, 66 МиБ, прогрессивный 0,22 с, 160 МиБ, CMYK 0,20 с, 77 МиБ. PNG из шума 10 MiB (3,5 Мпкс) 0,33 с, 105 МиБ, WebP из него 181 мс и 913 КиБ; fixture 0,11 с, 47 МиБ
Те же 40 Мпкс по всем типам PNG (правки по проверке, peak_kib, лимит 450 МиБ; строка выше не содержала серого с альфой и RGB с tRNS) до правки «Уточнения apply», п. 19: серый с альфой 8 бит, RGB 8 и 16 бит с tRNS — код 4; палитра, серый 8 бит и 1 бит с tRNS 395 МиБ. После: они все 357; RGBA 8 и 16 бит, серый с альфой 16 бит 357; RGB 204; серый 16 бит 404–405, это наибольшее; JPEG прогрессивный 262, CMYK 338
ru_maxrss против VmHWM ru_maxrss дочернего процесса наследует пик родителя через fork (452 МиБ у всех строк); верный пик — VmHWM из /proc/self/status: 363 МиБ у PNG RGBA 40 Мпкс
RLIMIT_AS, PNG RGBA 40 Мпкс 300 МиБ — MemoryError ловится, код процесса свой; от 400 МиБ проходит. Серый 16 бит и палитра с tRNS падают на 350, проходят на 450. JPEG при 150 МиБ — OSError, а не MemoryError (пройдёт как «не декодируется»). Аварий и core нет
«Дорогой» JPEG в пределах контракта: прогрессивный 8000 × 5000, самый маленький скан (23 байта) повторён 445 227 раз, 10 485 757 байт inspect_image принимает; за 60 с на 1 CPU не декодирован, родитель убивает за ~14 мс. Это настоящий случай «ограничено по времени», поток так не прервать
RLIMIT_CPU на этом файле 2 и 5 с: код −24 (SIGXCPU) ровно на лимите, 2157 и 5015 мс по стене
Убийство ядром: четыре процесса PNG RGBA 40 Мпкс одновременно в контейнере 1 ГБ три −9, один 0, родитель (PID 1) жив: ядро выбирает самых больших, worker переживает
Цена процесса на задание python -I 21 мс, с PIL.Image 52 мс, с плагинами JPEG/PNG/WebP 90 мс; весь рендер fixture — 120 мс по стене. Forkserver с предзагрузкой — 9 мс (первый запуск 212 мс)
Детерминизм два запуска fixture и PNG RGBA 40 Мпкс — одинаковые SHA-256 всех трёх вариантов
Метаданные из JPEG и PNG с EXIF и ICC: info после resize их хранит, но save не пишет: WebP — один чанк VP8 , JPEG — маркеры без APP1/APP2, строки производителя в байтах нет. RGBA: VP8X, ALPH, VP8 , альфа 0 на прозрачных; непрозрачный RGBA — VP8 . L, 1, P, LA, CMYK, I;16 сохраняются
WebP: quality, method, 1280 × 800 шум: q80 m4 702 КБ 129 мс, m6 704 КБ 343 мс, m2 1183 КБ 78 мс; мягкий шум: q80 m4 402 КБ 91 мс, m6 404 КБ 464 мс
macOS setrlimit(RLIMIT_AS) — ValueError: на хосте лимит памяти не действует
План выборки relay, 208 тыс. заданий, из них 8 тыс. живых индекс (COALESCE(next_attempt_at, created_at), id) WHERE state='queued' AND published_at IS NULL: Index Scan + LockRows, 0,05 мс на 100 строк, и в общем плане с параметром времени. Состояние параметром — Seq Scan, 7,4 мс: константа обязательна, как у уборщика. Счёт опубликованных — Index Only Scan, 0,35 мс на 5000; истёкшие аренды и потерянные — Index Scan, 0,007 мс
Публикация с подтверждением, один канал, asyncio.gather 100 сообщений — 7 мс, 1000 — 101 мс
declare_queue(...).declaration_result.message_count считает только готовые: 1111 → 1109 при двух неподтверждённых; потребителей называет отдельно
Очередь удалена мимо приложения публикация на том же канале — PublishError за 2 мс, канал жив; новое соединение с объявлением — успех
Предел памяти (rabbitmqctl set_vm_memory_high_watermark absolute 1MiB) публикация висит до срока, TimeoutError; часть сообщений уже в очереди: исход неизвестен, дубль возможен
Окно «после COMMIT до ack» без кода: отложенный триггер pg_sleep(3), pg_stat_activity показывает PgSleep active COMMIT;, docker kill -s STOP клиента, строка succeeded в БД при замороженном клиенте, docker kill статус контейнера running, не paused, поэтому SIGKILL работает; журнал клиента без строки о фиксации; выход 137; очередь: ready 1, unacked 0 за 0,64 с; следующий запуск — redelivered, succeeded, подтверждение без эффекта
SeaweedFS 4.48, s3:prefix с двумя значениями в StringLike <база>/attachments/, <база>/staging/ — 200 с ключами; <база>/, чужая база, .s3-check/, пустой — 403; удаление ключом уборщика — 204

Что найдено до решений

  1. Живая попытка теперь по-настоящему ограничена сроком. На уровне 3 поток декодирования сроком не прерывался, поэтому lease пришлось бы продлевать; с отдельным процессом срок попытки жёсткий, и аренда получается без пульса (решение 3).
  2. Сообщение перестаёт быть носителем работы. Как только следующую попытку и возврат зависшей публикует relay, а истина — в строке задания, любой лишний или потерянный дубль решается одной таблицей claim. Отсюда и закрытие W2, и S6: паузы в worker больше нет.
  3. Сценарий нельзя убрать правкой дельты (openspec validate --strict, как на уровне 3): потеря сценария у MODIFIED — ошибка. Поэтому «Брокер не подтвердил задание» и «Загрузка без подтверждения брокера убрана» сохранены именем, а их поведение описано заново; второй честно относится к смеси версий при замене реплик.
  4. Частично записанные объекты failed контракт не называет, но они мусор: скачать их нельзя (409), а без исходника replay невозможен. Удаляются вместе со staging по сроку (решение 9).
  5. Цепочка LB после отказа от публикации возвращается к числам лабы 4 (26 с и 73 с): самым долгим снова становится путь компенсации (решение 11).

Goals / Non-Goals

Goals:

  • Уровень «4» рубрики целиком и шаг 4 сценария защиты, с доказательствами на закоммиченном коде.
  • Настройки и счётчики, на которых track1-queue-overload измерит ≥3 настройки concurrency и prefetch на разных размерах, throughput, queue lag, p95 до ready, RSS, backpressure и ограничение принятой работы (решение 8).
  • Прежние механизмы не ломаются: компенсация, уборщик, сверка, места загрузки, цепочка таймаутов, rolling_update.

Non-Goals (сознательно):

  • замеры перегрузки и ограничение принятой работы на входе API — track1-queue-overload;
  • сверка наличия и размера объектов вариантов (решение 9);
  • DLX и очереди с TTL в брокере: реестр и сроки — в PostgreSQL (решения 4 и 5);
  • versioned pipeline и несколько pipeline_version — это трек 2, не выбран;
  • разделение прав пользователей брокера и trace context — лабы 7 и 6;
  • файлы исключений старых лаб — последний шаг всего прогона.

Decisions

1. Outbox на attachment_jobs, брокера в пути запроса нет

AttachmentService._store после _mark_queued сразу отвечает 202. Убираются _publish_job, _cancel_job, параметр publisher, attachment_job_repo.delete_unstarted, attachment_repo.return_to_pending, src/infra/broker/instance.py, зависимости в src/api/dependencies.py и src/main.py, поля брокера в «Started API», *broker-env и depends_on: rabbitmq у сервиса api.

Outbox — те же строки: state = 'queued' AND published_at IS NULL. Строка уже пишется в одной транзакции с queued (решение 1 архива). Что стало с 503 (вопрос преподавателю №3): отказ брокера больше не даёт 503; на загрузке 503 только от S3 и PostgreSQL. Контракт требует к 202 «полный проверенный оригинал в staging, метаданные, намерение обработки» — всё это есть без брокера.

Окна отказа контракта после изменения:

Окно Что происходит Что видит клиент
после staging до записи задания pending и объект staging; их убирает уборщик 503 или обрыв
после COMMIT queued до ответа работа идёт: relay опубликует обрыв; вложение станет ready, клиент о нём не знает, как и в лабе 4
после COMMIT до publish (relay упал) намерение в БД, следующий проход публикует 202 уже получен
после publish до confirm исход неизвестен: новая публикация, возможен дубль опрос queued
после confirm до отметки published_at откат отметки, новая публикация, дубль опрос queued или processing
после записи S3 до COMMIT результата аренда истекает, новая попытка пишет те же ключи опрос processing, затем queued
после COMMIT результата до ack повторная доставка — no-op опрос ready

Альтернатива: попытка публикации в API «на удачу» и relay как страховка. Отвергнута: два пути публикации, зависший брокер снова держит ответ до срока и место загрузки, пароль остаётся у реплик; выигрыш — до 0,25 с до ready. Альтернатива: отдельная таблица outbox. Отвергнута: второе состояние той же работы и транзакция на две строки там, где уже есть одна. Альтернатива: LISTEN/NOTIFY вместо опроса. Отвергнута: отдельное соединение мимо пула и свой путь переподключения, а опрос всё равно нужен для сроков и после пропущенного уведомления. Опрос на пустой выборке — 0,05 мс (проба).

2. Relay

python -m src.relay → src/relay/__main__.py (early_stop.install("relay"), «Invalid relay settings» и код 2, os._exit) → src/relay/main.py → AttachmentRelayService (src/core/services/attachment_relay.py). Свой engine (пул 1) и JobPublisher; S3 и Pillow нет.

Где живёт. Отдельный сервис compose на образе API:

Вариант Почему нет
в репликах API N издателей, клиент брокера и его пароль снова у реплик, фоновая работа в event loop обязательного пути; правило «реплики не держат фоновой работы»
в worker остановка worker на защите остановила бы и публикацию: сообщения в очереди при остановленном worker исчезли бы из сценариев уровня 3 и test_job_message_matches_schema; масштабирование worker множит издателей без нужды
в уборщике плановая сверка длится минуты и заняла бы единственный цикл; срок до ready зависел бы от неё

Проход (publish_pass), повторяется сразу, пока пакет полон, иначе пауза poll_interval_seconds или сигнал:

  1. Истёкшие аренды. UPDATE attachment_jobs … WHERE id IN (SELECT … state='processing' AND lease_expires_at < :now ORDER BY lease_expires_at LIMIT :n FOR UPDATE SKIP LOCKED): state='queued', last_error_code='lease_expired', lease_expires_at, next_attempt_at, published_at — NULL. Вложения тех же id — processing → queued. Одна транзакция, порядок блокировок: задание, затем вложение.
  2. Потерянные сообщения. Если есть queued с published_at < :now - republish_after_seconds, JobPublisher.ready_messages() (активное объявление очереди, message_count). Ноль готовых — таким заданиям published_at = NULL. Не ноль — ничего: длинная очередь не обрастает копиями. Объявление ещё и создаёт удалённую очередь.
  3. Публикация. Транзакция: room = max_published_backlog - count_published() (0 — без предела; места нет — конец прохода, запись один раз на смену состояния); выборка до min(batch_size, room) due-строк ORDER BY COALESCE(next_attempt_at, created_at), id FOR UPDATE SKIP LOCKED; JobPublisher.publish_many() с подтверждением под одним сроком publish_timeout_seconds; published_at = :now подтверждённым; COMMIT.

Статусы в выборках — literal(..., literal_execute=True): иначе общий план не докажет условие индекса (проба: 7,4 мс и Seq Scan).

Публикация внутри транзакции — осознанное исключение из правила «брокера и S3 в транзакции нет», как DELETE у уборщика: блокировка строки и есть признак «это задание публикует другой relay». Срок ограничен publish_timeout_seconds (2 с) < request_timeout_seconds (6 с), срока всего шага, < idle_in_transaction_session_timeout (10 с): замороженный relay блокировок не удержит. Worker, получивший сообщение раньше COMMIT, ждёт блокировку в lock_job и видит отметку: окна «сообщение есть, отметки нет» в обычной работе нет.

JobPublisher остаётся клиентом уровня 3: соединение лениво, сброс после любой ошибки, закрытие в фоне, mandatory, on_return_raises. Новые publish_many(items) -> set[UUID] (задача на сообщение и asyncio.wait с общим сроком: подтверждённые до срока считаются, остальные отменяются; вернул подмножество — ошибка уже записана, соединение сброшено, а отметка и COMMIT идут для подтверждённых) и ready_messages().

Сообщение: build_job_body(job, attempt=job.attempt + 1). job_id тот же, тело по схеме контракта.

Несколько экземпляров безопасны (SKIP LOCKED), на стенде один; второй появляется только на время замены образа. Порядок — по сроку, повтор стоит в той же очереди, что новые: при пределе опубликованных он не голодает. Гарантии порядка обработки нет и не нужно: задания независимы.

Задания уровня 3 без published_at подбираются тем же запросом; строки queued с published_at — сообщения уже в очереди; processing — истечёт аренда. Отдельного шага нет.

Альтернатива: без блокировки, выборка и условная отметка. Отвергнута: два relay дублировали бы каждое задание в обычной работе. Альтернатива: колонка «публикует relay X до T». Отвергнута: вторая аренда ради того, что строка блокировки делает даром. Альтернатива: транзакция на сообщение. Отвергнута: 20 подтверждений вместо пакета, а под нагрузкой один COMMIT на задание; пакет 100 подтверждается за 7 мс.

3. Claim, аренда и fencing

Worker больше не публикует: из AttachmentProcessingService уходит publisher, redelivered пишется только в журнал. Claim под lock_job, сравнение времени — часами приложения (utcnow()), как у остальных отметок; запас аренды закрывает расхождение часов консольного процесса и ВМ:

state условие действие сообщение
строки нет или чужое вложение Skipped job message, unknown ACK
succeeded проверка: вложение ready, thumbnail есть (строки уровня 3 других вариантов не имеют), finished ACK
failed finished: replay публикует своё сообщение ACK
queued published_at IS NULL и next_attempt_at > now not_due: relay опубликует в срок (S6) ACK
queued иначе бюджет исчерпан — failed retry_exhausted; иначе взять ACK после итога
processing lease_expires_at > now busy, без записи (W2) ACK
processing аренда истекла бюджет исчерпан — failed; иначе взять ACK после итога

Бюджет: attempt - attempt_base >= max_attempts. Взятие: attempt + 1, lease_expires_at = now + job_timeout_seconds + lease_margin_seconds.

Почему ACK у busy. Лишнее сообщение не нужно: если живая попытка умрёт, работу вернёт relay по аренде. Возврат в очередь занимал бы место prefetch и крутился бы паузами, а redelivered живого от потерянного не отличает: брокер ставит его и после nack. Цена — после KILL worker следующая попытка начнётся не сразу, а по истечении аренды (по умолчанию до 70 с). Это честный ответ на вопрос защиты: отличить мёртвого от живого можно только сроком.

Почему без пульса. Шаги попытки прерывает asyncio.timeout(job_timeout_seconds), процесс обработки убивается (решение 7), поэтому попытка не может жить дольше срока. Истёкшая аренда — значит, процесс мёртв или заморожен. Пульс сократил бы восстановление до десятков секунд, но добавил бы запись на задание каждые несколько секунд, зависимость от event loop и ложные срабатывания под перегрузкой — ровно там, где их будет мерить трек 1.

Fencing. Фиксация под lock_job: state = 'processing' AND attempt = :своя, иначе Skipped job message, superseded, ACK. То же уже есть у _fail и _retry. Уровень 3 принимал результат старой попытки; теперь замороженный процесс после разморозки ничего не меняет. Объект он всё же может дописать теми же байтами: ключ тот же, версия декодера та же (ограничение, REPORT.md).

Worker подтверждает всегда, кроме DROP (сообщение не по схеме) и REQUEUE: PostgreSQL недоступен (записать нельзя, пауза reconnect_seconds) или остановка.

Альтернатива: пульс (см. выше). Альтернатива: взять задание сразу при redelivered. Отвергнута: это и есть W2, дубль параллельно живой попытке. Альтернатива: опознавать потерянного по имени процесса в строке. Отвергнута: второй worker и перезапуск неотличимы без реестра живых, а срок всё равно нужен.

4. Повторы: backoff с jitter, постоянные и временные ошибки

Пауза перед попыткой N + 1: d = min(retry_max_delay_seconds, retry_base_delay_seconds × 2^(N−1)), random.uniform(d / 2, d) — чистая функция в модуле сервиса; N считается от последнего replay. При 5 / 300 и пяти попытках сумма пауз 37,5–75 с: рестарт S3 (~25 с) укладывается, как на уровне 3. Транзакция processing → queued пишет next_attempt_at, published_at = NULL; сообщение подтверждается сразу. Ожидание не занимает место конкуренции и не держит сообщение, остановка worker его не прерывает, а claim соблюдает срок (S6 закрыт).

Класс Причина (last_error_code) Итог
постоянная undecodable, limit_pixels, limit_memory, limit_cpu failed, invalid_image
постоянная source_missing, source_corrupted failed, processing_failed
временная storage_unavailable, timeout, render_killed, render_crashed, lease_expired, unexpected queued, затем retry_exhausted
не попытка PostgreSQL недоступен сообщение в очередь после паузы

Новых значений error_code нет: реплика прежней версии падает на незнакомом значении enum (_to_dto), а клиенту различие лимита и порчи ничего не даёт. Причина — для оператора.

Альтернатива: полный jitter uniform(0, d). Отвергнута: нижняя граница суммы пауз стремится к нулю, и рестарт S3 мог бы исчерпать попытки. Альтернатива: очереди с TTL и DLX, плагин отложенной доставки. Отвергнуты: срок и счёт попыток контракт просит хранить устойчиво, они уже в БД; аргументы очереди неизменяемы, плагин — ещё одна зависимость образа. Альтернатива: не считать попытки при отказе S3. Отвергнута: «бесконечный немой retry недопустим»; failed при долгом отказе лечит replay.

5. Реестр failed и replay

Реестр — строки attachment_jobs с state = 'failed', причина и код уже есть. DLQ брокера не нужна: всё принятое живёт в БД, а сообщение не по схеме работы не несёт и отбрасывается с записью error.

Команда: python -m src.relay replay [--attachment-id ID]... [--error-code C] [--reason R] [--limit N] [--apply] [--operator NAME], цель make replay, в контейнере docker compose run --rm --no-deps relay replay …. Нужен только PostgreSQL. По умолчанию dry-run: журнал показывает реестр. С --apply выбор обязателен, иначе код 2: случайно повторить всё нельзя. HTTP-ручки нет: контракт её не описывает, у API нет роли оператора (вопрос преподавателю, QUESTIONS.md).

AttachmentReplayService.replay_one — одна транзакция, порядок блокировок общий: lock_job, lock_attachment, проверки, attachments: failed → queued, error_code NULL; задание: queued, attempt_base = attempt, last_error_code, next_attempt_at, lease_expires_at, published_at, finished_at — NULL; запись attachment_job_replays. Сообщение публикует relay. Отказы, без изменений: not_found, already_ready, not_failed, source_gone (staging_key IS NULL). Код выхода 3 при любом отказе. Гонка с очисткой исключена блокировкой строки вложения.

Replay invalid_image разрешён: оператор мог поправить декодер; попытка упадёт снова, ограниченно. Номер attempt растёт монотонно: это fencing-токен, поэтому бюджет — отдельной колонкой, а не сбросом.

Альтернатива: сбрасывать attempt в 0. Отвергнута: попытка до replay с тем же номером смогла бы зафиксировать результат. Альтернатива: HTTP-ручка в contracts/extensions.openapi.json. Отвергнута: роль оператора и её проверка — вне контракта этой лабы, CLI в контейнере на защите проще и безопаснее. Альтернатива: DLQ сообщений. Отвергнута: второй реестр той же работы.

6. Варианты

src/utils/image_variants.py вместо thumbnail.py. Чистая функция render_variants(data, *, max_pixels) -> RenderedVariants; thumbnail_size — частный случай fit_size(width, height, max_side). Pillow импортирует только этот модуль, а его — только src/worker/render.py.

Одно декодирование, порядок:

  1. Image.open(formats=("PNG", "JPEG")), пиксели сверх лимита — TooManyPixels; orientation из EXIF; размеры считаются по показанным сторонам, как у thumbnail (своё округление вниз).
  2. JPEG: draft("RGB", (max(opt_w, min(w, 128)), max(opt_h, min(h, 128)))) — масштаб DCT под самый большой нужный размер.
  3. _prepared прежний, но после перевода в RGBA закрывает исходник («Уточнения apply», п. 19); base = resize(opt, LANCZOS, reducing_gap=2.0) — основа для optimized и thumbnail.
  4. Crop: центрированный квадрат короткой стороны. Источник — base, если её короткая сторона не меньше 256, иначе декодированное (у 5000 × 10 основа 1280 × 2, из неё квадрата не получить): resize((128, 128), LANCZOS, box=…, reducing_gap=2.0). Центр при повороте тот же, поэтому квадрат считается в хранимых координатах; расхождение смещения в 1 px при нечётной разности не имеет значения.
  5. Transpose по orientation — на малых изображениях.
  6. Thumbnail и crop: альфа на белый, JPEG quality=85. Optimized: без компоновки, save("WEBP", quality=80, method=4); метаданные не передаются.
Вариант Формат Размер Параметры Метаданные
thumbnail JPEG вписан в 256 × 256, без увеличения quality=85 EXIF и ICC не пишутся
crop JPEG 128 × 128, центр, маленькие растягиваются quality=85 то же
optimized WebP вписан в 1280 × 1280, без увеличения quality=80, method=4: m6 на пробе в 3,5 раза дольше без выигрыша EXIF, XMP, ICC нет; ориентация применена; прозрачность сохранена

Цвет: профиль ICC отбрасывается, учебные данные — sRGB (ограничение, REPORT.md). Результат детерминирован (проба). Ключ — variant_key(…, name); фиксация — три строки attachment_variants и ready одной транзакцией.

Альтернатива: декодировать на каждый вариант. Отвергнута: три раза по 0,5 с и три пика. Альтернатива: crop всегда из основы. Отвергнута: у вытянутых изображений квадрат в 2 px. Альтернатива: альфа на белый и у WebP. Отвергнута: контракт требует белый только у thumbnail, WebP прозрачность умеет. Альтернатива: pyvips. Отвергнута на уровне 3.

7. Лимиты: дочерний процесс на задание

src/infra/render/client.py — ImageRenderer.render(data) -> RenderedVariants: asyncio.create_subprocess_exec(sys.executable, "-m", "src.worker.render", …), рабочий каталог — корень приложения. Окружение — только PATH, PYTHONDONTWRITEBYTECODE, PYTHONUNBUFFERED, MALLOC_MMAP_THRESHOLD_: секретов в нём нет. Вход — байты в stdin, параметры — аргументы. Выход — строка JSON (размеры, длины, VmHWM), затем байты вариантов; SHA-256 считает родитель по тому, что запишет. src/worker/render.py первым делом ставит лимиты, а Pillow импортирует после них.

Лимит Механизм Превышение Итог
байты stored.size != size_bytes до чтения тела; size_bytes ограничен CHECK контракта source_corrupted постоянная
пиксели width × height до декодирования код 5, limit_pixels постоянная
память RLIMIT_AS = render_memory_limit_mib MemoryError, код 4, limit_memory постоянная
CPU RLIMIT_CPU = render_cpu_limit_seconds, жёсткий на секунду больше; RLIMIT_CORE = 0 сигнал SIGXCPU, limit_cpu постоянная
время родитель: asyncio.timeout(render_timeout_seconds), kill timeout временная
не декодируется ошибка Pillow, код 3 undecodable постоянная
убит ядром код −9, родитель не убивал render_killed временная
иное другой код или испорченный вывод render_crashed временная

Различие CPU и стены: CPU — свойство файла, повтор не поможет; стена — ещё и свойство нагрузки стенда. finally у клиента всегда убивает процесс и дожидается его с коротким сроком: отмена попытки при остановке или по сроку процесс не оставит.

Значения. render_memory_limit_mib 450: наибольший VmPeak на пробе 417 МиБ. Бюджет контейнера: пик VmHWM не больше ~410 МиБ на процесс × 2 + worker ~130 МиБ с двумя телами ≈ 950 МиБ < 1 ГБ (число worker уточняет задача 5.2). Сумма самих лимитов, 2 × 450 + 130 = 1030 МиБ, чуть больше 1024, но VmHWM меньше адресного пространства; а если памяти всё же не хватит, ядро убьёт самый большой процесс обработки, а не worker (проба), и это временная ошибка. render_cpu_limit_seconds 15: наибольшее законное на пробе — 0,55 с, запас от шумного файла и слабого хоста в десятки раз. render_timeout_seconds 40: при конкуренции 2 на 1 CPU два дорогих файла получают по половине ядра, 15 с CPU — это 30 с по стене, и постоянная ошибка наступает раньше временной; меньше job_timeout_seconds (валидатор), чтобы осталось время на запись. При большей конкуренции на том же CPU срок сработает раньше лимита: файл получит временную ошибку и кончится retry_exhausted, это видно в причине и мерит трек 1.

На macOS setrlimit(RLIMIT_AS) — ValueError: процесс продолжает, вывод отмечает, что лимит не применён, в журнале это видно (ограничение консольного запуска). VmHWM там нет — поле null.

Альтернатива: потоки (уровень 3). Отвергнута: поток не прервать, MemoryError и падение декодера роняют worker, лимит памяти — только на весь контейнер. Альтернатива: ProcessPoolExecutor. Отвергнута: убитый процесс ломает весь пул, RLIMIT_CPU накапливается на процесс. Альтернатива: forkserver с предзагрузкой — 9 мс вместо ~70 мс на задание. Отвергнута сейчас: секреты родителя в окружении, блокирующие каналы поверх asyncio, свой жизненный цикл сервера; граница — один модуль, и если трек 1 покажет, что запуск ограничивает маленькие файлы, это точка замены. Альтернатива: постоянный процесс на слот. Отвергнута: лимит CPU накапливается, память не возвращается, а сброс после убийства — та же сложность.

8. Prefetch, backpressure и что есть для трека 1

[worker] prefetch отдельно от concurrency. src/worker/main.py: set_qos(prefetch_count=prefetch), каждая доставка — задача, asyncio.Semaphore(concurrency) вокруг service.handle: сообщение сверх конкуренции ждёт без взятия и без аренды. CapacityLimiter не нужен. prefetch < concurrency допустим и наблюдаем: это рабочая конкуренция.

Цепочка сдерживания: места загрузки API (есть) → БД как буфер намерений → max_published_backlog → предел памяти брокера (relay получает отказ по сроку) → prefetch → concurrency → лимит контейнера. Ничто в этой цепочке не отказывает клиенту: приём ограничен только местами загрузки и диском. Само ограничение принятой работы вводит track1-queue-overload. Дорогу не закрывает: одно место в _store до строки pending, счёт по индексам решения 10 — миллисекунды.

Что мерит трек 1 Откуда брать
настройки WORKER__CONCURRENCY, WORKER__PREFETCH, WORKER__RENDER_*, RELAY__MAX_PUBLISHED_BACKLOG, RELAY__BATCH_SIZE, DATABASE__POOL_SIZE у worker; лимиты контейнера BENCH_WORKER_*; всё — окружением без пересборки
throughput finished_at заданий по окну; записи «Attachment became ready»
queue lag возраст старейшего queued; driver.py pipeline-state; rabbitmqctl list_queues messages_ready messages_unacknowledged; queue_wait_ms в «Started job attempt»
p95 до ready finished_at - created_at строки задания
RSS cgroup контейнера worker (сэмплер bench/, режим scan), он считает родителя и дочерние; render_peak_kib на задание
backpressure «Relay pass»: published_backlog, смена состояния предела; messages_ready; число queued без отметки
разделение затрат duration_ms, render_ms, queue_wait_ms

driver.py pipeline-state — только чтение: JSON с числом заданий по состояниям, due, ждущих срока, опубликованных и не взятых, истёкших аренд, возрастом старейшего, состоянием очереди.

9. Очистка staging, сверка и права

Кто удаляет. Уборщик: право s3:DeleteObject у него есть, а у worker нет и не появляется: worker читает и пишет весь bucket, и случайное удаление у него было бы опаснее пропущенной очистки (решение 12 архива). Цена — объект staging живёт до следующего прохода (interval_seconds, 60 с).

AttachmentCleanupService.clean_staging(*, retention_before, batch_size, stop_requested) — в том же цикле после clean_stale_pending, и в --once. Кандидаты keyset по индексу (status, updated_at, id) WHERE staging_key IS NOT NULL: сначала ready, затем failed с updated_at < :retention_before. Каждая строка — транзакция: FOR NO KEY UPDATE SKIP LOCKED с теми же условиями → DELETE в S3 → staging_key = NULL → COMMIT. Вызов S3 внутри транзакции, как шаг 2 уборки: не дольше срока шага (6 с). Именно NO KEY (with_for_update(key_share=True, skip_locked=True)): отправка сообщения со ссылкой на вложение берёт FOR KEY SHARE проверкой внешнего ключа, и обычный FOR UPDATE заставил бы её ждать DELETE в S3, а при зависшем S3 — получить 503, хотя сообщение от S3 не зависит. У строк pending этой проблемы не было: на них сообщения не ссылаются. Та же блокировка — у replay.

  • failed: сначала объекты вариантов всех имён (variant_key) и object_key, затем staging. Отсутствие объекта — не ошибка. Все DELETE укладываются в срок шага; не уложились — откат, ключ на месте, следующий проход повторит.
  • ключ вне <база>/staging/ (is_own_staging_key): warning, строка не меняется;
  • сбой S3 или PostgreSQL прерывает проход, итог — Finished staging cleanup pass.

Сбой после DELETE до COMMIT: ключ в строке есть, объекта нет. Для ready это ничего не значит, для failed replay получит source_missing и снова failed — безопасно.

Срок: [cleaner] staging_retention_seconds, 86400 — значение из .env.example skeleton (STAGING_RETENTION_SECONDS=86400). Закрывает вопрос преподавателю №2.

Что видит сверка:

Объект S3 → БД БД → S3
<база>/attachments/<id>/original как раньше только ready, как раньше
<база>/attachments/<id>/v<N>-<имя> строки нет — orphan_object; есть — свой не проверяется
<база>/staging/<id>/original новый шаг: строка этого id с этим staging_key — пропуск; иначе orphan_staging старше срока хранения, моложе — свежий не проверяется: отсутствие у queued даст processing_failed
другой ключ под <база>/staging/ unknown_object —

orphan_staging — в LIMITED_KINDS и ACTION_ORDER после orphan_object, перепроверка в БД и HEAD перед действием. listed_objects остаётся про префикс вложений (её сверяет модель bench/reconcile.py), новое поле listed_staging. Список — обёрткой _list_staging: тот же сигнал и предел скорости. Закрывает объект, дописанный замороженным API: спек storage-consistency обещал это здесь. Порог — срок хранения, а не grace: база, восстановленная из копии, иначе превратила бы staging живых строк в «объекты без метаданных» быстрее, чем оператор заметит.

Варианты БД → S3 сверка не проверяет. Рассмотрено: variant_missing только в отчёте. Отвергнуто на этом уровне: действия нет (байты можно получить только replay ready, а он запрещён), рубрика этого не требует, API и так пишет error при скачивании; лишний запрос на страницу и класс ради отчёта. Ограничение остаётся в REPORT.md.

Права. infra/s3/bootstrap.sh: список уборщика с условием s3:prefix на два значения, <база>/attachments/* и <база>/staging/* (проба: работает). S3_CLEANER_LIST_PREFIX прежний, staging выводится из проверенного имени базы. apply и check — новые строки. У worker и API прав не прибавилось.

Альтернатива: удалять staging в worker после фиксации. Отвергнута: право удаления шире, чем задача. Альтернатива: очистка отдельным сервисом. Отвергнута: у уборщика уже есть ключ, цикл и остановка. Альтернатива: lifecycle-правило bucket. Отвергнута: не знает состояния вложения и удалит текущую работу.

10. Схема

Две ревизии поверх a1d4c7e90b23, только расширение (migrations.md):

  1. added_job_replays_and_attempt_base, первой строкой SET LOCAL lock_timeout = '2s':
    • attachment_jobs.attempt_base integer NOT NULL DEFAULT 0, CHECK attempt_base BETWEEN 0 AND attempt NOT VALID;
    • attachment_job_replays: id uuid PK, job_id FK → attachment_jobs без каскада, operator text (CHECK длины 1–64), error_code text, reason text, attempt integer CHECK ≥ 0, created_at timestamptz, индекс по job_id.
  2. added_job_outbox_indexes, autocommit_block, SET lock_timeout, CONCURRENTLY, if_not_exists:
    • ix_attachment_jobs_outbox — (COALESCE(next_attempt_at, created_at), id) WHERE state = 'queued' AND published_at IS NULL;
    • ix_attachment_jobs_published — (published_at) WHERE state = 'queued' AND published_at IS NOT NULL;
    • ix_attachment_jobs_lease — (lease_expires_at) WHERE state = 'processing';
    • ix_attachments_staging_cleanup — (status, updated_at, id) WHERE staging_key IS NOT NULL.

Индексы — отдельной ревизией: CONCURRENTLY не живёт в транзакции, а ревизия с колонкой и таблицей обязана быть атомарной. Модели — Index(..., postgresql_where=text(...)), индекс по выражению autogenerate не сравнивает; alembic check проверяет колонки и таблицы. Индекс по реестру failed не нужен: выбор оператора редок, а строк failed мало.

Смесь версий (make rolling_update с уровня 3): новых статусов и error_code нет, поэтому 500 на чтении, как при переходе 201 → 202, здесь нет.

Кто На новой схеме
прежняя реплика API загружает и публикует сама; отмена при отказе брокера — прежняя; relay может опубликовать ту же строку: дубль, no-op
прежний worker берёт сообщения, делает только thumbnail (ready без crop и optimized, скачивание — 404): поэтому worker обновляется раньше relay
новая реплика и прежний relay relay ещё нет: задания ждут, загрузка отвечает 202
новый worker и старые строки ready не трогает, ready с одним thumbnail остаются как есть
прежний уборщик staging не чистит, ничего не ломает
новый уборщик на прежней политике AccessDenied на списке staging: сверка прервана, уборка работает; поэтому s3-bootstrap первым

11. Цепочка LB

После тела: проверка ~4 + tx1 6 + PUT 5 + tx2 6 ≈ 21 с, а ветка компенсации … + DELETE 5 ≈ 26 с, и это теперь наибольшее молчание. Длительность загрузки 17 + 30 + 26 ≈ 73 с < дренаж 90 с. Значения timeout server 30 с и ROLLOUT_DRAIN_TIMEOUT 90 с не меняются: запас вырос. Правятся комментарии infra/haproxy/haproxy.cfg, scripts/rolling-update.sh, balancer.md, settings.md и REPORT.md. driver.py lb-upload-timeouts не меняется: заглушка отвечает 202.

12. Настройки

Секция Поля (по умолчанию)
[worker] concurrency (2), prefetch (2), max_attempts (5), job_timeout_seconds (60), lease_margin_seconds (10), retry_base_delay_seconds (5), retry_max_delay_seconds (300), render_timeout_seconds (40, меньше job_timeout_seconds), render_cpu_limit_seconds (15), render_memory_limit_mib (450), graceful_shutdown_seconds (8, ≤ 8), reconnect_seconds (2)
[relay] poll_interval_seconds (0,25), batch_size (100), max_published_backlog (1000, 0 — без предела), republish_after_seconds (300), failure_pause_seconds (2)
[cleaner] ещё staging_retention_seconds (86400)
[broker] поля прежние; читают relay и worker

Все новые float — allow_inf_nan=False. Проверка соотношений — на полях через info.data, как idle_longer_than_request, чтобы в ошибке не было значений секции. Прежний ключ retry_delay_seconds в существующем config.toml молча игнорируется: extra секции — по умолчанию; шага оператора нет. STAGING_RETENTION_SECONDS → [cleaner] staging_retention_seconds в шапке .env.example и REPORT.md. Новых секретов нет.

13. Стенд

  • docker-compose.yml: сервис relay: образ API, pull_policy: never, entrypoint: ["python", "-m", "src.relay"], restart: unless-stopped, <<: [*db-env, *broker-env], DATABASE__POOL_SIZE: "1", depends_on PostgreSQL и брокер healthy, migrate completed, healthcheck: disable: true, stop_grace_period: 10s, лимиты 0,25 CPU / 256 МБ. У api убираются *broker-env и rabbitmq. Комментарии об окружении и соединениях.
  • Суммы: постоянные 9,0 CPU, 4992 МБ; с разовыми 10,0 CPU, 5376 МБ. Соединения PostgreSQL: API_REPLICAS × 10 + migrate 1 + cleaner 1 + worker 2 + relay 1 = 25, при замене 35.
  • scripts/restart.sh: relay не трогает, как worker и уборщика; строка в шапке. rolling-update.sh: только комментарий; порядок обновления — Migration Plan.
  • CI: .github/ci/compose.yml — relay с образом прогона и configs; шаги workflow те же.
  • Makefile: run_relay (консоль, те же мосты .env), replay. run_dev по-прежнему поднимает брокер: он нужен run_worker и run_relay.
  • make test_isolated: <проект>-test-relay рядом с -test-worker, журналы и уборка. Уборщика там нет: очистка staging проверяется на стенде отказов.

14. Внедрение сбоев без кода приложения

Точек сбоя в коде нет: всё снаружи, через fault_hook.py и команду драйвера. Таблица окон:

Окно Как держим Как рвём
после COMMIT queued до publish relay убит до загрузки kill relay, start relay
после confirm до отметки fail-attachments relay-stall <filename>: BEFORE UPDATE OF published_at на attachment_jobs, pg_sleep(3) по filename вложения; ждём queue-state: сообщение есть, published_at пуст kill relay, транзакция откатывается
после записи S3 до COMMIT ready-stall: оператор ждёт pg_sleep(4), объекты уже записаны (object-sha256) kill worker
после COMMIT до ack ready-commit-stall: отложенный триггер ограничения, pg_sleep(3) в COMMIT; wait-commit-stall ждёт PgSleep/COMMIT в pg_stat_activity; freeze worker — docker kill -s STOP; ждём succeeded kill worker: контейнер не paused, сигнал проходит (проба)
зависший worker pause s3, попытка в вызове S3; pause worker; срок аренды; unpause s3; run-worker — второй процесс unpause worker
дорогое изображение images.jpeg_scan_bomb() — настоящий файл лимит CPU
предел памяти, короткий срок, prefetch run-worker WORKER__…=…: второй worker с окружением, основной остановлен лимиты
убитый процесс обработки kill-render: docker exec в контейнере worker, SIGKILL процессу src.worker.render —
предел памяти брокера broker-memory-limit <значение>: rabbitmqctl set_vm_memory_high_watermark снятие

Новые действия hook: stop|start|kill|pause|unpause relay, freeze worker, run-worker K=V…, run-relay K=V…, stop-extra, kill-render, render-env, wait-commit-stall, object-sha256 <ключ>, broker-memory-limit, режимы ready-commit-stall, relay-stall, set-sha256, set-staging-key, set-next-attempt, delete-variant, cancel-to-pending (как отмена прежней версии), replay <аргументы> (записи и exit_code=), reconcile … --staging-retention S, replays <id>. peek-job и publish-job переходят из контейнера API в одноразовый контейнер relay: у API больше нет настроек брокера. delete-row удаляет и записи аудита.

Альтернатива: переменная FAULT_POINT в коде, выключенная по умолчанию. Отвергнута: проба показала, что самое узкое окно снимается снаружи, а точка сбоя в коде — это код продакшн-пути, который рабочий стенд мог бы включить одной строкой окружения.

15. Тесты

Клиент и генераторы: api_client.wait_job-хелперы не меняются; assert_one_thumbnail → assert_variants (три варианта, по объекту на каждый, variant-object-count 3, байты и поля); contract.py — содержимое WebP; images.py — jpeg_scan_bomb, полосы, jpeg_with_metadata. Сценарии уровня 3 меняют только ожидания, описанные дельтами. test_missing_variant переходит на стенд отказов с delete-variant: иначе варианта без метаданных не получить.

Стенд отказов: failures.compose.yml — relay (restart: "no", RELAY__POLL_INTERVAL_SECONDS: "0.2", RELAY__REPUBLISH_AFTER_SECONDS: "5"); worker: WORKER__MAX_ATTEMPTS: "4", WORKER__RETRY_BASE_DELAY_SECONDS: "4", WORKER__RETRY_MAX_DELAY_SECONDS: "16", WORKER__JOB_TIMEOUT_SECONDS: "10", WORKER__LEASE_MARGIN_SECONDS: "2", WORKER__RENDER_TIMEOUT_SECONDS: "8", WORKER__RENDER_CPU_LIMIT_SECONDS: "3", WORKER__GRACEFUL_SHUTDOWN_SECONDS: "2"; уборщик: CLEANER__STAGING_RETENTION_SECONDS: "60". Сумма пауз 14–28 с больше возврата S3 (~8 с): «Временная ошибка» успевает. run_failures.py — relay в запуске, FAULT_RELAY_*, FAULT_WORKER_* по новым именам, журнал relay при падении, уборка <проект>-worker-extra, <проект>-relay-extra. Ожидаемое время: плюс ~35 проверок, ~12 мин; итог — «Уточнения apply».

Ожидаемая смена старых тестов (разрешённая дельтами): test_durable_state_at_202, test_upload_with_broker_stopped и _paused, test_queue_deleted, test_duplicate_during_processing (busy теперь ACK), test_worker_killed_during_processing (ждёт аренду), test_ready_failure_retried, test_attempts_exhausted, test_transient_error_retried, test_original_published_unchanged, test_defense_scenario, тесты peek-job.

Сверка покрытия: job-outbox в CAPABILITIES; таблица — ниже. Исключения прежние, у data-storage «Ограничения обработки в схеме» проба расширяется.

16. bench/

  • Паспорт (.Image): app_containers и image() пишут метку com.docker.compose.image, а при её отсутствии — .Image; поле id остаётся именем. Сравнение образов профиля замены — по ней (docker.md).
  • bench.compose.yml, bench.env: relay описан, как worker, не запускается, лимиты BENCH_RELAY_*; Profile.relay_cpus, relay_memory. Реплики стенда больше не получают окружения брокера.
  • Профиль загрузок: брокер не запускается, start_broker и новый volume брокера из прогона, пометка broker_down и образ брокера в паспорте убираются, сводка без брокера. Смена методики названа в спеке; метка baseline снята на ff1a83b и не сравнивается, а регресс показывает make bench_uploads_quick. Метод start_broker и поля Profile остаются: их возьмёт трек 1.
  • Профиль замены: Profile.rollout_from → 7f38948, метка для отчёта pipeline-reliability.
  • Профиль сверки: reconcile_before прежний; модель: listed_objects не меняется, одна страница списка staging — в счёте LIST обоих источников.
  • Спек: «на образе до change» → «на образе commit из методики».

17. Драйвер и защита

  • defense-faults (шаг 4, рабочий стенд через LB, ~4 мин: аренда 70 с): (а) ready-stall, объекты записаны, SHA-256 до сбоя, kill worker, запуск, ожидание аренды, те же SHA-256, attempt 2; (б) ready-commit-stall, заморозка, succeeded, kill worker, запуск, redelivered, тот же updated_at, attempt 1, очередь пуста; (в) kill relay, загрузка 202, сообщения нет, запуск, ready; relay-stall, сообщение есть, отметки нет, kill relay, запуск, два сообщения при остановленном worker, запуск, ready, attempt 1; (г) замена staging → failed processing_failed → реестр → возврат объекта → replay → ready; replay готового — отказ, код 3. Триггеры — только на уникальный filename прогона, снимаются в finally, worker и relay запускаются при любом исходе, по сигналу тоже (WorkerGuard → общий сторож). → evidence/attachments/defense-faults.md. Тем же порядком на стенде отказов — test_defense_faults.
  • relay-process — как worker-process: PID 1, нет healthcheck, лимиты, запись о старте, неверные RELAY__*, остановка простаивающего и на старте, рестарт хранилищ. → evidence/relay/process.md.
  • pipeline-state — решение 8.
  • defense-scenario: relay не трогает, ждёт сообщение в очереди с опросом, проверяет три варианта. worker-process: _imaging нет и в процессе 1 worker, новые поля. attachment-storage: staging_key может быть уже пуст; data-storage — проба аудита. broker-check, s3-check, upload-consistency, reconcile-* — по изменениям. start — ещё make run_relay.

18. Журнал

  • Модуль relay (src/relay/main.py): «Started relay» со всеми значениями, «Stopped relay», «Invalid relay settings», «Stopped relay before startup».
  • Модуль attachment_relay_service: «Relay pass» (published, unconfirmed, recovered, republished, published_backlog, duration_ms; info, пустой — debug), warning «Recovered expired lease», info «Relay backlog is full» / «Relay backlog has room» на смену состояния.
  • Модуль attachment_replay_service: «Found failed job», «Replayed job» (operator, прежние error_code, reason), warning «Refused job replay» (refusal), «Finished replay pass».
  • Модуль attachment_processing_service: «Started job attempt» — ещё queue_wait_ms, message_attempt, redelivered; «Attachment became ready» — variants (имя, ширина, высота, размер), render_ms, render_peak_kib, render_memory_limit_applied, duration_ms; «Retrying job» — delay_seconds, next_attempt_at; «Skipped job message» — ещё not_due, superseded. «Started worker» — все значения.
  • Модуль attachment_service: «Uploaded attachment» — content_type значением, а не enum (запись KNOWN_ISSUES.md); записей о публикации нет. «Started API» — без брокера.
  • Модуль attachment_cleanup_service: «Finished staging cleanup pass» (removed_ready, removed_failed, skipped, interrupted_by, duration_ms), warning «Staging key is not own».
  • Итог сверки — ещё listed_staging.

19. Остановка worker (S5)

Закрытие клиентов — не по очереди, а asyncio.gather под одним _CLOSE_TIMEOUT_SECONDS (0,5 с): издателя у worker больше нет, остаются engine и S3, и сумма не растёт с их числом. Худший случай: graceful_shutdown_seconds 8 + отмена задач 0,5 + закрытие потребителя 0,5 + engine и S3 0,5 = 9,5 с < 10 с; верхняя граница настройки — 8. Комментарий и worker.md называют эту сумму. Отмена задачи убивает процесс обработки в finally клиента; os._exit прежний: поток декодирования отпал, но быстрый выход и незавершённые клиенты остаются. Задание, прерванное остановкой, получает следующую попытку по аренде: release при остановке не делается: окно редкое, а код на пути отмены await ненадёжен.

20. Evidence, отчёт и записи

Как на уровне 3: группы кода проверяются на рабочем дереве, завершающая группа — на закоммиченном коде отдельным запуском. REPORT.md: разделы уровня 4 (таблица критериев, эксперименты и отказы, параметры вариантов, лимиты и бюджет памяти, retention, ответы на вопросы защиты по новому поведению); то, что на уровне 3 было ограничением и закрыто, обновляется. Вопросы преподавателю №4 и №5 раздела отчёта помечаются закрытыми с ответом кода. KNOWN_ISSUES.md: записи «Разрыв COMMIT и publish» и «content_type» удаляются. QUESTIONS.md: раздел ## pipeline-reliability.

Покрытие сценариев

Новые и изменённые по сути сценарии спеков из CAPABILITIES. fault — make failure_checks; без пометки — make student_test.

Capability, сценарий Проверка
job-outbox «Загрузка при остановленном брокере» test_upload_with_broker_stopped, fault
«Загрузка при замороженном брокере» test_upload_with_broker_paused, fault
«Ответ не ждёт публикации», «Crash между фиксацией и публикацией», «Задание без отметки от прежней версии» test_relay_killed_before_publish, fault
«Crash после подтверждения до отметки» test_relay_killed_after_confirm, fault
«Отказ брокера во время работы relay» test_relay_survives_broker_outage, fault
«Отказ PostgreSQL во время работы relay» test_relay_survives_database_outage, fault
«Два relay» test_two_relays, fault
«Следующая попытка не раньше срока» test_relay_respects_next_attempt, fault
«Очередь удалена вместе с сообщением» test_lost_message_republished, fault
«Очередь с сообщениями не обрастает копиями» test_no_copies_while_queue_has_messages, fault
«Очередь ограничена пределом» test_published_backlog_limit, fault
«Брокер сдерживает публикацию» test_broker_memory_alarm, fault
attachment-processing «Вложение становится готовым» test_attachment_becomes_ready
«Что сохранено к ответу 202» test_durable_state_at_202, fault
«Worker убит посреди обработки» test_worker_killed_during_processing, fault
«Дубль во время обработки» test_duplicate_during_processing, fault
«Crash после записи объектов до фиксации» test_crash_after_objects_before_commit, fault
«Crash после фиксации до подтверждения» test_crash_after_commit_before_ack, fault
«Оригинал неизменен» test_original_published_unchanged, fault
«Разновидности форматов» test_thumbnail_format_variants
«Изображение в лимите пикселей» test_max_pixels_fit_worker_memory, fault; test_pixel_limit_png_modes
«Повтор после записи объектов» test_ready_failure_retried, fault
«Пауза растёт со случайной добавкой» test_retry_backoff_with_jitter, fault
«Попытка не раньше срока», «Пауза не занимает место конкуренции» test_retry_waits_outside_worker, fault
«Crop большого изображения», «Crop маленького изображения», «Crop с ориентацией и прозрачностью» test_crop_center, test_crop_small, test_crop_orientation_alpha
«Optimized большого изображения», «Optimized маленького изображения», «Optimized без метаданных», «Optimized сохраняет прозрачность» test_optimized_fit, test_optimized_small, test_optimized_no_metadata, test_optimized_alpha
«Пикселей больше лимита», «Объект больше лимита не читается» test_limit_pixels, test_limit_oversized_staging, fault
«Дорогое изображение» test_limit_cpu_scan_bomb, fault
«Предел памяти процесса обработки», «Срок процесса обработки» test_limit_memory, test_limit_render_timeout, fault
«Процесс обработки убит», «Секретов нет у процесса обработки» test_render_killed, fault
«Зависший worker» test_hung_worker_thawed_after_ready, fault
«Прежняя попытка при живой новой» test_hung_worker_lease_fencing, fault
«Долгая живая попытка» test_long_attempt_keeps_lease, fault
«Последняя попытка потеряна» test_last_attempt_lost, fault
«Реестр показан без изменений» test_replay_registry_dry_run, fault
«Replay возвращает работу» test_replay_returns_work, fault
«Replay готового не создаёт дубль» test_replay_ready_refused, fault
«Replay идущей работы» test_replay_in_progress_refused, fault
«Replay без исходника» test_replay_without_source_refused, fault
«Новый бюджет попыток» test_replay_new_budget, fault
«Replay по причине» test_replay_by_code, fault
«Prefetch больше конкуренции» test_prefetch_bounded, fault
message-broker «Брокер остановлен при загрузке», «Брокер вернулся» test_upload_with_broker_stopped, fault
«Брокер завис» test_upload_with_broker_paused, fault
«Очередь удалена» test_queue_deleted, fault
«Старт без брокера», «Рестарт брокера при работающем worker» test_start_without_broker, test_worker_survives_broker_restart, fault
attachments «Брокер не подтвердил задание» test_upload_with_broker_stopped, fault
«Скачивание crop и optimized» test_download_crop_optimized
«Отсутствующий вариант» test_missing_variant, fault
health «Брокер и worker недоступны» test_readiness_without_broker_and_worker, fault
data-storage «Ограничения обработки в схеме» исключение: driver.py --port <LB> attachment-storage → evidence/attachments/storage.md
storage-consistency «Загрузка без подтверждения брокера убрана» test_cancelled_upload_of_previous_version, fault
«Готовые вложения не тронуты», «Текущая работа не тронута» прежние тесты, fault
«Объекты вариантов своих вложений», «Текущая работа не считается расхождением» test_reconcile_variant_objects, test_reconcile_keeps_current_work, fault
«Объект staging без метаданных» test_reconcile_orphan_staging, fault
«Staging готового вложения убран» test_staging_removed_after_ready, fault
«Staging неудачного вложения хранится до срока», «Срок хранения прошёл» test_staging_retention, fault
«Текущая работа не убирается» test_staging_keeps_current_work, fault
«Очистка при отказе S3» test_staging_cleanup_survives_outage, fault
«Ключ staging другого вида не удаляется» test_staging_foreign_key_kept, fault

Спеки вне сверки — evidence с закоммиченного кода: container-run, container-image, graceful-shutdown, service-configuration → driver.py relay-process, worker-process, broker-check; «docker stop во время обработки» и «во время декодирования» — ещё test_worker_stop_during_processing, test_worker_stop_during_render, fault (сценарий в докстринге); object-storage → make s3_check, evidence/s3/cleaner-staging.md; service-logging → evidence/worker/logs.md, evidence/relay/logs.md; db-migrations → evidence/migrations/pipeline-reliability.md; load-balancing → driver.py lb-upload-timeouts; load-benchmark → make bench_uploads_quick, make bench_rollout, регресс быстрых профилей; student-tests → evidence/tests/, evidence/attachments/defense-faults.md, шаг 4 защиты на стенде отказов — test_defense_faults, fault (сценарий в докстринге).

Risks / Trade-offs

  • [Relay — ещё один процесс, без него задания ждут] → restart: unless-stopped, журнал, очередь намерений видна; принятая работа цела; приём не страдает.
  • [Публикация внутри транзакции] → срок 2 с < срока шага 6 с < простоя транзакции 10 с; блокируются только строки пакета; worker ждёт COMMIT.
  • [Дубли сообщений: неизвестный исход публикации, crash до отметки, потерянные] → каждый дубль — один SELECT … FOR UPDATE и ACK; эффект защищён ключом и fencing; это и есть at least once, названо в ответе на вопрос защиты.
  • [После KILL worker следующая попытка ждёт аренду, до 70 с] → настройка; пульс отвергнут (решение 3); повторная доставка готового — мгновенно.
  • [Процесс на задание — ~100 мс CPU на маленьком файле] → честная цена изоляции; мерит трек 1; замена — один модуль (решение 7).
  • [Дорогие файлы тратят CPU до лимита] → 15 с CPU на файл, одна попытка; при конкуренции 2 атакующий займёт worker на время лимита на каждый файл: места загрузки ограничивают скорость такой подачи, ограничение принятой работы — трек 1.
  • [Отказ S3 дольше ~минуты переводит взятые задания в failed] → replay по коду; пауза растёт только в пределах бюджета.
  • [Лимит памяти процесса обработки не действует на macOS] → только консольный запуск; стенд — Linux; названо в отчёте.
  • [Старые ready без crop и optimized] → скачивание 404, контракт это допускает; replay ready запрещён намеренно; рабочие данные лабы тестовые.
  • [Смесь версий: прежний worker делает ready только с thumbnail] → порядок обновления: worker раньше relay; окно ограничено сообщениями, уже лежавшими в очереди.
  • [Объект staging живёт до прохода уборщика, 60 с] → на диске меньше минуты лишнего; под нагрузкой уборщик 0,25 CPU может отставать, отставание видно по числу строк с staging_key у ready, его мерит трек 1.
  • [Копии при потере части сообщений] → republish только при нуле готовых: частичная потеря лечится, когда очередь опустеет. Сообщения, которые держит большой prefetch дольше порога, брокер готовыми не считает: они получат копию, а копия — лишний ACK; это видно трек 1 и не меняет эффекта.
  • [Удаление очереди при работающем worker: потребитель не узнаёт] → прежнее ограничение; relay создаст очередь заново, а worker нужно перезапустить; названо в REPORT.md.

Migration Plan

  1. Шага оператора нет: секретов не прибавилось, config.toml читается как есть.
  2. Без простоя: docker compose up -d s3-bootstrap, make rolling_update (две ревизии, затем реплики), docker compose up -d --no-deps worker cleaner, затем docker compose up -d --no-deps relay. До запуска relay новые загрузки отвечают 202 и ждут. С простоем — make run_docker.
  3. Откат: make rolling_update COMMIT=<прежний> MIGRATE=0 COMPOSE_FILE=docker-compose.yml:infra/rollback/broker.compose.yml (прежние реплики публикуют сами, им нужен адрес и пароль брокера: без override загрузка — 503; проверено задачей 14.1), docker compose up -d --no-deps прежних worker и уборщика, relay останавливается, когда нет заданий queued без отметки. Схема остаётся.
  4. Прежние строки ready не трогаются, кроме объекта staging: его уберёт первый проход уборщика.

Open Questions

Вопросы преподавателю в QUESTIONS.md (раздел pipeline-reliability): ни один не меняет подход и задачи; другой ответ правит одну функцию и её сценарий.

Уточнения apply

  1. Выбор replay: --attachment-id и фильтр по коду или причине вместе — код 2, а не пересечение: оператор, задавший и то и другое, почти наверняка ошибся.
  2. Условие published_at IS NOT NULL в has_published_before явное: без него общий план подготовленного выражения — Seq Scan (частичный индекс планировщик не доказывает по параметру), с ним — Index Only Scan.
  3. DTO варианта (RenderedVariantDTO, RenderedVariantsDTO) — в src/schemas/dataclasses/, их импортирует и image_variants.py, и клиент: тогда клиент не тянет Pillow.
  4. Коды процесса обработки: MemoryError проходит render_variants насквозь и даёт код 4 (limit_memory); OSError, ValueError, SyntaxError и UnidentifiedImageError — код 3 (undecodable).
  5. Новые действия hook сверх решения 14: expire-lease, kill-extra, pause-extra, unpause-extra, extra-log, attachment-row, attachment-free, cleaner-log, relay-log, relay-state, render-count; у run-worker ещё S3__TIMEOUT_SECONDS.
  6. Зависший worker в тесте: строка решения 14 («pause s3, pause worker, unpause worker») не доходит до fencing: при разморозке попытку сразу прерывает её срок, и путь фиксации не выполняется. Поэтому test_hung_worker_lease_fencing запускает отдельный worker со сроками больше времени теста (WORKER__JOB_TIMEOUT_SECONDS=120, RENDER=60, S3__TIMEOUT_SECONDS=60), аренду делает истекшей expire-lease, ждёт записи Skipped job message, superseded.
  7. Два теста усилены по итогам регрессий 4 и 8 (ниже):
    • crash_after_objects: ранний ack задание не теряет, аренда его возвращает, и прежний тест зелёный. Отличие видно только у брокера: до KILL messages_unacknowledged = 1;
    • test_staging_cleanup_survives_outage: старт уборщика при 0,25 CPU дольше времени теста, сообщения проходили раньше блокировки. Теперь перед каждым сообщением тест ждёт, что строку держит чужая транзакция (attachment-free: FOR SHARE SKIP LOCKED).
  8. test_no_storage_traces исправлен: брал variants[0] как thumbnail, а порядок вариантов контракт не задаёт и у нас он по имени (crop первый). Тест ошибочен сам; теперь вариант выбирается по имени.
  9. make test сразу после make run_docker со стоящим стендом падает: GET /health/live, 503. Причина — стенд: up -d реплик возвращается раньше, чем LB их проверит (api-1 DOWN 1/2, INI); через секунды проход зелёный, дефекта нет. Порядок прежний: README.md велит ждать /health/ready.
  10. Окно старта интерпретатора при 0,25 CPU длиннее: docker compose start relay, сразу stop — SIGTERM приходит до первых строк __main__, PID 1 без обработчика его отбрасывает, SIGKILL через 10 с, код 137. Через 0,6 с после старта — «Stopped relay before startup», код 0. Работы в этот момент у процесса нет, поэтому не правится; то же окно названо в docker.md («десятки миллисекунд» — при 1 CPU).
  11. Откат реплик требует override (отклонение от Migration Plan в propose): make rolling_update COMMIT=7f38948 MIGRATE=0 на новом compose давал загрузку 503: у api больше нет адреса и пароля брокера, а прежний код публикует сам. Добавлен infra/rollback/broker.compose.yml, команда отката в плане и balancer.md обновлена. Постоянно давать репликам пароль нельзя (решение 1).
  12. Задача 14.1: откат с override, прежние worker и уборщик, relay остановлен: make test — PASS; строка нового кода на прежней реплике — 200, 3 варианта, байты всех вариантов — 200, сообщение со ссылкой — 201, история — 200; загрузка на прежнем образе — ready, один thumbnail. Вперёд по плану: lb_stats без ручных состояний, новая загрузка — 3 варианта, вложение прежнего образа — ready, один thumbnail, original и thumbnail — 200, crop и optimized — 404; make reconcile — код 0, found пусто.
  13. Память worker (задача 9.6, расчёт решения 7): два PNG 10 MiB одновременно: VmHWM процесса 1 — 158 МиБ (VmRSS до 109, после 111), render_peak_kib ~84 МиБ на файл, render_ms 928, контейнер memory.peak 261 МиБ; снято на рабочем дереве. На 399da05 (evidence/worker/memory.md, задача 16.8): те же файлы — VmHWM 159, memory.peak 261; самый дорогой — серый 16 бит на 40 Мпкс и ~10 MiB файла: пик процесса 414 МиБ, memory.peak 905 МиБ, OOM нет (у RGBA на обеих границах 366, без тела 357); оценка суммой 159 + 2 × 414 = 987 МиБ < 1 ГБ. Оценка решения 7 (130 МиБ) была занижена, бюджет сходится. Лимит не менялся.
  14. Регрессии задачи 10.9 (каждая применена в рабочем дереве, откачена, хэши src совпали со снимком до них; образ собирался из дерева):
    • отметка до подтверждения: test_relay_killed_after_confirm — красный, published_at есть после KILL до подтверждения; test_upload_with_broker_paused — зелёный;
    • claim при живой аренде: test_duplicate_during_processing — красный, нет записи busy;
    • фиксация без номера попытки: запись первого прогона не воспроизвелась: при удалении только locked.attempt == job.attempt прежний тест зелёный, вторая попытка завершалась до разморозки первой, и решал state (замечание W2 проверки; какой именно была регрессия того прогона, не записано). На усиленном тесте (первая размораживается при живой второй, п. 20) — красный, нет записи superseded с attempt 1 за 30 с; прежний поток, теперь test_hung_worker_thawed_after_ready, зелёный. Условие на месте — оба зелёные, хэши src совпали;
    • ack до фиксации: на прежнем тесте зелёный (п. 7), на усиленном красный, messages_unacknowledged 0;
    • claim без проверки завершённого: test_crash_after_commit_before_ack — красный, нет записи finished за 30 с;
    • replay без проверки состояния: test_replay_ready_refused — красный, код 0 вместо 3;
    • очистка без условия статуса: test_staging_keeps_current_work — красный, объект staging незавершённого вложения удалён;
    • FOR UPDATE в очистке: на прежнем тесте зелёный (п. 7), на усиленном красный, сообщение ждало 4,79 с при границе 1 с;
    • рендер в процессе worker: test_limit_cpu_scan_bomb — красный, retry_exhausted вместо invalid_image;
    • фиксированная пауза: test_retry_backoff_with_jitter — красный, две паузы равны 4,0.
  15. Два теста сверки зависели от объёма bucket: с тремя вариантами и staging объектов на вложение стало до 5, и к концу набора проход на 0,25 CPU длиннее сроков теста. Два красных в полном make failure_checks на незанятом хосте, поодиночке зелёные:
    • test_scheduled_reconcile — run-cleaner останавливал уборщик через 6 с, проход прерывался сигналом и пометки не делал, а условие теста считало прерванный проход успешным. Теперь hook ждёт конец прохода (до 60 с), тест требует interrupted_by null: условие строже;
    • test_reconcile_fresh_overwrite_untouched — глубокий проход 24 с при grace стенда 20 с. Теперь проход идёт с --grace 60, меньше возраста строк: свойство то же, «моложе grace разового прохода», этап «после G + 1» — с grace стенда;
    • test_staging_cleanup_survives_outage — усиленный по п. 7 тест красный один раз: строка прежнего теста стояла в очереди раньше, при замороженном S3 проход каждый раз прерывался на ней (журнал: ключ другого вложения, потом removed_ready 2). Теперь очередь сначала опустошается;
    • test_reconcile_keeps_current_work — красный один раз: за настройкой, ожиданием G + 1 и длинным проходом срок хранения failed на стенде (60 с) истёк, и уборщик штатно убрал staging. Тест зависел от времени; проверяет он сверку, поэтому уборщик на его время остановлен;
    • test_defense_faults (через crash_after_objects) — красный один раз: запрос messages_unacknowledged из п. 7 длиннее окна триггера 4 с, фиксация успела, attempt 1 вместо 2. Перед запросом worker теперь заморожен: COMMIT он не отправит. Регрессия ack до фиксации проверена заново — красный.
  16. Полный make failure_checks: 140 проверок, pytest 2313 с (38,5 мин), PostgreSQL без признаков аварии, стенд и volumes удалены, у рабочего стенда прежний StartedAt. Последний полный прогон: 139 зелёных, красный один (п. 15, первый подпункт); правка этого теста проверена выборкой, полный прогон на commit — задача 15.4. Запас времени к концу набора мал: bucket стенда растёт, и проход сверки при 0,25 CPU длится десятки секунд.
  17. Удалено при коммите: src/utils/thumbnail.py и src/infra/broker/instance.py без импортов удалила основная сессия, вошло в e2a6427.
  18. Группа 15 на e2a6427: полный make failure_checks при остановленном рабочем стенде — 140 из 140, pytest 2373 с, правок тестов нет, правка п. 15 прошла в полном наборе. Метка pipeline-reliability снята первой, на чистом дереве: git.dirty false, swapouts_delta 0, файлы evidence/ из дерева выносить не пришлось. Образ контейнера на стенде сравнивается по метке com.docker.compose.image: .Image у контейнеров с одной меткой может расходиться и не годится для сравнения (docker.md); у реплик, relay, worker и уборщика метка одна.
  19. Замечание W1 проверки: _prepared держал исходник на время перевода и масштаба. У серого с альфой и RGB с tRNS на 40 Мпкс и исходник, и RGBA, и промежуточный буфер resize — по 160 МиБ: сумма с базой больше 450 МиБ, MemoryError, код 4, failed invalid_image limit_memory: ошибка постоянная, replay не поможет, а контракт такие файлы разрешает. Проба задачи 4.2 этих типов не содержала. Теперь после convert("RGBA") исходник закрывается: контекст with Image.open это переносит (пробы: выход из него без ошибки во всех типах, код 0), дальше image не читается, а ветка RGBA без перевода исходник не закрывает. Остальные ветки не тронуты, они укладываются: палитра без tRNS 242 МиБ, 1 бит 113, серый 16 бит 404–405. Проверены и чересстрочные (RGBA, серый с альфой — 357, серый 16 бит — 404) и вытянутые (40000 × 1000, 1000 × 40000, 4000000 × 10 — 328–329, серый 16 бит 405). Красный до правки: test_pixel_limit_png_modes — 3 упали (gray-alpha-8, rgb-8-trns, rgb-16-trns: failed, invalid_image), 2 прошли.
  20. Замечание W2 проверки: fencing без живой второй попытки не проверялся. test_hung_worker_lease_fencing теперь размораживает первую попытку, пока вторая в processing: обе на worker со сроками больше времени теста (run-worker, новый run-worker-second), S3 заморожен, пока вторая не взята и сама не заморожена: она ждёт S3 и не успевает к фиксации, транзакции у неё нет (attachment-free). Первая завершается superseded, задание и вложение не меняются, после разморозки второй итог даёт только она. Прежний поток — сценарий «Зависший worker» — test_hung_worker_thawed_after_ready. Дефекта приложения тест не показал: условие в _own_attempt работает.
  21. Правки по проверке на рабочем дереве: полный make failure_checks при остановленном рабочем стенде — 141 из 141, pytest 2266 с, PostgreSQL без признаков аварии; на 399da05 — 141 из 141, pytest 2302 с (задача 16.10). driver.py worker-process на 399da05: docker stop на двух дорогих JPEG — 8,15 с, при замороженных PostgreSQL и брокере — 9,18 с, код 0, все четыре задания дошли до failed, limit_cpu. relay-process: при замороженном брокере — 1,81 с, код 0.