diff --git a/.claude/skills/run-mtusi-messenger/SKILL.md b/.claude/skills/run-mtusi-messenger/SKILL.md index f45d9496..7d0bc208 100644 --- a/.claude/skills/run-mtusi-messenger/SKILL.md +++ b/.claude/skills/run-mtusi-messenger/SKILL.md @@ -30,7 +30,8 @@ bucket и БД (расхождения с обеих сторон, dry-run, `--a возврат оригинала; `--apply` под загрузками), `defense-scenario` и `defense-faults` — сценарий защиты лабы 5 и его шаг 4, `broker-check`, `worker-process`, `relay-process` — брокер и процессы, `pipeline-state` — состояние -конвейера (раздел «Лаба 5: брокер, relay и worker»). `upload` и +конвейера, `worker-memory` — память контейнера worker, `freeze-sessions` и `freeze-lb` +— заморозка PostgreSQL (раздел «Лаба 5: брокер, relay и worker»). `upload` и `download` — загрузка и скачивание вложения с SHA-256 на любом сервере. `stop-at-start` — остановка контейнеров образа во время старта, без стенда. Только @@ -136,6 +137,9 @@ python3 $D stop | `worker-process` | только стенд с LB: процесс worker, тот же раздел | | `relay-process` | только стенд с LB: процесс relay, тот же раздел | | `pipeline-state` | стенд compose, только чтение: JSON о конвейере, тот же раздел | +| `worker-memory` | только стенд с LB: память контейнера worker на двух файлах разом, тот же раздел | +| `freeze-sessions [--rounds 6] [--settle 15]` | стенд compose: сессии PostgreSQL и журнал пула после заморозки через TCP-прокси пробы, сервер не замораживается, тот же раздел | +| `freeze-lb [--rounds 3]` | свой временный проект compose, `mtusi-lab5` — код 2: `docker pause` PostgreSQL и цепочка сроков через LB, тот же раздел | | `attachment-failover [--mode stop\|kill]` | только стенд с LB: спек `attachments` «Принявшая реплика остановлена». Синтетические Алиса, Боб, Ева и чат; загрузка `tests/fixtures/sample.png` через LB — 202 и ожидание `ready` (реплика A — `X-Instance-Id` ответа), сообщение со ссылкой, `scripts/stop-one.sh` с `TARGET_INSTANCE_ID=A` и `STOP_MODE`, Боб скачивает через LB (до 30 попыток), пока не ответит другая реплика: SHA-256 совпадает, метаданные равны метаданным `ready`; Ева — 404 на метаданные и байты. В `finally` — `make replicas`, затем ожидание, пока LB снова видит все реплики `UP`. Печатает `docker compose ps` до и после и таблицу «шаг → ожидаемо → получено → реплика» без токенов. Код 1 при расхождении, без LB (порт консольного процесса драйвера) — код 2. Вывод — `evidence/attachments/failover.md` | | `attachment-storage` | только стенд с LB: спек `attachments` «Байты не в БД и не на диске API» и `data-storage` «Ограничения обработки в схеме». Две загрузки fixture через LB, 202 и ожидание `ready`; psql — колонки `attachments`, `message_attachments`, `attachment_jobs`, `attachment_variants` и `attachment_job_replays` (из `bytea` только 32-байтные `sha256` вложения и варианта), `object_key` = `<база>/attachments//original` без `filename`, `staging_key` = `<база>/staging//original` или уже пуст: готовое вложение его теряет на проходе уборщика; `weed shell fs.ls -l` — объект и три варианта в bucket, размер; анонимный GET ключа и каждого варианта с `127.0.0.1:S3_OUT_PORT` — 403; скачивание участником — тот же SHA-256; пробы в откатываемой транзакции — второе задание той же версии, второй вариант того же имени, `error_code` у не `failed`, `attachment_job_replays` с неизвестным заданием: каждая вставка отклонена (SQLSTATE и имя ограничения), после проб одна строка задания и три варианта; `docker diff` каждой реплики и worker — ни одного файла оригинала. Код 1 с названной проверкой, без LB — код 2. Вывод — `evidence/attachments/storage.md` | | `upload-consistency` | только стенд с LB: спеки `attachments` «Порядок записи» и `storage-consistency` (design change `upload-consistency`, решение 11; `async-attachments`, решения 3 и 11). Синтетические Алиса, Боб и чат; вложение R — 202 и `ready`. Шаги: (1) `docker compose pause s3` → загрузка через LB — 503 за ~5 с → `unpause` в `finally`; новая строка `pending` по psql (`id`, статус, возраст, ключ); (2) триггер «перевод в `queued` падает» (SQLSTATE 08006) на рабочей базе только для уникального `filename` прогона → загрузка 503 → строка `pending`, объекта staging уже нет (компенсация), триггер снят (`finally`, и остаток прошлого прогона — в начале); (3) метаданные, байты и сообщение со ссылкой на обе строки — 404; (4) после grace прогона 30 с — `docker compose run --rm --no-deps -e CLEANER__PENDING_GRACE_SECONDS=30 cleaner --once`, его JSON-вывод; тот же проход убирает staging R: `staging_key` пуст, объекта нет, метаданные прежние; (5) psql и `weed shell fs.tree` (файлы `original`, а не каталоги, под `attachments/` и `staging/`) — ни строк, ни объектов обеих загрузок, объектов без строки под префиксом вложений рабочей базы нет; R скачивается с тем же SHA-256. Таблица «проверка → ожидаемо → получено» без токенов и секретов; код 1 при расхождении, без LB — код 2. ~45 с. Вывод — `evidence/attachments/consistency.md` | @@ -192,7 +196,7 @@ TARGET_INSTANCE_ID= scripts/stop-one.sh # остановить python3 $D --port 8080 kill-inflight # kill реплики во время входов: 502 от LB без повтора python3 $D --port 8080 idle-conns # простаивающие соединения с репликами закрывает LB (~10 с), а не реплика (60 с) python3 $D --port 8080 hang-key # зависшая реплика держит ключ: повтор получает 201 после прерывания транзакции -make test_isolated && python3 $D --port 8080 cache-check --require-test-keys # кэш карточки: одно чтение chats на 50, TTL, ключи двух баз +make test_isolated; python3 $D --port 8080 cache-check --require-test-keys # кэш карточки: одно чтение chats на 50, TTL, ключи двух баз; `;`, а не `&&`: при первой съёмке набор красный как раз без этого файла, а ключи временной базы остаются python3 $D --port 8080 auth-storage # Argon2id в users, SHA-256 токена в sessions, ни токена, ни пароля в pg_dump python3 $D --port 8080 attachment-failover --mode kill # реплика, принявшая файл, убита: скачивание через другую, тот же SHA-256 python3 $D --port 8080 attachment-storage # байты только в приватном bucket: схема, ключ, объект, аноним 403, docker diff @@ -212,6 +216,9 @@ make bench_queue_quick # шаг защиты «для 5 — python3 $D broker-check # брокер: образ, volume, порт, предел памяти, очередь, пароль только у rabbitmq, relay, worker, остановка с кодом 0; ~30 с python3 $D --port 8080 worker-process # процесс worker: PID 1, лимиты, Pillow, журнал, неверные настройки, остановка, рестарт хранилищ, остановка под нагрузкой; ~5 мин python3 $D --port 8080 relay-process # процесс relay: то же, окружение без S3 и Valkey; ~2 мин +python3 $D --port 8080 worker-memory # два файла разом на границах контракта: memory.peak контейнера, render_peak, OOM нет; ~35 с +python3 $D --port 8080 freeze-sessions # заморозка через TCP-прокси пробы: 503 за срок плюс закрытие, сессий сверх пула нет; сервер не трогается; ~2,5 мин +python3 $D freeze-lb # docker pause PostgreSQL на временном проекте со своими данными в tmpfs: 503 через LB за ~8 с, 504 нет; ~1,5 мин python3 $D pipeline-state # JSON: задания по состояниям, due, ждут срока, опубликованы и не взяты, истёкшие аренды, очередь make replay # реестр failed, только показ; APPLY=1 ATTACHMENT= — вернуть в работу, код 3 — есть отказы docker compose logs --no-log-prefix relay | tail -3 # relay: Started relay, Relay pass, Recovered expired lease @@ -378,6 +385,49 @@ PostgreSQL и брокере; все четыре задания после эт Коды: 0, в том числе при недоступном брокере (`available: false`, ожидание до 15 с); 1 — нет PostgreSQL или конфигурации стенда, причина в stderr. `python3 $D pipeline-state | jq .due`. +**`worker-memory`** (`--port `; спек `attachment-processing`, «Изображение в лимите +пикселей»; design change `pipeline-reliability`, решение 7; ~35 с). Девять случаев: PNG из шума +10 MiB, шесть типов PNG на 40 Мпкс, RGBA и серый 16 бит на обеих границах контракта разом (файлы +— генераторы `student-tests/images.py` в контейнере образа без сети). На случай: `docker stop` +worker, две одинаковые загрузки, `docker start` (новая cgroup: `memory.peak` с нуля), оба `ready` +(до 90 с), затем `/proc/1/status`, `memory.peak`, `memory.events`, `docker inspect`, записи журнала +«Started job attempt» и «Attachment became ready». Строка таблицы на случай и таблица «проверка → +ожидаемо → получено»: все 18 `ready`, задания пересеклись во всех случаях, `oom` и `oom_kill` 0, +`OOMKilled` false, рестартов нет, наибольший `render_peak` меньше `render_memory_limit_mib`, +`memory.peak` и сумма пиков `VmHWM + 2 × render_peak` меньше лимита контейнера. `memory.peak` одного +случая плавает на сотни МиБ: зависит от совпадения пиков двух процессов. Коды: 0; 1 — расхождение; +130 — сигнал (worker и relay запускаются при любом исходе); 2 — нет стенда или есть незавершённые +задания: они добавили бы свой пик. Вывод — `evidence/worker/memory.md`. + +**`freeze-sessions [--rounds 6] [--settle 15]`** (спек `unit-of-work`; design change `unit-of-work`, +уточнения 17 и 18; порт не нужен; ~2,5 мин). Заморозка без заморозки сервера: одноразовый контейнер +`api` (`docker compose run --rm --no-deps -T --name <проект>-freeze-sessions --entrypoint python +api -`, скрипт через stdin, настройки и код образа, ключи в драйвер не попадают), приложение в его +процессе без lifespan, вызовы ASGI напрямую (httpx в образе нет), PostgreSQL только через TCP-прокси +пробы, закрытые ворота прокси — и есть заморозка. Срок `[database] request_timeout_seconds` 2 с. Режимы: +`second-block` (пул 2, ворота закрываются между блоком входа и `GET /chats`), `before-requests` +(пачка из четырёх `GET /users/me`, пул 2 и пул 4). После разморозки на раунд: сессии через прокси, +занятые соединения, четыре следующих запроса, записи логгера `sqlalchemy.pool`; в конце — занятые +соединения, снимок сессий через `--settle` с. Таблица: 503 в срок 2–4,5 с, сессии в пределах пула +сразу и после паузы, следующие запросы 200, записей пула 0, сессий брошенной проверки (запрос `;`) 0. +Контейнер удаляется при любом исходе, в базе остаётся по одному синтетическому пользователю на режим. +Коды: 0; 1 — расхождение; 130 — сигнал; 2 — PostgreSQL проекта не работает. Вывод — +`evidence/storage/freeze-sessions.md`. + +**`freeze-lb [--rounds 3]`** (та же запись verify; порт не нужен; ~1,5 мин). Только временный проект +compose: `COMPOSE_PROJECT_NAME` или `mtusi-lab5-freeze`, `mtusi-lab5` — отказ, код 2; перед `docker +pause` метка проекта контейнера сверяется ещё раз. Команда сама поднимает стенд и убирает его при любом +исходе, нужен только образ `mtusi-messenger:lab5` (`make run_docker`, иначе код 2): во временном каталоге +файл окружения из `.env.example` со случайными секретами и override — без портов PostgreSQL, Valkey и S3, +данные PostgreSQL, Valkey и S3 в tmpfs (volumes нет), `config_example.toml`, порт LB свободный. `up -d +--no-build haproxy`, ожидание двух реплик через LB, прогрев пула, синтетические пользователи и чат. На +заморозку: сессии `pg_stat_activity`, `docker pause` PostgreSQL, шесть одновременных запросов (`GET +/users/me`, история, `POST` сообщения, `GET /chats`, вход, метаданные вложения), `unpause` в `finally`, +время до первого 200, через 11 с — снова сессии. Таблица: все ответы 503 `unavailable`, 504 от LB нет, +каждый раньше `timeout server` 10 с, восстановление, сессий не больше пулов (20) и не растёт, сессий `;` +нет, контейнеров и volumes проекта после `down` 0. Коды: 0; 1 — расхождение; 130 — сигнал; 2 — рабочий +проект или нет образа. Вывод — раздел `evidence/storage/freeze-sessions.md`. + Gotchas: - **Сигнал во время `defense-scenario`, `defense-faults`, `worker-process`, `relay-process`.** diff --git a/.claude/skills/run-mtusi-messenger/driver.py b/.claude/skills/run-mtusi-messenger/driver.py index c95803a7..76a0fc78 100644 --- a/.claude/skills/run-mtusi-messenger/driver.py +++ b/.claude/skills/run-mtusi-messenger/driver.py @@ -152,6 +152,24 @@ значения по умолчанию, остановка простаивающего и на старте, «Worker переживает рестарт хранилищ»; worker и relay запущены при любом исходе; код 1 при расхождении, 130 по сигналу, 2 — нет стенда + worker-memory только стенд с LB: память контейнера worker, два одинаковых + файла разом в девяти случаях на границах контракта; worker остановлен, + загрузки, запуск (новая cgroup), ready, затем VmHWM, memory.peak, + memory.events, журнал; worker и relay запущены при любом исходе; + код 1 при расхождении, 130 по сигналу, 2 — нет стенда или есть + незавершённые задания + freeze-sessions [--rounds 6] [--settle 15] стенд compose: сессии + PostgreSQL и журнал пула после заморозки; приложение в процессе + одноразового контейнера api, PostgreSQL через TCP-прокси пробы, + заморожен прокси, сервер не трогается; режимы — заморозка между + блоками, заморозка до запросов при пуле 2 и 4; код 1 при + расхождении, 130 по сигналу, 2 — нет PostgreSQL + freeze-lb [--rounds 3] только временный проект compose (по умолчанию + mtusi-lab5-freeze, mtusi-lab5 — код 2; стенд поднимает и удаляет + сама, данные в tmpfs, volumes нет): docker pause PostgreSQL, шесть + одновременных запросов через LB, 503 раньше timeout server, unpause в + finally, время до первого 200, сессии до и после каждой заморозки; + код 1 при расхождении, 130 по сигналу reconcile-cycle только стенд с LB: спек storage-consistency, сверка bucket и БД — исходный dry-run без расхождений (иначе код 2), расхождения с обеих сторон (объект мимо API и чужой ключ — @@ -236,11 +254,13 @@ import json import os import re import secrets +import shutil import signal import socket import struct import subprocess import sys +import tempfile import threading import time import urllib.error @@ -8197,6 +8217,1216 @@ def df_replay_ready(run: FaultRun) -> None: run.result("replay ready", after, "refused, exit 3") +# worker-memory: память контейнера worker на двух файлах разом (спек +# attachment-processing, «Изображение в лимите пикселей»; design change +# pipeline-reliability, решение 7). Файлы — генераторами тестов в контейнере +# образа: images.py не идёт на python3 3.9 +WM_IMAGE_PY = r""" +import random +import sys +import zlib + +sys.path.insert(0, "/tmp") +import images + +limit = images.png_at_pixel_limit + + +def both_limits(color, depth): + # 40 Мпкс и почти 10 MiB файла: начало строк — шум, остальное — нули + row_bytes = 8000 * {0: 1, 6: 4}[color] * depth // 8 + compressor = zlib.compressobj(9) + rnd = random.Random(5) + noisy = 10_200_000 // row_bytes + parts = [] + for index in range(5000): + body = rnd.randbytes(row_bytes) if index < noisy else bytes(row_bytes) + parts.append(compressor.compress(b"\x00" + body)) + parts.append(compressor.flush()) + return images.png(8000, 5000, color=color, depth=depth, idat=b"".join(parts)) + + +CASES = { + "noise": lambda: images.png_noise(1868, 1868, seed=1), + "rgba": lambda: limit(6, 8), + "gray-alpha": lambda: limit(4, 8), + "rgb-trns": lambda: limit(2, 8, transparent=True), + "rgb16-trns": lambda: limit(2, 16, transparent=True), + "palette-trns": lambda: limit(3, 8, transparent=True), + "gray16": lambda: limit(0, 16), + "rgba-both": lambda: both_limits(6, 8), + "gray16-both": lambda: both_limits(0, 16), +} +sys.stdout.buffer.write(CASES[sys.argv[1]]()) +""" +WM_CASES = ( + ("noise", "PNG noise 10 MiB, 1868 x 1868"), + ("rgba", "PNG RGBA 8 bit, 40 Mpx"), + ("gray-alpha", "PNG gray with alpha 8 bit, 40 Mpx"), + ("rgb-trns", "PNG RGB 8 bit with tRNS, 40 Mpx"), + ("rgb16-trns", "PNG RGB 16 bit with tRNS, 40 Mpx"), + ("palette-trns", "PNG palette with tRNS, 40 Mpx"), + ("gray16", "PNG gray 16 bit, 40 Mpx"), + ("rgba-both", "PNG RGBA 8 bit, 40 Mpx and ~10 MiB"), + ("gray16-both", "PNG gray 16 bit, 40 Mpx and ~10 MiB"), +) +WM_MAX_BYTES = 10 * 1024 * 1024 +WM_READY_WAIT_S = 90 +WM_UNFINISHED_SQL = ( + "SELECT count(*) FROM attachment_jobs " + "WHERE state IN ('queued', 'processing');" +) +WM_READY_EVENT = "Attachment became ready" +WM_STARTED_EVENT = "Started job attempt" +MIB = 1024 * 1024 + + +def wm_image(image: str, case: str) -> bytes | None: + """Файл случая генераторами тестов: контейнер образа без сети.""" + 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", + WM_IMAGE_PY, + case, + ], + capture_output=True, + check=False, + ) + return proc.stdout if proc.returncode == 0 and proc.stdout else None + + +def wm_read(container: str, path: str) -> str: + """Файл внутри контейнера worker; контейнера нет — пусто.""" + return detached("docker", "exec", container, "cat", path)[1] + + +def wm_status_mib(status: str, field: str) -> int: + """Поле `/proc/1/status` в МиБ; нет — -1.""" + for line in status.splitlines(): + if line.startswith(field): + return int(line.split()[1]) // 1024 + return -1 + + +def wm_case( + port: int, + container: str, + token: str, + chat_id: str, + data: bytes, +) -> dict[str, object]: + """Worker остановлен, два одинаковых файла, запуск (новая cgroup: + `memory.peak` с нуля), оба готовы, затем счётчики и журнал.""" + detached("docker", "stop", container) + ids = [] + for _ in range(2): + status, _, payload = upload_bytes( + port, + token, + chat_id, + data, + content_type="image/png", + filename="worker-memory.png", + ) + if status == ATTACHMENT_ACCEPTED and isinstance(payload, dict): + ids.append(str(payload["id"])) + else: + print(f" upload: {status}", flush=True) + since = detached( + "docker", + "inspect", + "-f", + "{{.State.StartedAt}}", + container, + )[1].strip() + detached("docker", "start", container) + statuses = [ + str( + wait_attachment( + port, + token, + item, + timeout=WM_READY_WAIT_S, + ).get("status"), + ) + for item in ids + ] + status_file = wm_read(container, "/proc/1/status") + peak = wm_read(container, "/sys/fs/cgroup/memory.peak").strip() + events = dict( + line.split() + for line in wm_read( + container, + "/sys/fs/cgroup/memory.events", + ).splitlines() + if len(line.split()) == 2 + ) + state = detached( + "docker", + "inspect", + "-f", + "{{.State.OOMKilled}} {{.RestartCount}}", + container, + )[1].split() + records = json_records( + detached("docker", "logs", "--since", since, container)[1], + ) + ours = [item for item in records if item.get("attachment_id") in ids] + begins = sorted( + str(item["timestamp"]) + for item in ours + if item.get("event") == WM_STARTED_EVENT + ) + ready = [item for item in ours if item.get("event") == WM_READY_EVENT] + ends = sorted(str(item["timestamp"]) for item in ready) + return { + "statuses": statuses, + "peaks": [int(str(item["render_peak_kib"])) // 1024 for item in ready], + "render_ms": [str(item["render_ms"]) for item in ready], + "overlap": len(begins) == 2 and len(ends) == 2 and begins[1] < ends[0], + "hwm": wm_status_mib(status_file, "VmHWM"), + "rss": wm_status_mib(status_file, "VmRSS"), + "peak": int(peak) // MIB if peak.isdigit() else -1, + "oom": int(events.get("oom", -1)), + "oom_kill": int(events.get("oom_kill", -1)), + "oom_killed": state[0] if state else "-", + "restarts": state[1] if len(state) > 1 else "-", + } + + +def cmd_worker_memory(port: int) -> int: + """Память контейнера worker на файлах в пределах контракта. Worker и relay + запускаются при любом исходе; пользователи и файлы синтетические.""" + if not stand_answers(port, "worker-memory"): + return 2 + return run_guarded(lambda _guard: worker_memory(port)) + + +def worker_memory(port: int) -> int: + """Тело `cmd_worker_memory`.""" + config = json.loads(compose("config", "--format", "json")) + image = str(config["services"]["worker"]["image"]) + containers = service_containers("worker") + if not containers: + print("FAIL: service worker is not running, make run_docker first") + return 2 + name = str(containers[0]["Name"]).lstrip("/") + limit_mib = int(containers[0]["HostConfig"]["Memory"]) // MIB + unfinished = int(stand_psql(WM_UNFINISHED_SQL).strip() or 0) + if unfinished: + print( + f"worker-memory: {unfinished} unfinished jobs on the stand would " + "add to the peak, wait until they finish", + ) + return 2 + started = [ + item + for item in json_records(detached("docker", "logs", name)[1]) + if item.get("event") == "Started worker" + ] + render_limit = int(str(started[-1]["render_memory_limit_mib"])) + concurrency = started[-1].get("concurrency") + print( + f"worker {name}: limit {limit_mib} MiB, concurrency {concurrency}, " + f"render_memory_limit_mib {render_limit}", + ) + people = attachment_people(port, "wm") + if people is None: + return 1 + _, tokens, chat_id = people + print( + "case | file MiB | render_peak MiB | render_ms | overlap | VmHWM | " + "VmRSS | memory.peak | oom / oom_kill | OOMKilled | restarts", + flush=True, + ) + results = [] + sizes_ok = True + for case, title in WM_CASES: + data = wm_image(image, case) + if data is None or len(data) > WM_MAX_BYTES: + print(f"{title}: FAIL image generator", flush=True) + sizes_ok = False + continue + item = wm_case(port, name, tokens["alice"], chat_id, data) + results.append(item) + print( + " | ".join( + ( + title, + f"{len(data) / MIB:.2f}", + "/".join(str(value) for value in item["peaks"]), + "/".join(item["render_ms"]), + yes(bool(item["overlap"])), + str(item["hwm"]), + str(item["rss"]), + str(item["peak"]), + f"{item['oom']} / {item['oom_kill']}", + str(item["oom_killed"]), + str(item["restarts"]), + ), + ), + flush=True, + ) + render_peaks = [value for item in results for value in item["peaks"]] + max_render = max(render_peaks, default=-1) + max_hwm = max((item["hwm"] for item in results), default=-1) + max_peak = max((item["peak"] for item in results), default=-1) + bound = max_hwm + 2 * max_render + print( + f"largest render_peak {max_render} MiB, largest memory.peak " + f"{max_peak} MiB, sum of peaks {max_hwm} + 2 x {max_render} = " + f"{bound} MiB", + ) + total = 2 * len(WM_CASES) + rows = [ + ("every generated file within the contract", "yes", yes(sizes_ok)), + ( + "attachments ready", + str(total), + str( + sum( + status == "ready" + for item in results + for status in item["statuses"] + ), + ), + ), + ( + "cases with both jobs at once", + str(len(WM_CASES)), + str(sum(bool(item["overlap"]) for item in results)), + ), + ( + "render_peak records", + str(total), + str(len(render_peaks)), + ), + ( + "oom + oom_kill in all cases", + "0", + str(sum(item["oom"] + item["oom_kill"] for item in results)), + ), + ( + "OOMKilled in any case", + "no", + yes(any(item["oom_killed"] != "false" for item in results)), + ), + ( + "restarts in any case", + "no", + yes(any(item["restarts"] != "0" for item in results)), + ), + ( + f"render_peak below {render_limit} MiB", + "yes", + yes(0 <= max_render < render_limit), + ), + ( + f"memory.peak below {limit_mib} MiB", + "yes", + yes(0 <= max_peak < limit_mib), + ), + ( + f"sum of peaks below {limit_mib} MiB", + "yes", + yes(0 <= bound < limit_mib), + ), + ] + return report_reconcile( + rows, + passed="two files at once at the contract limits fit the worker " + "container", + ) + + +# freeze-sessions: сессии PostgreSQL и журнал пула после заморозки (change +# unit-of-work, замечания verify C1 и W1: design, уточнения 17 и 18). +# Приложение в процессе одноразового контейнера api, PostgreSQL только через +# TCP-прокси пробы: заморожен прокси, а не сервер. Клиент ASGI свой: httpx в +# образе нет +FS_PROBE_PY = r""" +import asyncio +import base64 +import gc +import json +import logging +import os +import sys +import time +import uuid + +POOL, REQUESTS, ROUNDS = (int(item) for item in sys.argv[1:4]) +SETTLE, SECOND_BLOCK = float(sys.argv[4]), sys.argv[5] == "second-block" +os.environ.update( + { + "APP__LOG_LEVEL": "ERROR", + "DATABASE__POOL_SIZE": str(POOL), + "DATABASE__MAX_OVERFLOW": "0", + "DATABASE__POOL_TIMEOUT_SECONDS": "1", + "DATABASE__REQUEST_TIMEOUT_SECONDS": "2", + "AUTH__KDF_CONCURRENCY": "1", + }, +) + +import asyncpg + +from src.api import dependencies +from src.config import settings +from src.core.services import ChatService +from src.infra.db import create_engine, create_session_factory +from src.main import app + + +class Proxy: + def __init__(self, host, port): + self.target = (host, port) + self.gate = asyncio.Event() + self.gate.set() + self.writers = set() + self.tasks = set() + self.server = None + self.port = 0 + + async def start(self): + self.server = await asyncio.start_server(self.handle, "127.0.0.1", 0) + self.port = self.server.sockets[0].getsockname()[1] + + async def handle(self, reader, writer): + up_reader, up_writer = await asyncio.open_connection(*self.target) + self.writers.update({writer, up_writer}) + for pair in ((reader, up_writer), (up_reader, writer)): + task = asyncio.ensure_future(self.pump(*pair)) + self.tasks.add(task) + task.add_done_callback(self.tasks.discard) + + async def pump(self, reader, writer): + try: + while data := await reader.read(65536): + await self.gate.wait() + writer.write(data) + await writer.drain() + except (ConnectionError, OSError): + pass + finally: + writer.transport.abort() + + def close(self): + self.gate.set() + for writer in list(self.writers): + writer.transport.abort() + self.server.close() + + +class Records(logging.Handler): + def __init__(self): + super().__init__(level=logging.WARNING) + self.seen = [] + + def emit(self, record): + self.seen.append(record.getMessage()[:40]) + + +async def request(method, path, *, headers=(), body=None): + raw = b"" if body is None else json.dumps(body).encode() + pairs = [(b"host", b"probe")] + pairs += [(k.lower().encode(), v.encode()) for k, v in headers] + if body is not None: + pairs.append((b"content-type", b"application/json")) + pairs.append((b"content-length", str(len(raw)).encode())) + scope = { + "type": "http", + "asgi": {"version": "3.0"}, + "http_version": "1.1", + "method": method, + "scheme": "http", + "path": path, + "raw_path": path.encode(), + "query_string": b"", + "root_path": "", + "headers": pairs, + "client": ("127.0.0.1", 1), + "server": ("probe", 80), + } + answer = {"status": 500, "body": b""} + finished = asyncio.Event() + delivered = False + + async def receive(): + nonlocal delivered + if delivered: + await finished.wait() + return {"type": "http.disconnect"} + delivered = True + return {"type": "http.request", "body": raw, "more_body": False} + + async def send(message): + if message["type"] == "http.response.start": + answer["status"] = message["status"] + elif message["type"] == "http.response.body": + answer["body"] += message.get("body", b"") + if not message.get("more_body"): + finished.set() + + try: + await app(scope, receive, send) + except Exception: # noqa: BLE001 — ответ 500 уже отправлен обработчиком + pass + finally: + finished.set() + return answer + + +async def main(): + admin = await asyncpg.connect( + host=settings.database.host, + port=settings.database.port, + user=settings.database.user, + password=settings.database.password.get_secret_value(), + database="postgres", + ) + proxy = Proxy(settings.database.host, settings.database.port) + await proxy.start() + engine = create_engine( + settings.database.model_copy( + update={"host": "127.0.0.1", "port": proxy.port}, + ), + ) + dependencies.session_factory = create_session_factory(engine) + records = Records() + logging.getLogger("sqlalchemy.pool").addHandler(records) + username = f"u{uuid.uuid4().hex[:12]}" + password = f"Pw-{uuid.uuid4().hex}" + made = await request( + "POST", + "/api/v1/users", + body={"username": username, "display_name": "U", "password": password}, + ) + assert made["status"] == 201, made["status"] + pair = base64.b64encode(f"{username}:{password}".encode()).decode() + login = await request( + "POST", + "/api/v1/auth/sessions", + headers=[("Authorization", f"Basic {pair}")], + ) + assert login["status"] == 201, login["status"] + token = json.loads(login["body"])["token"] + auth = [("Authorization", f"Bearer {token}")] + + async def me(): + return await request("GET", "/api/v1/users/me", headers=auth) + + rounds = [] + for number in range(ROUNDS): + # прогрев: соединения пула открыты + await asyncio.gather(*(me() for _ in range(REQUESTS))) + before = len(records.seen) + started = time.monotonic() + if SECOND_BLOCK: + # заморозка между входом и операцией: зазор таймеров — настоящая + # длительность блока входа, без искусственной паузы + original = ChatService.list_user_chats + + async def frozen_list(self, **kwargs): + proxy.gate.clear() + return await original(self, **kwargs) + + ChatService.list_user_chats = frozen_list + frozen = await request("GET", "/api/v1/chats", headers=auth) + ChatService.list_user_chats = original + else: + # одновременные запросы ждут на проверке соединения + proxy.gate.clear() + answers = await asyncio.gather( + *(me() for _ in range(REQUESTS)), + ) + frozen = answers[0] + elapsed = time.monotonic() - started + proxy.gate.set() + await asyncio.sleep(0.5) + sessions = await admin.fetchval( + "SELECT count(*) FROM pg_stat_activity " + "WHERE client_addr = inet_client_addr() " + "AND pid <> pg_backend_pid()", + ) + held_right_after = engine.pool.checkedout() + following = [(await me())["status"] for _ in range(4)] + item = { + "status": frozen["status"], + "elapsed": round(elapsed, 2), + "sessions": sessions, + "held_right_after": held_right_after, + "following": following, + "held": engine.pool.checkedout(), + "records": records.seen[before:], + } + rounds.append(item) + print( + f"round {number}: frozen {item['status']} {elapsed:.2f}s; " + f"server sessions via proxy {sessions}; " + f"held right after {held_right_after}; " + f"next requests {following}; held {item['held']}; " + f"pool records {item['records']}", + flush=True, + ) + held = engine.pool.checkedout() + gc.collect() + collected = engine.pool.checkedout() + print(f"end: held {held}, after gc.collect {collected}", flush=True) + await asyncio.sleep(SETTLE) + rows = await admin.fetch( + "SELECT state, left(query, 12) AS query, count(*) " + "FROM pg_stat_activity WHERE client_addr = inet_client_addr() " + "AND pid <> pg_backend_pid() GROUP BY 1, 2 ORDER BY 3 DESC", + ) + settled = [[row["state"], row["query"], row["count"]] for row in rows] + print(f"sessions after {SETTLE:g} s: {settled}", flush=True) + print( + "RESULT " + + json.dumps( + { + "rounds": rounds, + "held": held, + "collected": collected, + "settled": settled, + }, + ), + flush=True, + ) + await engine.dispose() + proxy.close() + await admin.close() + + +asyncio.run(main()) +""" +# пул, одновременных запросов, режим; срок блока пробы — 2 с +FS_MODES = ( + (2, 1, "second-block"), + (2, 4, "before-requests"), + (4, 4, "before-requests"), +) +FS_DEADLINE_S = 2.0 +# срок + закрытие соединения (DB_CLOSE_TIMEOUT_SECONDS 2 с) + запас +FS_ANSWER_LIMIT_S = 4.5 +FS_RESULT_PREFIX = "RESULT " + + +def fs_run( + project: str, + pool: int, + requests: int, + mode: str, + *, + rounds: int, + settle: float, +) -> dict[str, object] | None: + """Проба одного режима: одноразовый контейнер `api`, скрипт через stdin. + Вывод — без записей журнала; контейнер удаляется при любом исходе.""" + name = f"{project}-freeze-sessions" + subprocess.run(["docker", "rm", "-f", name], capture_output=True) + try: + proc = subprocess.run( + [ + "docker", + "compose", + "run", + "--rm", + "--no-deps", + "-T", + "--name", + name, + "--entrypoint", + "python", + "api", + "-", + str(pool), + str(requests), + str(rounds), + str(settle), + mode, + ], + cwd=ROOT, + input=FS_PROBE_PY, + capture_output=True, + text=True, + check=False, + timeout=rounds * 15 + settle + 120, + ) + finally: + subprocess.run(["docker", "rm", "-f", name], capture_output=True) + result = None + for line in proc.stdout.splitlines(): + if line.startswith(FS_RESULT_PREFIX): + result = json.loads(line[len(FS_RESULT_PREFIX) :]) + elif not line.startswith("{"): + print(line, flush=True) + if proc.returncode != 0 or result is None: + print(f"FAIL: probe exit code {proc.returncode}") + print(proc.stderr[-1500:]) + return None + return result + + +def fs_rows( + title: str, + pool: int, + result: dict[str, object], +) -> list[tuple[str, str, str]]: + """Строки таблицы одного режима.""" + rounds = result["rounds"] + settled = result["settled"] + count = str(len(rounds)) + return [ + ( + f"{title}: frozen answers 503", + count, + str(sum(item["status"] == 503 for item in rounds)), + ), + ( + f"{title}: answer in {FS_DEADLINE_S:g}-{FS_ANSWER_LIMIT_S:g} s", + count, + str( + sum( + FS_DEADLINE_S <= item["elapsed"] <= FS_ANSWER_LIMIT_S + for item in rounds + ), + ), + ), + ( + f"{title}: sessions right after thaw within the pool", + count, + str(sum(item["sessions"] <= pool for item in rounds)), + ), + ( + f"{title}: next requests all 200", + count, + str( + sum( + item["following"] == [200, 200, 200, 200] + for item in rounds + ), + ), + ), + ( + f"{title}: pool records", + "0", + str(sum(len(item["records"]) for item in rounds)), + ), + ( + f"{title}: held connections at the end", + "0", + str(result["held"]), + ), + ( + f"{title}: sessions after the pause within the pool", + "yes", + yes(sum(row[2] for row in settled) <= pool), + ), + ( + f"{title}: sessions of an abandoned ping (query ';')", + "0", + str(sum(row[2] for row in settled if row[1].strip() == ";")), + ), + ] + + +def cmd_freeze_sessions(*, rounds: int, settle: float) -> int: + """Сервера не замораживает: только свой TCP-прокси в процессе пробы. В + базе остаётся один синтетический пользователь на режим. Токенов и паролей + в выводе нет.""" + + def guarded() -> int: + try: + return freeze_sessions(rounds=rounds, settle=settle) + except KeyboardInterrupt as e: + print(f"FAIL: interrupted by {str(e) or 'SIGINT'}", flush=True) + return INTERRUPTED_EXIT + except (RuntimeError, subprocess.TimeoutExpired) as e: + print(f"FAIL: {e}", flush=True) + return 1 + + return rc_signals(guarded) + + +def freeze_sessions(*, rounds: int, settle: float) -> int: + """Тело `cmd_freeze_sessions`.""" + config = json.loads(compose("config", "--format", "json")) + project = str(config["name"]) + if not compose("ps", "-q", "--status", "running", "postgres").strip(): + print(f"FAIL: postgres of project {project} is not running") + return 2 + rows: list[tuple[str, str, str]] = [] + for pool, requests, mode in FS_MODES: + title = f"{mode}, pool {pool}, {requests} request(s)" + print(f"== {title}", flush=True) + result = fs_run( + project, + pool, + requests, + mode, + rounds=rounds, + settle=settle, + ) + if result is None: + rows.append((f"{title}: probe finished", "yes", "no")) + continue + rows.extend(fs_rows(title, pool, result)) + return report_reconcile( + rows, + passed="after a frozen database: no sessions over the pool, no pool " + "records, the next requests work", + ) + + +# freeze-lb: цепочка сроков через LB при замороженном PostgreSQL. docker pause +# — только на своём временном стенде: контейнеры сервисов, нужных пробе, +# данные в tmpfs (volumes нет), файл окружения со случайными значениями во +# временном каталоге, config_example.toml вместо config.toml, порт LB свободный +FL_DEFAULT_PROJECT = "mtusi-lab5-freeze" +FL_OVERRIDE = """\ +services: + postgres: + restart: "no" + ports: !reset [] + volumes: !reset [] + tmpfs: + - /var/lib/postgresql + valkey: + restart: "no" + ports: !reset [] + tmpfs: + - /data + s3: + restart: "no" + ports: !reset [] + volumes: !reset [] + tmpfs: + - /data + migrate: + volumes: !override + - type: bind + source: ./config_example.toml + target: /app/config.toml + read_only: true + api: + restart: "no" + volumes: !override + - type: bind + source: ./config_example.toml + target: /app/config.toml + read_only: true + haproxy: + restart: "no" +""" +# пусто в .env.example → длина случайного значения в байтах, как make env_setup +FL_SECRET_BYTES = { + "S3_ROOT_ACCESS_KEY": 10, + "S3_ROOT_SECRET_KEY": 20, + "S3_JWT_SIGNING_KEY": 32, + "S3_API_ACCESS_KEY": 10, + "S3_API_SECRET_KEY": 20, + "S3_CLEANER_ACCESS_KEY": 10, + "S3_CLEANER_SECRET_KEY": 20, + "S3_WORKER_ACCESS_KEY": 10, + "S3_WORKER_SECRET_KEY": 20, +} +FL_SESSIONS_SQL = ( + "SELECT state, left(query, 12), count(*) FROM pg_stat_activity " + "WHERE backend_type = 'client backend' AND pid <> pg_backend_pid() " + "GROUP BY 1, 2 ORDER BY 3 DESC;" +) +FL_POOL_TOTAL = 20 +FL_WARM_THREADS = 40 +FL_REQUEST_TIMEOUT_S = 25 +FL_SERVER_TIMEOUT_S = 10 +FL_RECOVERY_LIMIT_S = 30 +FL_SETTLE_S = 11 +FL_REPLICAS = 2 +FL_STAND_WAIT_S = 120 + + +def fl_write_stand(directory: Path, lb_port: int) -> tuple[Path, Path]: + """Файл окружения из `.env.example`: пустые секреты — случайные. `.env` + рабочего стенда не читается. Значения не печатаются.""" + lines = [] + for line in (ROOT / ".env.example").read_text("utf-8").splitlines(): + name, sep, value = line.partition("=") + if sep and not value and not line.startswith("#"): + value = secrets.token_hex(FL_SECRET_BYTES.get(name, 16)) + if name == "APP_OUT_PORT": + value = str(lb_port) + lines.append(f"{name}={value}" if sep else line) + env_file = directory / "stand.env" + env_file.touch(mode=0o600) + env_file.write_text("\n".join(lines) + "\n", "utf-8") + override = directory / "override.compose.yml" + override.write_text(FL_OVERRIDE, "utf-8") + return env_file, override + + +def fl_wait_replicas(port: int) -> int: + """Сколько разных реплик отвечает через LB, пока их не станет две.""" + deadline = time.monotonic() + FL_STAND_WAIT_S + seen: set[str] = set() + while time.monotonic() < deadline and len(seen) < FL_REPLICAS: + with contextlib.suppress(OSError, http.client.HTTPException): + status, hdrs, _ = call(port, "GET", "/health/ready") + if status == 200 and hdrs.get("x-instance-id"): + seen.add(hdrs["x-instance-id"]) + time.sleep(0.25) + return len(seen) + + +def fl_sessions() -> str: + return stand_psql(FL_SESSIONS_SQL).strip() + + +def fl_session_counts(text: str) -> tuple[int, int]: + """Всего сессий и сессий брошенной проверки (`;`) из вывода psql.""" + total = abandoned = 0 + for line in text.splitlines(): + parts = line.split("|") + if len(parts) == 3: + total += int(parts[2]) + abandoned += int(parts[2]) if parts[1].strip() == ";" else 0 + return total, abandoned + + +def fl_request_set( + token: str, + chat_id: str, + basic_value: str, +) -> dict[str, tuple[str, str, dict[str, str], object]]: + """Шесть запросов пробы: JSON-ручки и метаданные вложения.""" + bearer = {"token": token} + messages = f"{CHATS}/{chat_id}/messages" + return { + "GET /users/me": ("GET", f"{USERS}/me", bearer, None), + "GET messages": ("GET", messages, bearer, None), + "POST message": ("POST", messages, bearer, {"text": "freeze"}), + "GET /chats": ("GET", CHATS, bearer, None), + "POST login": ("POST", SESSIONS, {"authorization": basic_value}, None), + "GET attachment meta": ( + "GET", + f"{ATTACHMENTS}/{uuid.uuid4()}", + bearer, + None, + ), + } + + +def fl_call( + port: int, + spec: tuple[str, str, dict[str, str], object], +) -> tuple[object, float, str]: + """Статус, время и код ошибки; сбой клиента — вместо статуса его имя.""" + method, path, auth, body = spec + started = time.monotonic() + extra = key_header() if path.endswith("/messages") and body else None + try: + status, _, payload = call( + port, + method, + path, + body=body, + extra=extra, + timeout=FL_REQUEST_TIMEOUT_S, + **auth, + ) + except (OSError, http.client.HTTPException) as e: + return type(e).__name__, time.monotonic() - started, "-" + error = payload.get("error", {}) if isinstance(payload, dict) else {} + code = error.get("code", "-") if isinstance(error, dict) else "-" + return status, time.monotonic() - started, str(code) + + +def fl_freeze( + port: int, + postgres: str, + requests: dict[str, tuple[str, str, dict[str, str], object]], + token: str, +) -> tuple[dict[str, tuple[object, float, str]], float]: + """Заморозка на время шести запросов; разморозка при любом исходе. + Итог: ответы и время до первого 200 после разморозки.""" + results: dict[str, tuple[object, float, str]] = {} + + def one(label: str, spec: tuple[str, str, dict[str, str], object]) -> None: + results[label] = fl_call(port, spec) + + subprocess.run( + ["docker", "pause", postgres], + check=True, + capture_output=True, + ) + try: + # daemon: сигнал не ждёт запросы в полёте + threads = [ + threading.Thread(target=one, args=(label, spec), daemon=True) + for label, spec in requests.items() + ] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + finally: + with signals_ignored(): + subprocess.run( + ["docker", "unpause", postgres], + capture_output=True, + check=False, + ) + for label, (status, took, code) in sorted( + results.items(), + key=lambda item: item[1][1], + ): + print(f"{label:<22} {status} {took:.2f}s error={code}", flush=True) + started = time.monotonic() + recovered = -1.0 + while time.monotonic() - started < FL_RECOVERY_LIMIT_S: + status, _, _ = fl_call( + port, + ("GET", f"{USERS}/me", {"token": token}, None), + ) + if status == 200: + recovered = time.monotonic() - started + break + time.sleep(0.2) + print(f"recovered after unpause: {recovered:.2f}s", flush=True) + return results, recovered + + +def cmd_freeze_lb(*, rounds: int) -> int: + """Цепочка сроков через LB при замороженном PostgreSQL на своём временном + проекте compose; рабочий `mtusi-lab5` — код 2. Стенд поднимается и + удаляется командой (без удаления volumes: их нет, данные в tmpfs), S3 и + Valkey — как зависимости реплик; брокера и worker проба не требует.""" + project = os.environ.get("COMPOSE_PROJECT_NAME") or FL_DEFAULT_PROJECT + if project == RS_WORKING_PROJECT: + print( + "freeze-lb pauses PostgreSQL: run it on a temporary project " + f"(COMPOSE_PROJECT_NAME), not {RS_WORKING_PROJECT}", + ) + return 2 + + def guarded() -> int: + directory = Path(tempfile.mkdtemp(prefix="mtusi-freeze-lb-")) + try: + return freeze_lb(project, directory, rounds=rounds) + except KeyboardInterrupt as e: + print(f"FAIL: interrupted by {str(e) or 'SIGINT'}", flush=True) + return INTERRUPTED_EXIT + except ( + RuntimeError, + OSError, + ValueError, + http.client.HTTPException, + subprocess.SubprocessError, + ) as e: + print(f"FAIL: {type(e).__name__}: {e}", flush=True) + return 1 + finally: + shutil.rmtree(directory, ignore_errors=True) + + return rc_signals(guarded) + + +def freeze_lb(project: str, directory: Path, *, rounds: int) -> int: + """Тело `cmd_freeze_lb`. Окружение процесса выбирает проект: команды + compose драйвера идут на него, перед заморозкой проект сверяется ещё раз.""" + if subprocess.run( + ["docker", "image", "inspect", "mtusi-messenger:lab5"], + capture_output=True, + check=False, + ).returncode: + print( + "freeze-lb: no image mtusi-messenger:lab5, make run_docker first", + ) + return 2 + lb_port = lbto_free_port() + env_file, override = fl_write_stand(directory, lb_port) + os.environ["COMPOSE_PROJECT_NAME"] = project + os.environ["COMPOSE_FILE"] = f"{ROOT / 'docker-compose.yml'}:{override}" + os.environ["COMPOSE_ENV_FILES"] = str(env_file) + if json.loads(compose("config", "--format", "json"))["name"] != project: + print(f"FAIL: compose config is not of project {project}") + return 2 + rows: list[tuple[str, str, str]] = [] + try: + print( + f"project {project}: up, LB on 127.0.0.1 port {lb_port}", + flush=True, + ) + compose( + "up", + "-d", + "--no-build", + "haproxy", + timeout=FL_STAND_WAIT_S * 2, + ) + replicas = fl_wait_replicas(lb_port) + if replicas < FL_REPLICAS: + print(f"FAIL: {replicas} replicas answered through LB") + rows.append( + ("replicas behind LB", str(FL_REPLICAS), str(replicas)), + ) + else: + rows.extend(freeze_lb_rounds(project, lb_port, rounds=rounds)) + finally: + with signals_ignored(): + print(f"project {project}: down (no volumes)", flush=True) + detached( + "docker", + "compose", + "down", + "--timeout", + "3", + "--remove-orphans", + ) + label = f"label=com.docker.compose.project={project}" + left_containers = subprocess.run( + ["docker", "ps", "-aq", "--filter", label], + capture_output=True, + text=True, + check=False, + ).stdout.split() + left_volumes = subprocess.run( + ["docker", "volume", "ls", "-q", "--filter", label], + capture_output=True, + text=True, + check=False, + ).stdout.split() + rows.append( + ("containers of the project left", "0", str(len(left_containers))), + ) + rows.append(("volumes of the project left", "0", str(len(left_volumes)))) + return report_reconcile( + rows, + passed="frozen PostgreSQL: 503 from the replicas before timeout server " + "of LB, no sessions over the pool", + ) + + +def freeze_lb_rounds( + project: str, + port: int, + *, + rounds: int, +) -> list[tuple[str, str, str]]: + """Прогрев пула и заморозки подряд: сессии до и после каждой.""" + people = attachment_people(port, "fl") + if people is None: + return [("synthetic users", "yes", "no")] + _, tokens, chat_id = people + password = f"Pw-{uuid.uuid4().hex}" + made = synthetic_user(port, "fllogin", password) + if made is None: + return [("synthetic users", "yes", "no")] + basic_value = basic(str(made[0]["username"]), password) + postgres = compose("ps", "-q", "--status", "running", "postgres").strip() + owner = subprocess.run( + [ + "docker", + "inspect", + "-f", + '{{index .Config.Labels "com.docker.compose.project"}}', + postgres, + ], + capture_output=True, + text=True, + check=True, + ).stdout.strip() + if owner != project or owner == RS_WORKING_PROJECT: + return [("container to pause belongs to", project, owner)] + + def warm() -> None: + for _ in range(3): + with contextlib.suppress(OSError, http.client.HTTPException): + call(port, "GET", f"{USERS}/me", token=tokens["alice"]) + + for _ in range(3): + threads = [ + threading.Thread(target=warm, daemon=True) + for _ in range(FL_WARM_THREADS) + ] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + time.sleep(FL_SETTLE_S) + before = fl_sessions() + print(f"--- before\n{before}", flush=True) + answers: list[tuple[object, float, str]] = [] + recoveries: list[float] = [] + totals: list[int] = [] + abandoned = 0 + for number in range(1, rounds + 1): + print(f"=== freeze {number}", flush=True) + results, recovered = fl_freeze( + port, + postgres, + fl_request_set(tokens["alice"], chat_id, basic_value), + tokens["alice"], + ) + answers.extend(results.values()) + recoveries.append(recovered) + time.sleep(FL_SETTLE_S) + after = fl_sessions() + print( + f"--- after freeze {number} (+{FL_SETTLE_S} s)\n{after}", + flush=True, + ) + total, left = fl_session_counts(after) + totals.append(total) + abandoned += left + expected = str(rounds * 6) + return [ + ( + "answers 503 unavailable", + expected, + str( + sum( + status == 503 and code == "unavailable" + for status, _, code in answers + ), + ), + ), + ("answers from LB 504", "0", str(sum(a[0] == 504 for a in answers))), + ( + f"every answer before timeout server {FL_SERVER_TIMEOUT_S} s", + "yes", + yes(all(took < FL_SERVER_TIMEOUT_S for _, took, _ in answers)), + ), + ( + f"recovered within {FL_RECOVERY_LIMIT_S} s every time", + "yes", + yes(all(value >= 0 for value in recoveries)), + ), + ( + f"sessions within the pools ({FL_POOL_TOTAL}) after every freeze", + "yes", + yes(all(total <= FL_POOL_TOTAL for total in totals)), + ), + ( + "sessions do not grow after the first freeze", + "yes", + yes(max(totals) <= totals[0]), + ), + ("sessions of an abandoned ping (query ';')", "0", str(abandoned)), + ] + + def main() -> int: parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("--port", type=int, default=DEFAULT_PORT) @@ -8252,6 +9482,17 @@ def main() -> int: help="код 1 без очереди временной базы (идёт make test_isolated)", ) sub.add_parser("worker-process") + sub.add_parser("worker-memory") + frozen_sessions = sub.add_parser("freeze-sessions") + frozen_sessions.add_argument("--rounds", type=int, default=6) + frozen_sessions.add_argument( + "--settle", + type=float, + default=15, + help="пауза перед итоговым снимком сессий, с", + ) + frozen_lb = sub.add_parser("freeze-lb") + frozen_lb.add_argument("--rounds", type=int, default=3) sub.add_parser("defense-faults") sub.add_parser("relay-process") sub.add_parser("pipeline-state") @@ -8370,6 +9611,12 @@ def main() -> int: return cmd_broker_check(require_test_queue=args.require_test_queue) if args.cmd == "worker-process": return cmd_worker_process(port) + if args.cmd == "worker-memory": + return cmd_worker_memory(port) + if args.cmd == "freeze-sessions": + return cmd_freeze_sessions(rounds=args.rounds, settle=args.settle) + if args.cmd == "freeze-lb": + return cmd_freeze_lb(rounds=args.rounds) if args.cmd == "defense-faults": return cmd_defense_faults(port) if args.cmd == "relay-process": diff --git a/AGENTS.md b/AGENTS.md index 996ed09c..88889644 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -489,6 +489,9 @@ structlog (JSON в stdout), redis-py (клиент Valkey), aiobotocore | `driver.py --port relay-process` | то же у relay: PID 1, нет healthcheck, лимиты, запись о старте, неверные `RELAY__*`, остановка простаивающего, на старте и при замороженном брокере, рестарт хранилищ; `evidence/relay/process.md` | | `driver.py --port defense-faults` | шаг 4 защиты на рабочем стенде (~4 мин: аренда 70 с): crash после записи объектов и после фиксации до ack, relay убит до публикации и после подтверждения до отметки, replay неудачного и отказ replay готового; триггеры на `filename` прогона снимаются, worker и relay запускаются при любом исходе; `evidence/attachments/defense-faults.md` | | `driver.py --port pipeline-state` | только чтение, JSON: задания по состояниям, due, ждущие срока, опубликованные и не взятые, истёкшие аренды, возраст старейшего, очередь | +| `driver.py --port worker-memory` | память контейнера worker (~35 с): на девять случаев в пределах контракта два одинаковых файла разом, новая cgroup на случай; `memory.peak`, `VmHWM`, `render_peak`, OOM, сумма пиков меньше 1 ГБ; worker и relay запускаются при любом исходе; `evidence/worker/memory.md` | +| `driver.py freeze-sessions [--rounds 6] [--settle 15]` | сессии PostgreSQL и журнал пула после заморозки (~2,5 мин), работает и на рабочем стенде: приложение в процессе одноразового контейнера `api`, PostgreSQL только через TCP-прокси пробы, заморожен прокси, а не сервер; режимы — между блоками и до запросов при пуле 2 и 4; `evidence/storage/freeze-sessions.md` | +| `driver.py freeze-lb [--rounds 3]` | только не рабочий проект compose (`COMPOSE_PROJECT_NAME`, по умолчанию `mtusi-lab5-freeze`; `mtusi-lab5` — код 2): сама поднимает стенд с данными в tmpfs (volumes нет) на образе `mtusi-messenger:lab5` и убирает его при любом исходе; `docker pause` PostgreSQL, шесть запросов через LB — 503 за ~8 с, 504 нет, `unpause` в `finally`, сессий не больше пулов (~1,5 мин); раздел `evidence/storage/freeze-sessions.md` | | `make start_db` / `make stop_db` | Postgres стенда: `up -d --wait postgres` / `stop postgres` | | `make start_cache` / `make stop_cache` | Valkey стенда: `up -d --wait valkey` / `stop valkey`; volume нет, кэш после рестарта пуст | | `make start_s3` / `make stop_s3` | S3 стенда: `up -d --wait s3`, затем `up --no-deps --exit-code-from s3-bootstrap s3-bootstrap` (код bootstrap — код цели: `--wait` одноразовый сервис не ждёт) / `stop s3` | @@ -655,12 +658,12 @@ docker-compose.yml # проект mtusi-lab5: postgres, valkey, s3 (Se .dockerignore config_example.toml, .env.example evidence/broker/ # change async-attachments: stand.md (driver.py broker-check), isolated.md (очередь временной базы) -evidence/worker/ # change async-attachments: process.md (driver.py worker-process), logs.md (журнал задания) +evidence/worker/ # change async-attachments: process.md (driver.py worker-process), logs.md (журнал задания); memory.md (driver.py worker-memory) evidence/attachments/ # change async-attachments: defense.md (driver.py defense-scenario); change attachments: smoke.md, failover.md (driver.py attachment-failover stop и kill), storage.md (driver.py attachment-storage), slow-transfer.md (10 MiB через LB дольше 6 с); change upload-consistency: consistency.md (driver.py upload-consistency и журналы API и уборщика), cleaner-process.md (старт, отказ конфигурации, остановка, окно 0, рестарт хранилищ, отказ S3 во время прохода); по замечанию ревьюера: jpeg-structure.md (варианты JPEG — прежняя и новая проверка, Pillow, djpeg; регрессия на 301 JPEG; время; красный и зелёный прогоны test_undecodable_jpeg) evidence/s3/ # privacy.md — make s3_check на текущем коде; change s3-storage: bootstrap.md (первый запуск, повтор, смена секрета, ошибка шага, до bootstrap), privacy.md (make s3_check, нарушение и исправление, порты, секреты по сервисам), grpc-admin.md (gRPC шлюза без токена), restart.md (restart.sh и SIGKILL S3), client.md (операции, pause/stop, неверный секрет, журнал), memory.md (20 × 10 MiB PUT); change upload-consistency: cleaner-key.md (пользователь уборщика в bootstrap, смена секрета, make s3_check с ключом уборщика, секреты по сервисам); change track2-reconciler: cleaner-list.md (bootstrap с политикой списка по префиксу, неверный префикс, make s3_check со строками списка уборщика, окружение s3-bootstrap) evidence/reconcile/ # change track2-reconciler: cycle.md (driver.py reconcile-cycle), stress.md (driver.py reconcile-stress), service.md (Started cleaner с параметрами сверки, плановая сверка при старте, docker stop во время сверки при pause s3, код 1 разового прохода по сигналу — driver.py reconcile-signal, отказ старта на RECONCILER__*, коды 3 и 0; с change track2-reconcile-cost — остановка во время паузы предела скорости, driver.py reconcile-signal --pace) evidence/reconcile/<метка>/ # результаты make bench_reconcile (change track2-reconcile-cost): meta.json (раздел reconcile: план, этапы и модели, commit и образы «до», аргументы S3), passes.csv, windows.csv, summary.md (H1–H4 и S4), cost-by-n.svg, requests-by-n.svg, background-p95.svg, raw/ (записи уборщика по проходам, итог k6 блока H4) -evidence/storage/ # отказы БД, пул, statement_timeout, рестарт, порты Postgres, свежий clone; connection-cost.md — цена нового соединения и пинга; freeze-sessions.md — change unit-of-work: сессии и журнал пула после заморозки PostgreSQL +evidence/storage/ # отказы БД, пул, statement_timeout, рестарт, порты Postgres, свежий clone; connection-cost.md — цена нового соединения и пинга; freeze-sessions.md — change unit-of-work: сессии и журнал пула после заморозки PostgreSQL (driver.py freeze-sessions и freeze-lb) evidence/migrations/ # миграции с нуля и повторно, ошибка миграции; лаба 4: pending-index.md (ревизия 739b8f04d5fb с нуля, повтор, откат, EXPLAIN общего плана кандидатов уборщика на рабочей базе с откатом, rollout_quick), lost-at.md (ревизия 5c3e1f0a9b7d колонки lost_at: с нуля, повтор, откат, --sql с lock_timeout, make rolling_update с ревизией до и после) evidence/auth/ # passwords-and-tokens.md — driver.py auth-storage на стенде текущей лабы: Argon2id в users, SHA-256 токена в sessions, ни токена, ни пароля в pg_dump (исключения сверки покрытия) evidence/cache/ # hits.md — make test_isolated + driver.py cache-check на стенде текущей лабы: одно чтение chats на 50 через LB, TTL, ключи двух баз (исключения сверки покрытия) diff --git a/QUESTIONS.md b/QUESTIONS.md index 47cb6c62..fcd69160 100644 --- a/QUESTIONS.md +++ b/QUESTIONS.md @@ -42,11 +42,6 @@ `mtusi-rsig_postgres_data`, `mtusi-rsig_rabbitmq_data`, `mtusi-rsig_s3_data`. Прогон их не удалял. Перед удалением убедиться, что контейнеров на них нет (`docker ps -a --filter volume=<имя>`), затем `docker volume rm <имя>`. -- `make student_test` красный по `test_exclusion_evidence_exists` не только из-за - `evidence/queue/baseline2/summary.md`: в репозитории нет и `evidence/auth/passwords-and-tokens.md`, - `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md` (их нет и на - `5b5f59a`; снимаются по AGENTS.md, «Переход в следующую лабу»). Стадия apply в `evidence/` не - пишет: снять перед отчётом. - На хосте 150 анонимных volumes. Чьи они, не проверялось, часть может быть чужой, поэтому `docker volume prune` без просмотра запускать не стоит. - Остались volumes пробы стадии propose `track1-queue-overload`: @@ -254,6 +249,13 @@ - **Правки verify: лишняя строка в базе — отказ метки, как `lost`, но условие H6 не расширено:** пометка `unexpected` вне записанного до метки списка H6; строка, которую объясняет 5xx или обрыв, пометку не даёт (там же, п. 10). - **Правки verify: `UP 1/2` — реплика ещё в балансировке:** она получает запросы, `lb_down` на неё не срабатывает. Опора — сценарий «реплики MUST NOT выводиться из балансировщика» (там же, п. 11). - **Метка `baseline2` не основная, снимается `baseline3`:** за съёмку хост выгрузил в swap 309 432 страницы, пять ячеек с `host_swap`, в четырёх задержка вышла за разброс соседних повторов. Указание пользователя «забить» касается косяков хоста, явно не меняющих результат, а здесь результат ячеек изменился. Без пяти ячеек вердикты H1–H9 и рекомендация те же, но правило (design, решение 11; `bench.md`) записано до метки и не смягчается после. Каталог `baseline2` остаётся в git как запись. Если выгрузка повторится, третьей пересъёмки нет: основной станет метка с меньшим числом задетых ячеек, они будут названы в отчёте (задача 10.20а). +- **Финальные доказательства вне бенчмарка, команды драйвера.** Разовые пробы перенесены тремя командами, а не двумя: `worker-memory` (рабочий стенд, через LB), `freeze-sessions` (работает и на рабочем стенде: заморожен только прокси пробы) и `freeze-lb` (`docker pause` — запрещён на рабочем PostgreSQL). `freeze-lb` сама поднимает и убирает временный проект `mtusi-lab5-freeze`, а не ждёт его по окружению, как `reconcile-signal`: иначе проверяющему пришлось бы собирать стенд руками; данные в tmpfs, поэтому `down` без `-v` ничего не оставляет. Значения — случайные, из `.env.example`: `.env` не читается. +- **`freeze-sessions` идёт в одноразовом контейнере `api`, а не из дерева кода через `uv run`:** так пробе не нужен `.env` и код образа совпадает со стендом. httpx в образе нет, вызовы ASGI — своим клиентом; остальная логика `double_cancel.py` та же. Прежний файл называл аргументы пробы неверно: `2 6 1` и `2 6 4` — пул 2 и 1 или 4 запроса, а не срок 2 и пул 1 или 4; добавлен режим с настоящим пулом 4. +- **`make test_isolated` перед `cache-check` при первой съёмке — код 2.** Его набор требует файлы, которых ещё нет, а ключи временной базы он при этом оставляет: команды шли не через `&&`, причина названа в шапке `evidence/cache/hits.md`. +- **Шаги `evidence/idempotency/replay-after-restart.md` — `driver.py req` и `docker compose`,** скрипт только соединил их: отдельной команды драйвера не заводилось, задача её не просила, а шаги повторяются руками. +- **Пересняты `evidence/tests/student-test-lb.md` и `evidence/tests/test-isolated.md`:** задача их не называла, но на `d8fe2e8` они показывали единственный красный тест, который эта задача закрыла. `evidence/tests/failure-checks.md` остаётся на `d8fe2e8`: полный прогон на ноутбуке запрещён условиями задачи. +- **В `REPORT.md` добавлен вопрос 12 (`PR_SET_DUMPABLE`):** он был вопросом преподавателю в `QUESTIONS.md`, но в нумерованный список отчёта не попал. +- **Секреты в новых файлах `evidence/` сверены по токенам и путям, не по значениям `.env`:** файл `.env` в этой работе не читается. `evidence/tests/secrets.md` остаётся на прежнем commit; поиск значений по всему `evidence/` — перед PR. ### Вопросы @@ -265,3 +267,5 @@ Вопрос пользователю (основной сессии), прогон не останавливает: 3. Правило рекомендации требует «без `oom` и `failed`». После правки S5 аварийный перезапуск worker не от ядра (`worker_crash`) это условие не нарушает: раньше такой перезапуск считался `oom` косвенно. Условие не менялось, потому что записано до метки. В метке таких случаев не ждём (пробы: только ядро). Появится — считать настройку некандидатом? Сейчас: пометка в сводке, решение — в отчёте. + + **Решение основной сессии:** правило не менять, оно записано до метки. Если `worker_crash` появится в основной метке, отчёт называет такую настройку отдельно и не рекомендует её, не перекрашивая вердикт правила. В `baseline` и `baseline2` таких случаев нет. diff --git a/REPORT.md b/REPORT.md index 9cfda28c..21385458 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,8 +2,11 @@ - Автор, группа: Сафронов Роман Николаевич, БВТ2301 - Целевая оценка; выбранный трек 5: оценка 5, трек 1 «Очередь под перегрузкой» -- Состояние отчёта: закрыты **уровень 3** (change `async-attachments`) и **уровень 4** (change `pipeline-reliability`); уровень 5, трек 1 — change `track1-queue-overload`, метка `baseline`, раздел «Очередь под перегрузкой». Открыты три доказательства исключений сверки покрытия («Следующие шаги») -- Commit/PR: трек 1 — код `d667fa3`, метка `7999002` (ветка `feat/track1-queue-overload`); уровни 3 и 4 — `d8fe2e8` (ветка `feat/unit-of-work`, перенос на единицу работы и правки verify); снятое на прежних `6ba74b1`, `399da05`, `e2a6427` и `ff1a83b` названо в разделе доказательств; PR — TODO после публикации +- Состояние отчёта: закрыты **уровень 3** (change `async-attachments`) и **уровень 4** (change `pipeline-reliability`); уровень 5, трек 1 — change `track1-queue-overload`, раздел «Очередь под перегрузкой». Все доказательства исключений сверки покрытия сняты на стенде этой лабы +- Ветка решения: `solution/bvt2301-safronov`, в неё по очереди вливаются `feat/async-attachments`, `feat/pipeline-reliability`, `feat/unit-of-work`, `feat/track1-queue-overload` +- Commit: итоговый ``; трек 1 — код и метка в разделе «Очередь под перегрузкой»; уровни 3 и 4 — `d8fe2e8` (ветка `feat/unit-of-work`, перенос на единицу работы и правки verify); снятое на `9639aa1`, `6ba74b1`, `399da05`, `e2a6427` и `ff1a83b` названо в разделе доказательств +- PR: по шаблону `.github/pull_request_template.md`, заголовок `ЛР 5 — БВТ2301 — Сафронов — на 5`; номер — после публикации +- Согласования с преподавателем: три договорённости лаб 1–4 действуют, новых в лабе 5 нет (раздел «Согласования с преподавателем»). Открытые вопросы преподавателю — 12, раздел «Открытые вопросы преподавателю»; решения без пользователя — `QUESTIONS.md` - Источники, библиотеки и помощь ИИ — последний раздел ## Запуск из чистого clone @@ -226,7 +229,7 @@ CPU на успешный запрос при постоянных 200 запр Настоящий случай «дорогого» файла — прогрессивный JPEG в пределах контракта, один скан повторён 445 227 раз: `test_limit_cpu_scan_bomb`. -**Бюджет памяти контейнера worker (1 ГБ).** Замер двух файлов разом на `399da05` (`evidence/worker/memory.md`): пик процесса обработки на 40 Мпкс (`render_peak_kib`, лимит 450 МиБ) зависит от типа файла: PNG RGBA и всё, что переводится в RGBA (серый с альфой, RGB с tRNS, палитра с tRNS), — 357 МиБ, серый 16 бит — 404 МиБ, а на обеих границах контракта сразу, 40 Мпкс и ~10 MiB файла, — 366 и 414 МиБ. `VmHWM` процесса 1 при двух телах ~10 MiB — до 159 МиБ. Самый дорогой случай, два серых 16 бит на обеих границах: `memory.peak` контейнера 905 МиБ, `oom_kill` 0; у двух PNG 10 MiB из шума — 261 МиБ. Верхняя оценка суммой пиков: 159 + 2 × 414 = 987 МиБ < 1 ГБ. Если памяти всё же не хватит, ядро убьёт самый большой процесс обработки, а не worker (проба), это временная ошибка. +**Бюджет памяти контейнера worker (1 ГБ).** Замер двух файлов разом, команда `driver.py --port 8080 worker-memory`, два прогона на `9639aa1` (`evidence/worker/memory.md`): пик процесса обработки на 40 Мпкс (`render_peak_kib`, лимит 450 МиБ) зависит от типа файла: PNG RGBA и всё, что переводится в RGBA (серый с альфой, RGB с tRNS, палитра с tRNS), — 357 МиБ, серый 16 бит — 404 МиБ, а на обеих границах контракта сразу, 40 Мпкс и ~10 MiB файла, — 367 и 414 МиБ. `VmHWM` процесса 1 при двух телах ~10 MiB — до 159 МиБ. Самый дорогой случай, два серых 16 бит на обеих границах: `memory.peak` контейнера 926 и 705 МиБ в двух прогонах (пик зависит от совпадения пиков двух процессов), `oom_kill` 0; у двух PNG 10 MiB из шума — 262 МиБ. Опора — верхняя оценка суммой пиков: 159 + 2 × 414 = 987 МиБ < 1 ГБ. Если памяти всё же не хватит, ядро убьёт самый большой процесс обработки, а не worker (проба), это временная ошибка. ### Сервисы стенда и лимиты @@ -327,6 +330,7 @@ CPU на успешный запрос при постоянных 200 запр 9. **Контракт требует retention «неуспешных и непривязанных исходников», но молчит о конечных объектах, которые успела записать неудачная попытка.** Сделано: по истечении срока удаляются и они, метаданные `failed` остаются. Другой ответ убирает один шаг очистки. 10. **Предел незавершённых заданий: 429 или 503?** Контракт называет 429 «ограничением частоты запросов», здесь ограничено количество принятой работы; 503 — «зависимость недоступна». Сделано: 429 `rate_limited` с `Retry-After: 5`, как у занятых мест: зависимости живы, реплика готова. Другой ответ меняет строку `DOMAIN_ERRORS` и сценарии. 11. **Как долго загрузка обязана отвечать 202 при остановленном worker?** Рубрика уровня 3 показывает «worker остановлен → upload 202», трек 1 требует ограничить принятую работу. Сделано: пока незавершённых меньше предела (250); дальше 429, а текст, история, метаданные, готовые байты и `/health/ready` работают. Другой ответ — значение настройки. +12. **Требуется ли на уровне лабы закрыть чтение секретов worker процессом обработки?** Он идёт под тем же UID и может прочитать `/proc/1/environ` (раздел «Ограничения и следующие шаги»). Сделано: кодом не исправлено, в окружении самого процесса обработки секретов нет. Предложение — `PR_SET_DUMPABLE=0` в процессе worker до запуска процессов обработки: одна строка на старте worker и сценарий. ### Ответы на вопросы защиты @@ -362,18 +366,18 @@ CPU на успешный запрос при постоянных 200 запр ## Доказательства критериев -В шапке каждого файла — команда, дата, commit и стенд. На `d8fe2e8` (правки verify: сессии после заморозки, один срок на JSON-запрос, тест одновременных доставок) сняты `evidence/tests/student-test-lb.md`, `evidence/tests/test-isolated.md`, `evidence/tests/failure-checks.md`, `evidence/tests/service-tests.md`, `evidence/storage/freeze-sessions.md`. На `6ba74b1` (единица работы, поведение то же) сняты метки `evidence/bench/unit-of-work-after/` и `evidence/rollout/unit-of-work*/`, а ещё `evidence/replicas/test-persistence.md`, `evidence/failover/test-failover.md`, `evidence/attachments/defense-faults.md`, `evidence/s3/privacy.md`, `evidence/worker/process.md`, `evidence/relay/process.md`. На `399da05` сняты `evidence/worker/memory.md` и таблица «Красные прогоны» в `failure-checks.md`. Остальные файлы уровня 4 сняты на `e2a6427`: из кода приложения `399da05` меняет только `src/utils/image_variants.py`, одну ветку перевода в RGBA, а `6ba74b1` поведения не меняет. `d8fe2e8` меняет только путь отказа: метки и файлы на `6ba74b1` не переснимались, потому что на пути без отказа правка убирает один таймер блока и обменов с PostgreSQL не добавляет, а `make failure_checks` на новом commit те же отказы прошёл. Остались снятыми на прежнем коде `ff1a83b` и названы так в шапках: метка `evidence/uploads/baseline/`, `evidence/rollout/async-attachments/`, `evidence/migrations/async-attachments.md`, `evidence/s3/worker-key.md`: это доказательства перехода уровня 3, их поведение уровень 4 не менял. +В шапке каждого файла — команда, дата, commit и стенд. На `9639aa1` (код `src/` и `bench/` тот же, что на `5ee3257`, изменён только драйвер скилла: новые команды `worker-memory`, `freeze-sessions`, `freeze-lb`) сняты `evidence/tests/student-test-lb.md`, `evidence/tests/test-isolated.md`, `evidence/cache/hits.md`, `evidence/auth/passwords-and-tokens.md`, `evidence/idempotency/replay-after-restart.md`, `evidence/worker/memory.md`, `evidence/storage/freeze-sessions.md`. На `d8fe2e8` (правки verify: сессии после заморозки, один срок на JSON-запрос, тест одновременных доставок) сняты `evidence/tests/failure-checks.md`, `evidence/tests/service-tests.md`. На `6ba74b1` (единица работы, поведение то же) сняты метки `evidence/bench/unit-of-work-after/` и `evidence/rollout/unit-of-work*/`, а ещё `evidence/replicas/test-persistence.md`, `evidence/failover/test-failover.md`, `evidence/attachments/defense-faults.md`, `evidence/s3/privacy.md`, `evidence/worker/process.md`, `evidence/relay/process.md`. На `399da05` снята таблица «Красные прогоны» в `failure-checks.md`. Остальные файлы уровня 4 сняты на `e2a6427`: из кода приложения `399da05` меняет только `src/utils/image_variants.py`, одну ветку перевода в RGBA, а `6ba74b1` поведения не меняет. `d8fe2e8` меняет только путь отказа: метки и файлы на `6ba74b1` не переснимались, потому что на пути без отказа правка убирает один таймер блока и обменов с PostgreSQL не добавляет, а `make failure_checks` на новом commit те же отказы прошёл. Остались снятыми на прежнем коде `ff1a83b` и названы так в шапках: метка `evidence/uploads/baseline/`, `evidence/rollout/async-attachments/`, `evidence/migrations/async-attachments.md`, `evidence/s3/worker-key.md`: это доказательства перехода уровня 3, их поведение уровень 4 не менял. ### Уровень 3 | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | | Публичный smoke | `make test` | `PASS: lab5 public API scenario` | `evidence/tests/test-isolated.md` | -| Минимум лаб 1–4 сохранён с переходом 201 → 202 | `make student_test` через LB | 223 passed, 1 failed (`test_exclusion_evidence_exists`: только файлы последнего шага прогона), реплики выполнены; сверка: 371 сценарий, 349 проверены, 22 исключения | `evidence/tests/student-test-lb.md` | -| Тот же набор на временной базе | `make test_isolated` | smoke PASS; 217 passed, 6 skipped (реплики), 1 failed — то же; уборка полная | `evidence/tests/test-isolated.md` | +| Минимум лаб 1–4 сохранён с переходом 201 → 202 | `make student_test` через LB | 224 passed, реплики выполнены; сверка: 389 сценариев, 358 проверены, 31 исключение | `evidence/tests/student-test-lb.md` | +| Тот же набор на временной базе | `make test_isolated` | smoke PASS; 218 passed, 6 skipped (реплики); уборка полная | `evidence/tests/test-isolated.md` | | Отказы | `make failure_checks` (`d8fe2e8`) | 141 passed, pytest 2214 с, `crash markers 0` | `evidence/tests/failure-checks.md` | | Ветки сервисов и настоящая единица работы | `make service_test`, `make service_test_db` (`d8fe2e8`) | 201 passed за 1,44 с без хранилищ; 75 passed за 32,47 с на временной базе; 16 регрессий дают названный красный | `evidence/tests/service-tests.md` | -| Заморозка PostgreSQL: сессий сверх пула нет, одна запись об отказе | разовые пробы вне репозитория `double_cancel.py` в двух режимах и `probe_freeze.py` (`d8fe2e8`, описаны в файле доказательства); повторяются тестами `test_no_sessions_over_pool_after_freeze`, `test_deadline_in_second_block_single_record`, строка через LB — только по файлу | 503 за 4,01 с при сроке 2 с, записей пула нет, сессий через прокси 0 во всех раундах; через LB 503 за 8,01–8,02 с, 504 нет, сессий до и после каждой заморозки поровну | `evidence/storage/freeze-sessions.md` | +| Заморозка PostgreSQL: сессий сверх пула нет, одна запись об отказе | `driver.py --port 8080 freeze-sessions` (TCP-прокси пробы, сервер не трогается), `driver.py freeze-lb` (`docker pause` на своём временном проекте, рабочий `mtusi-lab5` — код 2); то же в тестах `test_no_sessions_over_pool_after_freeze`, `test_deadline_in_second_block_single_record` | 503 за 4,00–4,03 с при сроке 2 с, записей пула нет, сессий через прокси 0 во всех раундах; через LB 503 за 8,01–8,09 с, 504 нет, сессий до и после каждой заморозки поровну | `evidence/storage/freeze-sessions.md` | | 202 только после устойчивого приёма и сохранения задания | `test_durable_state_at_202`, `test_upload_with_broker_stopped`, `test_upload_with_broker_paused` | к 202 объект в staging, строка и намерение в одной транзакции; брокер остановлен или заморожен — по-прежнему 202, намерение ждёт (на уровне 3 было 503) | `evidence/tests/failure-checks.md` | | Остановка API после ответа не теряет работу | `test_api_killed_after_202` | реплика убита после 202, вложение становится `ready` | `evidence/tests/failure-checks.md` | | Отдельные broker и worker в общем compose | `driver.py broker-check`, `driver.py worker-process` | образ с тегом и digest, volume, AMQP только на loopback; PID 1 `python -m src.worker`, лимиты 1 CPU / 1 ГБ | `evidence/broker/stand.md`, `evidence/worker/process.md` | @@ -402,7 +406,7 @@ CPU на успешный запрос при постоянных 200 запр | Память реплики при загрузках | `make bench_uploads` (`ff1a83b`) | «с лимитом» 10 MiB: пик 172,9 / 180,1 / 185,6 MiB при 10 / 20 / 40 клиентах, OOM 0, 5xx 0 | `evidence/uploads/baseline/summary.md` | | Секретов в доказательствах нет | поиск значений из `.env` по `evidence/` | 17 значений, 0 совпадений | `evidence/tests/secrets.md` | -На этом шаге `test_exclusion_evidence_exists` ожидаемо красный: файлы `evidence/cache/hits.md`, `evidence/auth/passwords-and-tokens.md` и `evidence/idempotency/replay-after-restart.md` снимаются на последнем шаге всего прогона лабы. +Исключения сверки покрытия подтверждены файлами этой лабы: `evidence/cache/hits.md`, `evidence/auth/passwords-and-tokens.md`, `evidence/idempotency/replay-after-restart.md` сняты на `9639aa1`, `test_exclusion_evidence_exists` зелёный. ### Уровень 4 @@ -413,7 +417,7 @@ CPU на успешный запрос при постоянных 200 запр | Лимит по 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_pixel_limit_png_modes`, `test_render_killed`, `driver.py worker-process` | `RLIMIT_AS` — `invalid_image`; 40 Мпкс укладывается в любом типе PNG, включая серый с альфой и RGB с tRNS; убитый процесс обработки не роняет worker; лимиты 1 CPU / 1 ГБ; два файла на обеих границах — `memory.peak` 905 МиБ, OOM нет | `evidence/tests/failure-checks.md`, `evidence/worker/process.md`, `evidence/worker/memory.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 ГБ; два файла на обеих границах — `memory.peak` 705–926 МиБ, сумма пиков 987 МиБ, OOM нет (`driver.py worker-memory`) | `evidence/tests/failure-checks.md`, `evidence/worker/process.md`, `evidence/worker/memory.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` | @@ -763,7 +767,7 @@ Staging при заполненном пределе: 250 × 10 458 117 байт - Ранний ответ при загрузке: `urllib` напрямую к реплике на большом теле теряет ранний ответ; через LB и с httpx или curl — получает. - Keyset-пагинация: порядок задаёт `(created_at, id)`; `created_at` назначает сервер, при расхождении часов реплик порядок вставки возможен только по этому ключу. -**Следующие шаги.** Снять на итоговом коде оставшиеся доказательства исключений сверки покрытия: `evidence/auth/passwords-and-tokens.md`, `evidence/cache/hits.md`, `evidence/idempotency/replay-after-restart.md`, пока `test_exclusion_evidence_exists` по ним красный. Вне трека и не сделано: приоритет обработки над приёмом в S3, предел по байтам и на пользователя, forkserver, рост памяти S3 с накопленными объектами. Подтверждено замером только то, что есть в разделах выше. +**Следующие шаги.** Вне трека и не сделано: приоритет обработки над приёмом в S3, предел по байтам и на пользователя, forkserver, рост памяти S3 с накопленными объектами. Подтверждено замером только то, что есть в разделах выше. ## Источники, библиотеки и использование ИИ @@ -771,4 +775,4 @@ Staging при заполненном пределе: 250 × 10 458 117 байт **Библиотеки:** новые — aio-pika 10.2.1, Pillow 13.0.0 (из dev-группы в основную); уровень 4 новых не добавил: WebP уже есть в Pillow (libwebp 1.6.0); единица работы — тоже: `async def` тесты запускает плагин `anyio`, он уже в зависимостях. Остальное — `uv.lock`. Пробы уровня 4 — таблица «Пробы» `openspec/changes/archive/2026-10-31-pipeline-reliability/design.md`. -**ИИ.** Код, тесты, инструменты, спеки, снятие доказательств и этот отчёт сделаны с помощью Claude Code (Anthropic) по циклу OpenSpec: предложение, реализация, проверка; перенос на единицу работы (`unit-of-work`, по указанию пользователя) — так же, проверен наборами `student-tests/` и `make failure_checks` без их правок и временными регрессиями; решения и отвергнутые варианты — `design.md`, принятые без пользователя — `QUESTIONS.md`. Числа в отчёте перенесены из выводов команд на названном commit. +**ИИ.** Код, тесты, инструменты, спеки, снятие доказательств и этот отчёт сделаны с помощью Claude Code (Anthropic) по циклу OpenSpec: предложение, реализация, проверка, правки по проверке, архивация; каждую стадию вёл отдельный агент, основная сессия принимала результат и коммитила. Перенос на единицу работы (`unit-of-work`, по указанию пользователя) — так же, проверен наборами `student-tests/` и `make failure_checks` без их правок и временными регрессиями; очередь под перегрузкой (`track1-queue-overload`) — гипотезы и правило рекомендации записаны до метки, метки сняты командой `make bench_queue`; метку `baseline` отменили ошибки инструмента, найденные проверкой, `baseline2` — выгрузка хоста в swap (`QUESTIONS.md`). Выбор оценки, трека, брокера и единицы работы — решения автора; решения и отвергнутые варианты — `design.md`, принятые без пользователя — `QUESTIONS.md`. Каждый файл `evidence/` снят командой из его шапки на стенде этой лабы, а не сгенерирован; числа в отчёте перенесены из выводов команд на названном commit. diff --git a/evidence/auth/passwords-and-tokens.md b/evidence/auth/passwords-and-tokens.md new file mode 100644 index 00000000..d25bbb20 --- /dev/null +++ b/evidence/auth/passwords-and-tokens.md @@ -0,0 +1,19 @@ +# Хранение паролей и токенов + +- Команда: `python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 auth-storage` +- Дата: 2026-11-01, 10:33:45–10:33:46 UTC; код выхода 0 +- Commit: `9639aa1` (ветка `feat/track1-queue-overload`), код `src/` и `bench/` тот же, что на `5ee3257`; на рабочем дереве изменён только `.claude/skills/run-mtusi-messenger/driver.py`, команда `auth-storage` не менялась +- Стенд: проект compose `mtusi-lab5`, две реплики за HAProxy, собран `make run_docker` из `HEAD`; пользователи синтетические, пароль и токен только в памяти драйвера, в вывод не попадают +- Спеки: `users`, «Хэш в БД», `sessions`, «Токена нет в хранилище» (исключения сверки покрытия: схема и дамп по HTTP не видны) + +Итог: в `users` — строки Argon2id с разной солью у одного пароля, в `sessions` — только SHA-256 токена (32 байта); ни токена (текстом и в hex), ни пароля в `pg_dump --data-only` нет. + +```text +users auth_… and auth_…: same password P (36 characters with ':' and Cyrillic) + password_hash $argon2id$v=19$m=65536,t=3,p=4$… (97 chars) + password_hash $argon2id$v=19$m=65536,t=3,p=4$… (97 chars) + hashes differ: t +session of the first user: token T (43 characters); rows of sessions with token_hash = SHA-256(T): 1, octet_length 32 +pg_dump --data-only: 12 COPY blocks; T as text: no, T in hex: no, P as text: no +PASS: only Argon2id strings and SHA-256 of the token are stored +``` diff --git a/evidence/cache/hits.md b/evidence/cache/hits.md new file mode 100644 index 00000000..e1ff16f2 --- /dev/null +++ b/evidence/cache/hits.md @@ -0,0 +1,23 @@ +# Кэш карточки чата + +- Команды: `make test_isolated` (ключи временной базы), затем `python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 cache-check --require-test-keys` +- Дата: 2026-11-01; `make test_isolated` 10:29:02–10:31:48 UTC, `cache-check` 10:33:20–10:33:45 UTC, код выхода `cache-check` 0 +- Код выхода `make test_isolated` 2 и только по одной причине: 1 failed (`test_exclusion_evidence_exists`: этого файла и двух соседних ещё не было), 217 passed, 6 skipped (тесты реплик), 147 deselected; публичный `make test` в нём — код 0. Снятие файла этой команды требует её прогона, поэтому поменять порядок нельзя +- Commit: `9639aa1` (ветка `feat/track1-queue-overload`), код `src/` и `bench/` тот же, что на `5ee3257`; на рабочем дереве изменён только `.claude/skills/run-mtusi-messenger/driver.py`, команда `cache-check` не менялась +- Стенд: проект compose `mtusi-lab5`, две реплики за HAProxy, собран `make run_docker` из `HEAD`; пользователи и чат синтетические +- Спеки: `chat-cache`, «Чтение из кэша», «Срок записи», «Временная база» (исключения сверки покрытия: по HTTP ответ из кэша не отличить от ответа из PostgreSQL) + +Итог: на 50 чтений карточки через LB — одно чтение таблицы `chats` (первое, ключ перед этим удалён), +49 попаданий и +1 промах Valkey; срок ключа не больше настроенного, чтения его не продлевают; ключи рабочей и временной базы под разными префиксами. + +```text +users alice_… (creator) and bob_… (reader), chat baf5835e-a6d9-430f-81bd-a8133f510fac +key messenger:v1:messenger:chat:baf5835e-a6d9-430f-81bd-a8133f510fac +right after 201: EXISTS 1, TTL 3600 s (configured [cache] chat_ttl_seconds 3600 s in the replica); value keys ['created_at', 'id', 'member_ids', 'title'], member_ids in creation order: yes +DEL key: the first read is a miss; waiting 11 s +50 × GET /api/v1/chats/{id} by the reader through LB: 50 equal to the creation response; by replica 5de01d9e5999 25, 7f8add826e12 25 +after 11 s: reads of table chats (seq_scan + idx_scan) +1, keyspace_hits +49, keyspace_misses +1 +TTL 3588 s, then 10 more reads, TTL 3588 s: reads do not extend the key +keys messenger:v1:messenger:chat:*: 1 +keys messenger:v1:test_messenger:chat:*: 166 +PASS: one read of chats, the rest from Valkey; TTL is bounded; temporary database: 166 keys under its own prefix +``` diff --git a/evidence/idempotency/replay-after-restart.md b/evidence/idempotency/replay-after-restart.md new file mode 100644 index 00000000..fbc4426d --- /dev/null +++ b/evidence/idempotency/replay-after-restart.md @@ -0,0 +1,64 @@ +# Повтор отправки после рестарта API + +- Команды: `driver.py --port 8080 req POST /api/v1/chats//messages --token --data '{"text":"replay after restart"}' --key <ключ>`, `docker compose up -d --force-recreate api`, тот же `req` с тем же ключом и токеном, затем `req` с другим телом и `req GET` истории; скрипт шагов вне репозитория, сами шаги выше повторяются руками +- Дата: 2026-11-01, 10:34:20–10:34:29 UTC; коды выхода 0 +- Commit: `9639aa1` (ветка `feat/track1-queue-overload`), код `src/` и `bench/` тот же, что на `5ee3257`; на рабочем дереве изменён только `.claude/skills/run-mtusi-messenger/driver.py`, команда `req` не менялась +- Стенд: проект compose `mtusi-lab5`, две реплики за HAProxy, собран `make run_docker` из `HEAD`; пользователь и чат синтетические +- Спек: `idempotency`, «Повтор после рестарта API» (исключение сверки покрытия: тесты сервер не трогают) +- Вывод обезличен: ключ заменён на ``; токена и пароля в выводе нет + +Итог: новые контейнеры обеих реплик (другие `id` и `StartedAt`), повтор — тот же 201 и тот же `Message` от реплики, которой при первой отправке не было (`7f8add826e12` → `97b8c4574c46`). В истории одно сообщение; другое тело с тем же ключом — 409. Сессия и ключ лежат в PostgreSQL, поэтому рестарт реплик на них не влияет. Compose пересоздал только реплики, зависимости (`migrate`, `s3-bootstrap`) лишь повторно запустил: их контейнеры прежние, PostgreSQL не перезапускался. + +```text +--- before: api containers (name, id, StartedAt) +/mtusi-lab5-api-19 7f8add826e12 2026-11-01T10:28:40.349727095Z +/mtusi-lab5-api-20 5de01d9e5999 2026-11-01T10:28:40.064694511Z +--- first send +idempotency-key: +201 x-request-id: 5fa5de5420954757bec0dc2e58bc271e x-instance-id: 7f8add826e12 +{ + "id": "838a93d9-cffc-4fbe-94e8-413f9ab191fa", + "chat_id": "f71fb930-1195-42af-b70e-b80661bc22f6", + "sender_id": "1b623133-e1dc-4fca-a8a2-50caf09536ed", + "text": "replay after restart", + "created_at": "2026-11-01T10:34:21.613999Z", + "attachment_ids": [] +} +--- docker compose up -d --force-recreate api + Container mtusi-lab5-api-19 Recreated + Container mtusi-lab5-api-19 Started + Container mtusi-lab5-api-20 Recreated + Container mtusi-lab5-api-20 Started + Container mtusi-lab5-migrate-1 Started + Container mtusi-lab5-s3-bootstrap-1 Started +exit 0 +LB ready: 200 +--- after: api containers (name, id, StartedAt) +/mtusi-lab5-api-19 97b8c4574c46 2026-11-01T10:34:26.712304672Z +/mtusi-lab5-api-20 5aecf775f84d 2026-11-01T10:34:26.633759088Z +--- repeat with the same key, the same session +idempotency-key: +201 x-request-id: 22bc07391e784d0883fd07463c6ad179 x-instance-id: 97b8c4574c46 +{ + "id": "838a93d9-cffc-4fbe-94e8-413f9ab191fa", + "chat_id": "f71fb930-1195-42af-b70e-b80661bc22f6", + "sender_id": "1b623133-e1dc-4fca-a8a2-50caf09536ed", + "text": "replay after restart", + "created_at": "2026-11-01T10:34:21.613999Z", + "attachment_ids": [] +} +--- other body with the same key +idempotency-key: +409 x-request-id: 7b46b5bcc2a5446c8ca84ec664dcfd10 x-instance-id: 97b8c4574c46 +{ + "error": { + "code": "conflict", + "message": "Idempotency key was already used with another request", + "request_id": "7b46b5bcc2a5446c8ca84ec664dcfd10" + } +} +--- history +{"count":1,"ids":["838a93d9-cffc-4fbe-94e8-413f9ab191fa"]} +--- compare +Message of the repeat = Message of the first send: yes +``` diff --git a/evidence/storage/freeze-sessions.md b/evidence/storage/freeze-sessions.md index f8819968..4782a07d 100644 --- a/evidence/storage/freeze-sessions.md +++ b/evidence/storage/freeze-sessions.md @@ -1,87 +1,113 @@ # Сессии PostgreSQL и журнал пула после заморозки -- Команды: `uv run python double_cancel.py 2 6 1 second-block`, `uv run python double_cancel.py 2 6 4` (из корня дерева кода, `SETTLE=15`), `python3 probe_freeze.py http://localhost:8080 mtusi-lab5-postgres-1` трижды с `pg_stat_activity` до и после -- Дата: 2026-10-31, 23:03:57–23:06:24 UTC; коды выхода 0 -- Commit: `d8fe2e8` (ветка `feat/unit-of-work`), рабочее дерево чистое -- Стенд: проект compose `mtusi-lab5`, две реплики за HAProxy, собран `make run_docker` из `HEAD`; пользователи синтетические, по одному на прогон пробы +- Команды: `python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 freeze-sessions` (рабочий стенд, заморожен только прокси пробы) и `python3 .claude/skills/run-mtusi-messenger/driver.py freeze-lb` (`docker pause` PostgreSQL — на своём временном проекте) +- Дата: 2026-11-01; `freeze-sessions` 10:36:22–10:38:35 UTC, `freeze-lb` 10:41:46–10:43:14 UTC; коды выхода 0 +- Commit: `9639aa1` (ветка `feat/track1-queue-overload`), код `src/` и `bench/` тот же, что на `5ee3257`; на рабочем дереве изменён только `.claude/skills/run-mtusi-messenger/driver.py`: в нём и появились эти команды +- Стенд `freeze-sessions`: проект compose `mtusi-lab5`, собран `make run_docker` из `HEAD`; приложение в процессе одноразового контейнера `api` (`docker compose run --rm --no-deps -T --entrypoint python api -`, лимиты реплики), PostgreSQL стенда только через TCP-прокси пробы; в базе остаётся по одному синтетическому пользователю на режим +- Стенд `freeze-lb`: проект compose `mtusi-lab5-freeze` с образом `mtusi-messenger:lab5` и лимитами рабочего стенда, две реплики за HAProxy, Valkey, S3 с bootstrap; команда сама его поднимает и убирает: данные в tmpfs, volumes не создаются, окружение — случайные значения из `.env.example` во временном каталоге, конфигурация — `config_example.toml`. `mtusi-lab5` команда отвергает (код 2): рабочий PostgreSQL не замораживается - Change `unit-of-work`, замечания verify C1 и W1: `design.md`, уточнения 17 и 18 -- Вывод сокращён: у пробы C1 раунды 1–4 совпадают с показанными, в выводе `probe_freeze.py` убрано поле `instance` -Пробы — разовые скрипты стадии verify, в репозиторий не входят (`bench/` и `student-tests/` этим изменением не меняются). Сценарий воспроизводят тесты `service-tests/db/test_uow.py::test_no_sessions_over_pool_after_freeze` и `service-tests/db/test_request_flow.py::test_deadline_in_second_block_single_record` (`make service_test_db`, `evidence/tests/service-tests.md`). +Сценарий заморозки ещё проверяют тесты `service-tests/db/test_uow.py::test_no_sessions_over_pool_after_freeze` и `service-tests/db/test_request_flow.py::test_deadline_in_second_block_single_record` (`make service_test_db`, `evidence/tests/service-tests.md`). -| Проба | Что делает | +| Режим `freeze-sessions` | Что делает | |---|---| -| `double_cancel.py <срок> <раунды> <пул> [second-block]` | приложение в процессе (`httpx.ASGITransport`), PostgreSQL стенда только через свой TCP-прокси, замораживается прокси, а не сервер. Срок `[database] request_timeout_seconds` и пул — окружением. С `second-block` заморозка между входом и операцией `GET /chats`, без него — до пачки `GET /users/me` на все соединения пула. После разморозки: сессии через прокси, занятые соединения, следующие запросы, записи логгера `sqlalchemy.pool` | -| `probe_freeze.py <адрес LB> <контейнер PostgreSQL>` | через LB: шесть одновременных запросов JSON-ручек и метаданных вложения при `docker pause` PostgreSQL, `unpause` в `finally`, затем время до первого 200 | +| `second-block` | заморозка между входом и операцией `GET /chats`, один запрос, пул 2: зазор таймеров — настоящая длительность блока входа | +| `before-requests` | заморозка до пачки из четырёх `GET /users/me`, пул 2 и пул 4 | + +Срок `[database] request_timeout_seconds` в пробе 2 с, закрытие соединения добавляет до 2 с. После разморозки в каждом раунде: сессии через прокси (`client_addr` контейнера пробы), занятые соединения, четыре следующих запроса, записи логгера `sqlalchemy.pool`. Прежний файл называл первый аргумент разовой пробы сроком, а третий пулом: на деле это были размер пула и число запросов, поэтому `2 6 1 second-block` и `2 6 4` — режимы 1 и 2 здесь; режим пула 4 добавлен, потому что о нём и говорил прежний заголовок. ## Срок истёк во втором блоке: W1 -При сроке 2 с, пуле 1. До правки, по выводу verify на `6ba74b1`, те же 6 раундов дали 503 за 2,01 с и две записи пула: `Exception terminating connection` и `The garbage collector is trying to clean up non-checked-in connection`. Теперь записей нет: закрытие дорабатывает, поэтому ответ приходит за срок плюс закрытие. +До правки, по выводу verify на `6ba74b1`, те же 6 раундов дали 503 за 2,01 с и две записи пула: `Exception terminating connection` и `The garbage collector is trying to clean up non-checked-in connection`. Теперь записей нет: закрытие дорабатывает, поэтому ответ приходит за срок плюс закрытие. ```text -round 0: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] -round 1: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] -round 2: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] -round 3: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] -round 4: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] -round 5: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +== second-block, pool 2, 1 request(s) +round 0: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 1: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 2: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 3: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 4: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 5: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] end: held 0, after gc.collect 0 -sessions after settle: [('idle', 'ROLLBACK;', 1)] +sessions after 15 s: [['idle', 'ROLLBACK;', 1]] ``` ## Сессии сверх пула: C1 -При сроке 2 с, пуле 4, 6 заморозок подряд. Сессии через прокси сразу после каждой разморозки, по выводу verify: `9efab79` — 4, 8, 12, 12, 12, 12 (после паузы только 4 рабочих), `6ba74b1` — 4, 8, 12, 16, 20, 24 (после паузы 24 `idle` с запросом `;`). Здесь: +6 заморозок подряд. Сессии через прокси сразу после каждой разморозки, по выводу verify: `9efab79` — 4, 8, 12, 12, 12, 12 (после паузы только 4 рабочих), `6ba74b1` — 4, 8, 12, 16, 20, 24 (после паузы 24 `idle` с запросом `;`). Здесь после паузы — только рабочие соединения, не больше пула; следующие запросы шли по очереди. ```text -server sessions via proxy: 0 (все 6 раундов) -round 0: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] -round 5: frozen 503 4.01s; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +== before-requests, pool 2, 4 request(s) +round 0: frozen 503 4.02s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 1: frozen 503 4.00s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 2: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 3: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 4: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 5: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] end: held 0, after gc.collect 0 -sessions after settle: [('idle', 'ROLLBACK;', 2)] +sessions after 15 s: [['idle', 'ROLLBACK;', 2]] +== before-requests, pool 4, 4 request(s) +round 0: frozen 503 4.03s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 1: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 2: frozen 503 4.02s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 3: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 4: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +round 5: frozen 503 4.01s; server sessions via proxy 0; held right after 0; next requests [200, 200, 200, 200]; held 0; pool records [] +end: held 0, after gc.collect 0 +sessions after 15 s: [['idle', 'ROLLBACK;', 4]] ``` -После паузы — только рабочие соединения; следующие запросы шли по очереди, двух соединений им хватило. +Итоговая таблица команды: по восьми проверкам на режим (503, время 2–4,5 с, сессии в пределах пула, следующие запросы 200, записей пула 0, занятых соединений 0, сессий брошенной проверки `;` 0) — все совпали, `PASS: after a frozen database: no sessions over the pool, no pool records, the next requests work`. ## Настоящий PostgreSQL, через LB -`SELECT state, left(query, 12), count(*) FROM pg_stat_activity WHERE backend_type = 'client backend'` без своей сессии. Цепочка: срок 6 с + закрытие 2 с < `timeout server` 10 с, 504 нет. Сессий `;` нет; числа совпадают до и после каждой заморозки. +`SELECT state, left(query, 12), count(*) FROM pg_stat_activity WHERE backend_type = 'client backend'` без своей сессии. Цепочка: срок 6 с + закрытие 2 с < `timeout server` 10 с, 504 нет. Сессий `;` нет; числа совпадают до и после каждой заморозки. Перед первой заморозкой пул реплик прогрет запросами: `idle|ROLLBACK;|20` — по 10 соединений на реплику. Порт LB — свободный на момент запуска. ```text +project mtusi-lab5-freeze: up, LB on 127.0.0.1 port 55557 --- before idle|ROLLBACK;|20 -idle|COMMIT;|2 === freeze 1 -GET /chats 503 8.01s error=unavailable -GET messages 503 8.01s error=unavailable POST login 503 8.01s error=unavailable GET attachment meta 503 8.01s error=unavailable +GET /chats 503 8.01s error=unavailable +GET messages 503 8.01s error=unavailable GET /users/me 503 8.02s error=unavailable POST message 503 8.02s error=unavailable -recovered after unpause: 0.65s +recovered after unpause: 0.64s --- after freeze 1 (+11 s) idle|ROLLBACK;|20 -idle|COMMIT;|2 === freeze 2 -POST message 503 8.02s error=unavailable -POST login 503 8.02s error=unavailable -GET /chats 503 8.02s error=unavailable -GET messages 503 8.02s error=unavailable -GET attachment meta 503 8.02s error=unavailable -GET /users/me 503 8.02s error=unavailable -recovered after unpause: 0.64s +GET attachment meta 503 8.01s error=unavailable +POST login 503 8.01s error=unavailable +POST message 503 8.01s error=unavailable +GET /chats 503 8.01s error=unavailable +GET messages 503 8.01s error=unavailable +GET /users/me 503 8.01s error=unavailable +recovered after unpause: 0.63s --- after freeze 2 (+11 s) idle|ROLLBACK;|20 -idle|COMMIT;|2 === freeze 3 -GET messages 503 8.01s error=unavailable -POST login 503 8.01s error=unavailable -GET /chats 503 8.01s error=unavailable -POST message 503 8.02s error=unavailable -GET /users/me 503 8.02s error=unavailable -GET attachment meta 503 8.02s error=unavailable -recovered after unpause: 0.65s +GET messages 503 8.09s error=unavailable +GET /chats 503 8.09s error=unavailable +GET attachment meta 503 8.09s error=unavailable +POST login 503 8.09s error=unavailable +POST message 503 8.09s error=unavailable +GET /users/me 503 8.09s error=unavailable +recovered after unpause: 0.64s --- after freeze 3 (+11 s) idle|ROLLBACK;|20 -idle|COMMIT;|2 +project mtusi-lab5-freeze: down (no volumes) +answers 503 unavailable expected 18 got 18 +answers from LB 504 expected 0 got 0 +every answer before timeout server 10 s expected yes got yes +recovered within 30 s every time expected yes got yes +sessions within the pools (20) after every freeze expected yes got yes +sessions do not grow after the first freeze expected yes got yes +sessions of an abandoned ping (query ';') expected 0 got 0 +containers of the project left expected 0 got 0 +volumes of the project left expected 0 got 0 +PASS: frozen PostgreSQL: 503 from the replicas before timeout server of LB, no sessions over the pool ``` + +Отличие от прежнего снятия на `d8fe2e8`: там заморозка шла на рабочем стенде, с `idle|COMMIT;|2` от worker и relay. Здесь их на стенде нет, остальные 20 сессий — те же. Время ответа 8,01–8,09 с против 8,01–8,02 с: третий заход на этом снятии чуть медленнее, 504 нет. diff --git a/evidence/tests/student-test-lb.md b/evidence/tests/student-test-lb.md index 788ccb93..b46b2eeb 100644 --- a/evidence/tests/student-test-lb.md +++ b/evidence/tests/student-test-lb.md @@ -1,21 +1,24 @@ # Свой набор через LB - Команда: `make student_test` (`BASE_URL=http://localhost:8080 EXPECT_REPLICAS=2`) -- Дата: 2026-10-31, 23:02:21–23:03:39 UTC; код выхода 2 (код pytest 1) -- Commit: `d8fe2e8` (ветка `feat/unit-of-work`), рабочее дерево чистое +- Дата: 2026-11-01, 10:46:33–10:47:58 UTC; код выхода 0 +- Commit: `9639aa1` (ветка `feat/track1-queue-overload`), код `src/` и `bench/` тот же, что на `5ee3257`; на рабочем дереве изменены `.claude/skills/run-mtusi-messenger/`, отчётные файлы и `evidence/`, в образ они не входят - Стенд: проект compose `mtusi-lab5`, две реплики за HAProxy, relay, worker, собран `make run_docker` из `HEAD` -- Итог: **1 failed, 223 passed, 141 deselected, 78,03 с**. 141 deselected — проверки отказов (`evidence/tests/failure-checks.md`) -- Единственное красное — ожидаемое `test_exclusion_evidence_exists`, причина ровно `missing_evidence`: файлы старых исключений `evidence/cache/hits.md`, `evidence/auth/passwords-and-tokens.md`, `evidence/idempotency/replay-after-restart.md` снимаются на последнем шаге всего прогона лабы (`QUESTIONS.md`, «Перенос из лабы 4»). Приложение тут ни при чём: проверяется наличие файла в репозитории -- `student-tests/` с change `unit-of-work` не менялись (`git diff --stat` пуст): набор доказывает, что поведение то же -- Вывод сокращён: убраны строки `PASSED`, заголовки блоков вывода и текст функции теста +- Итог: **224 passed, 147 deselected, 84,81 с**. 147 deselected — проверки отказов (`evidence/tests/failure-checks.md`, снят на `d8fe2e8`) +- `test_exclusion_evidence_exists` зелёный: файлы исключений сняты на стенде этой лабы (`evidence/cache/hits.md`, `evidence/auth/passwords-and-tokens.md`, `evidence/idempotency/replay-after-restart.md`, `evidence/queue/baseline2/summary.md` и прежние) +- Вывод сокращён: убраны строки `PASSED` и заголовки блоков вывода ```text -student-tests/test_coverage.py::test_exclusion_evidence_exists FAILED [ 50%] -E AssertionError: exclusion refers to missing evidence/cache/hits.md: chat-cache / Временная база -E exclusion refers to missing evidence/cache/hits.md: chat-cache / Срок записи -E exclusion refers to missing evidence/cache/hits.md: chat-cache / Чтение из кэша -E exclusion refers to missing evidence/idempotency/replay-after-restart.md: idempotency / Повтор после рестарта API -E exclusion refers to missing evidence/auth/passwords-and-tokens.md: sessions / Токена нет в хранилище -E exclusion refers to missing evidence/auth/passwords-and-tokens.md: users / Хэш в БД -=========== 1 failed, 223 passed, 141 deselected in 78.03s (0:01:18) =========== +student-tests/test_coverage.py::test_exclusion_evidence_exists PASSED [ 50%] +uploaded via 97b8c4574c46, downloaded via ['5aecf775f84d', '97b8c4574c46'] +coverage: 389 scenarios in 17 specs, 358 tested (173 by make failure_checks), 31 excluded +sent via 97b8c4574c46, replayed via ['5aecf775f84d'] +409 via ['5aecf775f84d', '97b8c4574c46'] +one session, 20 requests: {'5aecf775f84d': 10, '97b8c4574c46': 10} +written via 97b8c4574c46, read via {'5aecf775f84d': 3, '97b8c4574c46': 3} +race: 10 clients x 10 messages, statuses {201: 100}, max in flight 10; history: 100 messages, 100 unique ids, 4 pages by 30 +username race: 10 clients, statuses {409: 9, 201: 1}, max in flight 10 +key race: 10 clients, statuses {201: 10}, max in flight 10; history: 1 messages +key race through replicas: {'5aecf775f84d': 5, '97b8c4574c46': 5} +================ 224 passed, 147 deselected in 84.81s (0:01:24) ================ ``` diff --git a/evidence/tests/test-isolated.md b/evidence/tests/test-isolated.md index b2db9c6e..624ca6f4 100644 --- a/evidence/tests/test-isolated.md +++ b/evidence/tests/test-isolated.md @@ -1,22 +1,21 @@ # Набор на временной базе - Команда: `make test_isolated` -- Дата: 2026-10-31, 23:00:01–23:02:21 UTC; код выхода 2 (`results: {'test': 0, 'student_test': 2}`) -- Commit: `d8fe2e8` (ветка `feat/unit-of-work`), рабочее дерево чистое +- Дата: 2026-11-01, 10:48:00–10:50:36 UTC; код выхода 0 (`results: {'test': 0, 'student_test': 0}`) +- Commit: `9639aa1` (ветка `feat/track1-queue-overload`), код `src/` и `bench/` тот же, что на `5ee3257`; на рабочем дереве изменены `.claude/skills/run-mtusi-messenger/`, отчётные файлы и `evidence/`, в образ они не входят - Стенд: образ из рабочего дерева, контейнеры `mtusi-lab5-test-api`, `mtusi-lab5-test-worker`, `mtusi-lab5-test-relay` на базе `test_messenger` поверх хранилищ рабочего стенда, один процесс API, `EXPECT_REPLICAS=1` -- Итог: smoke — `PASS: lab5`; набор — **1 failed, 217 passed, 6 skipped, 141 deselected, 121,10 с** -- 6 skipped — тесты реплик против одного процесса, причина напечатана -- Красное — ожидаемое `test_exclusion_evidence_exists`, только `missing_evidence` по трём файлам, которые снимаются на последнем шаге прогона лабы: `evidence/cache/hits.md`, `evidence/auth/passwords-and-tokens.md`, `evidence/idempotency/replay-after-restart.md`; разбор — `evidence/tests/student-test-lb.md` -- Вывод сокращён: убраны лог сборки, строки `PASSED` и журналы контейнеров, которые цель печатает при коде ≠ 0 +- Итог: smoke — `PASS: lab5`; набор — **218 passed, 6 skipped, 147 deselected, 134,11 с** +- 6 skipped — тесты реплик против одного процесса, причина напечатана; 147 deselected — проверки отказов (`evidence/tests/failure-checks.md`, снят на `d8fe2e8`) +- Вывод сокращён: убраны лог сборки и строки `PASSED` ```text python3 tests/smoke.py --base-url "http://localhost:8080" PASS: lab5 public API scenario; infrastructure and grading evidence remain separate. -student-tests/test_coverage.py::test_exclusion_evidence_exists FAILED [ 50%] -two series of 18 requests: {'fed908d45572': 36} -ready in 0.44 s -coverage: 371 scenarios in 16 specs, 349 tested (164 by make failure_checks), 22 excluded +student-tests/test_coverage.py::test_exclusion_evidence_exists PASSED [ 50%] +two series of 18 requests: {'d9060d224783': 36} +ready in 0.64 s +coverage: 389 scenarios in 17 specs, 358 tested (173 by make failure_checks), 31 excluded race: 10 clients x 10 messages, statuses {201: 100}, max in flight 10; history: 100 messages, 100 unique ids, 4 pages by 30 username race: 10 clients, statuses {409: 9, 201: 1}, max in flight 10 key race: 10 clients, statuses {201: 10}, max in flight 10; history: 1 messages @@ -26,8 +25,8 @@ SKIPPED [1] student-tests/test_idempotency.py:372: one API process (EXPECT_REPLI SKIPPED [1] student-tests/test_load_balancing.py:18: one API process (EXPECT_REPLICAS=1): replica checks need the stand with the load balancer SKIPPED [1] student-tests/test_load_balancing.py:34: one API process (EXPECT_REPLICAS=1): replica checks need the stand with the load balancer SKIPPED [1] student-tests/test_race.py:169: one API process (EXPECT_REPLICAS=1): replica checks need the stand with the load balancer -===== 1 failed, 217 passed, 6 skipped, 141 deselected in 121.10s (0:02:01) ===== +========== 218 passed, 6 skipped, 147 deselected in 134.11s (0:02:14) ========== [test_isolated] cleanup [test_isolated] remove objects /buckets/messenger/test_messenger/ and queue test_messenger.attachment.process.v1 -[test_isolated] results: {'test': 0, 'student_test': 2} +[test_isolated] results: {'test': 0, 'student_test': 0} ``` diff --git a/evidence/worker/memory.md b/evidence/worker/memory.md index af8d353a..829008d7 100644 --- a/evidence/worker/memory.md +++ b/evidence/worker/memory.md @@ -1,26 +1,65 @@ # Память контейнера worker -- Команда: разовая проба на рабочем стенде через LB (`student-tests/images.py`, `api_client.py`): для каждого случая `docker stop` worker, две одинаковые загрузки, `docker start` (новая cgroup: `memory.peak` с нуля), ожидание `ready` обоих, затем `/proc/1/status`, `memory.peak`, `memory.events` контейнера, `docker inspect`, журнал worker -- Дата: 2026-10-31, 15:57:24–15:57:52 UTC; проба дошла до конца без исключения (код выхода не записан), разовый скрипт в репозиторий не входит. Перед этим прогоном были ещё два: первый — без файлов на обеих границах, те же числа в пределах 2 МиБ у `render_peak` и `VmHWM`, `memory.peak` до 857 МиБ; второй остановился на 413: файл пробы вышел больше 10 MiB, ошибка самой пробы -- Commit: `399da05` (ветка `feat/pipeline-reliability`), рабочее дерево чистое +- Команда: `python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 worker-memory` (два прогона подряд: разброс `memory.peak` важен для вывода) +- Дата: 2026-11-01, прогон 1 — 10:35:01–10:35:35 UTC, прогон 2 — 10:35:48–10:36:22 UTC; коды выхода 0 +- Commit: `9639aa1` (ветка `feat/track1-queue-overload`), код `src/` и `bench/` тот же, что на `5ee3257`; на рабочем дереве изменён только `.claude/skills/run-mtusi-messenger/driver.py`: в нём и появилась эта команда - Стенд: проект compose `mtusi-lab5`, собран `make run_docker` из `HEAD`; worker 1 CPU / 1 ГБ без swap, конкуренция 2, `render_memory_limit_mib` 450 - Спеки: `attachment-processing` «Изображение в лимите пикселей», design change `pipeline-reliability`, решение 7, «Уточнения apply», п. 13 и 19 -- Столбцы: `render_peak_kib` записи «Attachment became ready» по двум заданиям; «пересеклись» — оба задания начаты раньше, чем первое стало `ready`; `VmHWM` и `VmRSS` — процесс 1 worker; `memory.peak` — вся cgroup контейнера с процессами обработки. Файлы «40 Мпкс и ~10 MiB»: начало строк — шум, остальное — нули, поэтому обе границы контракта достигнуты разом -| Два файла разом | Файл, МиБ | `render_peak`, МиБ | `render_ms` | Пересеклись | `VmHWM`, МиБ | `VmRSS`, МиБ | `memory.peak`, МиБ | `oom` / `oom_kill` | `OOMKilled` | Рестарты | -|---|---|---|---|---|---|---|---|---|---|---| -| PNG из шума 10 MiB, 1868 × 1868 | 9,99 | 84 / 84 | 840 / 856 | да | 159 | 110 | 261 | 0 / 0 | false | 0 | -| PNG RGBA 8 бит, 40 Мпкс | 0,15 | 357 / 357 | 872 / 885 | да | 111 | 110 | 794 | 0 / 0 | false | 0 | -| PNG серый с альфой 8 бит, 40 Мпкс | 0,07 | 357 / 357 | 723 / 775 | да | 110 | 110 | 795 | 0 / 0 | false | 0 | -| PNG RGB 8 бит с tRNS, 40 Мпкс | 0,11 | 357 / 357 | 908 / 929 | да | 110 | 110 | 791 | 0 / 0 | false | 0 | -| PNG RGB 16 бит с tRNS, 40 Мпкс | 0,22 | 357 / 357 | 1036 / 1037 | да | 111 | 110 | 795 | 0 / 0 | false | 0 | -| PNG палитра с tRNS, 40 Мпкс | 0,04 | 357 / 357 | 740 / 750 | да | 110 | 110 | 794 | 0 / 0 | false | 0 | -| PNG серый 16 бит, 40 Мпкс | 0,07 | 404 / 404 | 706 / 712 | да | 110 | 110 | 888 | 0 / 0 | false | 0 | -| PNG RGBA 8 бит, 40 Мпкс и ~10 MiB | 9,85 | 366 / 367 | 1226 / 1288 | да | 157 | 111 | 832 | 0 / 0 | false | 0 | -| PNG серый 16 бит, 40 Мпкс и ~10 MiB | 9,79 | 414 / 414 | 723 / 730 | да | 154 | 115 | 905 | 0 / 0 | false | 0 | +Что делает команда. Для каждого случая: `docker stop` worker, две одинаковые загрузки, `docker start` (новая cgroup: `memory.peak` с нуля), ожидание `ready` обоих, затем `/proc/1/status`, `memory.peak`, `memory.events` контейнера, `docker inspect`, журнал worker. Файлы — генераторы тестов `student-tests/images.py` в контейнере образа без сети. Worker и relay запускаются при любом исходе; при незавершённых заданиях на стенде — код 2, код 1 при расхождении таблицы проверок. -Итог: +Столбцы: `render_peak_kib` записи «Attachment became ready» по двум заданиям; `overlap` — оба задания начаты раньше, чем первое стало `ready`; `VmHWM` и `VmRSS` — процесс 1 worker; `memory.peak` — вся cgroup контейнера с процессами обработки. Файлы «40 Mpx and ~10 MiB»: начало строк — шум, остальное — нули, поэтому обе границы контракта достигнуты разом. + +## Прогон 1 + +```text +worker mtusi-lab5-worker-1: limit 1024 MiB, concurrency 2, render_memory_limit_mib 450 +case | file MiB | render_peak MiB | render_ms | overlap | VmHWM | VmRSS | memory.peak | oom / oom_kill | OOMKilled | restarts +PNG noise 10 MiB, 1868 x 1868 | 9.99 | 84/84 | 1015/1006 | yes | 155 | 111 | 262 | 0 / 0 | false | 0 +PNG RGBA 8 bit, 40 Mpx | 0.15 | 357/357 | 1064/1067 | yes | 111 | 111 | 795 | 0 / 0 | false | 0 +PNG gray with alpha 8 bit, 40 Mpx | 0.07 | 357/357 | 797/800 | yes | 111 | 111 | 795 | 0 / 0 | false | 0 +PNG RGB 8 bit with tRNS, 40 Mpx | 0.11 | 357/357 | 859/869 | yes | 111 | 111 | 795 | 0 / 0 | false | 0 +PNG RGB 16 bit with tRNS, 40 Mpx | 0.22 | 357/357 | 1128/1139 | yes | 111 | 111 | 793 | 0 / 0 | false | 0 +PNG palette with tRNS, 40 Mpx | 0.04 | 357/357 | 739/741 | yes | 111 | 111 | 796 | 0 / 0 | false | 0 +PNG gray 16 bit, 40 Mpx | 0.07 | 404/404 | 634/645 | yes | 111 | 111 | 816 | 0 / 0 | false | 0 +PNG RGBA 8 bit, 40 Mpx and ~10 MiB | 9.85 | 367/367 | 908/959 | yes | 159 | 112 | 832 | 0 / 0 | false | 0 +PNG gray 16 bit, 40 Mpx and ~10 MiB | 9.79 | 414/414 | 684/743 | yes | 159 | 111 | 926 | 0 / 0 | false | 0 +largest render_peak 414 MiB, largest memory.peak 926 MiB, sum of peaks 159 + 2 x 414 = 987 MiB +every generated file within the contract expected yes got yes +attachments ready expected 18 got 18 +cases with both jobs at once expected 9 got 9 +render_peak records expected 18 got 18 +oom + oom_kill in all cases expected 0 got 0 +OOMKilled in any case expected no got no +restarts in any case expected no got no +render_peak below 450 MiB expected yes got yes +memory.peak below 1024 MiB expected yes got yes +sum of peaks below 1024 MiB expected yes got yes +PASS: two files at once at the contract limits fit the worker container +worker and relay running at the end: yes +``` + +## Прогон 2 + +Таблица проверок та же, все совпали. + +```text +PNG noise 10 MiB, 1868 x 1868 | 9.99 | 84/84 | 847/847 | yes | 158 | 111 | 262 | 0 / 0 | false | 0 +PNG RGBA 8 bit, 40 Mpx | 0.15 | 357/357 | 867/873 | yes | 111 | 111 | 795 | 0 / 0 | false | 0 +PNG gray with alpha 8 bit, 40 Mpx | 0.07 | 357/357 | 735/801 | yes | 111 | 111 | 792 | 0 / 0 | false | 0 +PNG RGB 8 bit with tRNS, 40 Mpx | 0.11 | 357/357 | 907/950 | yes | 111 | 111 | 793 | 0 / 0 | false | 0 +PNG RGB 16 bit with tRNS, 40 Mpx | 0.22 | 357/357 | 1037/1048 | yes | 112 | 111 | 794 | 0 / 0 | false | 0 +PNG palette with tRNS, 40 Mpx | 0.04 | 357/357 | 727/728 | yes | 110 | 110 | 795 | 0 / 0 | false | 0 +PNG gray 16 bit, 40 Mpx | 0.07 | 404/404 | 627/635 | yes | 111 | 111 | 833 | 0 / 0 | false | 0 +PNG RGBA 8 bit, 40 Mpx and ~10 MiB | 9.85 | 367/367 | 890/933 | yes | 158 | 111 | 831 | 0 / 0 | false | 0 +PNG gray 16 bit, 40 Mpx and ~10 MiB | 9.79 | 414/414 | 687/748 | yes | 155 | 111 | 705 | 0 / 0 | false | 0 +largest render_peak 414 MiB, largest memory.peak 833 MiB, sum of peaks 158 + 2 x 414 = 986 MiB +``` + +## Итог - все задания `ready`; ни одного `oom` и `oom_kill`, `OOMKilled` false, рестартов нет; -- самый дорогой файл в пределах контракта — серый 16 бит на обеих границах: `render_peak` 414 МиБ при лимите 450, `memory.peak` контейнера 905 МиБ при лимите 1024; -- верхняя оценка суммой пиков, которые на деле не совпадают по времени: 159 + 2 × 414 = 987 МиБ < 1 ГБ. +- самый дорогой файл в пределах контракта — серый 16 бит на обеих границах: `render_peak` 414 МиБ при лимите 450; +- `memory.peak` контейнера на нём — 926 МиБ в прогоне 1 и 705 МиБ в прогоне 2 при лимите 1024: пик зависит от того, насколько совпали по времени пики двух процессов обработки, поэтому одно значение его не описывает. Опора бюджета — не замер `memory.peak`, а верхняя оценка суммой пиков, которые на деле не совпадают по времени: 159 + 2 × 414 = 987 МиБ < 1 ГБ. + +Сравнение с прежним снятием разовой пробой на `399da05` (2026-10-31): `render_peak` 84 / 357 / 404 / 366–367 / 414 МиБ и `VmHWM` до 159 МиБ — те же (±1 МиБ); `memory.peak` самого дорогого случая был 905 МиБ, теперь 705–926 МиБ, у серого 16 бит на 40 Мпкс 888 против 816–833 МиБ. Числа `REPORT.md` обновлены по этому файлу.