fix: address upload-memory verify findings

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-22 16:11:03 +03:00
co-authored by Claude Opus 5.5
parent 79cc06b1e0
commit 9d2ee30cd2
17 changed files with 391 additions and 65 deletions
+5 -1
View File
@@ -363,7 +363,11 @@ docker — `bench/uploads.py` (`--selftest`).
окна, пик старта, наибольшие `anon` и `sock`, `oom_kill`, код выхода и
`OOMKilled`, ответы по кодам, загрузок 201/с, p50/p95/p99, пики S3 и
LB, пометки), `summary.md` (медиана и min–max по ячейкам, сценарии
спеков, H1–H4 с итогом), `raw/<прогон>-k6.json`, `raw/<прогон>-peak.log`.
спеков — с ростом на клиента и итогом «Буферы соединений ограничены»
по сумме роста LB и `sock` реплики от C = 1 до 40, H1–H4 с итогом
только по ячейкам гипотез; у метки `baseline` этих строк ещё нет —
design, «Уточнения apply», пп. 12–13), `raw/<прогон>-k6.json`,
`raw/<прогон>-peak.log`.
`quick-uploads-*` — в `.gitignore`.
- **Время:** полный профиль — 72 прогона, ~50 мин; `uploads_quick` —
«без лимита» и «с лимитом», 10 MiB, C ∈ {1, 10, 40}, один повтор,
+9 -2
View File
@@ -180,7 +180,7 @@ make env_setup»). Значение уже существующей переме
`max_waiting` (int, `ge=0`, 16; 0 — без очереди, сразу 429),
`wait_timeout_seconds` (float, `gt=0`, 5), `body_timeout_seconds`
(float, `gt=0`, 30). Значения — в `config.toml`, разовая подмена —
`UPLOADS__*` (стенд отказов — 1 / 1 / 1 / 2 у третьего API, профиль
`UPLOADS__*` (стенд отказов — 1 / 1 / 1 / 3 у третьего API, профиль
`uploads` — 1000 / 0 у варианта «без лимита»). Настройки, а не
константы: у установок разный лимит памяти. Неверное значение —
ошибка проверки настроек с именем поля, сервис не стартует. «Started
@@ -192,7 +192,14 @@ API» называет все четыре.
- `wait_timeout_seconds` 5 — молчание реплики до тела `2 × [database]
request_timeout_seconds + wait_timeout_seconds` = 17 с меньше `timeout
server` LB пути загрузки (30 с, `balancer.md`); при смене любого из
них пересчитать цепочку;
них пересчитать цепочку. **Проверки соотношения при старте нет** (в
отличие от grace уборщика): `timeout server` живёт в `haproxy.cfg`, и
процесс API его не знает. Поэтому `wait_timeout_seconds` больше `30 −
2 × request_timeout_seconds` = 18 с сервис примет молча, а ожидающая
загрузка получит 504 от LB вместо 429 реплики (design change
`upload-memory`, «Уточнения apply», п. 14). То же для молчания после
тела (≈ 26 с): бо́льшие `request_timeout_seconds` и `[s3]
timeout_seconds` выводят его за 30 с так же молча;
- `body_timeout_seconds` 30 — один срок на всё тело с момента, как
загрузка заняла место (не срок простоя: клиент по байту раз в 29 с
держал бы место вечно). Наибольшая длительность загрузки 17 + 30 + 26
+5 -3
View File
@@ -180,12 +180,14 @@ paths:
требует `Retry-After` — положительное целое;
- третий API стенда отказов — «узкий по загрузкам»
(`<проект>-api-uploads`, `UPLOADS_ENV` в `run_failures.py`: 1 место,
1 в очереди, ожидание 1 с, срок тела 2 с), тестам —
1 в очереди, ожидание 1 с, срок тела 3 с), тестам —
`FAULT_UPLOADS_BASE_URL` (фикстура `uploads_api`, срок клиента 30 с)
и `FAULT_UPLOADS_ENV`; тесты сверяют, что стенд запущен с этим
окружением (`assert_uploads_stand`). Место держит загрузка A
(`held_slot`): генератор тела отдаёт половину и ждёт
`threading.Event`; A отпускается до истечения её срока тела (2 с);
`threading.Event`; A отпускается до истечения её срока тела (3 с:
в `test_upload_slots_busy` A держит место ~1,3–1,5 с, при 2 с запас
был ~0,5 с — verify, S5);
- тесты (`fault`): `test_upload_slots_busy` (B ждёт, C сразу 429 < 0,5
с, B — 429 не раньше 1 с, `Retry-After` ≥ 1; из трёх загрузок новая
строка и объект — только у A), `test_rejections_before_queue` (при
@@ -280,7 +282,7 @@ paths:
идемпотентности 2 с, пул 1, короткие таймауты) и с change
`upload-memory` «узкий по загрузкам» (`FAULT_UPLOADS_BASE_URL`,
`UPLOADS_ENV` → `FAULT_UPLOADS_ENV`: 1 место, 1 в очереди, ожидание
1 с, срок тела 2 с); без любого из трёх адресов `pytest -m fault`
1 с, срок тела 3 с); без любого из трёх адресов `pytest -m fault`
останавливается до первого теста; при падении печатаются журналы
всех трёх;
- уборщик (с лабы 4): после bootstrap — `up -d --no-deps cleaner` с
+3 -2
View File
@@ -41,8 +41,9 @@ LB пути загрузки 30 с, дренаж замены 90 с, профи
— трек 2 лабы 2 (план запроса и восстановление), профили `failover` и
`rollout`, серии трека 1 лабы 3 (`scaling-bench`, `scaling-improvement`,
`profile-resources`). Changes лаб 2 и 3 и `s3-storage`, `attachments`,
`upload-consistency` лабы 4 — в `openspec/changes/archive/`, активных
нет, спеки синхронизированы (новые capability: с `s3-storage` —
`upload-consistency` лабы 4 — в `openspec/changes/archive/`; активен
один `upload-memory` (до archive), спеки синхронизированы, в том числе с
его дельтами (новые capability: с `s3-storage` —
`object-storage`, с `attachments` — `attachments`, с
`upload-consistency` — `storage-consistency`); в `KNOWN_ISSUES.md` две открытые записи (bootstrap после удаления
bucket; 408 LB на медленные заголовки текстом HAProxy). Отчёт, evidence и рабочий план лабы 3 остались в её
+21
View File
@@ -1056,6 +1056,27 @@ apply»; вопрос 1 открыт — сделано 429, как по умо
повторов, искажено только время (9,95 загрузки/с против ~11,0, p95
2 815 мс против ~2 050); медиана ячейки и выводы H1–H4 от него не
зависят. Предупреждение названо в `REPORT.md`.
21. **Правки по verify (2026-10-22, tasks, группа 11; design, «Уточнения
apply», пп. 12–16).** Метка `baseline` не переснимается; числа,
которых нет в её сводке, `REPORT.md` даёт формулой из её ячеек.
- Разбор сводки: H1 считает 429, OOM и 5xx только по ячейкам
гипотезы (10 MiB, C = 10, 20, 40: у `baseline` 429 — 1 351, а не
2 731 обоих тел) и печатает рост сверх C = 10 на клиента;
«Буферы соединений ограничены» — своя строка с вердиктом по сумме
роста LB и `sock` реплики от C = 1 до 40 (у `baseline` 0,56 + 0,39 =
0,95 MiB при пороге 1).
- Спеки: в требовании срока пути загрузки — буфер приёма LB от
клиента 128 KiB; «Лимит размера до чтения тела» — одна копия тела и
блоки чтения, рост пика ≤ 1,5 тела (как в сценарии).
- Проверки соотношения `wait_timeout_seconds` и `timeout server` LB
при старте нет: LB-значение API не знает; соотношение — в
`settings.md` и `config_example.toml`.
- Срок тела «узкого» API стенда отказов — 3 с вместо 2 с: запас
держателя места в `test_upload_slots_busy` был ~0,5 с. Evidence
`failure-checks.md` — переснять после commit.
- `REPORT.md`: таблица 1 MiB, числа и commit строк тестов
(`ce1ae2c`), ограничение «оборванный клиент в очереди держит место
очереди до срока ожидания».
#### Вопросы
+52 -18
View File
@@ -461,8 +461,9 @@ LB — `tune.sndbuf.server 262144` (буфер отправки к реплик
`tune.rcvbuf.client 131072` (буфер приёма от клиента). Второй добавлен
после первой метки профиля: в ней пик LB рос на ~2,6 MiB на клиента,
очередь приёма сокета клиента — до 9 MiB (`97a4be4`; design, «Уточнения
apply», п. 11). С ним — 0,56 MiB на клиента, скорость одного клиента
прежняя.
apply», п. 11). С ним в метке `baseline` пик LB «с лимитом» 10 MiB растёт
на (52,3 − 30,5) / 39 = 0,56 MiB на клиента от 1 до 40 клиентов (ячейки
`summary.md`), скорость одного клиента прежняя.
**Цепочка таймаутов пути загрузки** (решение 7):
@@ -607,7 +608,13 @@ failure_checks` (`evidence/tests/student-test-lb.md`,
`evidence/attachments/cleaner-process.md`; `make test`, `make
student_test` через LB (197 passed, сверка 215 / 200 / 36 / 15) и
`driver.py upload-consistency` на этом коде — PASS, их файлы остались с
`87c48b9` и `5b42bd2`: правка их шагов не меняет.
`87c48b9` и `5b42bd2`: правка их шагов не меняет. Строки памяти и сроков
загрузки (change `upload-memory`) — с `ce1ae2c` (код `97a4be4`): метка
`evidence/uploads/baseline/`, `evidence/uploads/lb-timeouts.md` и
`rollout-upload.md`; с того же commit переснято `make failure_checks`
(37 / 37), `make test_isolated` и `make student_test` через LB
(`evidence/tests/`), поэтому строки тестов рубрики и отказов S3 в таблице
называют `ce1ae2c`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
@@ -618,8 +625,8 @@ student_test` через LB (197 passed, сверка 215 / 200 / 36 / 15) и
| «3»: остановка загрузившей реплики → download через другую | `driver.py --port 8080 attachment-failover --mode stop` и `--mode kill` | загрузку принял `5f5d4ac50d9a`, `stop-one.sh` его остановил (`stop` и `kill`), метаданные и байты — 200 от `847ad74efd7c`, SHA-256 совпал, посторонний — 404; после `make replicas` обе `UP` | `evidence/attachments/failover.md` |
| «3»: restart с volumes сохраняет метаданные и оригинал | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (`LAB=4`) | PASS: прежний токен читает данные, оригинал вложения тот же; `StartedAt` новый у всех шести контейнеров (API, LB, PostgreSQL, Valkey, S3) | `evidence/replicas/test-persistence.md` |
| «3»: failover с записью | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` (каждая реплика, `stop` и `kill`, `STOP_ONE_LOG`) | 4 × PASS, `failed_attempts` 0, восстановление 0,76–1,2 с; `STOP_ONE_LOG` — оба контейнера | `evidence/failover/test-failover.md` |
| «4»: тесты большого файла, повреждённого изображения, подмены MIME, чужого `attachment_id`, вложения другого чата; ошибка клиента не 500 | `make student_test` через LB (`test_rubric.py`: пять сценариев лабы 4), `make test_isolated` | 197 passed через LB, 192 passed + 5 пропусков тестов реплик в одном процессе (оба — `87c48b9`); каждая ошибка — 4xx в формате контракта; сверка покрытия: 215 сценариев 13 спеков, 200 тестами (36 — проверками отказов), 15 исключений | `evidence/tests/student-test-lb.md`, `evidence/tests/test-isolated-s3-cleanup.md` |
| «4»: отказы S3 на путях вложений, отклонённая загрузка ничего не оставляет | `make failure_checks` | 32 / 32, код 0 (`5889ca2`): S3 остановлен — загрузка 503, ровно одна новая строка `pending`, готовые те же, текст 201; скачивание 503, метаданные 200, история с `attachment_ids` 200, `/health/ready` 200; S3 заморожен — 503 не позже 5,6 с; отклонённые загрузки — ни новых строк, ни новых объектов (списки `id`); рабочий стенд не тронут | `evidence/tests/failure-checks.md` |
| «4»: тесты большого файла, повреждённого изображения, подмены MIME, чужого `attachment_id`, вложения другого чата; ошибка клиента не 500 | `make student_test` через LB (`test_rubric.py`: пять сценариев лабы 4), `make test_isolated` | 198 passed через LB, 193 passed + 5 пропусков тестов реплик в одном процессе (оба — `ce1ae2c`); каждая ошибка — 4xx в формате контракта; сверка покрытия: 227 сценариев 13 спеков, 210 тестами (45 — проверками отказов), 17 исключений | `evidence/tests/student-test-lb.md`, `evidence/tests/test-isolated-s3-cleanup.md` |
| «4»: отказы S3 на путях вложений, отклонённая загрузка ничего не оставляет | `make failure_checks` | 37 / 37, код 0 (`ce1ae2c`): S3 остановлен — загрузка 503, ровно одна новая строка `pending`, готовые те же, текст 201; скачивание 503, метаданные 200, история с `attachment_ids` 200, `/health/ready` 200; S3 заморожен — 503 не позже 5,6 с; отклонённые загрузки — ни новых строк, ни новых объектов (списки `id`); рабочий стенд не тронут | `evidence/tests/failure-checks.md` |
| «4»: прерывание загрузки и отказ между S3 и БД не оставляют вечных неучтённых объектов | `make failure_checks` (стенд отказов: уборщик с grace 20 с, интервал 1 с) | сбой записи строки (SQLSTATE 08006) — 503, ни строки, ни объекта; обрыв клиента посреди тела — ни строки, ни объекта; сбой фиксации `ready` — 503, объекта нет сразу (компенсация), строка `pending` не видна по API, на G/2 ещё на месте, после G + I + 5 с убрана; S3 заморожен на время PUT — строка убрана после grace, объект не появился; kill реплики между PUT и фиксацией — 201 не дошёл, строка и объект есть до grace, после — ни того, ни другого; COMMIT `ready` упал (отложенный триггер) — 503, объект на месте (исход неизвестен), после grace убран; загрузка дольше grace (строка «старше» на час, уборщик убрал её, пока перевод в `ready` ждал) — 503, а не 201 и не 500, ни строки, ни объекта; уборщик удалил объект, а удаление строки упало в той же транзакции уборки — 503, а не 201, `ready` без объекта нет, следующий проход доводит уборку; во всех — объектов без строки 0 (`object-ids − attachment-ids`); красный прогон до кода — 4 из 11 упали; тесты по verify: W1 — 201 на коде `f2dc0b3`, W2 и W3 — красные на временных регрессиях (компенсация на любой сбой, `RuntimeError` → 500) | `evidence/tests/failure-checks.md` |
| «4»: то же на рабочем стенде через LB | `driver.py --port 8080 upload-consistency` | S3 заморожен — 503 за 5,1 с, строка `pending` с ключом; сбой фиксации `ready` — 503, объекта нет; обе строки — 404 на метаданные, байты и ссылку; `cleaner --once` (grace 30 с) — `removed 2`, код 0; строк и объектов нет, «1200 objects, 1200 rows, 0 objects without a row»; готовое вложение — тот же SHA-256; в журнале API шаги `put` / `ready` и «Deleted attachment object», `filename` — 0 вхождений | `evidence/attachments/consistency.md` |
| «4»: документированный механизм компенсации и очистки с безопасным grace period | описание и проверка старта уборщика | таблица компенсации, уборщик под `FOR UPDATE SKIP LOCKED` в два шага — пометка строки, затем объект и строка одной транзакцией, B = 2 × 6 + 5 = 17 с, grace 900 с (×50); grace 17 с — код 2 с grace, обоими сроками и границей; интервал 0 и `abc` — код 2; старт — «Started cleaner» с 60 / 900 / 100; `docker compose stop cleaner` — 0,57 с, код 0 | раздел «Согласованность БД и S3», `evidence/attachments/cleaner-process.md` |
@@ -641,8 +648,8 @@ student_test` через LB (197 passed, сверка 215 / 200 / 36 / 15) и
| «4»: память S3 при одновременных загрузках | 20 одновременных PUT по 10 MiB ключом API | все подтверждены, анонимная память не больше 379 MiB из 512, OOM нет; с местами API в S3 не больше 4 PUT от реплики — в метке `uploads` 503 по сроку S3 нет | `evidence/s3/memory.md`, `evidence/uploads/baseline/summary.md` |
| Логи без секретов S3 | `grep -F` значений секретов по журналу клиента и `make run_dev` | 0 совпадений; отказ в учётных данных — одна запись `error` без секрета | `evidence/s3/client.md` |
| «4»: ≥ 10 одновременных загрузок, пик памяти | `make bench_uploads` (метка `baseline`, `97a4be4`, `dirty: false`; 72 прогона: 3 варианта × 2 тела × 4 уровня × 3 повтора; реплика 1 CPU / 512 МБ без swap) | «с лимитом», 10 MiB: пик реплики 169,5 / 177,3 / 181,3 MiB при 10 / 20 / 40 клиентах, OOM 0, 5xx 0, лишние — 429; «без лимита» и код до change при 40 × 10 MiB — OOM 3/3, код до change и при 20 × 10 MiB — OOM 3/3; в паспорте — предупреждение о swap хоста (раздел «Одновременные загрузки») | `evidence/uploads/baseline/summary.md` |
| «4»: лимит одновременных загрузок, очередь и 429 | `make failure_checks`: «узкий по загрузкам» API (1 место, 1 в очереди, ожидание 1 с, срок тела 2 с) | при полной очереди — 429 `rate_limited` быстрее 0,5 с, по сроку ожидания — 429 не раньше 1 с, `Retry-After` ≥ 1, ни строки, ни объекта; 404 / 413 / 415 — раньше очереди; место освобождается после 413, 415, 400 по сроку, обрыва и 503; ожидавшая — 201, её `created_at` позже `updated_at` державшей место | `evidence/tests/failure-checks.md` |
| «4»: срок передачи тела | `make failure_checks` (`test_slow_body`) | тело частями дольше 2 с — 400 «Upload body was not received in time», ни строки, ни объекта; мелкими частями в срок — 201 с тем же SHA-256 | `evidence/tests/failure-checks.md` |
| «4»: лимит одновременных загрузок, очередь и 429 | `make failure_checks`: «узкий по загрузкам» API (1 место, 1 в очереди, ожидание 1 с, срок тела 2 с в прогоне `ce1ae2c`; с правки по verify — 3 с, запас держателя места) | при полной очереди — 429 `rate_limited` быстрее 0,5 с, по сроку ожидания — 429 не раньше 1 с, `Retry-After` ≥ 1, ни строки, ни объекта; 404 / 413 / 415 — раньше очереди; место освобождается после 413, 415, 400 по сроку, обрыва и 503; ожидавшая — 201, её `created_at` позже `updated_at` державшей место | `evidence/tests/failure-checks.md` |
| «4»: срок передачи тела | `make failure_checks` (`test_slow_body`) | тело частями дольше срока тела стенда (2 с в прогоне `ce1ae2c`) — 400 «Upload body was not received in time», ни строки, ни объекта; мелкими частями в срок — 201 с тем же SHA-256 | `evidence/tests/failure-checks.md` |
| «4»: 10 одновременных загрузок проходят | `make student_test` через LB и `make test_isolated` (`test_concurrent_uploads`) | 10 участников одного чата, PNG ~1 MiB: все 201, `id` разные, скачиваются побайтно — и через LB, и на одном процессе | `evidence/tests/student-test-lb.md`, `evidence/tests/test-isolated-s3-cleanup.md` |
| «4»: таймауты LB пути загрузки | `driver.py lb-upload-timeouts` на текущем `haproxy.cfg` и на `f894040` | сейчас: молчание 12 с до и после тела — 201, другой путь — 504 через 10,01 с, 32 с — 504 через 30,11 с, клиент молчит посреди тела — 400 JSON через 30,02 с; на `f894040` — 502 / 504 через 10 с и 400 HTML (код 1) | `evidence/uploads/lb-timeouts.md` |
| «4»: плановая замена не обрывает загрузку | две загрузки ~20 и ~26 с через LB во время `make rolling_update` | обе 201 с тем же SHA-256; дренаж реплики с загрузкой — 14 с, остановка после ответа (`ROLLOUT_DRAIN_TIMEOUT` 90 с) | `evidence/uploads/rollout-upload.md` |
@@ -756,21 +763,42 @@ change `upload-memory` (Context, «Пробы»), а не из метки. Ра
| с лимитом | 20 | 177,3 | 0/3 | 269 | 0 | 0 | 10,90 | 2 059 | 42,9 |
| с лимитом | 40 | 181,3 | 0/3 | 269 | 452 | 0 | 11,00 | 2 092 | 52,3 |
Тело ~1 MiB, загрузок/с при 10 / 20 / 40 клиентах: «без лимита» 128,30 /
131,75 / 131,95, «с лимитом» 124,00 / 118,75 / 119,60; пик «с лимитом» —
119,7 / 127,0 / 132,2 MiB. Память до окна во всех ячейках — ~105 MiB,
пик старта реплики (фиктивный хэш пароля, разогрев) — ~152,6 MiB и в пик
окна не входит.
Те же медианы, тело ~1 MiB (OOM нет ни в одной ячейке, 5xx — 0):
| Вариант | C | Пик, MiB | OOM | 201 | 429 | 5xx | Загрузок/с | p95, мс | Пик LB, MiB |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| до | 1 | 110,0 | 0/3 | 1 445 | 0 | 0 | 62,85 | 17 | 30,8 |
| до | 10 | 136,8 | 0/3 | 2 976 | 0 | 0 | 129,85 | 108 | 34,4 |
| до | 20 | 153,0 | 0/3 | 2 950 | 0 | 0 | 127,85 | 196 | 37,6 |
| до | 40 | 199,2 | 0/3 | 3 043 | 0 | 0 | 132,15 | 365 | 52,8 |
| без лимита | 1 | 109,0 | 0/3 | 1 477 | 0 | 0 | 64,05 | 17 | 30,8 |
| без лимита | 10 | 127,1 | 0/3 | 2 946 | 0 | 0 | 128,30 | 107 | 34,8 |
| без лимита | 20 | 138,0 | 0/3 | 3 026 | 0 | 0 | 131,75 | 203 | 37,4 |
| без лимита | 40 | 163,2 | 0/3 | 3 045 | 0 | 0 | 131,95 | 367 | 52,7 |
| с лимитом | 1 | 109,0 | 0/3 | 1 480 | 0 | 0 | 64,20 | 17 | 30,5 |
| с лимитом | 10 | 119,7 | 0/3 | 2 822 | 0 | 0 | 124,00 | 106 | 34,6 |
| с лимитом | 20 | 127,0 | 0/3 | 2 728 | 0 | 0 | 118,75 | 211 | 38,3 |
| с лимитом | 40 | 132,2 | 0/3 | 2 751 | 460 | 0 | 119,60 | 210 | 52,5 |
Память до окна во всех ячейках — ~105 MiB, пик старта реплики (фиктивный
хэш пароля, разогрев) — ~152,6 MiB и в пик окна не входит.
Выводы (строки «Гипотезы» и «Сценарии спеков» `summary.md`):
- **H1 — подтверждена.** «С лимитом» пик 169,5 / 177,3 / 181,3 MiB при 10
/ 20 / 40 клиентах — меньше половины лимита (256 MiB); сверх C = 10 —
0,39 MiB на клиента (порог 1); OOM 0, 5xx 0, лишние загрузки — 429 (2
731 за ячейки 10 MiB). Сценарий `attachments` «Память не растёт с
числом загрузок» выполнен; `load-balancing` «Буферы соединений
ограничены» — пик LB 30,5 → 52,3 MiB от 1 до 40 клиентов (0,56 MiB на
клиента), буферы сокетов реплики ≤ 19,6 MiB.
/ 20 / 40 клиентах — меньше половины лимита (256 MiB); рост сверх C = 10
на клиента — (177,3 − 169,5) / 10 = 0,78 MiB при C = 20 и (181,3 −
169,5) / 30 = 0,39 MiB при C = 40 (порог 1); OOM 0, 5xx 0, лишние
загрузки — 429 (1 351 за ячейки 10 MiB, строка «Сценарии спеков»).
Строка H1 сводки метки считает 429 по обоим телам и C = 1 (2 731): так
разбор сводки работал до правки по verify, новые метки считают только
ячейки гипотезы. Сценарий `attachments` «Память не растёт с числом
загрузок» выполнен. `load-balancing` «Буферы соединений ограничены»
(C = 1 → 40, ячейки «с лимитом» 10 MiB) — пик LB (52,3 − 30,5) / 39 =
0,56 MiB на клиента, `sock` реплики (19,4 − 4,1) / 39 = 0,39 MiB, в
сумме 0,95 MiB при пороге 1 MiB, OOM 0: выполнен. Вердикта по нему в
сводке метки нет — его строку разбор пишет с правки по verify, числа
выше — из ячеек той же сводки.
- **H2 — подтверждена.** «Без лимита»: 1,20 тела на клиента при C = 10 и
1,13 при C = 20 (чуть ниже ожидаемых 1,2–1,3), при 40 × 10 MiB — OOM
3/3. «До»: 2,17 тела на клиента при C = 10 — вторая копия тела при PUT,
@@ -898,6 +926,12 @@ S3 (change `s3-storage`):
другой места есть; LB 429 не повторяет. Сглаживают очередь (16) и
`Retry-After: 1` — повтор клиента уходит на следующую реплику
(round-robin). Общей очереди на стенд нет.
- **Оборванный клиент в очереди держит её место до срока ожидания**
(5 с): обрыв соединения API замечает, только когда начинает читать
тело, то есть получив место. Пока такая загрузка ждёт, новая может
получить 429 при полной очереди; затем она берёт место, сразу
заканчивается `interrupted` и отпускает его (проба verify). Места
загрузки она не держит дольше обычной.
- **429 или 503 — вопрос преподавателю открыт** (`PLAN.md`, «Вопросы»,
п. 1). Ответ «503» поменяет строку таблицы ошибок, сценарии спеков и
ожидания тестов, но не подход.
+132 -17
View File
@@ -461,6 +461,25 @@ def per_client_bodies(row: dict[str, Any]) -> float | None:
return (peak - before) * MIB / body / clients
def growth_per_client(
base: float | None,
value: float | None,
clients: int,
) -> float | None:
"""Рост медианы ячейки над базовой ячейкой на клиента, MiB."""
if base is None or value is None or clients <= 0:
return None
return (value - base) / clients
def cell_median(
grouped: dict[tuple[str, str, int], list[dict[str, Any]]],
key: tuple[str, str, int],
column: str,
) -> float | None:
return median(num(r.get(column)) for r in grouped.get(key, []))
def hypotheses(
rows: list[dict[str, Any]],
*,
@@ -480,19 +499,20 @@ def hypotheses(
out = []
# H1: с лимитом пик ≤ половины лимита, рост сверх C=10 ≤ 1 MiB на
# клиента, OOM и 5xx нет, лишние — 429
limited = [r for r in rows if r["variant"] == "limited"]
# клиента, OOM и 5xx нет, лишние — 429. Всё — по ячейкам тела big и
# C = 10, 20, 40, как в тексте гипотезы (метка baseline считала OOM,
# 5xx и 429 по всем размерам и C = 1)
levels = [c for c in (10, 20, 40) if group("limited", big, c)]
if levels:
limited = [r for c in levels for r in group("limited", big, c)]
peaks = {c: peak("limited", c) for c in levels}
base = peaks.get(10)
growth_ok = all(
base is not None
and peaks[c] is not None
and peaks[c] - base <= (c - 10)
growth = {
c: growth_per_client(base, peaks[c], c - 10)
for c in levels
if c > 10
)
}
growth_ok = all(v is not None and v <= 1 for v in growth.values())
half_ok = all(
v is not None and v <= memory_limit_mib / 2 for v in peaks.values()
)
@@ -508,8 +528,13 @@ def hypotheses(
"и 5xx нет, лишние — 429",
"numbers": "пик, MiB: "
+ ", ".join(f"C={c} {fmt(peaks[c])}" for c in levels)
+ f" (половина лимита {memory_limit_mib / 2:g}); OOM "
f"{oom}, 5xx {fives}, 429 {busy}",
+ f" (половина лимита {memory_limit_mib / 2:g}); сверх "
"C=10, MiB на клиента: "
+ (
", ".join(f"C={c} {fmt(v, 2)}" for c, v in growth.items())
or "—"
)
+ f"; OOM {oom}, 5xx {fives}, 429 {busy}",
"result": "да" if verdict else "нет",
},
)
@@ -749,16 +774,34 @@ def scenario_lines(rows: list[dict[str, Any]], big: str) -> list[str]:
lim = [grouped.get(("limited", big, c), []) for c in (10, 20, 40)]
if any(lim):
flat = [r for items in lim for r in items]
base = cell_median(grouped, ("limited", big, 10), "peak_mib")
over = [
f"C={c} "
+ fmt(
growth_per_client(
base,
cell_median(grouped, ("limited", big, c), "peak_mib"),
c - 10,
),
2,
)
for c, items in zip((20, 40), lim[1:], strict=True)
if items
]
lines.append(
"- `attachments`, «Память не растёт с числом загрузок» и "
"`load-balancing`, «Буферы соединений ограничены» («с лимитом», "
f"{big}): пик реплики "
"- `attachments`, «Память не растёт с числом загрузок» («с "
f"лимитом», {big}): пик реплики "
+ ", ".join(
f"C={c} {fmt(median(num(r['peak_mib']) for r in items))}"
for c, items in zip((10, 20, 40), lim, strict=True)
if items
)
+ " MiB, sock "
+ (
" MiB (сверх C=10, MiB на клиента: " + ", ".join(over) + ")"
if over
else " MiB"
)
+ ", sock "
+ ", ".join(
f"C={c} {fmt(median(num(r['sock_max_mib']) for r in items))}"
for c, items in zip((10, 20, 40), lim, strict=True)
@@ -774,10 +817,52 @@ def scenario_lines(rows: list[dict[str, Any]], big: str) -> list[str]:
f"{sum(errors_5xx(r) for r in flat)}, 429 "
f"{sum(int(num(r.get('s429')) or 0) for r in flat)}.",
)
lines.append(buffers_line(grouped, big))
lines.append("")
return lines
def buffers_line(
grouped: dict[tuple[str, str, int], list[dict[str, Any]]],
big: str,
) -> str:
"""`load-balancing`, «Буферы соединений ограничены»: рост медианы пика
LB и наибольшего `sock` реплики «с лимитом» от C = 1 до C = 40 на
клиента; выполнен, если их сумма ≤ 1 MiB и при C = 40 нет OOM.
Сумма — строже прочтения «каждый ≤ 1 MiB» (design, «Уточнения apply»,
п. 13)."""
one, top = ("limited", big, 1), ("limited", big, 40)
name = (
"- `load-balancing`, «Буферы соединений ограничены» («с лимитом», "
f"{big}, C = 1 → 40): "
)
if not grouped.get(one) or not grouped.get(top):
return name + "нет данных (нужны ячейки C = 1 и C = 40)."
parts, total = [], 0.0
for column, label in (
("lb_peak_mib", "пик LB"),
("sock_max_mib", "sock"),
):
a = cell_median(grouped, one, column)
b = cell_median(grouped, top, column)
slope = growth_per_client(a, b, 39)
if slope is None:
return name + f"нет данных ({label})."
total += slope
parts.append(
f"{label} ({fmt(b)} − {fmt(a)}) / 39 = {fmt(slope, 2)} MiB на "
"клиента",
)
ooms = sum(is_oom(r) for r in grouped[top])
verdict = "да" if total <= 1 and not ooms else "нет"
return (
name
+ "; ".join(parts)
+ f"; сумма {fmt(total, 2)} (порог 1 MiB на клиента), OOM при "
f"C = 40 {ooms}/{len(grouped[top])}; выполнен — {verdict}."
)
# --------------------------------------------------------------- selftest
@@ -912,19 +997,24 @@ def selftest() -> int:
return {**base, **extra}
rows = [
synth("limited", 1, 120, s429=7, lb_peak_mib=30, sock_max_mib=4),
synth("limited", 10, 170),
synth("limited", 20, 178, s429=5),
synth("limited", 40, 180, s429=60),
# другое тело: в H1 не входит ни 429, ни OOM
synth("limited", 40, 140, size="1MiB", s429=1000, flags="oom"),
synth("unlimited", 10, 230),
synth("unlimited", 20, 350),
synth("unlimited", 40, 512, flags="oom"),
synth("before", 10, 316),
synth("before", 20, 512, flags="oom"),
]
result = {
h["id"]: h["result"]
for h in hypotheses(rows, memory_limit_mib=512, big="10MiB")
}
checked = hypotheses(rows, memory_limit_mib=512, big="10MiB")
result = {h["id"]: h["result"] for h in checked}
h1 = checked[0]["numbers"]
expect("H1 429 of big body, C >= 10", "429 65" in h1, True)
expect("H1 OOM of big body", "OOM 0," in h1, True)
expect("H1 growth", "C=20 0.80, C=40 0.33" in h1, True)
expect("H1", result["H1"], "да")
expect("H2", result["H2"], "да")
expect("H3", result["H3"], "да")
@@ -960,6 +1050,31 @@ def selftest() -> int:
text = render_summary(meta, rows)
expect("summary has H1", "| H1 |" in text, True)
expect("summary has cells", "| с лимитом | 10MiB | 40 |" in text, True)
expect(
"replica growth over C=10",
"(сверх C=10, MiB на клиента: C=20 0.80, C=40 0.33)" in text,
True,
)
expect(
"buffers verdict",
"пик LB (50.0 − 30.0) / 39 = 0.51 MiB на клиента; sock (5.0 − 4.0) "
"/ 39 = 0.03 MiB на клиента; сумма 0.54"
in text
and "выполнен — да." in text,
True,
)
wide = rows + [synth("limited", 40, 181, lb_peak_mib=100)]
expect(
"buffers over the bound",
"выполнен — нет." in render_summary(meta, wide),
True,
)
expect(
"buffers without C=1",
"нет данных (нужны ячейки C = 1 и C = 40)"
in "\n".join(scenario_lines(rows[1:], "10MiB")),
True,
)
if failures:
print("selftest failed:\n " + "\n ".join(failures), flush=True)
return 1
+2 -1
View File
@@ -88,7 +88,8 @@ max_concurrent = 4
max_waiting = 16
# секунды ожидания места, затем 429 rate_limited с Retry-After; вход,
# членство и ожидание (2 × 6 + 5 = 17 с) меньше timeout server LB пути
# загрузки (30 с)
# загрузки (30 с). Проверки при старте нет: больше 18 с — 504 от LB
# вместо 429
wait_timeout_seconds = 5
# секунды на всё тело с момента, как загрузка заняла место; иначе 400
body_timeout_seconds = 30
+52 -2
View File
@@ -560,7 +560,8 @@ B = 17) и проверка уборщика. Удаление объекта у
`make failure_checks` — третий API стенда отказов
`<проект>-api-uploads` (`run_failures.py`, `UPLOADS_ENV`):
`UPLOADS__MAX_CONCURRENT=1`, `UPLOADS__MAX_WAITING=1`,
`UPLOADS__WAIT_TIMEOUT_SECONDS=1`, `UPLOADS__BODY_TIMEOUT_SECONDS=2`.
`UPLOADS__WAIT_TIMEOUT_SECONDS=1`, `UPLOADS__BODY_TIMEOUT_SECONDS=3`
(было 2 — «Уточнения apply», п. 15).
Тесты получают `FAULT_UPLOADS_BASE_URL` и `FAULT_UPLOADS_ENV`. Место
держит загрузка A: тело — генератор, который отдаёт половину и ждёт
`threading.Event` теста. Пока она идёт, тест выполняет нужный запрос,
@@ -804,4 +805,53 @@ git до sync дельт (`student-tests.md`).
скачивание), а `tune.rcvbuf.client` живёт в том же `haproxy.cfg`, что
`tune.sndbuf.server`, и действует на стенде `bench/` и в драйвере
без правки compose. Спек от правки не меняется: сценарий требует ≤ 1
MiB на клиента, и теперь он выполняется.
MiB на клиента, и теперь он выполняется. По verify (S1) требование
срока пути загрузки называет и этот буфер (128 KiB), сценарий тот же.
Правки по `/opsx:verify` (2026-10-22, задачи группы 11; пользователь
недоступен, решения — по спекам и design). Метка `baseline` не
переснимается: правки разбора действуют на будущие метки, числа
`baseline` в `REPORT.md` — формулой из ячеек её `summary.md`.
12. **H1 — по ячейкам гипотезы** (W1). `hypotheses()` считала OOM, 5xx
и 429 «с лимитом» по обоим телам и C = 1, хотя H1 — про 10 MiB и C =
10, 20, 40: в `baseline` строка H1 — «429 2731», а у ячеек 10 MiB
429 — 1 351 (строка «Сценарии спеков»). Теперь все три счётчика — по
тем же ячейкам, что и пик; строка H1 ещё печатает рост сверх C = 10 на
клиента по уровням (W2). Вердикт `baseline` не меняется: у 1 MiB нет
ни OOM, ни 5xx.
13. **«Буферы соединений ограничены» — своей строкой сводки** (W2):
рост медианы пика LB и наибольшего `sock` реплики «с лимитом» от C =
1 до C = 40, делённый на 39, их сумма и итог «выполнен — да / нет».
Сценарий говорит «пик памяти LB и буферов сокетов реплики растёт не
больше чем на 1 MiB на клиента»; порог проверяется на сумме — это
строже прочтения «каждый не больше 1 MiB» и выполняется при обоих. В
`baseline` — 0,56 + 0,39 = 0,95 MiB. Нет ячейки C = 1 или C = 40 —
«нет данных».
14. **Соотношение `wait_timeout_seconds` и `timeout server` LB — без
проверки при старте** (S3). У уборщика проверка есть, потому что
grace и граница B — его собственные настройки. `timeout server` пути
загрузки (30 с) живёт в `haproxy.cfg`, процесс API его не знает:
проверка дублировала бы константу LB в коде и молчала бы при правке
`haproxy.cfg`, а при запуске в консоли без LB мешала бы зря.
Соотношение (`2 × request_timeout_seconds + wait_timeout_seconds` <
30 с, то есть ожидание ≤ 18 с при сроке шага БД 6 с) и последствие
(504 от LB вместо 429) — в `settings.md` и `config_example.toml`.
15. **Срок тела «узкого» API стенда отказов — 3 с, а не 2 с** (S5). В
`test_upload_slots_busy` держатель места A занимает его, затем
пауза 0,2 с, B встаёт в очередь, ещё 0,2 с, C получает 429, B — 429
через 1 с ожидания; A отпускается после этого, примерно через 1,3–1,5
с от начала своего тела, и дошлёт вторую половину. При сроке 2 с запас
— ~0,5 с, а медленный шаг входа или членства B на занятом хосте
сдвигает отпускание A на то же время. 3 с дают ~1,5 с запаса.
`test_slow_body` и `test_slot_released_after_failures` берут срок из
`FAULT_UPLOADS_ENV`: тело частями за срок + 1 с — 400, за половину
срока — 201; набор дольше на ~2 с. Evidence `failure-checks.md` снят
на 2 с (`ce1ae2c`) и переснимается после commit правки.
16. **`attachments`, «Лимит размера до чтения тела»** (S4): вместо «не
больше лимита и одного блока чтения тела» — «одна копия тела и блоки
чтения — тела от клиента и клиента S3», с ростом пика реплики не
больше 1,5 тела на загрузку, как в сценарии «Одна копия тела при
записи в S3». Прежний текст не выполнялся буквально: замер — 1,19–1,20
тела, сверх одной копии — блоки чтения aiohttp и botocore и
накладные расходы аллокатора.
@@ -9,9 +9,11 @@ SHALL отдаваться без чтения тела. Без `Content-Length`
частями) тело SHALL читаться потоком со счётчиком. Ответ 413 SHALL
отдаваться, как только прочитано больше лимита, остаток тела MUST NOT
читаться. На одну загрузку процесс API MUST NOT держать в памяти больше
лимита и одного блока чтения тела. Это касается всех шагов загрузки, в
том числе записи объекта в S3: для отправки тело MUST NOT копироваться
целиком.
одной копии тела (не больше лимита) и блоков чтения — тела от клиента и
клиента S3. Это касается всех шагов загрузки, в том числе записи
объекта в S3: для отправки тело MUST NOT копироваться целиком. С
накладными расходами процесса рост пика памяти реплики — не больше 1,5
размера тела на загрузку (сценарий «Одна копия тела при записи в S3»).
#### Scenario: Граница размера
@@ -95,7 +95,8 @@ SHALL быть доступно только изнутри контейнера
Соединение с недочитанным телом SHALL держать в буферах ядра ограниченный
объём: буфер приёма сокетов реплики API — не больше 512 KiB, буфер
отправки LB к реплике — 256 KiB. Так ожидающие и отклонённые загрузки не
отправки LB к реплике — 256 KiB, буфер приёма LB от клиента — 128 KiB.
Так ожидающие и отклонённые загрузки не
переносят тела целиком ни в память реплики, ни в память LB.
#### Scenario: Долгая обработка загрузки
+86 -3
View File
@@ -471,13 +471,17 @@
- «с лимитом» — ни `oom`, ни 5xx; «до» и «без лимита» на 40 × 10 MiB —
`oom` 3/3, «до» на 20 × 10 MiB — 3/3;
- H1 — да (пик 169,5 / 177,3 / 181,3 MiB при C = 10 / 20 / 40, сверх
C = 10 — 0,39 MiB на клиента, 429 — 2 731); H2 — да («без лимита» 1,20
C = 10 — 0,78 MiB на клиента при C = 20 и 0,39 при C = 40, 429 —
1 351 за ячейки 10 MiB; строка H1 сводки считает оба тела — 2 731,
правка разбора — 11.1); H2 — да («без лимита» 1,20
тела на клиента при C = 10, 1,13 при C = 20, OOM 3/3 при 40; «до» 2,17
при C = 10, OOM 3/3 при 20); H3 — да (122 % / 121 % на 10 MiB, 97 / 90
/ 91 % на 1 MiB); H4 — да (503 — 0 в 63 прогонах без OOM);
- «Буферы соединений ограничены»: пик LB «с лимитом» 10 MiB — 30,5 /
36,1 / 42,9 / 52,3 MiB при C = 1 / 10 / 20 / 40, 0,56 MiB на клиента;
`sock` LB до 26,7 MiB.
36,1 / 42,9 / 52,3 MiB при C = 1 / 10 / 20 / 40, (52,3 − 30,5) / 39 =
0,56 MiB на клиента, `sock` реплики (19,4 − 4,1) / 39 = 0,39 MiB
(числа ячеек; вердикта в сводке метки нет — 11.2); `sock` LB до
26,7 MiB.
- [x] 10.4 `driver.py lb-upload-timeouts` →
`evidence/uploads/lb-timeouts.md`. Две медленные загрузки (~20 с, по
одной на реплику) во время `make rolling_update` →
@@ -529,3 +533,82 @@
сроки загрузки». Вопрос 1 ответа не получил — в «Согласования» не
внесён, назван в ограничениях. Числа сверены с `summary.md` метки,
все ссылки `evidence/…` из `REPORT.md` существуют.
## 11. Замечания проверки
Находки `/opsx:verify` (2026-10-22, CRITICAL нет). Метка
`evidence/uploads/baseline/` не переснимается и не меняется: правки
сводки действуют на будущие метки, а числа baseline в `REPORT.md`
считаются формулой из ячеек её `summary.md`.
- [x] 11.1 W1 — 429 в H1. `bench/uploads.py`, `hypotheses()`: H1
считает OOM, 5xx и 429 только по ячейкам «с лимитом» тела `big` и C ∈
{10, 20, 40}, а не по всем размерам и C = 1; случай в `--selftest`
(ячейки 1 MiB и C = 1 с 429 и OOM в H1 не входят). `REPORT.md` и 10.3:
«429 — 1 351 за ячейки 10 MiB» (`summary.md`, «Сценарии спеков») и
фраза, что строка H1 сводки метки `baseline` считает оба тела (2 731).
Проверка: `uv run python bench/uploads.py --selftest`.
`--selftest` — ok (новые случаи: ячейки 1 MiB с 429 и OOM и C = 1 с
429 в H1 не входят, «429 65»). Разбор `runs.csv` метки `baseline` новым
кодом в scratchpad (файлы метки не тронуты): H1 — «429 1351», «да».
Design, «Уточнения apply», п. 12.
- [x] 11.2 W2 — рост на клиента в сводке. `scenario_lines()` и
`hypotheses()`: рост пика реплики сверх C = 10 на клиента по уровням
(H1) и сценарий «Буферы соединений ограничены» — рост пика LB и `sock`
реплики от C = 1 до C = 40 на клиента, их сумма и итог. `REPORT.md`:
0,39 и 0,56 MiB — формулой из ячеек сводки, с C = 20 (0,78). Проверка:
`--selftest`.
Новая строка сводки на данных `baseline`: «пик LB (52.3 − 30.5) / 39 =
0.56; sock (19.4 − 4.1) / 39 = 0.39; сумма 0.95 (порог 1) … выполнен —
да»; рост сверх C = 10 — 0,78 / 0,39. Порог — на сумме (design,
«Уточнения apply», п. 13).
- [x] 11.3 W3 — таблица доказательств. `REPORT.md`: строки «4» тестов
рубрики и отказов S3 — числа и commit прогона `ce1ae2c` (198 passed,
193 + 5, сверка 227 / 210 / 45 / 17; 37 / 37), абзац перед таблицей —
фраза про evidence `upload-memory` с `ce1ae2c`. Проверка: числа
совпадают с `evidence/tests/*.md`.
- [x] 11.4 W4 — таблица результатов. `REPORT.md`: строки тела 1 MiB из
`summary.md` метки (варианты, OOM, ответы по кодам, p95, C = 1).
Проверка: числа совпадают со сводкой.
- [x] 11.5 S1 — `load-balancing`, требование срока пути загрузки:
«буфер приёма LB от клиента — 128 KiB» (дельта и основной спек).
Проверка: `openspec validate upload-memory --strict`, `--specs`.
- [x] 11.6 S2 — `REPORT.md`, «Ограничения»: оборванный клиент в очереди
держит её место до срока ожидания (5 с).
- [x] 11.7 S3 — соотношение `wait_timeout_seconds` и `timeout server`
LB без проверки при старте: `settings.md` и `config_example.toml`
(почему проверки нет — design, «Уточнения apply»).
Проверку при старте не делал (design, п. 14): `timeout server` — в
`haproxy.cfg`, процесс API его не знает.
- [x] 11.8 S4 — `attachments`, «Лимит размера до чтения тела»:
«одно тело и блоки чтения клиента S3» вместо «лимита и одного блока
чтения», согласовано со сценарием «Одна копия тела при записи в S3»
(1,5 тела); дельта и основной спек.
- [x] 11.9 S5 — запас `test_upload_slots_busy`: срок тела «узкого» API
стенда отказов 3 с вместо 2 с (`run_failures.py`, `test_failures.py`,
правила, design, `REPORT.md`); `test_slow_body` и
`test_slot_released_after_failures` берут срок из окружения.
Проверка: `make failure_checks` на дереве (не evidence).
Запас (design, п. 15): A держит место ~1,3–1,5 с от начала тела, при
сроке 2 с запас ~0,5 с, при 3 с — ~1,5 с. `make failure_checks` на
дереве (2026-10-22): 37 passed за 246,7 с, журнал PostgreSQL — crash
markers 0, стенд убран, список volumes прежний (155, тот же хэш).
`evidence/tests/failure-checks.md` снят на 2 с (`ce1ae2c`) — переснять
после commit; `REPORT.md` до пересъёмки называет 2 с прогона
`ce1ae2c` и 3 с с правки.
- [x] 11.10 S6 — AGENTS.md: change `upload-memory` активен до archive
(вводный абзац и строка «активных нет»).
- [x] 11.11 `make lint`, `make check`, `make validate
PYTHON=.venv/bin/python`, `openspec validate upload-memory --strict` и
`--specs`, `--selftest`.
Все — код 0: `openspec validate upload-memory --strict` — valid,
`--specs` — 24 passed; блоки «Лимит размера до чтения тела» и
«Загрузки через балансировщик» дельты и основных спеков совпали
построчно. `make student_test BASE_URL=http://localhost:8090` (не
evidence) — 198 passed, 37 deselected: сверка покрытия после правки
спеков зелёная.
+5 -3
View File
@@ -63,9 +63,11 @@ SHALL отдаваться без чтения тела. Без `Content-Length`
частями) тело SHALL читаться потоком со счётчиком. Ответ 413 SHALL
отдаваться, как только прочитано больше лимита, остаток тела MUST NOT
читаться. На одну загрузку процесс API MUST NOT держать в памяти больше
лимита и одного блока чтения тела. Это касается всех шагов загрузки, в
том числе записи объекта в S3: для отправки тело MUST NOT копироваться
целиком.
одной копии тела (не больше лимита) и блоков чтения — тела от клиента и
клиента S3. Это касается всех шагов загрузки, в том числе записи
объекта в S3: для отправки тело MUST NOT копироваться целиком. С
накладными расходами процесса рост пика памяти реплики — не больше 1,5
размера тела на загрузку (сценарий «Одна копия тела при записи в S3»).
#### Scenario: Граница размера
+2 -1
View File
@@ -502,7 +502,8 @@ SHALL быть без состояния, выставленного вручн
Соединение с недочитанным телом SHALL держать в буферах ядра ограниченный
объём: буфер приёма сокетов реплики API — не больше 512 KiB, буфер
отправки LB к реплике — 256 KiB. Так ожидающие и отклонённые загрузки не
отправки LB к реплике — 256 KiB, буфер приёма LB от клиента — 128 KiB.
Так ожидающие и отклонённые загрузки не
переносят тела целиком ни в память реплики, ни в память LB.
#### Scenario: Долгая обработка загрузки
+1 -1
View File
@@ -177,7 +177,7 @@ def tight_api() -> Iterator[Api]:
@pytest.fixture(scope="session")
def uploads_api() -> Iterator[Api]:
"""API стенда отказов с одним местом загрузки, одной загрузкой в
очереди, ожиданием места 1 с и сроком тела 2 с (`FAULT_UPLOADS_ENV`)."""
очереди, ожиданием места 1 с и сроком тела 3 с (`FAULT_UPLOADS_ENV`)."""
with Api(
FAULT_UPLOADS_BASE_URL,
timeout=UPLOADS_CLIENT_TIMEOUT_S,
+6 -4
View File
@@ -11,7 +11,7 @@ S3 со своими volumes, порты хранилищ не публикую
`MAX_IMAGE_PIXELS=1` в окружении — лимиты вложений от них не зависят),
«тесный» (сроки сессии и ключа идемпотентности 2 с, пул из одного
соединения) и «узкий по загрузкам» (одно место загрузки, одна в
очереди, ожидание места 1 с, срок тела 2 с; change `upload-memory`);
очереди, ожидание места 1 с, срок тела 3 с; change `upload-memory`);
- прогоняет тесты с маркером `fault` (`pytest -m fault`), передав им hook
`student-tests/fault_hook.py`; при падении печатает журналы API и
уборщика;
@@ -79,13 +79,15 @@ LIMITS_ENV = {
}
# «узкий по загрузкам» API (change upload-memory, design, решение 11): одно
# место загрузки, одна загрузка в очереди, ожидание места 1 с, срок тела
# 2 с. Те же пары тест получает в `FAULT_UPLOADS_ENV` и сверяет, что стенд
# запущен с ними
# 3 с: держатель места в test_upload_slots_busy отпускается через ~1,3–1,5 с
# после того, как занял место (ожидавшая получает 429 через 1 с), и срок
# тела должен оставить запас (с 2 с он был ~0,5 с; verify, S5). Те же пары
# тест получает в `FAULT_UPLOADS_ENV` и сверяет, что стенд запущен с ними
UPLOADS_ENV = {
"UPLOADS__MAX_CONCURRENT": "1",
"UPLOADS__MAX_WAITING": "1",
"UPLOADS__WAIT_TIMEOUT_SECONDS": "1",
"UPLOADS__BODY_TIMEOUT_SECONDS": "2",
"UPLOADS__BODY_TIMEOUT_SECONDS": "3",
}
+3 -3
View File
@@ -6,7 +6,7 @@ Valkey и S3, уборщик незавершённых загрузок (grace
(`BASE_URL`, с `MAX_UPLOAD_BYTES=1` и `MAX_IMAGE_PIXELS=1` в окружении),
«тесный» (сроки сессии и ключа идемпотентности 2 с, пул из одного
соединения) и «узкий по загрузкам» (`FAULT_UPLOADS_BASE_URL`: одно место
загрузки, одна в очереди, ожидание 1 с, срок тела 2 с — change
загрузки, одна в очереди, ожидание 1 с, срок тела 3 с — change
`upload-memory`). На хранилища и API тесты действуют только через фикстуру
`stand` (hook `student-tests/fault_hook.py`) и всегда возвращают их в
рабочее состояние. Решение 4 design change `failure-checks`, решение 10
@@ -1151,10 +1151,10 @@ EXPECTED_UPLOADS_ENV = {
"UPLOADS__MAX_CONCURRENT": "1",
"UPLOADS__MAX_WAITING": "1",
"UPLOADS__WAIT_TIMEOUT_SECONDS": "1",
"UPLOADS__BODY_TIMEOUT_SECONDS": "2",
"UPLOADS__BODY_TIMEOUT_SECONDS": "3",
}
WAIT_TIMEOUT_S = float(UPLOADS_ENV.get("UPLOADS__WAIT_TIMEOUT_SECONDS", "1"))
BODY_TIMEOUT_S = float(UPLOADS_ENV.get("UPLOADS__BODY_TIMEOUT_SECONDS", "2"))
BODY_TIMEOUT_S = float(UPLOADS_ENV.get("UPLOADS__BODY_TIMEOUT_SECONDS", "3"))
# отказ без ожидания места: вход, членство и ответ
IMMEDIATE_S = 0.5
# пауза, за которую запрос в соседнем потоке доходит до места или очереди