fix: address pipeline-reliability verify findings
Close the source image after converting to RGBA so PNGs at the pixel limit fit the render memory limit. Strengthen the fencing test so that it fails without the attempt check, and measure worker and relay stops under load. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -413,7 +413,9 @@ rolling_update COMMIT=<прежний> MIGRATE=0
|
||||
COMPOSE_FILE=docker-compose.yml:infra/rollback/broker.compose.yml` (прежние реплики
|
||||
публикуют сами, и без адреса и пароля брокера их загрузка — 503), прежние
|
||||
worker и уборщик, relay останавливается, когда нет заданий `queued` без отметки. Схема
|
||||
остаётся.
|
||||
остаётся. Новая реплика прежнего образа, созданная после отката без этого override
|
||||
(`make replicas`, `docker compose up`), тоже получит 503 на загрузке: `COMPOSE_FILE` с
|
||||
override нужен, пока стенд на прежнем образе.
|
||||
|
||||
**Bootstrap S3 скрипт не запускает** (design change `s3-storage`,
|
||||
решение 9): новая реплика поднимается с `--no-deps`. Bootstrap, как
|
||||
|
||||
@@ -387,12 +387,20 @@ paths:
|
||||
SKIP LOCKED`: держит ли строку чужая транзакция), `delete-variant`,
|
||||
`cancel-to-pending`, `replay`, `replays`, `reconcile … --staging-retention S --grace
|
||||
S`; `run-cleaner` ждёт конец первого прохода, а не весь срок; `peek-job`
|
||||
и `publish-job` — одноразовым контейнером relay;
|
||||
и `publish-job` — одноразовым контейнером relay; `run-worker-second` — третий
|
||||
worker рядом с замороженным первым (`test_hung_worker_lease_fencing`), `extra-log`,
|
||||
`pause-extra`, `unpause-extra` принимают `worker-second`;
|
||||
- окна сбоя — без точек в коде: после COMMIT до publish — relay убит; после confirm до
|
||||
отметки — `relay-stall`, `kill relay`; после записи S3 до COMMIT — `ready-stall`,
|
||||
`kill worker`; после COMMIT до ack — `ready-commit-stall`, `wait-commit-stall`, `freeze`,
|
||||
`kill`. Зависший worker: первый worker со сроками больше времени теста, иначе при
|
||||
разморозке его прервал бы таймер, а не fencing; аренду делает истекшей `expire-lease`;
|
||||
`kill`. Зависший worker: worker со сроками больше времени теста, иначе при
|
||||
разморозке его прервал бы таймер, а не fencing; аренду делает истекшей `expire-lease`.
|
||||
Номер попытки решает, только пока вторая жива: `test_hung_worker_lease_fencing`
|
||||
размораживает первую при замороженной второй (та взята и ждёт S3, блокировки строки
|
||||
нет); если вторая уже дала итог (`test_hung_worker_thawed_after_ready`), решает `state`;
|
||||
- `test_pixel_limit_png_modes` — обычный набор: `images.png_at_pixel_limit` даёт 8000 × 5000
|
||||
любого типа PNG; типы, которые переводятся в другой режим, не должны держать исходник на
|
||||
время масштаба;
|
||||
- стенд отказов: `relay` (`restart: "no"`, опрос 0,2 с, порог потерянного 5 с), worker —
|
||||
4 попытки, пауза 4–16 с, срок 10 с, запас аренды 2 с, процесс обработки 8 с / 3 с CPU,
|
||||
остановка 2 с; уборщик — срок хранения 60 с; `FAULT_RELAY_*`, новые `FAULT_WORKER_*`,
|
||||
|
||||
@@ -106,4 +106,7 @@ change `async-attachments` (2, 6–8) и `pipeline-reliability` (1–9, 19). З
|
||||
- **Ограничения** называются в `REPORT.md`: восстановление после KILL по аренде,
|
||||
дубли сообщений, объект, дописанный прежней попыткой теми же байтами, профиль ICC,
|
||||
лимит памяти на macOS, цена процесса на задание, удаление очереди при работающем
|
||||
worker.
|
||||
worker. Изоляция секретов неполная: в окружении процесса обработки их нет, но он
|
||||
идёт под тем же UID, что PID 1 worker, и после эксплойта декодера прочитает
|
||||
`/proc/1/environ` (ключи S3, пароли PostgreSQL и брокера); предложение
|
||||
`PR_SET_DUMPABLE=0` — `QUESTIONS.md`.
|
||||
|
||||
@@ -209,7 +209,7 @@ python3 $D lb-upload-timeouts # сроки LB пути загру
|
||||
python3 $D --port 8080 defense-scenario # защита лабы 5: worker стоит, 202, 201, 409, 201, сообщение в очереди, рестарт, worker, ready, оригинал и три варианта; ~1,5 мин
|
||||
python3 $D --port 8080 defense-faults # шаг 4 защиты: crash до фиксации и до ack, relay убит до публикации и до отметки, replay; ~4 мин
|
||||
python3 $D broker-check # брокер: образ, volume, порт, предел памяти, очередь, пароль только у rabbitmq, relay, worker, остановка с кодом 0; ~30 с
|
||||
python3 $D --port 8080 worker-process # процесс worker: PID 1, лимиты, Pillow, журнал, неверные настройки, остановка, рестарт хранилищ; ~2 мин
|
||||
python3 $D --port 8080 worker-process # процесс worker: PID 1, лимиты, Pillow, журнал, неверные настройки, остановка, рестарт хранилищ, остановка под нагрузкой; ~5 мин
|
||||
python3 $D --port 8080 relay-process # процесс relay: то же, окружение без S3 и Valkey; ~2 мин
|
||||
python3 $D pipeline-state # JSON: задания по состояниям, due, ждут срока, опубликованы и не взяты, истёкшие аренды, очередь
|
||||
make replay # реестр failed, только показ; APPLY=1 ATTACHMENT=<id> — вернуть в работу, код 3 — есть отказы
|
||||
@@ -348,8 +348,12 @@ run --rm --no-deps -e … worker`) — код 2, запись называет
|
||||
0, затем `start`; `docker stop` контейнера образа (без сети, лимиты сервиса) через 0,2–0,4 с
|
||||
после `docker run` — код 0, не дольше 1 с, «Stopped worker before startup» хотя бы в одной
|
||||
попытке; `scripts/restart.sh` — у worker прежний `StartedAt`, `RestartCount` 0, новая
|
||||
загрузка `ready`. Коды: 0, 1 — расхождение, 130 — сигнал, 2 — нет стенда. Вывод —
|
||||
`evidence/worker/process.md`.
|
||||
загрузка `ready`; остановка под нагрузкой: два дорогих JPEG в обработке (генератор
|
||||
`student-tests/images.py` в контейнере образа), `docker stop` быстрее 9,5 с, код 0, без OOM,
|
||||
«Stopped worker» последней записью — сначала при живых хранилищах, затем при замороженных
|
||||
PostgreSQL и брокере; все четыре задания после этого доходят по аренде до `failed`, `limit_cpu`
|
||||
(до 200 с, поэтому вся команда ~5 мин). Коды: 0, 1 — расхождение, 130 — сигнал, 2 — нет стенда.
|
||||
Вывод — `evidence/worker/process.md`.
|
||||
|
||||
**`relay-process`** (`--port <LB>`; те же спеки; ~2 мин). Те же шаги о сервисе `relay`: PID 1 —
|
||||
`python -m src.relay`, healthcheck `NONE`, лимиты 0,25 CPU и 256 МБ; в окружении нет `S3__`,
|
||||
@@ -360,7 +364,9 @@ run --rm --no-deps -e … worker`) — код 2, запись называет
|
||||
значения; подмена окружением (`RELAY__BATCH_SIZE=7`, `RELAY__POLL_INTERVAL_SECONDS=1`);
|
||||
`docker compose stop relay` — код контейнера 0, быстрее 10 с, «Stopped relay» с `exit_code` 0;
|
||||
`docker stop` на старте — «Stopped relay before startup»; `scripts/restart.sh` — прежний
|
||||
`StartedAt`, `RestartCount` 0, новая загрузка `ready`. Коды те же. Вывод — `evidence/relay/process.md`.
|
||||
`StartedAt`, `RestartCount` 0, новая загрузка `ready`; `docker stop relay` при замороженном брокере
|
||||
с намерением в работе — быстрее 10 с, код 0, «Stopped relay» последней записью, после запуска relay
|
||||
вложение `ready`. Коды те же. Вывод — `evidence/relay/process.md`.
|
||||
|
||||
**`pipeline-state`** (решение 8; порт не нужен, только чтение, идёт и под нагрузкой). JSON:
|
||||
`jobs_by_state` (`queued`, `processing`, `succeeded`, `failed`), `due` (`queued` без отметки, срок
|
||||
|
||||
@@ -5883,6 +5883,21 @@ PROCESS_LOG_WAIT_S = 30
|
||||
PROCESS_EARLY_DELAYS = (0.3, 0.2, 0.4)
|
||||
PROCESS_EARLY_STOP_LIMIT_S = 1.0
|
||||
PROCESS_EARLY_LABEL = "mtusi.process-check"
|
||||
# остановка под нагрузкой (design change pipeline-reliability, решение 19): 8 +
|
||||
# 0,5 × 3. Два файла — конкуренция worker
|
||||
PROCESS_STOP_BOUND_S = 9.5
|
||||
LOAD_FILES = 2
|
||||
LOAD_FROZEN = ("postgres", "rabbitmq")
|
||||
LOAD_TAKEN_WAIT_S = 30
|
||||
LOAD_RENDER_SETTLE_S = 1
|
||||
# аренда 70 с, затем по паре файлов: 15 с CPU на файл при конкуренции 2 — 30 с
|
||||
LOAD_FINISH_WAIT_S = 200
|
||||
EXPENSIVE_JPEG_PY = """\
|
||||
import sys
|
||||
sys.path.insert(0, "/tmp")
|
||||
import images
|
||||
sys.stdout.buffer.write(images.jpeg_scan_bomb())
|
||||
"""
|
||||
|
||||
|
||||
class ProcessSpec(NamedTuple):
|
||||
@@ -6973,12 +6988,285 @@ def service_process(port: int, guard: StandGuard, spec: ProcessSpec) -> int:
|
||||
yes(isinstance(attachment, dict)),
|
||||
),
|
||||
)
|
||||
if service == "worker":
|
||||
rows.extend(
|
||||
worker_stop_under_load(port, guard, image, tokens, chat_id),
|
||||
)
|
||||
else:
|
||||
rows.extend(relay_stop_broker_frozen(port, guard, tokens, chat_id))
|
||||
return report_reconcile(
|
||||
rows,
|
||||
passed=f"the {service} process matches the spec",
|
||||
)
|
||||
|
||||
|
||||
def expensive_jpeg(image: str) -> bytes | None:
|
||||
"""Дорогой JPEG тем же генератором, что у тестов: Pillow есть в образе, а
|
||||
драйвер — только stdlib."""
|
||||
source = ROOT / "student-tests" / "images.py"
|
||||
proc = subprocess.run(
|
||||
[
|
||||
"docker",
|
||||
"run",
|
||||
"--rm",
|
||||
"--network",
|
||||
"none",
|
||||
"-v",
|
||||
f"{source}:/tmp/images.py:ro",
|
||||
"--entrypoint",
|
||||
"python",
|
||||
image,
|
||||
"-I",
|
||||
"-c",
|
||||
EXPENSIVE_JPEG_PY,
|
||||
],
|
||||
capture_output=True,
|
||||
check=False,
|
||||
)
|
||||
return proc.stdout if proc.returncode == 0 and proc.stdout else None
|
||||
|
||||
|
||||
def stopped_record_rows(
|
||||
title: str,
|
||||
service: str,
|
||||
container: str,
|
||||
) -> list[tuple[str, str, str]]:
|
||||
"""Код контейнера и последняя запись журнала после `docker stop`."""
|
||||
state = subprocess.run(
|
||||
[
|
||||
"docker",
|
||||
"inspect",
|
||||
"-f",
|
||||
"{{.State.ExitCode}} {{.State.OOMKilled}}",
|
||||
container,
|
||||
],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
check=False,
|
||||
).stdout.split()
|
||||
_, out = detached("docker", "logs", container)
|
||||
last = [
|
||||
item
|
||||
for item in json_records(out)
|
||||
if item.get("event") in (f"Started {service}", f"Stopped {service}")
|
||||
]
|
||||
return [
|
||||
(f"{title}: container exit code", "0", state[0] if state else "-"),
|
||||
(f"{title}: OOM killed", "false", state[1] if state[1:] else "-"),
|
||||
(
|
||||
f"{title}: last record",
|
||||
f"Stopped {service}",
|
||||
str(last[-1].get("event")) if last else "-",
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
def worker_stop_during_render(
|
||||
port: int,
|
||||
guard: StandGuard,
|
||||
token: str,
|
||||
chat_id: str,
|
||||
data: bytes,
|
||||
*,
|
||||
frozen: bool,
|
||||
) -> tuple[list[tuple[str, str, str]], list[str]]:
|
||||
"""Два дорогих файла в обработке, `docker stop`: обработка не успевает за
|
||||
срок остановки, поэтому идёт весь путь решения 19. Замороженные PostgreSQL и
|
||||
брокер отвечать на закрытие клиентов не будут."""
|
||||
title = "stop frozen storage" if frozen else "stop under load"
|
||||
rows: list[tuple[str, str, str]] = []
|
||||
ids: list[str] = []
|
||||
stopped, _ = detached("docker", "compose", "stop", "worker")
|
||||
rows.append((f"{title}: worker stopped before uploads", "0", str(stopped)))
|
||||
for index in range(LOAD_FILES):
|
||||
status, _, payload = upload_bytes(
|
||||
port,
|
||||
token,
|
||||
chat_id,
|
||||
data,
|
||||
content_type="image/jpeg",
|
||||
filename=f"process-load-{index}.jpg",
|
||||
)
|
||||
rows.append((f"{title}: upload {index}", "202", str(status)))
|
||||
if isinstance(payload, dict) and "id" in payload:
|
||||
ids.append(str(payload["id"]))
|
||||
started_code = start_service("worker")
|
||||
rows.append((f"{title}: worker started", "0", str(started_code)))
|
||||
deadline = time.monotonic() + LOAD_TAKEN_WAIT_S
|
||||
states: list[object] = []
|
||||
while time.monotonic() < deadline:
|
||||
states = [df_job(item).get("state") for item in ids]
|
||||
if states and all(state == "processing" for state in states):
|
||||
break
|
||||
time.sleep(READY_POLL_S)
|
||||
rows.append(
|
||||
(
|
||||
f"{title}: both files in processing",
|
||||
"processing",
|
||||
",".join(sorted({str(state) for state in states})),
|
||||
),
|
||||
)
|
||||
# обработка идёт, а не только взята
|
||||
time.sleep(LOAD_RENDER_SETTLE_S)
|
||||
containers = service_ids("worker")
|
||||
if not containers:
|
||||
rows.append((f"{title}: worker running", "yes", "no"))
|
||||
return rows, ids
|
||||
if frozen:
|
||||
guard.cleanups.append(
|
||||
lambda: (
|
||||
detached("docker", "compose", "unpause", *LOAD_FROZEN) and None
|
||||
),
|
||||
)
|
||||
try:
|
||||
if frozen:
|
||||
code, _ = detached("docker", "compose", "pause", *LOAD_FROZEN)
|
||||
rows.append((f"{title}: storage paused", "0", str(code)))
|
||||
started = time.monotonic()
|
||||
code, _ = detached(
|
||||
"docker",
|
||||
"stop",
|
||||
"--timeout",
|
||||
str(PROCESS_STOP_LIMIT_S),
|
||||
containers[0],
|
||||
)
|
||||
took = time.monotonic() - started
|
||||
finally:
|
||||
if frozen:
|
||||
detached("docker", "compose", "unpause", *LOAD_FROZEN)
|
||||
print(f"{title}: docker stop worker took {took:.2f} s", flush=True)
|
||||
rows.append((f"{title}: command exit code", "0", str(code)))
|
||||
rows.append(
|
||||
(
|
||||
f"{title}: under {PROCESS_STOP_BOUND_S} s",
|
||||
"yes",
|
||||
yes(took < PROCESS_STOP_BOUND_S),
|
||||
),
|
||||
)
|
||||
rows.extend(stopped_record_rows(title, "worker", containers[0]))
|
||||
rows.append(
|
||||
(f"{title}: worker back", "0", str(start_service("worker"))),
|
||||
)
|
||||
if frozen:
|
||||
rows.append(
|
||||
("LB ready after unpause", "yes", yes(wait_lb_ready(port))),
|
||||
)
|
||||
return rows, ids
|
||||
|
||||
|
||||
def worker_stop_under_load(
|
||||
port: int,
|
||||
guard: StandGuard,
|
||||
image: str,
|
||||
tokens: dict[str, str],
|
||||
chat_id: str,
|
||||
) -> list[tuple[str, str, str]]:
|
||||
"""Остановка на двух дорогих JPEG, затем то же при замороженных хранилищах
|
||||
(спек `graceful-shutdown`, решение 19). Принятая работа не теряется: аренда
|
||||
вернёт задания, и они упрутся в лимит CPU."""
|
||||
data = expensive_jpeg(image)
|
||||
rows: list[tuple[str, str, str]] = [
|
||||
("expensive JPEG generated", "yes", yes(data is not None)),
|
||||
]
|
||||
if data is None:
|
||||
return rows
|
||||
token = tokens["alice"]
|
||||
attachments: list[str] = []
|
||||
for frozen in (False, True):
|
||||
part, ids = worker_stop_during_render(
|
||||
port,
|
||||
guard,
|
||||
token,
|
||||
chat_id,
|
||||
data,
|
||||
frozen=frozen,
|
||||
)
|
||||
rows.extend(part)
|
||||
attachments.extend(ids)
|
||||
deadline = time.monotonic() + LOAD_FINISH_WAIT_S
|
||||
for attachment_id in attachments:
|
||||
final = wait_attachment(
|
||||
port,
|
||||
token,
|
||||
attachment_id,
|
||||
timeout=max(0.0, deadline - time.monotonic()),
|
||||
)
|
||||
job = df_job(attachment_id)
|
||||
rows.append(
|
||||
(
|
||||
f"stopped work finished: {attachment_id}",
|
||||
"failed limit_cpu",
|
||||
f"{final.get('status')} {job.get('last_error_code')}",
|
||||
),
|
||||
)
|
||||
return rows
|
||||
|
||||
|
||||
def relay_stop_broker_frozen(
|
||||
port: int,
|
||||
guard: StandGuard,
|
||||
tokens: dict[str, str],
|
||||
chat_id: str,
|
||||
) -> list[tuple[str, str, str]]:
|
||||
"""`docker stop relay`, пока намерение есть, а брокер заморожен: публикация
|
||||
висит до своего срока, остановка дожидается только текущего шага."""
|
||||
title = "stop frozen broker"
|
||||
token = tokens["alice"]
|
||||
rows: list[tuple[str, str, str]] = []
|
||||
containers = service_ids("relay")
|
||||
if not containers:
|
||||
return [(f"{title}: relay running", "yes", "no")]
|
||||
guard.cleanups.append(
|
||||
lambda: detached("docker", "compose", "unpause", "rabbitmq") and None,
|
||||
)
|
||||
try:
|
||||
code, _ = detached("docker", "compose", "pause", "rabbitmq")
|
||||
rows.append((f"{title}: broker paused", "0", str(code)))
|
||||
status, _, payload = upload_bytes(
|
||||
port,
|
||||
token,
|
||||
chat_id,
|
||||
FIXTURE_PNG.read_bytes(),
|
||||
content_type="image/png",
|
||||
filename=FIXTURE_PNG.name,
|
||||
)
|
||||
rows.append((f"{title}: upload", "202", str(status)))
|
||||
# relay уже в публикации: срок 2 с
|
||||
time.sleep(LOAD_RENDER_SETTLE_S)
|
||||
started = time.monotonic()
|
||||
code, _ = detached(
|
||||
"docker",
|
||||
"stop",
|
||||
"--timeout",
|
||||
str(PROCESS_STOP_LIMIT_S),
|
||||
containers[0],
|
||||
)
|
||||
took = time.monotonic() - started
|
||||
finally:
|
||||
detached("docker", "compose", "unpause", "rabbitmq")
|
||||
print(f"{title}: docker stop relay took {took:.2f} s", flush=True)
|
||||
rows.append((f"{title}: command exit code", "0", str(code)))
|
||||
rows.append(
|
||||
(
|
||||
f"{title}: under {PROCESS_STOP_LIMIT_S} s",
|
||||
"yes",
|
||||
yes(took < PROCESS_STOP_LIMIT_S),
|
||||
),
|
||||
)
|
||||
rows.extend(stopped_record_rows(title, "relay", containers[0]))
|
||||
rows.append((f"{title}: relay back", "0", str(start_service("relay"))))
|
||||
if isinstance(payload, dict) and "id" in payload:
|
||||
final = wait_attachment(port, token, str(payload["id"]))
|
||||
rows.append(
|
||||
(
|
||||
f"{title}: upload after start",
|
||||
"ready",
|
||||
str(final.get("status")),
|
||||
),
|
||||
)
|
||||
return rows
|
||||
|
||||
|
||||
def process_early_stop(
|
||||
spec: ProcessSpec,
|
||||
image: str,
|
||||
|
||||
@@ -457,8 +457,8 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore
|
||||
| `make start_broker` / `make stop_broker` | брокер стенда: `up -d --wait rabbitmq` / `stop rabbitmq` |
|
||||
| `driver.py --port <LB> defense-scenario` | сценарий защиты на рабочем стенде: worker остановлен → 202 → сообщение 201 → 409 → текст 201 → `scripts/restart.sh` → worker → `ready`, оригинал и thumbnail; `id` и `StartedAt`, worker запускается при любом исходе; `evidence/attachments/defense.md` |
|
||||
| `driver.py --port <LB> broker-check [--require-test-queue]` | образ и digest, volume, порт, предел памяти, очередь, остановка брокера; `evidence/broker/stand.md`, `evidence/broker/isolated.md` |
|
||||
| `driver.py --port <LB> worker-process` | PID 1, лимиты, остановка, неверные `WORKER__*`, рестарт хранилищ; `evidence/worker/process.md` |
|
||||
| `driver.py --port <LB> relay-process` | то же у relay: PID 1, нет healthcheck, лимиты, запись о старте, неверные `RELAY__*`, остановка простаивающего и на старте, рестарт хранилищ; `evidence/relay/process.md` |
|
||||
| `driver.py --port <LB> worker-process` | PID 1, лимиты, остановка, неверные `WORKER__*`, рестарт хранилищ, остановка на двух дорогих JPEG (быстрее 9,5 с, в том числе при замороженных PostgreSQL и брокере), ~5 мин; `evidence/worker/process.md` |
|
||||
| `driver.py --port <LB> relay-process` | то же у relay: PID 1, нет healthcheck, лимиты, запись о старте, неверные `RELAY__*`, остановка простаивающего, на старте и при замороженном брокере, рестарт хранилищ; `evidence/relay/process.md` |
|
||||
| `driver.py --port <LB> defense-faults` | шаг 4 защиты на рабочем стенде (~4 мин: аренда 70 с): crash после записи объектов и после фиксации до ack, relay убит до публикации и после подтверждения до отметки, replay неудачного и отказ replay готового; триггеры на `filename` прогона снимаются, worker и relay запускаются при любом исходе; `evidence/attachments/defense-faults.md` |
|
||||
| `driver.py --port <LB> pipeline-state` | только чтение, JSON: задания по состояниям, due, ждущие срока, опубликованные и не взятые, истёкшие аренды, возраст старейшего, очередь |
|
||||
| `make start_db` / `make stop_db` | Postgres стенда: `up -d --wait postgres` / `stop postgres` |
|
||||
|
||||
@@ -172,6 +172,7 @@
|
||||
- **Решения apply (подробно — design, «Уточнения apply»):** у `make replay` `--attachment-id` и фильтр по коду или причине вместе нельзя (код 2); `FOR NO KEY UPDATE` и ack после фиксации проверяются пробой блокировки строки и счётчиком `messages_unacknowledged`: прежний вид тестов этих регрессий не замечал; откат реплик на прежний образ — с `infra/rollback/broker.compose.yml`, без него загрузка 503; зависший worker в тесте — отдельный процесс с длинными сроками и `expire-lease`, иначе его прерывал бы таймер, а не fencing.
|
||||
- **Удалено при коммите:** `src/utils/thumbnail.py` и `src/infra/broker/instance.py` без импортов удалила основная сессия, вошло в `e2a6427`.
|
||||
- **Группа 15:** метка `bench_rollout` снята первой, на чистом дереве, остальные доказательства — после: новые файлы `evidence/` выносить из дерева не пришлось (`git.dirty` false). Полный `make failure_checks` — при остановленном рабочем стенде, чтобы не сужать малый запас времени к концу набора: 140 из 140, тесты не правились. `driver.py pipeline-state` при замороженном брокере — отдельный файл `evidence/relay/pipeline-state.md`; `broker-check --require-test-queue` снят между двумя `make test_isolated`. `evidence/s3/worker-key.md`, `evidence/migrations/async-attachments.md`, метки `evidence/rollout/async-attachments`, `evidence/uploads/baseline` остаются со своим `ff1a83b`: это переход уровня 3, новые снимки — `evidence/s3/cleaner-staging.md`, `evidence/migrations/pipeline-reliability.md`, метка `evidence/rollout/pipeline-reliability`.
|
||||
- **Правки по проверке (группа 16):** исходник закрывается только при переводе в RGBA: остальные ветки `_prepared` на границе и так укладываются в лимит (пробы, design, «Уточнения apply», п. 19). Тест типов PNG — в обычном наборе (`test_pixel_limit_png_modes`), а не в проверках отказов: особого стенда ему не нужно. Прежний поток зависшего worker сохранён отдельным тестом `test_hung_worker_thawed_after_ready`: усиленный `test_hung_worker_lease_fencing` его не заменяет, сценарий «Зависший worker» проверяет другое окно. Для второй попытки hook получил `run-worker-second`: основной worker стенда со сроком 10 с при разморозке прервал бы таймер.
|
||||
|
||||
### Вопросы
|
||||
|
||||
@@ -181,3 +182,4 @@
|
||||
2. Контракт называет replay «явным операторским», но не говорит, как его вызывать, а новые возможности просит добавлять в `contracts/extensions.openapi.json`. Достаточно ли команды в контейнере? Сделано: `make replay`, HTTP-ручки нет: в API нет роли оператора. Другой ответ добавляет ручку поверх той же транзакции.
|
||||
3. Изображение, которое не уложилось в лимиты времени или памяти обработки, — это `invalid_image` или отдельный код? Контракт приводит коды как пример. Сделано: `invalid_image`, точная причина — в записи для оператора. Другой ответ добавляет значение enum и требует порядка обновления реплик раньше worker.
|
||||
4. Контракт требует retention для «неуспешных и непривязанных исходников», но молчит о конечных объектах, которые успела записать неудачная попытка. Сделано: по истечении срока удаляются и они, метаданные `failed` остаются. Другой ответ убирает один шаг очистки.
|
||||
5. Секреты worker читаются процессом обработки через `/proc/1/environ` под тем же UID: окружение самого процесса обработки их не содержит, но после эксплойта декодера защиты нет. Кодом не исправлено, ограничение названо в `REPORT.md` и `worker.md`. Предложение: `prctl(PR_SET_DUMPABLE, 0)` в процессе worker до запуска процессов обработки: тогда чужой процесс того же UID не откроет его `/proc/<pid>/environ` и `mem`. Требуется ли это на уровне лабы?
|
||||
|
||||
@@ -115,7 +115,7 @@ make replay → relay replay: реестр failed и возврат работы
|
||||
|
||||
Настоящий случай «дорогого» файла — прогрессивный JPEG в пределах контракта, один скан повторён 445 227 раз: `test_limit_cpu_scan_bomb`.
|
||||
|
||||
**Бюджет памяти контейнера worker (1 ГБ).** Замер двух PNG 10 MiB одновременно: `VmHWM` процесса 1 — 158 МиБ, `render_peak_kib` ~84 МиБ на файл, `memory.peak` контейнера 261 МиБ (design, «Уточнения apply», п. 13). На худшем файле, PNG RGBA 40 Мпкс с пиком процесса ~410 МиБ: 158 + 2 × 410 = 978 МиБ < 1 ГБ. Если памяти всё же не хватит, ядро убьёт самый большой процесс обработки, а не worker (проба), это временная ошибка.
|
||||
**Бюджет памяти контейнера worker (1 ГБ).** Пик процесса обработки на 40 Мпкс (`peak_kib`, лимит 450 МиБ) зависит от типа файла: PNG RGBA и всё, что переводится в RGBA (серый с альфой, RGB с tRNS, палитра с tRNS), — 357 МиБ, серый 16 бит — 404–405 МиБ, и это наибольшее значение. Процесс 1 worker при двух телах 10 MiB — 158 МиБ (`VmHWM`). Расчёт на самом дорогом файле: 158 + 2 × 405 = 968 МиБ < 1 ГБ. Числа и `memory.peak` контейнера, в том числе при двух серых 16 бит разом, — `evidence/worker/memory.md`. Если памяти всё же не хватит, ядро убьёт самый большой процесс обработки, а не worker (проба), это временная ошибка.
|
||||
|
||||
### Сервисы стенда и лимиты
|
||||
|
||||
@@ -221,7 +221,7 @@ make replay → relay replay: реестр failed и возврат работы
|
||||
|
||||
**Почему повторная доставка нормальна и где ключ идемпотентности job?** Подтверждение и результат работы нельзя зафиксировать атомарно: процесс может умереть между COMMIT и ack, relay — между confirm и отметкой, и сообщение придёт снова. Это at least once, а не exactly once. Эффект идемпотентен: ключ — `(attachment_id, pipeline_version, variant)`, первичный ключ `attachment_variants`, вставка `ON CONFLICT DO NOTHING`; ключи объектов одни и те же при каждом повторе, логическая работа — `UNIQUE (attachment_id, pipeline_version)`. Сообщение — подсказка, истина в строке: доставка готовой работы подтверждается без записи (`test_redelivery_of_ready_is_noop`, `test_crash_after_commit_before_ack`: `attempt` 1, тот же `updated_at`), `ready` не откатывается, replay готового — отказ `already_ready`.
|
||||
|
||||
**Как отличить зависший worker от долго работающего и не запустить два неконтролируемых дубля?** Только сроком: флаг `redelivered` этого не доказывает, брокер ставит его и после `nack`. Попытка жёстко ограничена: шаги прерывает `asyncio.timeout(job_timeout_seconds)`, процесс обработки убивается, поэтому аренда `job_timeout + lease_margin` (70 с) обходится без пульса. Истёкшая аренда значит «мёртв или заморожен», такую попытку возвращает relay. Пока аренда жива, дубль подтверждается без эффекта и без траты номера (`busy`, `test_duplicate_during_processing`), долгая живая попытка не теряет работу (`test_long_attempt_keeps_lease`). Новая попытка получает новый номер, и фиксация условна: `state = 'processing' AND attempt = :своя`. Размороженный прежний процесс получает `superseded` и ничего не меняет (`test_hung_worker_lease_fencing`). Цена — после KILL следующая попытка ждёт аренду, до 70 с (наблюдали 70 с, `evidence/attachments/defense-faults.md`). Пульс отвергнут: запись на задание каждые несколько секунд, зависимость от event loop и ложные срабатывания под перегрузкой.
|
||||
**Как отличить зависший worker от долго работающего и не запустить два неконтролируемых дубля?** Только сроком: флаг `redelivered` этого не доказывает, брокер ставит его и после `nack`. Попытка жёстко ограничена: шаги прерывает `asyncio.timeout(job_timeout_seconds)`, процесс обработки убивается, поэтому аренда `job_timeout + lease_margin` (70 с) обходится без пульса. Истёкшая аренда значит «мёртв или заморожен», такую попытку возвращает relay. Пока аренда жива, дубль подтверждается без эффекта и без траты номера (`busy`, `test_duplicate_during_processing`), долгая живая попытка не теряет работу (`test_long_attempt_keeps_lease`). Новая попытка получает новый номер, и фиксация условна: `state = 'processing' AND attempt = :своя`. Размороженный прежний процесс получает `superseded` и ничего не меняет, в том числе пока новая попытка ещё идёт: тогда решает только номер (`test_hung_worker_lease_fencing`). Цена — после KILL следующая попытка ждёт аренду, до 70 с (наблюдали 70 с, `evidence/attachments/defense-faults.md`). Пульс отвергнут: запись на задание каждые несколько секунд, зависимость от event loop и ложные срабатывания под перегрузкой.
|
||||
|
||||
### Сценарий защиты
|
||||
|
||||
@@ -294,7 +294,7 @@ make replay → relay replay: реестр failed и возврат работы
|
||||
| Лимит по bytes | `test_limit_oversized_staging` | объект больше строки не читается: `processing_failed` | `evidence/tests/failure-checks.md` |
|
||||
| Лимит по пикселям | `test_limit_pixels` | `invalid_image`, причина `limit_pixels` | `evidence/tests/failure-checks.md` |
|
||||
| Лимит по времени | `test_limit_cpu_scan_bomb`, `test_limit_render_timeout` | настоящий дорогой JPEG прерван по CPU: `invalid_image`; срок процесса — временная ошибка | `evidence/tests/failure-checks.md` |
|
||||
| Лимит по памяти worker | `test_limit_memory`, `test_max_pixels_fit_worker_memory`, `test_render_killed`, `driver.py worker-process` | `RLIMIT_AS` — `invalid_image`; 40 Мпкс укладывается; убитый процесс обработки не роняет worker; лимиты 1 CPU / 1 ГБ | `evidence/tests/failure-checks.md`, `evidence/worker/process.md` |
|
||||
| Лимит по памяти worker | `test_limit_memory`, `test_max_pixels_fit_worker_memory`, `test_pixel_limit_png_modes`, `test_render_killed`, `driver.py worker-process` | `RLIMIT_AS` — `invalid_image`; 40 Мпкс укладывается в любом типе PNG, включая серый с альфой и RGB с tRNS; убитый процесс обработки не роняет worker; лимиты 1 CPU / 1 ГБ | `evidence/tests/failure-checks.md`, `evidence/worker/process.md` |
|
||||
| Разрыв PostgreSQL и брокера закрыт outbox | `test_upload_with_broker_stopped`, `test_upload_with_broker_paused`, `test_relay_survives_broker_outage`, `test_relay_survives_database_outage`, `driver.py relay-process`, `broker-check` | 202 без брокера; у реплик нет настроек брокера; relay переживает отказы (тот же `StartedAt`, `RestartCount` 0) | `evidence/tests/failure-checks.md`, `evidence/relay/process.md`, `evidence/broker/stand.md` |
|
||||
| Crash между COMMIT и publish, задача доходит до `ready` без ручного задания | `driver.py defense-faults`, окна «после COMMIT `queued` до publish» и «после подтверждения до отметки»; `test_relay_killed_before_publish`, `test_relay_killed_after_confirm` | `published_at` пуст, 0 сообщений, после запуска relay — `ready`, `attempt` 1; при KILL после confirm — 2 сообщения, `ready`, `attempt` 1, очередь пуста | `evidence/attachments/defense-faults.md`, `evidence/tests/failure-checks.md` |
|
||||
| Состояние намерений видно оператору | `driver.py pipeline-state`, в том числе при замороженном брокере | задания по состояниям, due, аренды; брокер заморожен — `available: false`, код 0 | `evidence/relay/pipeline-state.md` |
|
||||
@@ -303,7 +303,7 @@ make replay → relay replay: реестр failed и возврат работы
|
||||
| Реестр `failed` | `make replay`, `test_replay_registry_dry_run`, `test_replay_by_code` | показ без изменений; выбор по коду и причине; реестр — строки PostgreSQL, отдельной DLQ нет | `evidence/relay/logs.md`, `evidence/attachments/defense-faults.md` |
|
||||
| Безопасный явный replay, не дубль успешной job | `driver.py defense-faults`, окна replay; `test_replay_returns_work`, `test_replay_ready_refused`, `test_replay_in_progress_refused`, `test_replay_without_source_refused`, `test_replay_new_budget` | `--apply` с выбором, то же задание, `attempt` 2, `attempt_base` 1, запись аудита; `ready` — код 3 `already_ready`, ничего не изменилось | `evidence/attachments/defense-faults.md`, `evidence/relay/logs.md` |
|
||||
| Остановка worker после записи объекта до ack, повтор завершает тот же результат | `driver.py defense-faults`, окна «после записи объектов до COMMIT» и «после COMMIT до ack»; `test_crash_after_objects_before_commit`, `test_crash_after_commit_before_ack` | те же SHA-256 трёх объектов в S3 и метаданных, `attempt` 2; после COMMIT — no-op, тот же `updated_at` | `evidence/attachments/defense-faults.md`, `evidence/tests/failure-checks.md` |
|
||||
| Timeout и lease зависшего `processing` | `test_hung_worker_lease_fencing`, `test_long_attempt_keeps_lease`, `test_duplicate_during_processing`, `test_last_attempt_lost`, `test_worker_killed_during_processing` | истёкшую аренду возвращает relay; прежняя попытка после разморозки — `superseded`; живая не теряется, дубль без эффекта | `evidence/tests/failure-checks.md` |
|
||||
| Timeout и lease зависшего `processing` | `test_hung_worker_lease_fencing`, `test_hung_worker_thawed_after_ready`, `test_long_attempt_keeps_lease`, `test_duplicate_during_processing`, `test_last_attempt_lost`, `test_worker_killed_during_processing` | истёкшую аренду возвращает relay; прежняя попытка после разморозки — `superseded`; живая не теряется, дубль без эффекта | `evidence/tests/failure-checks.md` |
|
||||
| Ограниченная конкуренция и prefetch | `test_concurrency_bounded`, `test_prefetch_bounded`, `test_published_backlog_limit`, `test_broker_memory_alarm` | prefetch 2 + конкуренция 2, сообщения сверх них у брокера; предел опубликованных 1000 | `evidence/tests/failure-checks.md`, `evidence/worker/process.md` |
|
||||
| Очистка staging после безопасной фиксации | `test_staging_removed_after_ready`, `test_staging_retention`, `test_staging_keeps_current_work`, `test_staging_cleanup_survives_outage`, `test_staging_foreign_key_kept`, `test_reconcile_orphan_staging`, `driver.py upload-consistency`, `make s3_check` | у `ready` убран следующим проходом (`removed_ready`), у `failed` по сроку; текущая работа цела; отказ S3 не держит сообщения; список уборщика только по двум префиксам | `evidence/tests/failure-checks.md`, `evidence/attachments/consistency.md`, `evidence/s3/cleaner-staging.md` |
|
||||
| Шаг 4 сценария защиты | `driver.py --port 8080 defense-faults` | шесть окон, все строки `expected` = `got`, триггеров не осталось | `evidence/attachments/defense-faults.md` |
|
||||
@@ -366,7 +366,7 @@ H1 (пик ограничен местами) и H4 (нет 503 по сроку
|
||||
| Сообщение потеряно вместе с очередью | relay публикует снова, при непустой очереди копий нет | так (`test_lost_message_republished`, `test_no_copies_while_queue_has_messages`) | через `republish_after_seconds`, 300 с |
|
||||
| Worker убит посреди обработки или после записи объектов | следующая попытка по аренде, те же ключи | так (`defense-faults.md`, `test_worker_killed_during_processing`) | 70 с на рабочем стенде, потерь нет, попытка посчитана |
|
||||
| Worker убит после COMMIT до ack | повторная доставка, no-op | так (`defense-faults.md`, `test_crash_after_commit_before_ack`) | сразу после запуска, потерь нет |
|
||||
| Worker заморожен дольше аренды | новая попытка, прежняя не фиксирует | так (`test_hung_worker_lease_fencing`) | по аренде, дублей эффекта нет |
|
||||
| Worker заморожен дольше аренды | новая попытка, прежняя не фиксирует ни при живой новой, ни после её итога | так (`test_hung_worker_lease_fencing`, `test_hung_worker_thawed_after_ready`) | по аренде, дублей эффекта нет |
|
||||
| Дорогой файл в пределах контракта | процесс обработки прерван по CPU, worker цел | так (`test_limit_cpu_scan_bomb`) | 15 с CPU на рабочем стенде, `invalid_image` |
|
||||
| S3 недоступен при обработке | повторы с backoff под одним `job_id`, затем `ready` или `retry_exhausted` | так (`test_transient_error_retried`, `test_attempts_exhausted`) | рабочий стенд выдерживает сумму пауз 37,5–75 с и сроки попыток (расчёт по настройкам, design, решение 4; тесты — на коротких сроках стенда отказов); дольше — `failed`, возврат `make replay` |
|
||||
| S3 недоступен при очистке staging | проход прерван, сообщения не ждут | так (`test_staging_cleanup_survives_outage`) | следующий проход повторяет |
|
||||
@@ -385,6 +385,7 @@ H1 (пик ограничен местами) и H4 (нет 503 по сроку
|
||||
- **Профиль ICC отбрасывается.** Учебные данные — sRGB; изображение с другим профилем изменит цвет в вариантах.
|
||||
- **Лимит памяти на macOS.** `setrlimit(RLIMIT_AS)` на хосте macOS отказывает, консольный worker это пишет в журнал (`render_memory_limit_applied`); на стенде Linux лимит действует.
|
||||
- **Цена процесса на задание.** ~100 мс CPU на маленьком файле; forkserver (9 мс) отвергнут сейчас: секреты родителя в окружении и свой жизненный цикл. Граница — один модуль, цену меряет трек 1.
|
||||
- **Изоляция секретов процесса обработки неполная.** В его окружении секретов нет, но он идёт под тем же UID, что процесс 1 worker, и может прочитать `/proc/1/environ` с ключами S3 и паролями PostgreSQL и брокера. От случайной утечки это защищает, после эксплойта декодера — нет. Предложение — `PR_SET_DUMPABLE=0` в процессе worker, вопрос преподавателю (`QUESTIONS.md`, `## pipeline-reliability`).
|
||||
- **Дорогие файлы тратят CPU до лимита.** 15 с CPU на файл, при конкуренции 2 такой поток занимает worker; скорость подачи ограничивают только места загрузки. Ограничение принятой работы — трек 1.
|
||||
- **Сверка не проверяет объекты вариантов.** Наличие и размер объектов вариантов сверка не проверяет: вариант без объекта даёт 500 на скачивание и `error` в журнале (`test_missing_variant`). Объекты staging она с этого уровня видит (`orphan_staging`).
|
||||
- **Удаление очереди при работающем worker.** Потребитель этого не замечает: relay создаст очередь заново, worker нужно перезапустить. На стенде такого нет, кроме уборки своей очереди после остановки своего worker.
|
||||
|
||||
@@ -68,7 +68,7 @@ test_reconcile_orphan_staging test_defense_faults
|
||||
|---|---|---|
|
||||
| отметка `published_at` до подтверждения | `test_relay_killed_after_confirm` | `published_at` есть после KILL до подтверждения |
|
||||
| claim при живой аренде | `test_duplicate_during_processing` | нет записи `busy` |
|
||||
| фиксация без номера попытки | `test_hung_worker_lease_fencing` | нет записи `superseded` за 30 с |
|
||||
| фиксация без номера попытки | `test_hung_worker_lease_fencing` (усиленный: первая попытка размораживается при живой второй; прежний вид теста здесь зелёный, итог решал `state`) | нет записи `superseded` с `attempt` 1 за 30 с |
|
||||
| ack до фиксации | `test_crash_after_objects_before_commit` (усиленный) | `messages_unacknowledged` 0 |
|
||||
| claim без проверки завершённого | `test_crash_after_commit_before_ack` | нет записи `finished` за 30 с |
|
||||
| replay без проверки состояния | `test_replay_ready_refused` | код 0 вместо 3 |
|
||||
|
||||
@@ -34,6 +34,7 @@
|
||||
|---|---|
|
||||
| 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 мс. Это настоящий случай «ограничено по времени», поток так не прервать |
|
||||
@@ -241,7 +242,7 @@ Replay `invalid_image` разрешён: оператор мог поправи
|
||||
Одно декодирование, порядок:
|
||||
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` прежний; `base = resize(opt, LANCZOS, reducing_gap=2.0)` — основа для optimized и thumbnail.
|
||||
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 — на малых изображениях.
|
||||
@@ -469,7 +470,7 @@ Replay `invalid_image` разрешён: оператор мог поправи
|
||||
| «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_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 |
|
||||
@@ -479,7 +480,8 @@ Replay `invalid_image` разрешён: оператор мог поправи
|
||||
| «Дорогое изображение» | `test_limit_cpu_scan_bomb`, fault |
|
||||
| «Предел памяти процесса обработки», «Срок процесса обработки» | `test_limit_memory`, `test_limit_render_timeout`, fault |
|
||||
| «Процесс обработки убит», «Секретов нет у процесса обработки» | `test_render_killed`, fault |
|
||||
| «Зависший worker» | `test_hung_worker_lease_fencing`, 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 |
|
||||
@@ -554,11 +556,11 @@ Replay `invalid_image` разрешён: оператор мог поправи
|
||||
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 МиБ. На худшем файле (пик процесса ~410 МиБ, RGBA 40 Мпкс): 158 + 2 × 410 = 978 МиБ < 1 ГБ. Оценка решения 7 (130 МиБ) была занижена на 28 МиБ, бюджет сходится. Лимит не менялся.
|
||||
13. **Память worker (задача 9.6, расчёт решения 7):** два PNG 10 MiB одновременно: `VmHWM` процесса 1 — 158 МиБ (`VmRSS` до 109, после 111), `render_peak_kib` ~84 МиБ на файл, `render_ms` 928, контейнер `memory.peak` 261 МиБ; снято на рабочем дереве, файл на commit — `evidence/worker/memory.md`, задача 16.8. На самом дорогом файле, сером 16 бит 40 Мпкс, пик процесса 405 МиБ (у RGBA — 357, таблица проб): 158 + 2 × 405 = 968 МиБ < 1 ГБ. Оценка решения 7 (130 МиБ) была занижена на 28 МиБ, бюджет сходится. Лимит не менялся.
|
||||
14. **Регрессии задачи 10.9** (каждая применена в рабочем дереве, откачена, хэши `src` совпали со снимком до них; образ собирался из дерева):
|
||||
- отметка до подтверждения: `test_relay_killed_after_confirm` — красный, `published_at` есть после KILL до подтверждения; `test_upload_with_broker_paused` — зелёный;
|
||||
- claim при живой аренде: `test_duplicate_during_processing` — красный, нет записи `busy`;
|
||||
- фиксация без номера попытки: `test_hung_worker_lease_fencing` — красный, нет записи `superseded` за 30 с;
|
||||
- фиксация без номера попытки: запись первого прогона не воспроизвелась: при удалении только `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;
|
||||
@@ -575,3 +577,6 @@ Replay `invalid_image` разрешён: оператор мог поправи
|
||||
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 без признаков аварии; полный прогон на commit — задача 16.10. `driver.py worker-process` на рабочем дереве: `docker stop` на двух дорогих JPEG — 8,15 с, при замороженных PostgreSQL и брокере — 9,19 с, код 0, все четыре задания дошли до `failed`, `limit_cpu`. `relay-process`: при замороженном брокере — 1,71 с, код 0.
|
||||
@@ -230,6 +230,10 @@ Thumbnail SHALL быть изображением JPEG, вписанным в 25
|
||||
заданий worker обрабатывает одновременно
|
||||
- **THEN** каждое вложение становится `ready`, thumbnail 256 × 160, crop 128 × 128,
|
||||
optimized 1280 × 800, а контейнер worker не завершён из-за памяти
|
||||
- **WHEN** участник загружает по одному PNG 8000 × 5000 других типов: серый с
|
||||
альфа-каналом, RGB 8 и 16 бит с tRNS, палитра с tRNS, серый 16 бит
|
||||
- **THEN** каждое вложение становится `ready` с теми же размерами вариантов, а не
|
||||
`failed`: контракт разрешает 40 млн пикселей в любом типе
|
||||
|
||||
### Requirement: Идемпотентный эффект
|
||||
|
||||
@@ -526,6 +530,13 @@ NOT начинаться: сообщение подтверждается без
|
||||
- **THEN** число начатых попыток — 2, причина возврата записана в журнал relay, а метаданные после разморозки
|
||||
совпадают с зафиксированными вторым worker во всех полях
|
||||
|
||||
#### Scenario: Прежняя попытка при живой новой
|
||||
|
||||
- **WHEN** worker заморожен посреди попытки, срок аренды истёк, второй worker взял задание, ещё не зафиксировал
|
||||
результат и не держит блокировку строки, и первый разморожен
|
||||
- **THEN** первая попытка завершается без записи, задание остаётся в `processing` с номером второй попытки, а
|
||||
вложение не `ready`; итог даёт только вторая: вложение `ready`, число начатых попыток — 2
|
||||
|
||||
#### Scenario: Долгая живая попытка
|
||||
|
||||
- **WHEN** фиксация результата задержана дольше всех пауз, но попытка укладывается в срок
|
||||
|
||||
@@ -313,3 +313,31 @@ evidence и `REPORT.md`: её запускает основная сессия
|
||||
|
||||
Проверка: у каждой новой строки таблицы доказательств есть команда, наблюдение и файл; `make lint`, `make check`, `openspec validate pipeline-reliability --strict`.
|
||||
- [x] 15.6 Коммит evidence и `REPORT.md` основной сессией. Проверка: `git status` чист; `git log -2` — commit кода назван в шапках файлов evidence.
|
||||
|
||||
## 16. Замечания проверки
|
||||
|
||||
HEAD до правок — `6bd6053`, код снят на `e2a6427`. Этап 1 — код, тесты, спеки и документы на рабочем дереве, агент не коммитит. Этап 2 — evidence на commit правок, его хэш передаёт основная сессия.
|
||||
|
||||
### Этап 1
|
||||
|
||||
- [x] 16.1 W1: допустимые PNG на границе контракта становятся `failed`. `_prepared` закрывает исходник после `convert("RGBA")`. Воспроизвести; black-box тест на серый с альфой и RGB с tRNS, падение до правки; сценарий «Изображение в лимите пикселей» в дельте и основном спеке; `REPORT.md`, таблица проб в design.
|
||||
|
||||
Проверка: пробы процесса обработки по всем режимам до и после; `with Image.open` и другие режимы не сломаны; тест красный до правки, зелёный после.
|
||||
- [x] 16.2 W2: `test_hung_worker_lease_fencing` не ловит удаление номера попытки. Первая попытка размораживается, пока вторая жива и не держит блокировку строки; сценарий «Прежняя попытка при живой новой» в требовании «Аренда попытки» (дельта и основной спек); докстринг, строка `evidence/tests/failure-checks.md`, design, «Уточнения apply», п. 14.
|
||||
|
||||
Проверка: без `locked.attempt == job.attempt` тест красный, с условием зелёный; регрессия откачена, хэши `src` совпали.
|
||||
- [x] 16.3 W3: бюджет памяти в `REPORT.md` и design, п. 13 — формулировка по фактам после W1.
|
||||
|
||||
Проверка: числа совпадают с пробами; файл замера — этап 2.
|
||||
- [x] 16.4 S2: `driver.py worker-process` — остановка под нагрузкой на двух дорогих JPEG (граница 9,5 с), при замороженных PostgreSQL и брокере; `relay-process` — `docker stop relay` при замороженном брокере.
|
||||
|
||||
Проверка: `ruff format --check` драйвера; разовый запуск на стенде; файлы evidence — этап 2.
|
||||
- [x] 16.5 S3: `balancer.md` — новая реплика без override после отката получит 503 на загрузке.
|
||||
- [x] 16.6 S1: ограничение `/proc/1/environ` — `REPORT.md`, `worker.md`, вопрос в `QUESTIONS.md` с предложением `PR_SET_DUMPABLE=0`. Кодом не исправляется.
|
||||
- [x] 16.7 Регресс на рабочем дереве: `make lint`, `make check`, `openspec validate pipeline-reliability --strict`, пересборка стенда, `make test`, `make student_test`, полный `make failure_checks`.
|
||||
|
||||
### Этап 2 (после commit правок)
|
||||
|
||||
- [ ] 16.8 `evidence/worker/memory.md`: `VmHWM`, `render_peak`, `memory.peak` — PNG 10 MiB и граничные 40 Мпкс, в том числе два серых 16 бит разом; OOM.
|
||||
- [ ] 16.9 `evidence/worker/process.md`, `evidence/relay/process.md`, `evidence/attachments/defense-faults.md` с кодом выхода в шапке.
|
||||
- [ ] 16.10 `evidence/tests/failure-checks.md` — полный прогон на этом commit; `REPORT.md` — commit измеренного состояния и бюджет.
|
||||
|
||||
@@ -276,6 +276,10 @@ Thumbnail SHALL быть изображением JPEG, вписанным в 25
|
||||
заданий worker обрабатывает одновременно
|
||||
- **THEN** каждое вложение становится `ready`, thumbnail 256 × 160, crop 128 × 128,
|
||||
optimized 1280 × 800, а контейнер worker не завершён из-за памяти
|
||||
- **WHEN** участник загружает по одному PNG 8000 × 5000 других типов: серый с
|
||||
альфа-каналом, RGB 8 и 16 бит с tRNS, палитра с tRNS, серый 16 бит
|
||||
- **THEN** каждое вложение становится `ready` с теми же размерами вариантов, а не
|
||||
`failed`: контракт разрешает 40 млн пикселей в любом типе
|
||||
|
||||
### Requirement: Идемпотентный эффект
|
||||
|
||||
@@ -602,6 +606,13 @@ NOT начинаться: сообщение подтверждается без
|
||||
- **THEN** число начатых попыток — 2, причина возврата записана в журнал relay, а метаданные после разморозки
|
||||
совпадают с зафиксированными вторым worker во всех полях
|
||||
|
||||
#### Scenario: Прежняя попытка при живой новой
|
||||
|
||||
- **WHEN** worker заморожен посреди попытки, срок аренды истёк, второй worker взял задание, ещё не зафиксировал
|
||||
результат и не держит блокировку строки, и первый разморожен
|
||||
- **THEN** первая попытка завершается без записи, задание остаётся в `processing` с номером второй попытки, а
|
||||
вложение не `ready`; итог даёт только вторая: вложение `ready`, число начатых попыток — 2
|
||||
|
||||
#### Scenario: Долгая живая попытка
|
||||
|
||||
- **WHEN** фиксация результата задержана дольше всех пауз, но попытка укладывается в срок
|
||||
|
||||
@@ -81,7 +81,11 @@ def _prepared(image: Image.Image) -> Image.Image:
|
||||
# вырос бы с ~320 до ~480 МиБ
|
||||
return image
|
||||
if image.mode in _ALPHA_MODES or "transparency" in image.info:
|
||||
return image.convert("RGBA")
|
||||
converted = image.convert("RGBA")
|
||||
# исходник дальше не нужен: на 40 млн пикселей с ним на время масштаба
|
||||
# пик выше лимита процесса (четыре байта на пиксель у LA и RGB тоже)
|
||||
image.close()
|
||||
return converted
|
||||
if image.mode == "1":
|
||||
return image.convert("L")
|
||||
if image.mode in ("P", "CMYK"):
|
||||
|
||||
+25
-10
@@ -61,10 +61,13 @@
|
||||
pause|unpause worker заморозка контейнера (зависший worker)
|
||||
run-worker K=V… второй worker `<FAULT_PROJECT>-worker-extra` с
|
||||
этим окружением
|
||||
run-worker-second K=V… третий worker `<FAULT_PROJECT>-worker-second-extra`:
|
||||
вторая попытка рядом с замороженной первой
|
||||
run-relay K=V… второй relay `<FAULT_PROJECT>-relay-extra`
|
||||
stop-extra убрать дополнительные контейнеры
|
||||
extra-log worker|relay журнал дополнительного контейнера
|
||||
kill-extra|pause-extra|unpause-extra worker
|
||||
extra-log worker|worker-second|relay
|
||||
журнал дополнительного контейнера
|
||||
kill-extra|pause-extra|unpause-extra worker|worker-second
|
||||
то же с дополнительным worker
|
||||
expire-lease <id> срок аренды задания вложения — в прошлом: окно,
|
||||
где таймеры прежней попытки ещё не сработали
|
||||
@@ -756,7 +759,8 @@ BROKER_LIMIT_RE = re.compile(r"^[0-9]+(MiB|GiB|MB|GB)?$")
|
||||
SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
|
||||
# варианты контракта: имя в DELETE_VARIANT_SQL
|
||||
VARIANT_NAMES = ("thumbnail", "crop", "optimized")
|
||||
EXTRA_SERVICES = ("worker", "relay")
|
||||
SECOND_WORKER = "worker-second"
|
||||
EXTRA_SERVICES = ("worker", SECOND_WORKER, "relay")
|
||||
COMMIT_STALL_TIMEOUT_S = 15
|
||||
# аргументы replay: значения проверяет сама команда, а эти — чтобы в compose
|
||||
# run не ушло лишнее
|
||||
@@ -1221,8 +1225,15 @@ def extra_name(project: str, name: str) -> str:
|
||||
return f"{project}-{name}-extra"
|
||||
|
||||
|
||||
def run_extra(project: str, name: str, pairs: list[str]) -> str:
|
||||
"""Второй процесс сервиса с этим окружением; прежний такой убирается."""
|
||||
def run_extra(
|
||||
project: str,
|
||||
name: str,
|
||||
pairs: list[str],
|
||||
*,
|
||||
service: str | None = None,
|
||||
) -> str:
|
||||
"""Ещё один процесс сервиса с этим окружением; прежний такой убирается.
|
||||
`service` — сервис compose, если он не совпадает с именем процесса."""
|
||||
for pair in pairs:
|
||||
if not EXTRA_ENV_RE.fullmatch(pair):
|
||||
raise HookError(f"bad environment pair: {pair!r}")
|
||||
@@ -1241,7 +1252,7 @@ def run_extra(project: str, name: str, pairs: list[str]) -> str:
|
||||
"--name",
|
||||
container,
|
||||
*options,
|
||||
name,
|
||||
service or name,
|
||||
)
|
||||
return ""
|
||||
|
||||
@@ -1718,16 +1729,20 @@ def run(project: str, action: str, args: list[str]) -> str:
|
||||
return container_state(service_container(project, "relay"))
|
||||
if action == "run-worker":
|
||||
return run_extra(project, "worker", args)
|
||||
if action == "run-worker-second":
|
||||
return run_extra(project, SECOND_WORKER, args, service="worker")
|
||||
if action == "run-relay":
|
||||
return run_extra(project, "relay", args)
|
||||
if action == "stop-extra" and not args:
|
||||
return stop_extra(project)
|
||||
if action == "extra-log" and len(args) == 1:
|
||||
return docker("logs", extra_name(project, args[0]))
|
||||
if action in ("kill-extra", "pause-extra", "unpause-extra") and args == [
|
||||
"worker",
|
||||
]:
|
||||
docker(action.split("-")[0], extra_name(project, "worker"))
|
||||
if (
|
||||
action in ("kill-extra", "pause-extra", "unpause-extra")
|
||||
and len(args) == 1
|
||||
and args[0] in ("worker", SECOND_WORKER)
|
||||
):
|
||||
docker(action.split("-")[0], extra_name(project, args[0]))
|
||||
return ""
|
||||
if action == "expire-lease" and len(args) == 1:
|
||||
return row_change(project, EXPIRE_LEASE_SQL, args[0], "")
|
||||
|
||||
@@ -335,6 +335,36 @@ def png_rgba_large(width: int = 8000, height: int = 5000) -> bytes:
|
||||
return buffer.getvalue()
|
||||
|
||||
|
||||
def png_at_pixel_limit(
|
||||
color: int,
|
||||
depth: int,
|
||||
*,
|
||||
transparent: bool = False,
|
||||
width: int = 8000,
|
||||
height: int = 5000,
|
||||
) -> bytes:
|
||||
"""PNG любого типа на 40 млн пикселей из нулей: файл мал, а декодирование
|
||||
разворачивает все пиксели. `transparent` — чанк tRNS (прозрачный цвет):
|
||||
Pillow открывает такой файл без альфы и переводит в RGBA отдельным шагом."""
|
||||
row = b"\x00" * (1 + (width * depth * _CHANNELS[color] + 7) // 8)
|
||||
compressor = zlib.compressobj(9)
|
||||
parts = [compressor.compress(row) for _ in range(height)]
|
||||
parts.append(compressor.flush())
|
||||
data = png(
|
||||
width,
|
||||
height,
|
||||
color=color,
|
||||
depth=depth,
|
||||
idat=b"".join(parts),
|
||||
)
|
||||
if not transparent:
|
||||
return data
|
||||
# tRNS — после IHDR и PLTE (перед первым IDAT): у палитры индекс, иначе цвет
|
||||
index = data.index(b"IDAT") - 4
|
||||
body = b"\x00" if color == 3 else b"\x00" * (6 if color == 2 else 2)
|
||||
return data[:index] + chunk(b"tRNS", body) + data[index:]
|
||||
|
||||
|
||||
def png_stripes(
|
||||
stripes: tuple[tuple[int, tuple[int, int, int]], ...] = (
|
||||
(100, (255, 0, 0)),
|
||||
|
||||
@@ -382,6 +382,7 @@ def main() -> int:
|
||||
s3_name,
|
||||
scheduled_name,
|
||||
f"{project}-worker-extra",
|
||||
f"{project}-worker-second-extra",
|
||||
f"{project}-relay-extra",
|
||||
]
|
||||
|
||||
|
||||
@@ -36,6 +36,7 @@ VARIANT_TYPES = {
|
||||
"optimized": "image/webp",
|
||||
}
|
||||
VARIANT_NAMES = tuple(VARIANT_TYPES)
|
||||
LARGE_BODY_CLIENT_TIMEOUT_S = 30
|
||||
|
||||
|
||||
def thumbnail_of(
|
||||
@@ -242,6 +243,41 @@ def test_thumbnail_format_variants(
|
||||
variant_of(api, alice, attachment, variant)
|
||||
|
||||
|
||||
@pytest.mark.spec("attachment-processing", "Изображение в лимите пикселей")
|
||||
@pytest.mark.parametrize(
|
||||
("color", "depth", "transparent"),
|
||||
[
|
||||
pytest.param(4, 8, False, id="gray-alpha-8"),
|
||||
pytest.param(2, 8, True, id="rgb-8-trns"),
|
||||
pytest.param(2, 16, True, id="rgb-16-trns"),
|
||||
pytest.param(3, 8, True, id="palette-trns"),
|
||||
pytest.param(0, 16, False, id="gray-16"),
|
||||
],
|
||||
)
|
||||
def test_pixel_limit_png_modes(
|
||||
base_url: str,
|
||||
alice: Actor,
|
||||
chat: dict[str, Any],
|
||||
color: int,
|
||||
depth: int,
|
||||
transparent: bool,
|
||||
) -> None:
|
||||
"""Контракт разрешает 40 млн пикселей в любом типе PNG. Эти типы
|
||||
переводятся в другой режим при подготовке: держать исходник на время
|
||||
перевода и масштаба — пик выше лимита памяти процесса обработки."""
|
||||
data = images.png_at_pixel_limit(color, depth, transparent=transparent)
|
||||
# срок клиента: тело на 40 млн пикселей проверяется дольше 5 с по умолчанию
|
||||
with Api(base_url, timeout=LARGE_BODY_CLIENT_TIMEOUT_S) as slow:
|
||||
attachment = slow.upload_ready(alice, chat["id"], data)
|
||||
sizes = {
|
||||
"thumbnail": (256, 160),
|
||||
"crop": (128, 128),
|
||||
"optimized": (1280, 800),
|
||||
}
|
||||
for name, size in sizes.items():
|
||||
assert variant_of(slow, alice, attachment, name).size == size
|
||||
|
||||
|
||||
@pytest.mark.spec("attachment-processing", "Crop большого изображения")
|
||||
def test_crop_center(
|
||||
api: Api,
|
||||
|
||||
@@ -1761,17 +1761,18 @@ def wait_extra_record(
|
||||
event: str,
|
||||
*,
|
||||
timeout: float = 30,
|
||||
extra: str = "worker",
|
||||
**fields: Any,
|
||||
) -> dict[str, Any]:
|
||||
deadline = time.monotonic() + timeout
|
||||
while True:
|
||||
for record in extra_records(stand):
|
||||
for record in extra_records(stand, extra):
|
||||
if record.get("event") == event and all(
|
||||
record.get(name) == value for name, value in fields.items()
|
||||
):
|
||||
return record
|
||||
assert time.monotonic() < deadline, (
|
||||
f"no extra worker record {event!r} with {fields} in {timeout} s"
|
||||
f"no {extra} record {event!r} with {fields} in {timeout} s"
|
||||
)
|
||||
time.sleep(0.3)
|
||||
|
||||
@@ -5260,18 +5261,121 @@ def test_render_killed(
|
||||
assert done["attempt"] == 2, done
|
||||
|
||||
|
||||
@pytest.mark.spec("attachment-processing", "Зависший worker")
|
||||
@pytest.mark.spec("attachment-processing", "Прежняя попытка при живой новой")
|
||||
def test_hung_worker_lease_fencing(
|
||||
api: Api,
|
||||
stand: Stand,
|
||||
alice: Actor,
|
||||
chat: dict[str, Any],
|
||||
) -> None:
|
||||
"""Первый worker — со сроками больше времени теста: разморозка застаёт его
|
||||
таймеры живыми, и он доходит до фиксации, где решает только номер попытки (с
|
||||
обычными сроками его прервал бы таймер, а не fencing). Аренду делает истекшей
|
||||
hook, а не ожидание: при таком сроке попытки её не дождаться. Второй процесс —
|
||||
основной worker стенда."""
|
||||
"""Первая попытка размораживается, когда вторая жива: задание в `processing`,
|
||||
блокировки строки нет. Решает только номер попытки: по `state` фиксация первой
|
||||
прошла бы. Оба worker — со сроками больше времени теста, иначе при разморозке
|
||||
их прервал бы таймер, а не fencing. S3 заморожен, пока вторая не взята: она
|
||||
ждёт его и не успеет зафиксировать результат раньше своей заморозки. Итог даёт
|
||||
только вторая. Аренду делает истекшей hook: при таком сроке её не дождаться."""
|
||||
second = "worker-second"
|
||||
timers = (
|
||||
"WORKER__JOB_TIMEOUT_SECONDS=120",
|
||||
"WORKER__RENDER_TIMEOUT_SECONDS=60",
|
||||
"S3__TIMEOUT_SECONDS=60",
|
||||
)
|
||||
seen_relay = len(relay_records(stand))
|
||||
try:
|
||||
with worker_stopped(stand):
|
||||
accepted = api.upload(alice, chat["id"], images.sample_png())
|
||||
attachment_id = accepted["id"]
|
||||
wait_queue_messages(stand, 1)
|
||||
with outage(stand, "pause", "s3"):
|
||||
stand("run-worker", *timers)
|
||||
wait_job(stand, attachment_id, state="processing", attempt=1)
|
||||
wait_extra_record(
|
||||
stand,
|
||||
"Started job attempt",
|
||||
attachment_id=attachment_id,
|
||||
attempt=1,
|
||||
)
|
||||
stand("pause-extra", "worker")
|
||||
stand("expire-lease", attachment_id)
|
||||
wait_relay_record(
|
||||
stand,
|
||||
"Recovered expired lease",
|
||||
skip=seen_relay,
|
||||
attachment_id=attachment_id,
|
||||
)
|
||||
stand("run-worker-second", *timers)
|
||||
wait_job(stand, attachment_id, state="processing", attempt=2)
|
||||
wait_extra_record(
|
||||
stand,
|
||||
"Started job attempt",
|
||||
extra=second,
|
||||
attachment_id=attachment_id,
|
||||
attempt=2,
|
||||
)
|
||||
stand("pause-extra", second)
|
||||
# вторая взята и заморожена в вызове S3: транзакции нет
|
||||
assert stand("attachment-free", attachment_id)
|
||||
taken = job_row(stand, attachment_id)
|
||||
assert taken is not None
|
||||
assert taken["state"] == "processing", taken
|
||||
assert taken["attempt"] == 2, taken
|
||||
stand("unpause-extra", "worker")
|
||||
wait_extra_record(
|
||||
stand,
|
||||
"Skipped job message",
|
||||
attachment_id=attachment_id,
|
||||
attempt=1,
|
||||
reason="superseded",
|
||||
)
|
||||
assert job_row(stand, attachment_id) == taken
|
||||
assert (
|
||||
assert_ok(
|
||||
api.attachment_meta(alice, attachment_id),
|
||||
200,
|
||||
"Attachment",
|
||||
)["status"]
|
||||
== "processing"
|
||||
)
|
||||
stand("unpause-extra", second)
|
||||
meta = api.wait_attachment(
|
||||
alice,
|
||||
attachment_id,
|
||||
timeout=JOB_WAIT_S,
|
||||
)
|
||||
wait_extra_record(
|
||||
stand,
|
||||
"Attachment became ready",
|
||||
extra=second,
|
||||
attachment_id=attachment_id,
|
||||
attempt=2,
|
||||
)
|
||||
job = job_row(stand, attachment_id)
|
||||
assert job is not None
|
||||
assert job["state"] == "succeeded", job
|
||||
assert job["attempt"] == 2, job
|
||||
assert not [
|
||||
record
|
||||
for record in extra_records(stand)
|
||||
if record.get("event") == "Attachment became ready"
|
||||
and record.get("attachment_id") == attachment_id
|
||||
]
|
||||
finally:
|
||||
stand("stop-extra")
|
||||
assert_variants(api, stand, alice, meta)
|
||||
|
||||
|
||||
@pytest.mark.spec("attachment-processing", "Зависший worker")
|
||||
def test_hung_worker_thawed_after_ready(
|
||||
api: Api,
|
||||
stand: Stand,
|
||||
alice: Actor,
|
||||
chat: dict[str, Any],
|
||||
) -> None:
|
||||
"""Вторая попытка уже дала `ready`, первая разморожена: итог её не меняет.
|
||||
Первый worker — со сроками больше времени теста: разморозка застаёт его
|
||||
таймеры живыми, и он доходит до фиксации (с обычными сроками его прервал бы
|
||||
таймер, а не fencing). Здесь решает и `state`; номер попытки —
|
||||
`test_hung_worker_lease_fencing`. Второй процесс — основной worker стенда."""
|
||||
seen_relay = len(relay_records(stand))
|
||||
with worker_stopped(stand):
|
||||
accepted = api.upload(alice, chat["id"], images.sample_png())
|
||||
|
||||
Reference in New Issue
Block a user