This commit is contained in:
2026-11-06 19:22:27 +03:00
parent 482e7ff477
commit ff6d7c1e73
20 changed files with 58826 additions and 3 deletions
+1
View File
@@ -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
+2
View File
@@ -0,0 +1,2 @@
# Shell scripts are mounted into Linux containers, including on Windows hosts.
*.sh text eol=lf
+1
View File
@@ -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}
+37
View File
@@ -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, запуск, ссылки на эти доказательства, ограничения и помощь ИИ.
+2
View File
@@ -0,0 +1,2 @@
PASS: upload validation, active staging retention, permanent failure, message replay, expired staging
PASS: real subprocess timeout, termination and successful retry
+1
View File
@@ -0,0 +1 @@
PASS: outbox COMMIT/publish gap, stopped worker, API and broker restart
+5
View File
@@ -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
+19
View File
@@ -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
1 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
2 1 1 1 320 200 49354 18 6 45.69717665200005 0.39389742033903496 45.332322 43.354063 18 43.352613 1 220.434
3 1 1 1 1280 800 774325 18 6 46.36494216900064 0.38822436000005855 45.690003 43.478215 17 43.483165 1 220.574
4 1 1 1 2560 1600 3095842 18 6 50.051750227999946 0.3596277836040675 48.61938 46.288583 17 46.243644 1 254.23
5 1 2 1 320 200 49354 18 6 24.970797072000096 0.7208420279136186 24.151489 21.722265 16 21.622827 2 357.164
6 1 2 1 1280 800 774325 18 6 27.756625333000557 0.6484938202699787 26.906551 24.179169 16 24.151913 2 357.484
7 1 2 1 2560 1600 3095842 18 6 30.89121619800062 0.5826899104466149 29.276858 26.462352 16 26.398178 2 398.773
8 1 4 1 320 200 49354 18 6 30.706496757999957 0.5861951671615051 30.198425 27.003696 16 27.005221 4 624.723
9 1 4 1 1280 800 774325 18 6 32.03026625700022 0.56196847867495 30.771213 27.799776 14 27.734374 4 629.391
10 1 4 1 2560 1600 3095842 18 6 33.556769314999656 0.5364044384318641 31.874479 28.928972 14 28.955958 4 700.137
11 2 4 1 2560 1600 3095842 18 6 36.27555272599966 0.4962019500008588 34.628852 31.143277 14 31.074291 4 712.543
12 2 4 1 1280 800 774325 18 6 32.433771702999366 0.5549770826787752 31.417533 28.421323 14 28.33212 4 627.523
13 2 4 1 320 200 49354 18 6 31.647972769999797 0.568756808874116 30.943396 27.535648 16 27.47535 4 565.867
14 2 2 1 2560 1600 3095842 18 6 36.96276580199992 0.4869765454355173 35.219853 31.503015 16 31.49645 2 423.055
15 2 2 1 1280 800 774325 18 6 36.61566027800018 0.4915929376484563 35.487861 31.857229 16 31.797539 2 357.262
16 2 2 1 320 200 49354 18 6 34.0682360790006 0.5283513933113508 33.333839 28.783239 16 28.790205 2 356.77
17 2 1 1 2560 1600 3095842 18 6 61.558325450000666 0.2924056148119248 59.328557 56.653392 17 56.578126 1 254.727
18 2 1 1 1280 800 774325 18 6 56.564085449999766 0.3182231243871384 55.765589 52.567299 17 52.510874 1 221.125
19 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
+95
View File
@@ -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 и пароли не сохраняются.
+37
View File
@@ -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 вложений. После освобождения очереди приём автоматически возобновился.
+4
View File
@@ -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 секунд,
+3
View File
@@ -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');
+149
View File
@@ -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()
+21
View File
@@ -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', 'Очередь обработки заполнена; повторите загрузку позже')
+2
View File
@@ -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)
+4
View File
@@ -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}]
+1
View File
@@ -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))
+10 -3
View File
@@ -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)
+240
View File
@@ -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()