forked from mtusi2026/mtusi2026lab5
Grade 5
This commit is contained in:
@@ -4,6 +4,7 @@ APP_PORT=8080
|
||||
SESSION_TTL_SECONDS=3600
|
||||
MAX_UPLOAD_BYTES=10485760
|
||||
MAX_IMAGE_PIXELS=40000000
|
||||
MAX_PENDING_ATTACHMENTS=64
|
||||
WORKER_CONCURRENCY=2
|
||||
JOB_MAX_ATTEMPTS=5
|
||||
JOB_TIMEOUT_SECONDS=60
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
# Shell scripts are mounted into Linux containers, including on Windows hosts.
|
||||
*.sh text eol=lf
|
||||
@@ -22,6 +22,7 @@ x-api: &api
|
||||
S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:?Set S3_SECRET_ACCESS_KEY in .env}
|
||||
MAX_UPLOAD_BYTES: ${MAX_UPLOAD_BYTES:-10485760}
|
||||
MAX_IMAGE_PIXELS: ${MAX_IMAGE_PIXELS:-40000000}
|
||||
MAX_PENDING_ATTACHMENTS: ${MAX_PENDING_ATTACHMENTS:-64}
|
||||
BROKER_URL: redis://broker:6379/0
|
||||
WORKER_CONCURRENCY: ${WORKER_CONCURRENCY:-2}
|
||||
JOB_MAX_ATTEMPTS: ${JOB_MAX_ATTEMPTS:-5}
|
||||
|
||||
@@ -0,0 +1,37 @@
|
||||
# Проверка перед защитой — 6 ноября 2026
|
||||
|
||||
Техническая реализация покрывает уровни 3, 4 и трек 1 уровня 5.
|
||||
Формальное оформление ещё не завершено: REPORT.md и шаблон PR оставлены
|
||||
с TODO по указанию автора. Оценку выставляет преподаватель после защиты.
|
||||
|
||||
| Требование | Проверка и результат |
|
||||
|---|---|
|
||||
| Публичный API, 202/queued, доступ, оригинал, thumbnail | `python -X utf8 tests/smoke.py --base-url http://127.0.0.1:8080` — PASS |
|
||||
| Структура и неизменность контрактов | `python -X utf8 scripts/check_contract.py` — PASS; контракт и публичные тесты не изменены |
|
||||
| Размеры, округление, EXIF, alpha, pixel limit | `docker compose run --rm --no-deps -v ./student-tests:/checks:ro worker python -m unittest discover -s /checks` — 5/5 OK |
|
||||
| Outbox, сохранность при остановках, lease, дубли, retry/replay, cleanup | `python -X utf8 student-tests/pipeline.py` — [вывод](defense-pipeline.txt) |
|
||||
| Постоянные ошибки, retention, идемпотентность сообщения, реальный timeout процесса | `python -X utf8 student-tests/edge_cases.py` — [вывод](defense-edge-cases.txt) |
|
||||
| Жёсткий сбой после COMMIT до publish | `python -X utf8 student-tests/pipeline.py --outbox-only` — API завершается через SIGKILL при остановленном dispatcher; [вывод](defense-outbox-crash.txt) |
|
||||
| Трек 1: три настройки, разные размеры, throughput/lag/p95/RSS | Проверена матрица 18 замеров / 324 файла и SHA-256 текущих исходников приложения/эксперимента; [результаты](queue-results.md), [методика](queue-method.md) |
|
||||
| Backpressure и восстановление | При лимите 12: 12 ответов 202, 12 ответов 429; после перезапусков все 12 ID готовы, исходники и варианты сохранены; новая загрузка принята |
|
||||
|
||||
Полный нагрузочный эксперимент при этой проверке не повторялся: сохранённые
|
||||
данные соответствуют текущим исходникам, матрица и результаты перепроверены.
|
||||
Новый чистый clone отдельно не разворачивался. Исправлен обнаруженный риск
|
||||
Windows-checkout: `.gitattributes` сохраняет LF для `.sh`; Git-фильтры проверены
|
||||
с `core.autocrlf=true`. Прикладной код и измеренные параметры не менялись.
|
||||
|
||||
## Что объяснить на защите
|
||||
|
||||
- До 202 сохранены staging и транзакция PostgreSQL с вложением и outbox-job.
|
||||
- Ответ Redis на XADD при AOF/appendfsync=always подтверждает запись в брокер;
|
||||
XACK подтверждает обработку потребителем. Это разные границы.
|
||||
- Доставка at least once: дубль возможен. Постоянный job_id, ключи вариантов,
|
||||
транзакционное состояние и lease-token делают результат идемпотентным.
|
||||
- Timeout ограничивает отдельный процесс, lease восстанавливает работу после
|
||||
его смерти; токен и блокировка job защищают фиксацию результата.
|
||||
- Для этого стенда concurrency=2 даёт меньший RSS, чем 4, без устойчивой потери
|
||||
throughput. Два повтора и p95 по 18 файлам не доказывают универсальный SLA.
|
||||
|
||||
Перед сдачей остаётся заполнить REPORT.md и шаблон PR: автор/группа, целевая
|
||||
оценка 5, трек 1, запуск, ссылки на эти доказательства, ограничения и помощь ИИ.
|
||||
@@ -0,0 +1,2 @@
|
||||
PASS: upload validation, active staging retention, permanent failure, message replay, expired staging
|
||||
PASS: real subprocess timeout, termination and successful retry
|
||||
@@ -0,0 +1 @@
|
||||
PASS: outbox COMMIT/publish gap, stopped worker, API and broker restart
|
||||
@@ -0,0 +1,5 @@
|
||||
PASS: outbox COMMIT/publish gap, stopped worker, API and broker restart
|
||||
PASS: crash after_objects, redelivery and stable variants
|
||||
PASS: crash after_commit, redelivery and stable variants
|
||||
PASS: bounded retries, failed registry, explicit audited replay, ready replay rejected
|
||||
PASS: staging cleanup preserves ready objects
|
||||
@@ -0,0 +1,19 @@
|
||||
repeat,concurrency,prefetch_per_consumer,width,height,bytes,requests,clients,elapsed_s,throughput_per_s,ready_p95_s,queue_wait_p95_s,queue_lag_max_jobs,queue_oldest_max_s,processing_max,rss_peak_mib
|
||||
1,1,1,320,200,49354,18,6,45.69717665200005,0.39389742033903496,45.332322,43.354063,18,43.352613,1,220.434
|
||||
1,1,1,1280,800,774325,18,6,46.36494216900064,0.38822436000005855,45.690003,43.478215,17,43.483165,1,220.574
|
||||
1,1,1,2560,1600,3095842,18,6,50.051750227999946,0.3596277836040675,48.61938,46.288583,17,46.243644,1,254.23
|
||||
1,2,1,320,200,49354,18,6,24.970797072000096,0.7208420279136186,24.151489,21.722265,16,21.622827,2,357.164
|
||||
1,2,1,1280,800,774325,18,6,27.756625333000557,0.6484938202699787,26.906551,24.179169,16,24.151913,2,357.484
|
||||
1,2,1,2560,1600,3095842,18,6,30.89121619800062,0.5826899104466149,29.276858,26.462352,16,26.398178,2,398.773
|
||||
1,4,1,320,200,49354,18,6,30.706496757999957,0.5861951671615051,30.198425,27.003696,16,27.005221,4,624.723
|
||||
1,4,1,1280,800,774325,18,6,32.03026625700022,0.56196847867495,30.771213,27.799776,14,27.734374,4,629.391
|
||||
1,4,1,2560,1600,3095842,18,6,33.556769314999656,0.5364044384318641,31.874479,28.928972,14,28.955958,4,700.137
|
||||
2,4,1,2560,1600,3095842,18,6,36.27555272599966,0.4962019500008588,34.628852,31.143277,14,31.074291,4,712.543
|
||||
2,4,1,1280,800,774325,18,6,32.433771702999366,0.5549770826787752,31.417533,28.421323,14,28.33212,4,627.523
|
||||
2,4,1,320,200,49354,18,6,31.647972769999797,0.568756808874116,30.943396,27.535648,16,27.47535,4,565.867
|
||||
2,2,1,2560,1600,3095842,18,6,36.96276580199992,0.4869765454355173,35.219853,31.503015,16,31.49645,2,423.055
|
||||
2,2,1,1280,800,774325,18,6,36.61566027800018,0.4915929376484563,35.487861,31.857229,16,31.797539,2,357.262
|
||||
2,2,1,320,200,49354,18,6,34.0682360790006,0.5283513933113508,33.333839,28.783239,16,28.790205,2,356.77
|
||||
2,1,1,2560,1600,3095842,18,6,61.558325450000666,0.2924056148119248,59.328557,56.653392,17,56.578126,1,254.727
|
||||
2,1,1,1280,800,774325,18,6,56.564085449999766,0.3182231243871384,55.765589,52.567299,17,52.510874,1,221.125
|
||||
2,1,1,320,200,49354,18,6,52.09092416000021,0.3455496382577507,51.537452,49.49779,18,49.4865,1,221.094
|
||||
|
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,95 @@
|
||||
# Трек 1: очередь под перегрузкой
|
||||
|
||||
## Гипотеза
|
||||
|
||||
При фиксированном лимите worker в 2 CPU увеличение concurrency с 1 до 2
|
||||
повысит throughput и сократит ожидание. Увеличение до 4 даст меньший выигрыш
|
||||
и увеличит RSS. Для крупных изображений сильнее проявится ограничение CPU;
|
||||
для маленьких заметнее накладные расходы запуска отдельного процесса.
|
||||
Общий лимит незавершённых вложений должен удерживать очередь в заданных
|
||||
границах при остановленном worker, не теряя уже подтверждённые загрузки.
|
||||
|
||||
## Воспроизведение
|
||||
|
||||
Нужны Docker Compose, Python на хосте, локальный `.env` и свободный порт 8080.
|
||||
Эксперимент запускается без другой нагрузки, после завершения текущих задач.
|
||||
Он создаёт только синтетические данные и не удаляет volumes.
|
||||
|
||||
```sh
|
||||
docker compose up -d --build
|
||||
python -X utf8 scripts/queue_experiment.py
|
||||
```
|
||||
|
||||
По умолчанию выполняются два повтора, в каждом по 18 загрузок для каждой
|
||||
комбинации. Настройки `(concurrency, prefetch на потребителя)`:
|
||||
`(1, 1)`, `(2, 1)`, `(4, 1)`. Prefetch оставлен равным 1: каждый потребитель
|
||||
читает одно сообщение и подтверждает его перед чтением следующего.
|
||||
Меняется только concurrency, чтобы сравнение не смешивало два фактора.
|
||||
|
||||
Три JPEG: 320×200, 1280×800, 2560×1600. RGB-шум генерируется
|
||||
`random.Random(202605)`, JPEG quality=85; файлы генерируются до измерения.
|
||||
Размеры и SHA-256 входят в результаты. Это труднее для кодека, чем однотонная
|
||||
картинка, но не репрезентативная коллекция фотографий.
|
||||
|
||||
Шесть HTTP-клиентов одновременно загружают файлы через nginx на обе API-реплики.
|
||||
Для обычных замеров лимит очереди равен 64. Перед каждой конфигурацией —
|
||||
прогрев шестью маленькими изображениями. Во втором повторе порядок
|
||||
concurrency и размеров обращается, чтобы уменьшить влияние порядка/прогрева.
|
||||
Worker сохраняет одинаковые лимиты: 2 CPU, 2 GiB контейнеру, 768 MiB процессу.
|
||||
Все сервисы, данные и настройки обработки изображений одинаковы.
|
||||
|
||||
Скрипт временно переопределяет настройки через отдельный Compose-файл;
|
||||
в `finally` возвращает настройки базового `compose.yaml`/`.env` и запускает cleanup.
|
||||
Не меняет `.env`, отчёт, контракт или публичные тесты.
|
||||
|
||||
## Метрики
|
||||
|
||||
- Throughput: число готовых файлов / время от начала первой отправки до
|
||||
наблюдения готовности всего пакета. Включает HTTP upload и ожидание очереди.
|
||||
- p95 до ready: `attachments.updated_at - attachments.created_at`, от
|
||||
устойчивой записи метаданных до публикации готовности; передача bytes
|
||||
до этой записи сюда не входит. Nearest-rank p95; при 18 файлах это максимум.
|
||||
- p95 ожидания: `jobs.first_started_at - jobs.created_at`, включая outbox
|
||||
и ожидание worker. Время первого захвата сохраняется в БД.
|
||||
- Queue lag: максимум числа queued и максимальный возраст старейшей queued
|
||||
записи; processing учитывается отдельно. Опрос состояния каждые ~100 ms.
|
||||
- RSS: максимум суммы `VmRSS` процессов внутри контейнера worker из `/proc`.
|
||||
Процесс измерения исключён. Это RSS, а не `docker stats`/page cache;
|
||||
общие страницы разных процессов могут учитываться повторно.
|
||||
|
||||
Драйвер запускается через `docker compose exec` внутри worker и не требует
|
||||
дополнительных библиотек на хосте. Его HTTP/SQL-опросы делят CPU-квоту с worker;
|
||||
это одинаковая, но не нулевая погрешность для всех конфигураций. Между отсчётами
|
||||
можно пропустить краткий пик RSS. Для точных эксплуатационных SLA этих данных мало.
|
||||
|
||||
## Перегрузка и восстановление
|
||||
|
||||
Worker и cleanup останавливаются; лимит уменьшается до 12. Двенадцать
|
||||
параллельных клиентов отправляют 24 файла. Проверяются ровно 12 ответов 202
|
||||
и 12 ответов 429 с `Retry-After`, отсутствие записей/объектов для отказов,
|
||||
доступность health и отправки сообщений, content=409 для queued.
|
||||
Проверка охватывает обе API-реплики.
|
||||
|
||||
API и broker перезапускаются при остановленном worker. После запуска worker
|
||||
все первоначально принятые ID должны стать ready с тремя вариантами и исходным
|
||||
SHA-256. Новая загрузка после опустошения очереди должна снова получить 202
|
||||
и завершиться. Это проверяет восстановление после перегрузки, а не только
|
||||
ограничение числа одновременно исполняемых HTTP-запросов.
|
||||
|
||||
Admission использует PostgreSQL advisory lock до COMMIT, поэтому две реплики
|
||||
не могут одновременно пересчитать свободные места и превысить лимит.
|
||||
Проверка выполняется до S3 PUT, но после приёма/валидации HTTP bytes:
|
||||
защищены объём принятой работы и staging, а не входящий сетевой трафик.
|
||||
При максимуме 10 MiB на файл активный staging ограничен примерно
|
||||
`MAX_PENDING_ATTACHMENTS × 10 MiB`; старые ready/failed объекты живут по
|
||||
правилам cleanup и в этот лимит не входят. Операторский replay также
|
||||
проверяет доступную ёмкость. При отказе клиент самостоятельно решает,
|
||||
когда повторить upload; прозрачных повторов POST нет.
|
||||
|
||||
## Артефакты
|
||||
|
||||
`queue-load.json` содержит профиль, время запуска UTC, commit базы,
|
||||
SHA-256 исходников эксперимента/приложения, ID Docker-образа, ресурсы Docker,
|
||||
все замеры, временные ряды и проверки восстановления.
|
||||
`queue-load.csv` — компактная таблица замеров. `queue-results.md` — разбор
|
||||
полученных чисел и ограничений. Секреты, session tokens и пароли не сохраняются.
|
||||
@@ -0,0 +1,37 @@
|
||||
# Результаты трека 1
|
||||
|
||||
Дата UTC: 2026-11-06T16:08:28.320053+00:00. База: `482e7ff477c8cdd9c7e6ceae7833ba19f61d9d98`.
|
||||
|
||||
Методика: [queue-method.md](queue-method.md). Исходные измерения: [JSON](queue-load.json), [CSV](queue-load.csv).
|
||||
|
||||
18 замеров: 3 настройки concurrency, 3 размера, 2 повтора; 324 измеряемые загрузки. Prefetch на потребителя = 1. Все загрузки получили 202 и завершились с первой попытки.
|
||||
|
||||
Throughput и p95 усреднены по двум прогонам; lag и RSS — максимумы двух прогонов. В скобках указан диапазон throughput.
|
||||
|
||||
| Размер | Concurrency | Файлов/с (диапазон) | p95 ready, с | p95 ожидания, с | Max queued | Peak RSS, MiB |
|
||||
|---|---:|---:|---:|---:|---:|---:|
|
||||
| 320x200 | 1 | 0.37 (0.35–0.39) | 48.43 | 46.43 | 18 | 221.1 |
|
||||
| 320x200 | 2 | 0.62 (0.53–0.72) | 28.74 | 25.25 | 16 | 357.2 |
|
||||
| 320x200 | 4 | 0.58 (0.57–0.59) | 30.57 | 27.27 | 16 | 624.7 |
|
||||
| 1280x800 | 1 | 0.35 (0.32–0.39) | 50.73 | 48.02 | 17 | 221.1 |
|
||||
| 1280x800 | 2 | 0.57 (0.49–0.65) | 31.20 | 28.02 | 16 | 357.5 |
|
||||
| 1280x800 | 4 | 0.56 (0.55–0.56) | 31.09 | 28.11 | 14 | 629.4 |
|
||||
| 2560x1600 | 1 | 0.33 (0.29–0.36) | 53.97 | 51.47 | 17 | 254.7 |
|
||||
| 2560x1600 | 2 | 0.53 (0.49–0.58) | 32.25 | 28.98 | 16 | 423.1 |
|
||||
| 2560x1600 | 4 | 0.52 (0.50–0.54) | 33.25 | 30.04 | 14 | 712.5 |
|
||||
|
||||
## Перегрузка
|
||||
|
||||
При остановленном worker и лимите 12 обе API-реплики приняли ровно 12 из 24 загрузок; 12 получили 429 с Retry-After. Отказанные загрузки не создали метаданных или S3-объектов. Health и отправка сообщений оставались доступны.
|
||||
|
||||
После рестарта API/broker и запуска worker все 12 первоначальных ID стали ready. Проверены SHA-256 оригиналов и наличие трёх вариантов. Наблюдаемое время опустошения: 18.63 с (от запуска проверяющего процесса после старта worker). Новая загрузка после восстановления получила 202 и тоже завершилась.
|
||||
|
||||
## Вывод и ограничения
|
||||
|
||||
Переход с 1 на 2 обработчика повышает средний throughput и сокращает ожидание на всех трёх размерах. Четыре обработчика не дают устойчивого выигрыша над двумя, но увеличивают RSS примерно до 626–713 MiB. Для этого стенда оставлено concurrency=2: это разумный компромисс задержки и памяти.
|
||||
|
||||
Гипотеза о пользе двух обработчиков подтверждается. Увеличение до четырёх имеет убывающую отдачу; на крупных файлах диапазоны throughput перекрываются. Результат совместим с ограничением worker в 2 CPU и накладными расходами запуска отдельного процесса на файл, но без CPU-профилирования разделить эти причины нельзя.
|
||||
|
||||
Docker: 8 CPU, примерно 7.76 GiB RAM; worker ограничен 2 CPU и 2 GiB. Всего два повтора, заметен разброс, доверительные интервалы не оценивались. Nearest-rank p95 для пакета из 18 файлов фактически равен максимуму. Это локальное сравнение, не универсальный SLA и не доказательство оптимальности concurrency=2 на любом оборудовании. Драйвер делит CPU-квоту с worker; RSS суммирует процессы и может повторно учитывать общие страницы. Полные ограничения и определения метрик приведены в методике.
|
||||
|
||||
Backpressure доказан для принятой незавершённой работы: advisory lock не позволил двум репликам превысить общий лимит. Он не ограничивает уже переданные HTTP bytes и общий архив готовых/failed вложений. После освобождения очереди приём автоматически возобновился.
|
||||
@@ -13,6 +13,10 @@ Redis использует volume, AOF и `appendfsync always`, eviction отк
|
||||
Сбой до/после XADD даёт повторную доставку, а не потерю принятого задания.
|
||||
Readiness API зависит от PostgreSQL, сессионного Redis и S3;
|
||||
недоступность broker/worker не мешает сохранять работу в outbox.
|
||||
При достижении `MAX_PENDING_ATTACHMENTS` (64 queued/processing суммарно
|
||||
по всем репликам) upload получает 429 с `Retry-After`, без нового S3-объекта.
|
||||
Лимит также проверяется при операторском replay. Описание и воспроизводимый
|
||||
эксперимент перегрузки: [evidence/queue-method.md](../evidence/queue-method.md).
|
||||
|
||||
Worker: два потребителя, у каждого не больше одной выполняемой задачи.
|
||||
Каждая попытка работает в отдельном процессе: timeout 60 секунд,
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
ALTER TABLE attachment_jobs ADD COLUMN first_started_at timestamptz;
|
||||
CREATE INDEX attachments_pending_idx ON attachments(status)
|
||||
WHERE status IN ('queued', 'processing');
|
||||
@@ -0,0 +1,149 @@
|
||||
"""Track 1: reproducible local benchmark and overload/recovery proof. Uses Docker Compose."""
|
||||
import argparse
|
||||
import csv
|
||||
from datetime import datetime, timezone
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import platform
|
||||
import subprocess
|
||||
import tempfile
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
PROBE = (ROOT / 'student-tests/queue_probe.py').read_text(encoding='utf-8')
|
||||
|
||||
|
||||
def run(args, input=None):
|
||||
result = subprocess.run(args, cwd=ROOT, input=input, text=True, encoding='utf-8',
|
||||
stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||||
if result.returncode:
|
||||
raise RuntimeError('Command failed: ' + ' '.join(args[:4]) + '\n' + result.stderr[-4000:])
|
||||
return result.stdout.strip()
|
||||
|
||||
|
||||
def compose(*args, override=None, input=None):
|
||||
command = ['docker', 'compose', '-f', str(ROOT / 'compose.yaml')]
|
||||
if override:
|
||||
command += ['-f', str(override)]
|
||||
return run(command + list(args), input)
|
||||
|
||||
|
||||
def ready():
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
with urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2) as response:
|
||||
if response.status == 200:
|
||||
return
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.5)
|
||||
raise RuntimeError('API did not become ready')
|
||||
|
||||
|
||||
def probe(*args, service='worker'):
|
||||
return json.loads(compose('exec', '-T', service, 'python', '-', *map(str, args), input=PROBE))
|
||||
|
||||
|
||||
def configure(path, concurrency, limit, api=False):
|
||||
path.write_text(json.dumps({'services': {
|
||||
'worker': {'environment': {'WORKER_CONCURRENCY': str(concurrency)}},
|
||||
'api': {'environment': {'MAX_PENDING_ATTACHMENTS': str(limit)}},
|
||||
}}), encoding='utf-8')
|
||||
services = ['worker', 'api'] if api else ['worker']
|
||||
compose('up', '-d', '--no-deps', '--force-recreate', *services, override=path)
|
||||
ready()
|
||||
|
||||
|
||||
def write_results(data):
|
||||
path = ROOT / 'evidence/queue-load.json'
|
||||
path.write_text(json.dumps(data, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
|
||||
fields = ['repeat', 'concurrency', 'prefetch_per_consumer', 'width', 'height', 'bytes',
|
||||
'requests', 'clients', 'elapsed_s', 'throughput_per_s', 'ready_p95_s',
|
||||
'queue_wait_p95_s', 'queue_lag_max_jobs', 'queue_oldest_max_s',
|
||||
'processing_max', 'rss_peak_mib']
|
||||
with (ROOT / 'evidence/queue-load.csv').open('w', encoding='utf-8', newline='') as output:
|
||||
writer = csv.DictWriter(output, fieldnames=fields, extrasaction='ignore')
|
||||
writer.writeheader()
|
||||
writer.writerows(data['runs'])
|
||||
|
||||
|
||||
def source_hash():
|
||||
digest = hashlib.sha256()
|
||||
paths = [ROOT / 'compose.yaml', ROOT / 'scripts/queue_experiment.py', ROOT / 'student-tests/queue_probe.py']
|
||||
paths += list((ROOT / 'src').rglob('*.py')) + list((ROOT / 'migrations').glob('*.sql'))
|
||||
for path in sorted(paths):
|
||||
digest.update(path.relative_to(ROOT).as_posix().encode())
|
||||
digest.update(path.read_bytes().replace(b'\r\n', b'\n'))
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--count', type=int, default=18)
|
||||
parser.add_argument('--repeats', type=int, default=2)
|
||||
args = parser.parse_args()
|
||||
if not 6 <= args.count <= 48 or args.repeats < 1:
|
||||
parser.error('count must be 6..48; repeats must be positive')
|
||||
ready()
|
||||
active = compose('exec', '-T', 'api', 'python', '-c',
|
||||
"from src.database import create_db_engine; from sqlalchemy import text; "
|
||||
"e=create_db_engine(); c=e.connect(); print(c.execute(text(\"SELECT count(*) FROM attachments WHERE status IN ('queued','processing')\")).scalar())")
|
||||
if active != '0':
|
||||
raise RuntimeError('Wait for existing queued/processing work before this isolated experiment')
|
||||
data = {
|
||||
'started_at': datetime.now(timezone.utc).isoformat(),
|
||||
'base_commit': run(['git', 'rev-parse', 'HEAD']), 'source_sha256': source_hash(),
|
||||
'host_platform': platform.platform(),
|
||||
'docker': json.loads(run(['docker', 'info', '--format', '{"cpus":{{.NCPU}},"memory_bytes":{{.MemTotal}}}'])),
|
||||
'image_id': run(['docker', 'image', 'inspect', 'mtusi2026lab5-api:local', '--format', '{{.Id}}']),
|
||||
'profile': {'sizes': [[320, 200], [1280, 800], [2560, 1600]], 'concurrency': [1, 2, 4],
|
||||
'prefetch_per_consumer': 1, 'requests_per_run': args.count, 'clients': 6,
|
||||
'repeats': args.repeats, 'seed': 202605, 'jpeg_quality': 85,
|
||||
'worker_cpus': 2, 'worker_memory_mib': 2048, 'sampling_seconds': 0.1,
|
||||
'baseline_admission_limit': 64, 'overload_admission_limit': 12},
|
||||
'runs': [],
|
||||
}
|
||||
with tempfile.TemporaryDirectory(prefix='lab5-queue-') as directory:
|
||||
override = Path(directory) / 'compose.json'
|
||||
try:
|
||||
for repeat in range(1, args.repeats + 1):
|
||||
order = [1, 2, 4] if repeat % 2 else [4, 2, 1]
|
||||
sizes = data['profile']['sizes'] if repeat % 2 else list(reversed(data['profile']['sizes']))
|
||||
for concurrency in order:
|
||||
print(f'Configuration: repeat={repeat}, concurrency={concurrency}, prefetch=1', flush=True)
|
||||
configure(override, concurrency, 64, api=repeat == 1 and concurrency == 1)
|
||||
probe('measure', '--count', 6, '--clients', 6) # Same warmup for every configuration.
|
||||
for width, height in sizes:
|
||||
result = probe('measure', '--width', width, '--height', height, '--count', args.count)
|
||||
assert result['processing_max'] <= concurrency
|
||||
result.update(repeat=repeat, concurrency=concurrency, prefetch_per_consumer=1)
|
||||
data['runs'].append(result)
|
||||
write_results(data)
|
||||
print(f" {width}x{height}: {result['throughput_per_s']:.2f}/s, "
|
||||
f"p95={result['ready_p95_s']:.2f}s, RSS={result['rss_peak_mib']:.1f} MiB", flush=True)
|
||||
print('Overload: stop worker, 24 concurrent uploads, shared limit=12', flush=True)
|
||||
configure(override, 2, 12, api=True)
|
||||
compose('stop', 'worker', 'cleanup')
|
||||
overloaded = probe('overload', '--count', 24, '--clients', 12, '--limit', 12, service='api')
|
||||
data['overload'] = overloaded
|
||||
write_results(data)
|
||||
# Accepted work must survive restarts while the worker is still stopped.
|
||||
compose('restart', 'api', 'broker')
|
||||
ready()
|
||||
compose('start', 'worker')
|
||||
data['recovery'] = probe('recover', '--expected', json.dumps(overloaded))
|
||||
data['completed_at'] = datetime.now(timezone.utc).isoformat()
|
||||
write_results(data)
|
||||
print('PASS: 12 accepted, 12 rejected with Retry-After; all accepted IDs recovered; new upload accepted', flush=True)
|
||||
finally:
|
||||
# Restore the user's base Compose settings, including any values in .env.
|
||||
compose('up', '-d', '--no-deps', '--force-recreate', 'api', 'worker')
|
||||
compose('start', 'cleanup')
|
||||
ready()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,21 @@
|
||||
"""A shared admission limit for unfinished attachments across all API replicas."""
|
||||
import os
|
||||
|
||||
from sqlalchemy import func, select
|
||||
|
||||
from .errors import APIError
|
||||
from .models import Attachment
|
||||
|
||||
MAX_PENDING = int(os.getenv('MAX_PENDING_ATTACHMENTS', '64'))
|
||||
if MAX_PENDING < 1:
|
||||
raise ValueError('MAX_PENDING_ATTACHMENTS must be positive')
|
||||
|
||||
|
||||
def reserve_capacity(session):
|
||||
# Keep the lock until the new queued row commits. Counting without this lock
|
||||
# would allow simultaneous uploads on different replicas to exceed the limit.
|
||||
session.execute(select(func.pg_advisory_xact_lock(202605)))
|
||||
count = session.scalar(select(func.count()).select_from(Attachment).where(
|
||||
Attachment.status.in_(['queued', 'processing'])))
|
||||
if count >= MAX_PENDING:
|
||||
raise APIError(429, 'rate_limited', 'Очередь обработки заполнена; повторите загрузку позже')
|
||||
@@ -6,6 +6,7 @@ from PIL import Image, UnidentifiedImageError
|
||||
from sqlalchemy import func, select
|
||||
|
||||
from .errors import APIError
|
||||
from .admission import reserve_capacity
|
||||
from .models import Attachment, AttachmentJob, ChatMember
|
||||
from .object_storage import BUCKET, PREFIX, s3_client
|
||||
from .store import ensure_uuid, serialize, store
|
||||
@@ -61,6 +62,7 @@ def save_attachment(source, chat_id, actor_id, filename, content_type, size, dig
|
||||
staging_key = 'staging/' + attachment_id
|
||||
with store.sessions.begin() as session:
|
||||
store._chat(session, chat_id, actor_id)
|
||||
reserve_capacity(session)
|
||||
lock_object(session, staging_key)
|
||||
s3_client().put_object(Bucket=BUCKET, Key=staging_key, Body=source,
|
||||
ContentLength=size, ContentType=content_type)
|
||||
|
||||
@@ -14,6 +14,7 @@ from sqlalchemy import and_, or_, select
|
||||
from sqlalchemy.orm import sessionmaker
|
||||
|
||||
from .database import create_db_engine
|
||||
from .admission import reserve_capacity
|
||||
from .models import Attachment, AttachmentJob
|
||||
from .object_storage import BUCKET, s3_client
|
||||
|
||||
@@ -96,6 +97,8 @@ def claim(sessions, message):
|
||||
if attachment.status != 'queued' or job.available_at > now():
|
||||
return None
|
||||
job.attempt += 1
|
||||
if job.first_started_at is None:
|
||||
job.first_started_at = now()
|
||||
job.lease_token = str(uuid4())
|
||||
job.lease_until = now() + timedelta(seconds=LEASE_SECONDS)
|
||||
attachment.status = 'processing'
|
||||
@@ -124,6 +127,7 @@ def replay(sessions, job_id, reason):
|
||||
if not attachment.staging_key:
|
||||
raise ValueError('Staging retention expired; upload the file again')
|
||||
s3_client().head_object(Bucket=BUCKET, Key=attachment.staging_key)
|
||||
reserve_capacity(session)
|
||||
job.replay_audit = job.replay_audit + [{'at': now().isoformat(), 'reason': reason,
|
||||
'after_attempt': job.attempt,
|
||||
'last_error': job.last_error}]
|
||||
|
||||
@@ -90,6 +90,7 @@ class AttachmentJob(Base):
|
||||
attempt: Mapped[int] = mapped_column(BigInteger, server_default='0')
|
||||
failures: Mapped[int] = mapped_column(BigInteger, server_default='0')
|
||||
last_error: Mapped[str | None] = mapped_column(Text)
|
||||
first_started_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
|
||||
available_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now())
|
||||
published_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
|
||||
lease_until: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
|
||||
|
||||
@@ -92,7 +92,7 @@ else:
|
||||
''', fault=fault)
|
||||
|
||||
|
||||
def main():
|
||||
def main(outbox_only=False):
|
||||
client = Client(os.getenv('BASE_URL', 'http://127.0.0.1:8080'))
|
||||
alice, bob, eve, chat = client.bootstrap()
|
||||
try:
|
||||
@@ -103,7 +103,9 @@ def main():
|
||||
check(not state(aid)['published'], 'outbox was already published')
|
||||
client.message(alice, chat, '', attachments=[aid])
|
||||
client.call('GET', f'/api/v1/attachments/{aid}/content', 409, actor=bob)
|
||||
compose('restart', 'api')
|
||||
# Hard crash after durable COMMIT while dispatcher is stopped: no publish yet.
|
||||
compose('kill', '-s', 'SIGKILL', 'api')
|
||||
compose('start', 'api')
|
||||
ready(client)
|
||||
check(state(aid)['status'] == 'queued', 'API restart lost upload')
|
||||
compose('start', 'dispatcher')
|
||||
@@ -119,6 +121,8 @@ def main():
|
||||
check(download['headers'].get_content_type() == variant['content_type'], 'variant MIME mismatch')
|
||||
check(client.call('GET', f'/api/v1/attachments/{aid}/content', actor=bob)['bytes'] == content, 'original changed')
|
||||
print('PASS: outbox COMMIT/publish gap, stopped worker, API and broker restart', flush=True)
|
||||
if outbox_only:
|
||||
return
|
||||
|
||||
for fault in ('after_objects', 'after_commit'):
|
||||
compose('stop', 'worker')
|
||||
@@ -194,4 +198,7 @@ else:
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
import argparse
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--outbox-only', action='store_true', help='Only the COMMIT/publish crash scenario')
|
||||
main(parser.parse_args().outbox_only)
|
||||
|
||||
@@ -0,0 +1,240 @@
|
||||
"""Executed via Docker exec stdin. Prints only sanitized measurements as JSON."""
|
||||
import argparse
|
||||
import base64
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from datetime import datetime, timezone
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
import math
|
||||
import os
|
||||
from pathlib import Path
|
||||
import random
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from uuid import uuid4
|
||||
|
||||
sys.path.insert(0, '/app')
|
||||
from PIL import Image
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy.orm import sessionmaker
|
||||
from src.database import create_db_engine
|
||||
from src.models import Attachment, AttachmentJob
|
||||
from src.object_storage import BUCKET, s3_client
|
||||
|
||||
BASE = 'http://nginx:8080'
|
||||
|
||||
|
||||
def call(method, path, body=None, token=None, raw=None, headers=None):
|
||||
headers = dict(headers or {})
|
||||
if token:
|
||||
headers['Authorization'] = 'Bearer ' + token
|
||||
if body is not None:
|
||||
raw = json.dumps(body).encode()
|
||||
headers['Content-Type'] = 'application/json'
|
||||
request = urllib.request.Request(BASE + path, data=raw, headers=headers, method=method)
|
||||
try:
|
||||
response = urllib.request.urlopen(request, timeout=60)
|
||||
except urllib.error.HTTPError as error:
|
||||
response = error
|
||||
with response:
|
||||
data = response.read()
|
||||
payload = json.loads(data) if response.headers.get_content_type() == 'application/json' else data
|
||||
return response.status, payload, response.headers
|
||||
|
||||
|
||||
def bootstrap():
|
||||
username, password = 'q_' + uuid4().hex[:20], uuid4().hex
|
||||
status, user, _ = call('POST', '/api/v1/users', body={
|
||||
'username': username, 'password': password, 'display_name': 'Synthetic queue experiment'})
|
||||
assert status == 201, ('user', status)
|
||||
basic = base64.b64encode(f'{username}:{password}'.encode()).decode()
|
||||
status, session, _ = call('POST', '/api/v1/auth/sessions', headers={'Authorization': 'Basic ' + basic})
|
||||
assert status == 201, ('session', status)
|
||||
token = session['token']
|
||||
status, chat, _ = call('POST', '/api/v1/chats', token=token,
|
||||
body={'title': 'Synthetic queue experiment', 'member_ids': [user['id']]})
|
||||
assert status == 201, ('chat', status)
|
||||
return user['id'], chat['id'], token
|
||||
|
||||
|
||||
def fixture(width, height):
|
||||
pixels = random.Random(202605).randbytes(width * height * 3)
|
||||
with Image.frombytes('RGB', (width, height), pixels) as picture, io.BytesIO() as output:
|
||||
picture.save(output, format='JPEG', quality=85)
|
||||
return output.getvalue()
|
||||
|
||||
|
||||
def percentile(values):
|
||||
return sorted(values)[max(0, math.ceil(len(values) * 0.95) - 1)]
|
||||
|
||||
|
||||
def rss_mib():
|
||||
# Sum process RSS, not cgroup memory.current (which also counts page cache).
|
||||
# Shared pages may be counted twice. Exclude this measurement process.
|
||||
total = 0
|
||||
for path in Path('/proc').glob('[0-9]*/status'):
|
||||
if path.parent.name == str(os.getpid()):
|
||||
continue
|
||||
try:
|
||||
for line in path.read_text().splitlines():
|
||||
if line.startswith('VmRSS:'):
|
||||
total += int(line.split()[1])
|
||||
except (FileNotFoundError, ProcessLookupError):
|
||||
pass
|
||||
return total / 1024
|
||||
|
||||
|
||||
def rows_for(sessions, owner_id):
|
||||
with sessions() as session:
|
||||
return list(session.execute(select(Attachment, AttachmentJob).join(
|
||||
AttachmentJob, AttachmentJob.attachment_id == Attachment.id)
|
||||
.where(Attachment.owner_id == owner_id)))
|
||||
|
||||
|
||||
def summary(rows):
|
||||
states = {key: 0 for key in ('queued', 'processing', 'ready', 'failed')}
|
||||
ages = []
|
||||
for attachment, _ in rows:
|
||||
states[attachment.status] += 1
|
||||
if attachment.status == 'queued':
|
||||
ages.append((datetime.now(timezone.utc) - attachment.created_at).total_seconds())
|
||||
return {**states, 'oldest_queued_s': max(ages, default=0)}
|
||||
|
||||
|
||||
def staging_keys():
|
||||
return {obj['Key'] for page in s3_client().get_paginator('list_objects_v2').paginate(
|
||||
Bucket=BUCKET, Prefix='staging/') for obj in page.get('Contents', [])}
|
||||
|
||||
|
||||
def upload_batch(args, sessions):
|
||||
owner, chat, token = bootstrap()
|
||||
data = fixture(args.width, args.height)
|
||||
before_staging = staging_keys() if args.mode == 'overload' else set()
|
||||
samples = []
|
||||
started = time.monotonic()
|
||||
|
||||
def upload(_):
|
||||
return call('POST', f'/api/v1/chats/{chat}/attachments?filename=load.jpg', token=token,
|
||||
raw=data, headers={'Content-Type': 'image/jpeg'})
|
||||
|
||||
with ThreadPoolExecutor(max_workers=args.clients) as pool:
|
||||
futures = [pool.submit(upload, i) for i in range(args.count)]
|
||||
while True:
|
||||
rows = rows_for(sessions, owner)
|
||||
snapshot = summary(rows)
|
||||
samples.append({'elapsed_s': round(time.monotonic() - started, 3),
|
||||
'rss_mib': round(rss_mib(), 3), **snapshot})
|
||||
if all(f.done() for f in futures):
|
||||
responses = [f.result() for f in futures]
|
||||
accepted = [payload for status, payload, _ in responses if status == 202]
|
||||
if args.mode == 'overload':
|
||||
rows = rows_for(sessions, owner)
|
||||
snapshot = summary(rows)
|
||||
if args.mode == 'overload' or snapshot['ready'] + snapshot['failed'] == len(accepted):
|
||||
break
|
||||
if time.monotonic() - started > 300:
|
||||
raise AssertionError('Batch did not drain in 300 seconds')
|
||||
time.sleep(0.1)
|
||||
elapsed = time.monotonic() - started
|
||||
codes = {str(code): sum(status == code for status, _, _ in responses)
|
||||
for code in sorted({status for status, _, _ in responses})}
|
||||
replicas = len({headers['X-Instance-Id'] for _, _, headers in responses})
|
||||
result = {'width': args.width, 'height': args.height, 'bytes': len(data),
|
||||
'sha256': hashlib.sha256(data).hexdigest(), 'requests': args.count,
|
||||
'clients': args.clients, 'http_statuses': codes, 'api_replicas_seen': replicas,
|
||||
'elapsed_s': elapsed, 'owner_id': owner, 'attachment_ids': [a['id'] for a in accepted]}
|
||||
assert len(rows) == len(accepted), 'Rejected upload created metadata'
|
||||
assert replicas == 2, 'Experiment must exercise both API replicas'
|
||||
if args.mode == 'overload':
|
||||
assert len(accepted) == args.limit, (codes, args.limit)
|
||||
assert codes.get('429') == args.count - args.limit, codes
|
||||
assert all(a.status == 'queued' for a, _ in rows), 'Worker was not stopped'
|
||||
assert staging_keys() - before_staging == {'staging/' + a['id'] for a in accepted}, 'Rejected upload left S3 object'
|
||||
for status, payload, headers in responses:
|
||||
if status == 429:
|
||||
assert payload['error']['code'] == 'rate_limited'
|
||||
assert int(headers['Retry-After']) > 0
|
||||
assert call('GET', '/health/ready')[0] == 200
|
||||
assert call('GET', f"/api/v1/attachments/{accepted[0]['id']}/content", token=token)[0] == 409
|
||||
assert call('POST', f'/api/v1/chats/{chat}/messages', token=token,
|
||||
body={'text': 'Still responsive under overload'},
|
||||
headers={'Idempotency-Key': uuid4().hex})[0] == 201
|
||||
result.update({'limit': args.limit, 'accepted': len(accepted), 'rejected': codes['429'],
|
||||
'health_and_messages_available': True, 'rejected_leave_no_objects': True})
|
||||
else:
|
||||
assert codes == {'202': args.count}, codes
|
||||
assert all(a.status == 'ready' and j.attempt == 1 for a, j in rows), 'Failed/retried job in baseline'
|
||||
waits = [(j.first_started_at - j.created_at).total_seconds() for _, j in rows]
|
||||
latencies = [(a.updated_at - a.created_at).total_seconds() for a, _ in rows]
|
||||
result.update({'throughput_per_s': len(rows) / elapsed,
|
||||
'ready_p95_s': percentile(latencies), 'queue_wait_p95_s': percentile(waits),
|
||||
'queue_lag_max_jobs': max(s['queued'] for s in samples),
|
||||
'queue_oldest_max_s': max(s['oldest_queued_s'] for s in samples),
|
||||
'processing_max': max(s['processing'] for s in samples),
|
||||
'rss_peak_mib': max(s['rss_mib'] for s in samples),
|
||||
'samples': samples})
|
||||
return result
|
||||
|
||||
|
||||
def recover(args, sessions):
|
||||
expected = json.loads(args.expected)
|
||||
started = time.monotonic()
|
||||
while time.monotonic() - started < 180:
|
||||
rows = rows_for(sessions, expected['owner_id'])
|
||||
assert not any(a.status == 'failed' for a, _ in rows), 'Accepted job failed'
|
||||
if len(rows) == expected['accepted'] and all(a.status == 'ready' for a, _ in rows):
|
||||
break
|
||||
time.sleep(0.2)
|
||||
else:
|
||||
raise AssertionError('Accepted work did not recover')
|
||||
assert {a.id for a, _ in rows} == set(expected['attachment_ids']), 'Lost/replaced accepted IDs'
|
||||
for attachment, _ in rows:
|
||||
keys = [attachment.object_key] + [v['object_key'] for v in attachment.variants]
|
||||
assert len(attachment.variants) == 3
|
||||
for key in keys:
|
||||
s3_client().head_object(Bucket=BUCKET, Key=key)
|
||||
with s3_client().get_object(Bucket=BUCKET, Key=attachment.object_key)['Body'] as body:
|
||||
assert hashlib.sha256(body.read()).hexdigest() == expected['sha256']
|
||||
elapsed = time.monotonic() - started
|
||||
# A new accepted upload proves capacity is released after draining.
|
||||
# One request need not hit both replicas, so perform this explicitly.
|
||||
owner, chat, token = bootstrap()
|
||||
status, _, _ = call('POST', f'/api/v1/chats/{chat}/attachments?filename=after.jpg', token=token,
|
||||
raw=fixture(320, 200), headers={'Content-Type': 'image/jpeg'})
|
||||
assert status == 202, 'Admission did not recover'
|
||||
deadline = time.monotonic() + 60
|
||||
while time.monotonic() < deadline:
|
||||
fresh = rows_for(sessions, owner)
|
||||
if fresh and fresh[0][0].status == 'ready':
|
||||
break
|
||||
time.sleep(0.2)
|
||||
else:
|
||||
raise AssertionError('New upload did not complete after overload')
|
||||
return {'accepted_ids_preserved': True, 'all_ready': len(rows), 'original_checksums_match': True,
|
||||
'all_variants_exist': True, 'drain_observed_s': elapsed, 'new_upload_status': status}
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument('mode', choices=['measure', 'overload', 'recover'])
|
||||
parser.add_argument('--width', type=int, default=320)
|
||||
parser.add_argument('--height', type=int, default=200)
|
||||
parser.add_argument('--count', type=int, default=18)
|
||||
parser.add_argument('--clients', type=int, default=6)
|
||||
parser.add_argument('--limit', type=int, default=12)
|
||||
parser.add_argument('--expected')
|
||||
args = parser.parse_args()
|
||||
engine = create_db_engine()
|
||||
try:
|
||||
sessions = sessionmaker(engine, expire_on_commit=False)
|
||||
result = recover(args, sessions) if args.mode == 'recover' else upload_batch(args, sessions)
|
||||
print(json.dumps(result))
|
||||
finally:
|
||||
engine.dispose()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Reference in New Issue
Block a user