ЛР 5 - БВТ2303 - Гаджиев - на 4 #4
+8
-20
@@ -1,20 +1,8 @@
|
||||
.git
|
||||
.github
|
||||
.env
|
||||
.env.*
|
||||
!.env.example
|
||||
secrets
|
||||
certs
|
||||
volumes
|
||||
data
|
||||
backups
|
||||
*.key
|
||||
*.pem
|
||||
*.p12
|
||||
*.pfx
|
||||
*.jks
|
||||
.venv
|
||||
__pycache__
|
||||
node_modules
|
||||
evidence
|
||||
.DS_Store
|
||||
# Белый список: в контекст сборки попадает только то, что явно разрешено ниже.
|
||||
# Так в образ точно не утекут .env, secrets/, .git, тесты и отчёты.
|
||||
*
|
||||
!requirements.txt
|
||||
!src/
|
||||
!migrations/
|
||||
**/__pycache__
|
||||
**/*.pyc
|
||||
|
||||
@@ -23,3 +23,80 @@ WORKER_CONCURRENCY=2
|
||||
JOB_MAX_ATTEMPTS=5
|
||||
JOB_TIMEOUT_SECONDS=60
|
||||
STAGING_RETENTION_SECONDS=86400
|
||||
|
||||
|
||||
# --- Дополнительные настройки этого решения (значения по умолчанию из src/messenger/config.py) ---
|
||||
# API_REPLICAS — число реплик API за балансировщиком (deploy.replicas в compose.yaml).
|
||||
# IDEMPOTENCY_TTL_SECONDS приложением не читается: ключ хранится вместе с сообщением
|
||||
# бессрочно, то есть не меньше 24 ч из контракта (migrations/004_message_idempotency.sql).
|
||||
# S3_ACCESS_KEY_ID_FILE / S3_SECRET_ACCESS_KEY_FILE — ключи отдельного пользователя S3 для API и worker
|
||||
# (права только на свой bucket, secrets/s3_config.json). Ключи администратора S3 (secrets/s3_root_*)
|
||||
# есть только у s3-init, в API и worker не передаются.
|
||||
# Сколько секунд сессия может лежать в кэше Valkey (не дольше самой сессии).
|
||||
SESSION_CACHE_TTL_SECONDS=30
|
||||
# Пул соединений с PostgreSQL и таймауты.
|
||||
DB_POOL_MIN_SIZE=1
|
||||
DB_POOL_MAX_SIZE=10
|
||||
DB_POOL_TIMEOUT_SECONDS=3
|
||||
DB_CONNECT_TIMEOUT_SECONDS=3
|
||||
DB_STATEMENT_TIMEOUT_MS=5000
|
||||
# Valkey: таймаут операции, размер пула соединений, период фоновой проверки (PING).
|
||||
CACHE_TIMEOUT_MS=300
|
||||
CACHE_POOL_MAX_SIZE=20
|
||||
CACHE_CHECK_INTERVAL_SECONDS=1
|
||||
# Остановка по SIGTERM: сначала столько секунд /health/ready = 503 (уход из балансировки),
|
||||
# потом не дольше GRACEFUL_SHUTDOWN_SECONDS на начатые запросы.
|
||||
SHUTDOWN_DRAIN_SECONDS=3
|
||||
GRACEFUL_SHUTDOWN_SECONDS=8
|
||||
# S3: таймауты и число попыток (недоступный S3 -> быстрый 503).
|
||||
S3_CONNECT_TIMEOUT_SECONDS=2
|
||||
S3_READ_TIMEOUT_SECONDS=5
|
||||
S3_MAX_ATTEMPTS=2
|
||||
# Общий предел на одну операцию S3, включая DNS: ответ клиенту не дольше этого.
|
||||
S3_OPERATION_TIMEOUT_SECONDS=6
|
||||
# Readiness (с lab5): S3 проверяется фоном раз в S3_HEALTH_INTERVAL_SECONDS; нет успешной
|
||||
# проверки дольше S3_HEALTH_MAX_AGE_SECONDS -> /health/ready = 503.
|
||||
S3_HEALTH_INTERVAL_SECONDS=1
|
||||
S3_HEALTH_MAX_AGE_SECONDS=3
|
||||
# Приём файла: в памяти не больше UPLOAD_SPOOL_BYTES на загрузку (остальное — временный файл,
|
||||
# удаляется после запроса); вся передача не дольше UPLOAD_TIMEOUT_SECONDS. Проверка структуры
|
||||
# файла (без декодирования) — не больше IMAGE_CHECK_CONCURRENCY одновременно на реплику,
|
||||
# очередь ждёт не дольше IMAGE_CHECK_WAIT_SECONDS (иначе 503).
|
||||
UPLOAD_SPOOL_BYTES=1048576
|
||||
UPLOAD_TIMEOUT_SECONDS=60
|
||||
IMAGE_CHECK_CONCURRENCY=2
|
||||
IMAGE_CHECK_WAIT_SECONDS=10
|
||||
# --- с lab5: outbox, worker, повторы ---
|
||||
# BROKER_URL_FILE — адрес RabbitMQ с паролем (secrets/broker_url). Пароль брокер получает
|
||||
# файлом secrets/rabbitmq_credentials.conf. WORKER_CONCURRENCY — заданий одновременно
|
||||
# и prefetch брокера; JOB_MAX_ATTEMPTS — всего попыток (первая + повторы);
|
||||
# JOB_TIMEOUT_SECONDS — лимит времени одной попытки (дочерний процесс убивается);
|
||||
# STAGING_RETENTION_SECONDS — сколько хранится оригинал failed-вложения для replay.
|
||||
# Число worker-контейнеров (deploy.replicas в compose.yaml).
|
||||
WORKER_REPLICAS=1
|
||||
# Лимит памяти одной попытки (адресное пространство дочернего процесса, RLIMIT_AS).
|
||||
WORKER_MEMORY_LIMIT_MB=640
|
||||
# Backoff с jitter: пауза перед попыткой n+1 — случайная в [d/2, d], d = min(MAX, BASE * 2^(n-1)).
|
||||
RETRY_BASE_SECONDS=2
|
||||
RETRY_MAX_SECONDS=60
|
||||
# Lease: аренда задания на JOB_LEASE_SECONDS, продление каждые JOB_HEARTBEAT_SECONDS;
|
||||
# поиск истёкших аренд раз в REAPER_INTERVAL_SECONDS.
|
||||
JOB_LEASE_SECONDS=30
|
||||
JOB_HEARTBEAT_SECONDS=10
|
||||
REAPER_INTERVAL_SECONDS=5
|
||||
# Страховка от потерянного сообщения: queued без движения дольше этого — отправить ещё раз.
|
||||
QUEUED_REPUBLISH_SECONDS=600
|
||||
# Relay outbox: опрос таблицы (кроме мгновенного сигнала после загрузки) и размер пачки.
|
||||
RELAY_POLL_SECONDS=1
|
||||
RELAY_BATCH_SIZE=50
|
||||
# Качество вариантов: JPEG (thumbnail, crop) и WebP (optimized; method 0..6 — скорость/размер).
|
||||
JPEG_QUALITY=85
|
||||
WEBP_QUALITY=80
|
||||
WEBP_METHOD=4
|
||||
# Уборка объектов S3 (фоновый поток worker): grace period, период, хранение отправленного outbox.
|
||||
ATTACHMENT_GRACE_SECONDS=900
|
||||
CLEANUP_INTERVAL_SECONDS=300
|
||||
OUTBOX_RETENTION_SECONDS=604800
|
||||
# Внедрение отказов для проверок (faults.py). ТОЛЬКО учебный стенд: точки отказа включаются
|
||||
# файлами в /tmp/faults внутри контейнера, тесты создают их через docker exec.
|
||||
FAULTS_ENABLED=1
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
# Git на Windows (core.autocrlf=true) меняет LF на CRLF при checkout. Для этих файлов это ломает запуск:
|
||||
# sh-скрипт с \r не выполняется, а конфиги Valkey и HAProxy читаются внутри Linux-контейнеров.
|
||||
*.sh text eol=lf
|
||||
*.sql text eol=lf
|
||||
*.conf text eol=lf
|
||||
*.cfg text eol=lf
|
||||
# cmd.exe ожидает CRLF.
|
||||
*.cmd text eol=crlf
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
# Базовый образ закреплён точной версией (не latest), чтобы сборка была воспроизводимой.
|
||||
# Один образ на все процессы приложения: API (python -m messenger), worker (python -m messenger.worker),
|
||||
# миграции (python -m messenger.migrate) и настройку S3 (python -m messenger.s3bootstrap).
|
||||
FROM python:3.12.8-slim-bookworm
|
||||
|
||||
# Не создавать .pyc, сразу выводить логи (без буфера), не кэшировать скачанные пакеты.
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
PIP_NO_CACHE_DIR=1 \
|
||||
PIP_DISABLE_PIP_VERSION_CHECK=1 \
|
||||
MALLOC_ARENA_MAX=2 \
|
||||
OPENBLAS_NUM_THREADS=1 \
|
||||
OMP_NUM_THREADS=1
|
||||
# MALLOC_ARENA_MAX=2 (с lab4): glibc по умолчанию заводит отдельную «кучу» на каждый поток,
|
||||
# и освобождённая после загрузки файла память не переиспользуется другими потоками.
|
||||
# Эксперимент make upload-memory: 6 одновременных загрузок по 8,8 МиБ на реплику дали рост
|
||||
# пика RSS ~105 МиБ без этой настройки и ~30 МиБ с ней (REPORT.md lab4).
|
||||
# OPENBLAS_NUM_THREADS / OMP_NUM_THREADS=1 (с lab5): numpy (нужен simplejpeg в worker) иначе заводит
|
||||
# пул потоков на каждое ядро и резервирует под них память, а это мешает лимиту памяти дочернего
|
||||
# процесса обработки (RLIMIT_AS, sandbox.py).
|
||||
|
||||
WORKDIR /srv
|
||||
|
||||
# Сначала только список зависимостей: пока он не меняется, Docker берёт этот слой
|
||||
# из кэша и не переустанавливает пакеты при каждой правке кода.
|
||||
# --only-binary: только готовые wheel (psycopg-binary, argon2), без компиляции в образе.
|
||||
COPY requirements.txt .
|
||||
RUN pip install --only-binary=:all: -r requirements.txt
|
||||
|
||||
COPY src/ ./
|
||||
# SQL-миграции едут в образе вместе с кодом: версия схемы всегда соответствует версии приложения.
|
||||
# Применяет их сервис migrate (`python -m messenger.migrate`), реплики API только проверяют схему.
|
||||
COPY migrations/ ./migrations/
|
||||
|
||||
# Непривилегированный пользователь: если приложение взломают, у атакующего не будет root.
|
||||
RUN useradd --system --uid 10001 --no-create-home --shell /usr/sbin/nologin app
|
||||
USER app
|
||||
|
||||
# Версия сборки (с lab3): пишется в лог при старте, по ней student-tests/rolling_update.py
|
||||
# проверяет, что все реплики заменены новой версией. ARG стоит в конце, чтобы смена версии
|
||||
# не пересобирала слои с зависимостями и кодом.
|
||||
ARG APP_VERSION=dev
|
||||
ENV APP_VERSION=${APP_VERSION}
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
# Docker сам периодически опрашивает /health/ready и показывает статус healthy/unhealthy.
|
||||
# Ready проверяет PostgreSQL и S3, а после SIGTERM отвечает 503 (реплика уходит из балансировки).
|
||||
# У worker нет HTTP: его healthcheck задан в compose.yaml (файл /tmp/worker.alive).
|
||||
# curl в slim-образе нет, поэтому проверяем средствами Python. Частоту задаёт compose.yaml.
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=3 \
|
||||
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_PORT', '8080'), timeout=2)"]
|
||||
|
||||
# Exec-форма (JSON-массив): python запускается напрямую как PID 1 и сам получает SIGTERM.
|
||||
CMD ["python", "-m", "messenger"]
|
||||
@@ -1,13 +1,31 @@
|
||||
PYTHON ?= python3
|
||||
BASE_URL ?= http://localhost:8080
|
||||
# 127.0.0.1, а не localhost: на части Windows-машин localhost резолвится очень медленно.
|
||||
# С lab3 это адрес балансировщика HAProxy — единственной точки входа API.
|
||||
BASE_URL ?= http://127.0.0.1:8080
|
||||
# API с SESSION_TTL_SECONDS=2 (сервис api-short-ttl, профиль ttl), тоже через балансировщик.
|
||||
BASE_URL_TTL ?= http://127.0.0.1:8081
|
||||
CA_FILE ?=
|
||||
ACTION_SCRIPT ?=
|
||||
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
|
||||
# Передаём адреса собственным тестам через окружение (работает и в cmd, и в sh).
|
||||
export BASE_URL
|
||||
export BASE_URL_TTL
|
||||
|
||||
.PHONY: help check validate test load test-persistence test-failover
|
||||
.PHONY: help check validate test load test-persistence test-failover \
|
||||
secrets up down ps logs restore student-test race expiry failure-valkey failure-postgres \
|
||||
failure-valkey-pause db-test explain demo cache-stats \
|
||||
balancing idempotency failover persistence failover-metrics rolling-update load-profile check-stack report-tables \
|
||||
attachments attachment-failover failure-s3 s3-checks upload-memory cleanup s3-bootstrap \
|
||||
worker-stop worker-start worker-outage redelivery outbox-crash worker-crash retry-replay lease concurrency \
|
||||
staging-cleanup cleanup-race imaging-test jobs failed job replay queues
|
||||
|
||||
help:
|
||||
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
|
||||
@echo "secrets/up/down/ps/logs/restore: stand; student-test, race, expiry, failure-valkey, failure-postgres, failure-valkey-pause, db-test, explain, demo, cache-stats: own checks (lab2)"
|
||||
@echo "balancing, idempotency, failover, persistence, failover-metrics, rolling-update, load-profile, check-stack, report-tables: own checks (lab3)"
|
||||
@echo "attachments, attachment-failover, failure-s3, s3-checks, upload-memory, cleanup, s3-bootstrap: own checks (lab4)"
|
||||
@echo "worker-stop, worker-start, worker-outage, redelivery, outbox-crash, worker-crash, retry-replay, lease, concurrency, staging-cleanup, cleanup-race, imaging-test: own checks (lab5)"
|
||||
@echo "jobs, failed, job ID=..., replay ID=..., queues: operator commands (lab5)"
|
||||
|
||||
check:
|
||||
$(PYTHON) scripts/check_contract.py
|
||||
@@ -28,3 +46,206 @@ test-persistence:
|
||||
test-failover:
|
||||
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
|
||||
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
|
||||
|
||||
# ---------- стенд ----------
|
||||
|
||||
secrets:
|
||||
sh scripts/init-secrets.sh
|
||||
|
||||
up:
|
||||
docker compose up -d --build --wait
|
||||
|
||||
# Без -v: volumes с данными сохраняются. Удаление данных — только осознанно: docker compose down -v
|
||||
down:
|
||||
docker compose --profile ttl --profile tools down
|
||||
|
||||
# ID контейнера + состояние. ID реплики api = её X-Instance-Id.
|
||||
ps:
|
||||
docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}"
|
||||
|
||||
logs:
|
||||
docker compose logs --tail 50 api worker broker lb s3 s3-init
|
||||
|
||||
# Вернуть остановленные реплики (после make test-failover): запустить всё, что должно работать,
|
||||
# и дождаться, пока HAProxy снова возьмёт в работу все реплики.
|
||||
restore:
|
||||
docker compose up -d --wait
|
||||
$(PYTHON) student-tests/stand.py
|
||||
|
||||
# ---------- собственные проверки lab1–lab2 (теперь через балансировщик) ----------
|
||||
|
||||
student-test:
|
||||
$(PYTHON) -m unittest discover -s student-tests -p "test_*.py" -v
|
||||
|
||||
race:
|
||||
$(PYTHON) student-tests/race.py
|
||||
|
||||
# Поднимает API с TTL сессии 2 с (за балансировщиком, 127.0.0.1:8081), проверяет и убирает его.
|
||||
expiry:
|
||||
docker compose --profile ttl up -d --wait api-short-ttl
|
||||
$(PYTHON) student-tests/expiry.py; status=$$?; docker compose --profile ttl rm -sf api-short-ttl >/dev/null 2>&1; exit $$status
|
||||
|
||||
failure-valkey:
|
||||
$(PYTHON) student-tests/dependency_failure.py valkey
|
||||
|
||||
failure-postgres:
|
||||
$(PYTHON) student-tests/dependency_failure.py postgres
|
||||
|
||||
# Valkey на паузе (данные в нём сохраняются), logout, снова в строю: токен должен остаться отозванным.
|
||||
failure-valkey-pause:
|
||||
$(PYTHON) student-tests/cache_revocation.py
|
||||
|
||||
db-test:
|
||||
docker compose --profile tools run --rm db-test
|
||||
|
||||
explain:
|
||||
docker compose exec -T postgres psql -X -q -U messenger -d messenger -v ON_ERROR_STOP=1 < infra/sql/explain_history.sql
|
||||
|
||||
demo:
|
||||
$(PYTHON) student-tests/demo.py
|
||||
|
||||
# Роль Valkey: сколько ключей в кэше и сколько попаданий/промахов; права пользователя health.
|
||||
VALKEY_HEALTH = docker compose exec -T valkey valkey-cli --user health --pass none --no-auth-warning
|
||||
cache-stats:
|
||||
$(VALKEY_HEALTH) dbsize
|
||||
$(VALKEY_HEALTH) info stats | grep -E "keyspace_(hits|misses)"
|
||||
-$(VALKEY_HEALTH) get sess:anything
|
||||
|
||||
# ---------- собственные проверки lab3 ----------
|
||||
|
||||
# Реплики, общие сессии и кэш, X-Instance-Id (входит и в student-test).
|
||||
balancing:
|
||||
$(PYTHON) -m unittest discover -s student-tests -p "test_balancing.py" -v
|
||||
|
||||
# Idempotency-Key: повторы, конкурентные запросы через разные реплики (входит и в student-test).
|
||||
idempotency:
|
||||
$(PYTHON) -m unittest discover -s student-tests -p "test_idempotency.py" -v
|
||||
|
||||
# Публичный failover-тест для КАЖДОЙ реплики по очереди + какой контейнер реально остановлен.
|
||||
failover:
|
||||
$(PYTHON) student-tests/run_failover.py
|
||||
|
||||
# Публичный persistence-тест + время старта каждого контейнера до и после hook.
|
||||
persistence:
|
||||
$(PYTHON) student-tests/run_persistence.py
|
||||
|
||||
# Уровень 4: остановка (SIGTERM) и авария (SIGKILL) каждой реплики под нагрузкой: RPS, ошибки, восстановление.
|
||||
failover-metrics:
|
||||
$(PYTHON) student-tests/failover_metrics.py
|
||||
|
||||
# Уровень 4: поочерёдная замена реплик новой версией под нагрузкой.
|
||||
rolling-update:
|
||||
$(PYTHON) student-tests/rolling_update.py
|
||||
|
||||
# Профиль нагрузки: публичный tests/load.py (30 с, 4 потока) + CPU/RAM контейнеров во время нагрузки.
|
||||
load-profile:
|
||||
$(PYTHON) student-tests/load_profile.py
|
||||
|
||||
# Уровень 4: лимиты CPU/RAM, нет портов API в обход LB, нет container_name, сети, версии.
|
||||
check-stack:
|
||||
$(PYTHON) student-tests/check_stack.py
|
||||
|
||||
# Таблицы замеров из evidence/*.json -> REPORT.md (между метками measurements).
|
||||
report-tables:
|
||||
$(PYTHON) student-tests/report_tables.py
|
||||
|
||||
# ---------- собственные проверки lab4 ----------
|
||||
|
||||
# Вложения через API: лимиты, «бомба», битые файлы, подмена MIME, filename, чужое и из другого чата
|
||||
# (входит и в student-test).
|
||||
attachments:
|
||||
$(PYTHON) -m unittest discover -s student-tests -p "test_attachments.py" -v
|
||||
|
||||
# Уровень 3: upload -> сразу остановка обслужившей реплики -> ready и download через другую (тот же SHA-256).
|
||||
attachment-failover:
|
||||
$(PYTHON) student-tests/attachment_failover.py
|
||||
|
||||
# Уровень 3: S3 недоступен -> реплики не готовы, балансировщик отвечает 503; после запуска файл цел.
|
||||
failure-s3:
|
||||
$(PYTHON) student-tests/failure_s3.py
|
||||
|
||||
# Уровень 4: приватный bucket вне API, минимальные права ключа API, консоль закрыта, bootstrap идемпотентен,
|
||||
# (lab5) в сообщении брокера только ID.
|
||||
s3-checks:
|
||||
$(PYTHON) student-tests/s3_checks.py
|
||||
|
||||
# Уровень 4: >= 10 одновременных загрузок, пик памяти реплик -> evidence/upload-memory.json и REPORT.md.
|
||||
upload-memory:
|
||||
$(PYTHON) student-tests/upload_memory.py
|
||||
|
||||
# Уборщик объектов S3 вручную (обычно работает в worker): make cleanup ARGS=--dry-run (только показать).
|
||||
cleanup:
|
||||
docker compose exec -T api python -m messenger.cleanup $(ARGS)
|
||||
|
||||
# Повторить настройку bucket (идемпотентно).
|
||||
s3-bootstrap:
|
||||
docker compose run --rm s3-init
|
||||
|
||||
# ---------- lab5: брокер, worker, outbox ----------
|
||||
|
||||
# Остановить / запустить worker (демонстрация из README: загрузки ждут в очереди, API работает).
|
||||
worker-stop:
|
||||
docker compose stop worker
|
||||
|
||||
worker-start:
|
||||
docker compose start worker
|
||||
|
||||
# Уровень 3: worker остановлен -> 202 -> сообщение с вложением -> перезапуск API и брокера -> worker -> ready.
|
||||
worker-outage:
|
||||
$(PYTHON) student-tests/worker_outage.py
|
||||
|
||||
# Уровень 3: повторная доставка того же задания и сообщение не по схеме (в DLQ).
|
||||
redelivery:
|
||||
$(PYTHON) student-tests/redelivery.py
|
||||
|
||||
# Уровень 4: падение API/relay между COMMIT и publish и после publish — transactional outbox.
|
||||
outbox-crash:
|
||||
$(PYTHON) student-tests/outbox_crash.py
|
||||
|
||||
# Уровень 4: падение worker после записи объектов до ack и после COMMIT до ack.
|
||||
worker-crash:
|
||||
$(PYTHON) student-tests/worker_crash.py
|
||||
|
||||
# Уровень 4: повторы с backoff и jitter, исчерпание попыток, постоянная ошибка, DLQ, replay.
|
||||
retry-replay:
|
||||
$(PYTHON) student-tests/retry_replay.py
|
||||
|
||||
# Уровень 4: lease — долгая задача продлевает аренду, замороженный worker её теряет, fencing.
|
||||
lease:
|
||||
$(PYTHON) student-tests/lease_takeover.py
|
||||
|
||||
# Уровень 4: не больше WORKER_CONCURRENCY заданий и prefetch сообщений одновременно.
|
||||
concurrency:
|
||||
$(PYTHON) student-tests/concurrency.py
|
||||
|
||||
# Уровень 4: staging удаляется после COMMIT; уборка объектов без ссылок, retention для replay.
|
||||
staging-cleanup:
|
||||
$(PYTHON) student-tests/staging_cleanup.py
|
||||
|
||||
# Замечание к MR: уборщик не удаляет текущую работу — replay, загрузка и обработка во время уборки.
|
||||
cleanup-race:
|
||||
$(PYTHON) student-tests/cleanup_race.py
|
||||
|
||||
# Варианты картинок и лимиты worker — проверки внутри образа (там Pillow).
|
||||
imaging-test:
|
||||
docker compose --profile tools run --rm imaging-test
|
||||
|
||||
# Оператор: сколько заданий в каждом состоянии / реестр failed / одно задание / явный replay.
|
||||
jobs:
|
||||
docker compose exec -T api python -m messenger.jobs stats
|
||||
|
||||
failed:
|
||||
docker compose exec -T api python -m messenger.jobs failed
|
||||
|
||||
job:
|
||||
@test -n "$(ID)" || (echo "make job ID=<attachment_id>"; exit 2)
|
||||
docker compose exec -T api python -m messenger.jobs show $(ID)
|
||||
|
||||
replay:
|
||||
@test -n "$(ID)" || (echo "make replay ID=<attachment_id>"; exit 2)
|
||||
docker compose exec -T api python -m messenger.jobs replay $(ID) --actor $(or $(ACTOR),operator)
|
||||
|
||||
# Очереди брокера: готовые к выдаче и выданные без ack (основная очередь и DLQ).
|
||||
queues:
|
||||
docker compose exec -T broker rabbitmqctl -q list_queues -p messenger name messages_ready messages_unacknowledged
|
||||
|
||||
|
||||
@@ -1,37 +1,188 @@
|
||||
# Отчёт — лабораторная 5
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Гаджиев Нухбала, БВТ2303
|
||||
- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не выбран
|
||||
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab5/pulls/4
|
||||
- Использованные источники, библиотеки и помощь ИИ: всё из lab4 (FastAPI, uvicorn, pydantic, psycopg 3, argon2-cffi, valkey-py, boto3, Pillow 13.0.0, HAProxy 3.2, PostgreSQL 17, Valkey 8.1, SeaweedFS 4.44) и новое: RabbitMQ 4.2.9 (брокер), pika 1.4.4 (клиент RabbitMQ), simplejpeg 1.9.0 и numpy 2.3.5 (строгая проверка JPEG через libjpeg-turbo). Документация: RabbitMQ (Reliability Guide, Consumer Acknowledgements and Publisher Confirms, Quorum Queues, Dead Letter Exchanges, Configuration), pika (BlockingConnection, add_callback_threadsafe), PostgreSQL (SELECT … FOR UPDATE SKIP LOCKED), Pillow (draft, resize с reducing_gap, ImageOps.exif_transpose), спецификация PNG (блоки, фильтры строк, Adam7). ИИ использовался только как вспомогательный ресурс: для оценки решения, написания комментариев к коду и составления текстовых документов.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Проверял на Windows 11 в Git Bash с Docker Desktop (WSL 2). Нужны Docker с Compose, Python 3 (только для тестов, стандартная библиотека) и GNU Make. Образы закреплены: python:3.12.8-slim-bookworm (основа образа API и worker), haproxy:3.2.25-alpine, postgres:17.10-bookworm, valkey/valkey:8.1.9, chrislusf/seaweedfs:4.44, rabbitmq:4.2.9-alpine. Перед запуском остановить стенд lab4 (`docker compose -p mtusi-lab4 down`), иначе занят порт 8080.
|
||||
|
||||
```sh
|
||||
git clone https://gitea.privcloud.tech/ng14/mtusi2026lab5.git && cd mtusi2026lab5
|
||||
git checkout solution/bvt2303-gadzhiev
|
||||
cp .env.example .env
|
||||
sed -i 's/\r$//' .env # только Windows: убрать \r из .env
|
||||
sh scripts/init-secrets.sh # secrets/: пароли PostgreSQL, Valkey, RabbitMQ, ключи S3 (значения не выводятся)
|
||||
docker compose up -d --build --wait # postgres, valkey, s3, broker -> migrate, s3-init -> api x2, worker -> lb
|
||||
make ps # api x2, worker, lb, postgres, valkey, s3, broker: healthy; migrate, s3-init: Exited (0)
|
||||
|
||||
make check PYTHON=python
|
||||
make test PYTHON=python
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.cmd PYTHON=python # Linux/macOS: scripts/stop-one.sh
|
||||
make restore PYTHON=python
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.cmd PYTHON=python # Linux/macOS: scripts/restart.sh
|
||||
```
|
||||
|
||||
Свои проверки lab5: `make worker-outage`, `redelivery`, `outbox-crash`, `worker-crash`, `retry-replay`, `lease`, `concurrency`, `staging-cleanup`, `cleanup-race`, `imaging-test`, `db-test` (на Windows с `PYTHON=python`). Проверки lab2–lab4 остались: `make student-test`, `attachments`, `attachment-failover`, `failure-s3`, `s3-checks`, `failover`, `persistence`, `check-stack` и др. Все HTTP-проверки идут через балансировщик `http://127.0.0.1:8080`.
|
||||
|
||||
Bootstrap. Схему БД создаёт одноразовый `migrate` (миграции 001–006), bucket — одноразовый `s3-init`. Пользователя, пароль, vhost и права RabbitMQ брокер берёт из файла-секрета `secrets/rabbitmq_credentials.conf` при первом запуске с пустым volume; exchange и очереди объявляют relay и worker при подключении (повторное объявление с теми же параметрами ничего не меняет). Всё повторяемо: `docker compose run --rm migrate`, `make s3-bootstrap`. Действие оператора одно: один раз создать секреты.
|
||||
|
||||
Остановить worker для демонстрации: `make worker-stop`, запустить: `make worker-start`. Команды оператора: `make jobs` (сколько заданий в каждом состоянии), `make failed` (реестр failed), `make job ID=<attachment_id>` (задание, журнал, outbox, варианты), `make replay ID=<attachment_id>`, `make queues` (очереди брокера и DLQ), `make cleanup ARGS=--dry-run` (или `ARGS="--attachment <id>"` — только одно вложение).
|
||||
|
||||
Безопасная остановка: `make down` (volumes `pgdata`, `s3data`, `rabbitmqdata` остаются). Намеренное удаление учебных данных: `docker compose down -v`, затем `rm -rf secrets` и снова `sh scripts/init-secrets.sh` (пароль RabbitMQ задаётся только при первом запуске, поэтому секреты и volume удаляются вместе).
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab4, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```text
|
||||
клиент --> lb: HAProxy, 127.0.0.1:8080 (единственная точка входа)
|
||||
+--> api-1 --+--> postgres: пользователи, чаты, сообщения, сессии, вложения, ЗАДАНИЯ и OUTBOX (pgdata)
|
||||
+--> api-2 --+--> valkey: общий кэш сессий
|
||||
(relay) +--> s3 SeaweedFS: staging/<id> (принятый оригинал), originals/<id>, variants/<id>/v1/... (s3data)
|
||||
+--> broker RabbitMQ: очередь attachments.process и DLQ attachments.dead (rabbitmqdata)
|
||||
worker (отдельный процесс) <-- broker; читает staging, пишет originals и variants в s3, результат в postgres
|
||||
migrate, s3-init — одноразовые; сети: edge (lb <-> api), backend internal (всё остальное); наружу только lb
|
||||
```
|
||||
|
||||
| Роль | Сервис | Версия | Health / готовность | Volume | Сеть / порт | Credentials |
|
||||
| --- | --- | --- | --- | --- | --- | --- |
|
||||
| Балансировщик | `lb` | haproxy:3.2.25-alpine | `/lb-health` | нет | edge; 127.0.0.1:8080, :8081, :8404 | не нужны |
|
||||
| API ×2 (+ relay outbox) | `api` | образ из Dockerfile | `/health/ready`: PostgreSQL и S3 | нет | edge + backend, портов нет | `database_url`, `cache_url`, `s3_access_key_id`, `s3_secret_access_key`, `broker_url` |
|
||||
| Worker | `worker` | тот же образ, `python -m messenger.worker` | файл `/tmp/worker.alive` моложе 30 с | нет | backend, портов нет | `database_url`, ключи S3 API, `broker_url` |
|
||||
| Брокер | `broker` | rabbitmq:4.2.9-alpine (без веб-консоли) | `rabbitmq-diagnostics ping` | `rabbitmqdata` | backend, 5672 | `rabbitmq_credentials.conf` (секрет-файл в conf.d) |
|
||||
| Миграции | `migrate` | тот же образ | код выхода 0 | нет | backend | только `database_url` |
|
||||
| База | `postgres` | postgres:17.10-bookworm | `pg_isready` | `pgdata` | backend, 5432 | `POSTGRES_PASSWORD_FILE` |
|
||||
| Кэш сессий | `valkey` | valkey/valkey:8.1.9 | `valkey-cli ping` | нет | backend, 6379 | ACL-файл |
|
||||
| S3 | `s3` | chrislusf/seaweedfs:4.44 | `/healthz` на :9000 | `s3data` | backend, 9000 | `s3_config.json` |
|
||||
| Bootstrap S3 | `s3-init` | тот же образ | код выхода 0 | нет | backend | только ключи администратора S3 |
|
||||
|
||||
Источник истины: метаданные, состояние заданий и outbox — PostgreSQL, байты — bucket, брокер только доставляет «напоминание» обработать задание. Решение «что делать с сообщением» всегда принимается по строке задания в БД.
|
||||
|
||||
Приём (`src/messenger/attachments.py`) и что сохранено в момент 202:
|
||||
1. Проверки как в lab4: токен, участник чата, `filename`, `Content-Type`, размер до и во время чтения, тип по первым байтам, пиксели по заголовку до распаковки.
|
||||
2. Структура файла без декодирования пикселей (`images.py`): у PNG — блоки, CRC, палитра, tRNS, ничего после IEND, распаковка IDAT порциями по 1 МиБ с подсчётом байт и проверкой типа фильтра строк. У JPEG — всё, что строгий декодер worker (libjpeg-turbo) проверяет по маркерам и заголовкам: известные маркеры и длины сегментов, кадр SOF, таблицы DQT/DHT (коды Хаффмана помещаются в свою длину), каждый компонент скана SOS есть в SOF и не повторяется, параметры сканов, порядок и число маркеров RST, версия JFIF, код Adobe, схема субдискретизации, которую понимает декодер, EOI. Заведомо битые — 415. В worker остаются только ошибки внутри сжатых данных скана: их не найти без декодирования каждого блока (failed, `invalid_image`).
|
||||
3. PUT оригинала в `staging/<id>` (ключ назначает сервер).
|
||||
4. Одна транзакция: вложение `queued` + задание `attempt=1` + строка outbox (тело сообщения) + запись в журнал. После COMMIT — 202 `queued`. Сам ответ не ждёт брокера. Шаги 3–4 идут под advisory-блокировкой ID вложения: пока загрузка не закоммичена, уборщик её staging не трогает.
|
||||
|
||||
Outbox (`relay.py`, поток в каждой реплике API). Relay берёт неотправленные строки с `FOR UPDATE SKIP LOCKED` (реплики не мешают друг другу), публикует в брокер с publisher confirm и только потом ставит `published_at`. Если API упал после COMMIT, строку отправит relay другой реплики или этой после перезапуска. Если relay упал после подтверждения брокера, строка уйдёт ещё раз (дубль, это нормально при at-least-once). Брокер недоступен — загрузки по-прежнему 202, строки ждут в PostgreSQL. Поэтому брокер не входит в readiness, а S3 входит: без S3 не принять файл в staging.
|
||||
|
||||
Брокер. Quorum queue `attachments.process` на диске (`rabbitmqdata`, постоянный hostname — данные лежат в каталоге имени узла), сообщения persistent, publisher confirms, ручной ack. `x-delivery-limit=10` и DLX: сообщение, которое раз за разом не доходит до ack, уходит в DLQ `attachments.dead`. Права пользователя RabbitMQ — только на `attachments*`. `consumer_timeout` 5 мин, heartbeat 10 с (зависший процесс теряет соединение примерно за 20 с, и выданные ему сообщения возвращаются в очередь). Сообщение по `contracts/jobs.schema.json`: только `schema_version`, `job_id`, `type`, `attachment_id`, `pipeline_version`, `attempt`, `created_at`, без байтов, ключей S3, URL и паролей. `created_at` — время постановки этой попытки.
|
||||
|
||||
Worker (`worker.py`). Проверяет сообщение по схеме (не по схеме — reject в DLQ). Решает по строке задания: ready/failed — ack без работы, старая попытка — ack без работы, чужой действующий lease — ack без работы, queued — берёт под lease. Скачивает staging и сверяет размер и SHA-256 с БД. Обрабатывает в дочернем процессе (`sandbox.py`) с лимитами. Пишет `originals/<id>` и варианты в ключи `variants/<id>/v1/<имя>`, коммитит результат с проверкой жетона lease и только потом ack. После COMMIT удаляет staging.
|
||||
|
||||
Состояния (наружу как есть): `queued` → `processing` (lease) → `ready` / `failed`; временная ошибка или истёкший lease → снова `queued` со следующей попыткой; `failed` → `queued` только по replay оператора. Ключ эффекта `(attachment_id, pipeline_version, variant)` — первичный ключ `attachment_variants` и он же ключ объекта в S3: повтор не создаёт второй набор. Ready не откатывается назад: все переходы обновляют вложение только из `queued`/`processing`.
|
||||
|
||||
Повторы и ошибки. Постоянные (`invalid_image`, `image_too_large`, `source_missing`, `source_corrupted`) — failed сразу, сообщение в DLQ. Временные (`storage_unavailable`, `processing_timeout`, `worker_crashed`, `lease_expired`, `processing_failed`) — следующая попытка через backoff с jitter: пауза случайная в [d/2, d], d = min(60 с, 2 с · 2^(n−1)). Всего попыток `JOB_MAX_ATTEMPTS=5`, потом failed с `retry_exhausted` и DLQ. Реестр failed — таблица `attachment_jobs` (`make failed`), журнал — `job_events`. Replay (`make replay ID=...`) переводит только failed в queued с новой попыткой и записью в журнале (кто и что было). Для ready или ещё идущего задания он ничего не делает. Если staging уже удалён (прошло `STAGING_RETENTION_SECONDS`), replay отказывает (`source_missing`, тоже с записью в журнале). Всё это одна транзакция под блокировкой строк задания и вложения — тех же, что берёт уборщик.
|
||||
|
||||
Lease (`jobs.py`). Захват — жетон и срок `JOB_LEASE_SECONDS=30`. Пока worker жив, он продлевает аренду каждые 10 с, поэтому долгая задача не теряет её. Зависший или мёртвый worker не продлевает, и через 30 с фоновая проверка (`reap`, раз в 5 с) засчитывает попытку как неудачную и назначает следующую. Результат принимается, только если жетон совпадает (fencing): опоздавший worker ничего не перезапишет, а обнаружив потерю lease, бросает работу. Если lease держит прежний запуск того же контейнера (Docker его перезапустил), попытка засчитывается сразу, без ожидания 30 с. Попытка не дольше `JOB_TIMEOUT_SECONDS=60`: дочерний процесс убивается.
|
||||
|
||||
Варианты (`imaging.py`). thumbnail — JPEG, вписан в 256×256, без увеличения, размеры вниз, минимум 1 px (320×200 → 256×160). crop — JPEG 128×128, центральный квадрат, маленькие увеличиваются. optimized — WebP, вписан в 1280×1280, без увеличения. Ориентация EXIF применяется. В JPEG прозрачность накладывается на белый фон, WebP её сохраняет. Качество: JPEG `quality=85, optimize=True`, WebP `quality=80, method=4` (с потерями). EXIF, XMP и ICC-профиль в варианты не переносятся (место съёмки и камера не утекают; цвета wide-gamut фото могут немного отличаться). Повтор даёт те же байты. JPEG декодируется в уменьшенном масштабе (draft), 16-битные PNG переводятся в 8 бит.
|
||||
|
||||
Лимиты worker. Байты: объект из staging не больше 10 MiB и совпадает с размером и SHA-256 в БД. Пиксели: не больше 40 млн, проверяются до декодирования. Сжатые данные JPEG проверяются строго (libjpeg-turbo, предупреждение = ошибка): Pillow битый скан молча «дорисовывает» серым. Память: дочерний процесс с `RLIMIT_AS = WORKER_MEMORY_LIMIT_MB = 640` МиБ (нехватка → `image_too_large`), контейнер — 1 ГиБ. Время: `JOB_TIMEOUT_SECONDS=60`, потом SIGKILL. Параллельно `WORKER_CONCURRENCY=2` задания, prefetch брокера тоже 2.
|
||||
|
||||
Уборка (`cleanup.py`, поток worker раз в 5 мин и `make cleanup`). Нужные объекты: оригиналы и варианты ready, ВСЕ объекты вложений в работе (queued, processing: worker может прямо сейчас писать оригинал и варианты), все объекты failed-вложения моложе 24 ч (replay запишет их заново в те же ключи), staging загрузки, которая ещё не закоммичена. Остальное удаляется, только если старше grace 15 мин: staging готового (если worker не успел удалить), объекты failed после retention, объекты без строки в БД. Есть dry-run и уборка одного вложения (`--attachment`). Как уборщик не удаляет текущую работу (замечание к MR): список объектов и снимок ссылок только отбирают кандидатов, а решение по каждому вложению принимается заново под блокировками (`store.cleanup_attachment`): advisory-блокировка ID вложения без ожидания (её держит идущая загрузка — тогда вложение пропускается), затем строки задания и вложения (`FOR NO KEY UPDATE`, тот же порядок, что у worker и replay). У failed-вложения после retention в той же транзакции помечается, что исходника нет (`staging_key = NULL`, запись `staging_expired` в журнале): replay, который ждал блокировку или пришёл позже, безопасно отказывает. Из S3 объекты удаляются уже после COMMIT и только те, что больше никогда не понадобятся, поэтому медленный S3 не держит блокировки, а оборванная сессия БД не открывает окно для гонки.
|
||||
|
||||
Что перенесено из lab4: весь код, миграции 001–005, свои тесты, Dockerfile, конфиги HAProxy/Valkey, SeaweedFS и `s3-init`, скрипты. Что изменено: сервисы `broker` и `worker`, volume `rabbitmqdata`, секреты RabbitMQ, миграция 006 (задания, outbox, варианты, журнал), модули `broker.py`, `relay.py`, `jobs.py`, `worker.py`, `sandbox.py`, `imaging.py`, `faults.py`; загрузка 201 → 202; `images.py` — вместо полного декодирования проверка структуры (PNG по спецификации, JPEG по правилам строгого декодера); `/health/ready` проверяет и S3; уборщик переехал в worker и знает про staging и варианты; hook перезапуска перезапускает ещё брокер и worker.
|
||||
|
||||
Исправления по замечаниям к MR:
|
||||
1. Структурно повреждённый JPEG (SOS ссылается на компонент 250, которого нет в SOF) принимался с 202 и только потом становился failed. Причина: у скана проверялась длина, но не связь с кадром. Теперь `images.py` повторяет все проверки заголовков строгого декодера worker (список — в п. 2 «Приёма»), такой файл получает 415. Совпадение с декодером проверено в образе: 800 случайных повреждений заголовков и 8208 комбинаций субдискретизации без расхождений (`make imaging-test`).
|
||||
2. Уборщик мог удалить staging уже принятого replay: удалял по снимку ссылок без согласования с изменением состояния. Теперь решение принимается под блокировками по текущему состоянию, replay — одна транзакция под теми же блокировками, а staging сначала помечается удалённым в БД (подробно — в абзаце «Уборка»). Тем же механизмом закрыты ещё два окна, которые видны при grace = 0: загрузка между PUT в staging и COMMIT и объекты worker до COMMIT результата. Проверки: `make db-test` (барьеры в настоящей PostgreSQL) и `make cleanup-race` (то же на стенде с точками-паузами).
|
||||
|
||||
Переменные (новые; остальные как в lab4, см. `.env.example`):
|
||||
|
||||
| Переменная | Что делает |
|
||||
| --- | --- |
|
||||
| BROKER_URL_FILE | адрес RabbitMQ с паролем (`/run/secrets/broker_url`) |
|
||||
| WORKER_CONCURRENCY | заданий одновременно и prefetch брокера (2) |
|
||||
| JOB_MAX_ATTEMPTS | всего попыток, потом failed / retry_exhausted (5) |
|
||||
| JOB_TIMEOUT_SECONDS | лимит времени одной попытки (60 с) |
|
||||
| STAGING_RETENTION_SECONDS | сколько хранится staging failed-вложения для replay (86400 с) |
|
||||
| WORKER_REPLICAS, WORKER_MEMORY_LIMIT_MB | число контейнеров worker (1), лимит памяти попытки (640 МиБ) |
|
||||
| RETRY_BASE_SECONDS, RETRY_MAX_SECONDS | backoff: 2 с, удвоение, не больше 60 с, jitter [d/2, d] |
|
||||
| JOB_LEASE_SECONDS, JOB_HEARTBEAT_SECONDS, REAPER_INTERVAL_SECONDS | lease 30 с, продление каждые 10 с, поиск истёкших раз в 5 с |
|
||||
| QUEUED_REPUBLISH_SECONDS | страховка: queued без движения 10 мин — отправить сообщение ещё раз |
|
||||
| RELAY_POLL_SECONDS, RELAY_BATCH_SIZE | опрос outbox раз в 1 с (плюс сигнал сразу после загрузки), пачка 50 |
|
||||
| JPEG_QUALITY, WEBP_QUALITY, WEBP_METHOD | 85, 80, 4 |
|
||||
| IMAGE_CHECK_CONCURRENCY, IMAGE_CHECK_WAIT_SECONDS | проверок структуры одновременно на реплику (2), ожидание очереди (10 с) |
|
||||
| S3_HEALTH_INTERVAL_SECONDS, S3_HEALTH_MAX_AGE_SECONDS | фоновая проверка S3 для readiness раз в 1 с, не старше 3 с |
|
||||
| OUTBOX_RETENTION_SECONDS | отправленные строки outbox хранятся неделю |
|
||||
| FAULTS_ENABLED | точки отказа для тестов (только учебный стенд, включаются файлами в `/tmp/faults` контейнера) |
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | make test | PASS: lab5 public API scenario (202, ready, оригинал и JPEG thumbnail 256×160) | evidence/test.txt |
|
||||
| Структура skeleton и контракт не изменены | make check | PASS: offline skeleton structure | evidence/check.txt |
|
||||
| 3: минимум lab4 сохранён, upload 201 → 202 | make student-test; make failover; make persistence | все тесты OK; публичный failover PASS для каждой реплики; persistence PASS (данные, токен и файл после перезапуска всего стенда) | evidence/student-test.txt, failover.txt, persistence.txt |
|
||||
| 3: 202 только после устойчивого приёма; остановка API после ответа не теряет работу | make attachment-failover; make outbox-crash (A) | реплику, ответившую 202, сразу остановили — вложение всё равно ready, другая реплика отдаёт тот же SHA-256; API упал после COMMIT до ответа — задание всё равно выполнено | evidence/attachment-failover.txt, outbox-crash.txt |
|
||||
| 3: отдельные broker и worker в общем Compose | compose.yaml; make check-stack | `broker` (rabbitmq:4.2.9-alpine, volume, без портов и консоли) и `worker` (отдельный процесс, без портов) | evidence/stack.txt |
|
||||
| 3: сообщения durable, at least once, ack только после устойчивого эффекта | make worker-outage; make worker-crash; make redelivery | сообщение пережило перезапуск брокера (строка outbox отправлена один раз); падение до ack — повторная доставка; ack после COMMIT | evidence/worker-outage.txt, worker-crash.txt, redelivery.txt |
|
||||
| 3: недоступность worker не заставляет API делать resize | make worker-outage | worker остановлен: 202, вложение остаётся queued, /content — 409, текстовые сообщения работают | evidence/worker-outage.txt |
|
||||
| 3: состояния queued/processing/ready/failed в API | make attachments; make lease; make retry-replay | queued в ответе 202, processing во время обработки, ready с вариантами, failed с error_code | evidence/student-test.txt, lease.txt, retry-replay.txt |
|
||||
| 3: оригинал неизменен, thumbnail по контракту | make test; make attachments; make imaging-test | SHA-256 оригинала совпадает; thumbnail JPEG 256×160 (по заголовку JPEG), маленькие не увеличиваются | evidence/test.txt, student-test.txt, imaging-test.txt |
|
||||
| 3: ограниченный retry (5), финальное failed с безопасным error_code | make retry-replay (B) | 5 попыток → failed, error_code=retry_exhausted, без stack trace | evidence/retry-replay.txt |
|
||||
| 3: повтор одной job не создаёт второго набора вариантов | make redelivery; make outbox-crash (C) | дубли → duplicate_ignored, 3 строки и 3 объекта вариантов, SHA-256 те же | evidence/redelivery.txt, outbox-crash.txt |
|
||||
| 3: демонстрация worker остановлен → … → ready; задание переживает рестарт брокера | make worker-outage | 202 → сообщение с вложением → перезапуск API и брокера → worker → ready, thumbnail доступен | evidence/worker-outage.txt |
|
||||
| 4: crop 128×128 и optimized WebP, параметры качества и удаления метаданных | make attachments; make imaging-test | crop JPEG 128×128, optimized WebP ≤1280; ориентация EXIF, белый фон под прозрачностью; в вариантах нет EXIF/XMP/ICC | evidence/student-test.txt, imaging-test.txt |
|
||||
| 4: лимиты по байтам, пикселям, времени и памяти worker | make imaging-test; make attachments | 36 Мп RGBA в лимите 640 МиБ — ok, в лимите 200 МиБ — image_too_large; таймаут — процесс убит; лимит пикселей до декодирования; битый скан JPEG — invalid_image; ровно 10 MiB и 40 млн px — ready, на 1 больше — 413 | evidence/imaging-test.txt, student-test.txt |
|
||||
| Контракт: заведомо повреждённые JPEG — 415 (замечание к MR 1) | make student-test; make imaging-test | пример из замечания (байт i+5 первого SOS = 250) и ещё 26 повреждений заголовков — 415; корректные progressive и с маркерами RST — ready; проверка API совпадает со строгим декодером на 800 случайных повреждениях и 8208 схемах субдискретизации | evidence/student-test.txt, imaging-test.txt |
|
||||
| 4: transactional outbox, crash между COMMIT и publish, ready без ручного задания | make outbox-crash; make db-test | A: API упал после COMMIT; B: relay упал до publish; C: relay упал после publish — во всех ready, одна попытка, один набор вариантов; D: брокер остановлен — 202, строка ждёт, потом ready | evidence/outbox-crash.txt, db-test.txt |
|
||||
| 4: backoff с jitter, постоянные и временные ошибки | make retry-replay; make db-test | паузы в [d/2, d] при d = 2, 4, 8, 16 с; битый JPEG — invalid_image сразу, попытка 1 | evidence/retry-replay.txt, db-test.txt |
|
||||
| 4: DLQ / реестр failed и безопасный явный replay | make retry-replay | failed → DLQ +1 и `jobs failed`; replay failed → ready с записью в журнале; replay ready — noop, нового сообщения нет | evidence/retry-replay.txt |
|
||||
| 4: остановка worker после записи объекта до ack, повтор — тот же результат | make worker-crash (A, B) | A: те же ключи и те же SHA-256, ready на попытке 2; B: после COMMIT до ack — повторная доставка без обработки | evidence/worker-crash.txt |
|
||||
| 4: timeout/lease для зависшего processing | make lease | долгая задача продлевает lease; замороженный worker теряет его, задание забирает второй worker, проснувшийся ничего не перезаписывает | evidence/lease.txt |
|
||||
| 4: ограниченная конкуренция и prefetch | make concurrency | одновременно не больше 2 заданий в processing и 2 сообщений без ack, остальные ждут в очереди | evidence/concurrency.txt |
|
||||
| 4: очистка staging после безопасной фиксации | make staging-cleanup | staging удаляется сразу после COMMIT; остатки и «сироты» — после grace; staging failed хранится до retention; dry-run и повтор безопасны | evidence/staging-cleanup.txt |
|
||||
| Уборка не удаляет текущую работу (замечание к MR 2) | make cleanup-race; make db-test | grace 0: снимок → replay → уборщик: staging не удалён, потом ready (было failed/source_missing); уборщик уже пометил staging удалённым и держит блокировку → replay ждёт её и отказывает source_missing, задание failed; загрузка до COMMIT — пропущена (занято); объекты worker до COMMIT — не удалены | evidence/cleanup-race.txt, db-test.txt |
|
||||
| Свойства lab4: S3 приватный, права, bootstrap; S3 недоступен | make s3-checks; make failure-s3 | анонимно 403, ключ API не может создать, удалить или открыть bucket; в сообщении брокера только ID; S3 остановлен — реплики не готовы, балансировщик отвечает 503, после запуска файл цел | evidence/s3-checks.txt, failure-s3.txt |
|
||||
| Выбранный трек 5 | — | не выбран | — |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Ноутбук: AMD Ryzen 7 4700U, 7,4 ГБ памяти, Windows 11, Docker Desktop (WSL 2). Лимиты: api — 1 CPU и 512 МиБ на реплику, worker — 1 CPU и 1 ГиБ, broker — 1 CPU и 512 МиБ. Данные синтетические, их создают сами тесты. Клиент и стенд на одной машине.
|
||||
|
||||
Память и время одной обработки (замер вне стенда: Linux, те же Pillow 13.0.0 и simplejpeg 1.9.0; пик VmPeak дочернего процесса, вместе с ~130 МиБ базовых библиотек). Гипотеза: самая тяжёлая допустимая картинка — PNG RGBA 40 Мп (160 МиБ пикселей), и она укладывается в лимит 640 МиБ. Методика: `python -m messenger.imaging` на сгенерированных файлах, VmPeak и VmHWM из `/proc/self/status`.
|
||||
|
||||
| Файл | Время | Пик адресного пространства | Пик RSS |
|
||||
| --- | --- | --- | --- |
|
||||
| fixture 320×200 PNG | 0,05 с | 139 МиБ | 38 МиБ |
|
||||
| PNG RGB 6400×6250 (40 Мп) | 1,0 с | 327 МиБ | 226 МиБ |
|
||||
| PNG RGBA 6400×6250 (40 Мп) | 1,1 с | 479 МиБ | 379 МиБ |
|
||||
| PNG 16 бит, серый, 40 Мп | 0,7 с | 328 МиБ | 228 МиБ |
|
||||
| JPEG 6400×6250 | 0,3 с | 244 МиБ | 149 МиБ |
|
||||
| JPEG 4000×3000 с шумом, 9,3 МБ | 0,5 с | 180 МиБ | 81 МиБ |
|
||||
|
||||
Вывод: худший случай (RGBA 40 Мп) — 479 МиБ, лимит 640 МиБ с запасом. Две такие задачи одновременно (~760 МиБ RSS) помещаются в 1 ГиБ контейнера. Сначала было 633 МиБ: каждый из трёх вариантов делался из полноразмерной картинки. Теперь полноразмерная используется для одного уменьшения (в optimized), а thumbnail и crop делаются из optimized. Проверка структуры в API на тех же файлах занимает 0,03–0,3 с (картинка 1×40 000 000 — 0,9 с) без пиксельного буфера. На стенде лимиты подтверждает `make imaging-test`.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `docker compose stop worker`, upload | 202, queued, API работает | 202, queued, /content 409, текст 201 | после `start worker` ready за 3,8 с; потерь нет |
|
||||
| Перезапуск API и брокера с volumes, worker остановлен | задание не теряется | строка outbox отправлена один раз до перезапуска, после запуска worker — ready | потерь нет |
|
||||
| API падает после COMMIT, до 202 | работа принята | клиент получил 502, вложение ready (строку отправил relay другой реплики) | сразу; потерь нет |
|
||||
| relay падает до / после publish | задание доходит до ready | до: строка отправлена после перезапуска; после: дубль, duplicate_ignored | секунды (перезапуск контейнера Docker); потерь нет |
|
||||
| брокер остановлен | загрузки 202, задания ждут | строка outbox не отправлена, после запуска брокера — ready | ready через 11,8 с после запуска брокера |
|
||||
| worker падает после записи в S3 до ack | тот же результат | попытка 2, те же ключи и SHA-256 | секунды (прежний запуск того же контейнера) |
|
||||
| worker заморожен (`docker pause`) | задание переходит к другому worker | lease истёк, второй worker сделал ready, проснувшийся бросил работу | 33 с после заморозки (JOB_LEASE_SECONDS=30) |
|
||||
| временная ошибка 2 раза / всегда | повтор с паузой / failed | ready на попытке 3 / failed retry_exhausted после 5 попыток | паузы 1,96 / 2,31 / 5,86 / 13,62 с (диапазоны 1–2, 2–4, 4–8, 8–16 с) |
|
||||
| `docker compose stop s3` | реплики не готовы, 503 | реплики вне балансировки через 0,9 с, live 200, ready 503, балансировщик отвечает 503 | после `start s3` реплики вернулись через 18,0 с, файл цел |
|
||||
| остановка одной реплики API (`make failover`) | запросы идут на другую | по 124 успешных записи, 0 ошибок | 4,5 и 4,6 с до первого успешного запроса |
|
||||
| перезапуск всего стенда (`make persistence`) | данные, файл и токен сохраняются | всё на месте | 49,6 с вместе с ожиданием готовности |
|
||||
| уборщик прочитал ссылки, затем replay (`make cleanup-race` A) | staging нужен текущей работе | уборщик перепроверил под блокировкой: удалено 0, staging на месте | после запуска worker — ready; потерь нет |
|
||||
| уборщик решил удалить staging (пометил в БД, COMMIT ещё нет), в это время replay (B) | безопасный отказ replay | replay ждал блокировку 8,0 с (пауза уборщика в тесте), отказ source_missing, задание failed, журнал: staging_expired → replay_refused | работа не потеряна: её и не было (retention истёк) |
|
||||
| уборка во время загрузки, до COMMIT (C) и во время обработки, до COMMIT (D) | ничего не удаляется | C: вложение пропущено как занятое; D: 4 объекта оставлены (processing) | загрузка — 202 → ready; обработка — ready, SHA-256 совпадают |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Всё на одном узле: RabbitMQ, SeaweedFS, PostgreSQL и HAProxy в одном экземпляре. Выдерживается отказ одной реплики API, остановка и падение worker, перезапуск брокера с volume. Потеря диска или всего хоста — нет.
|
||||
- At-least-once, а не exactly-once: дубли бывают, и это нормально (relay упал после publish, worker упал до ack). Защита — состояние задания в БД, ключ эффекта и жетон lease.
|
||||
- Readiness зависит от S3: пока S3 недоступен, не работает и текстовая часть API (как при отказе PostgreSQL). Это сознательный выбор: без S3 нельзя принять файл в staging, а это обязательный путь. Брокер и worker на readiness не влияют.
|
||||
- После падения worker задание ждёт до 30 с (срок lease), если упал не прежний запуск того же контейнера, а другой worker. Меньший lease быстрее восстанавливает работу, но чаще отбирает задание у медленного worker.
|
||||
- Точки отказа и точки-паузы (`faults.py`) включены только на учебном стенде (`FAULTS_ENABLED=1`) и срабатывают по файлу внутри контейнера; в рабочей среде переменной нет.
|
||||
- JPEG со схемами субдискретизации, которых не понимает декодер worker (TurboJPEG): например, 4:4:1 или CMYK 4:2:2 — отклоняются 415 как неподдерживаемые, хотя формально корректны. Поддерживаются 4:4:4, 4:2:2, 4:2:0, 4:4:0, 4:1:1 и оттенки серого.
|
||||
- Загрузка держит соединение с БД, пока пишет файл в staging (до 6 с, лимит операции S3). Replay ждёт блокировку вложения до 20 с (её коротко берут уборщик и worker), потом отвечает busy.
|
||||
- Остатки неудачной попытки failed-вложения (оригинал и варианты в S3) лежат до конца retention (24 ч): раньше их удалять нельзя, иначе replay может потерять только что записанные объекты.
|
||||
- Цветовой профиль ICC в варианты не переносится. Анимированные PNG обрабатываются по первому кадру. JPEG с данными после маркера конца принимается (так устроены многие фото с телефона), варианты из него делаются заново.
|
||||
- Вложения lab4 (ready без вариантов) остаются ready, их варианты — 404. Переобработка старых вложений новой версией pipeline — это трек 2 на «5».
|
||||
- Пользователь RabbitMQ один на API и worker (права только на `attachments*`). Отдельные пользователи и mTLS — lab7.
|
||||
+334
@@ -0,0 +1,334 @@
|
||||
# Стенд lab5: HAProxy (единственная точка входа) -> API x2 -> PostgreSQL (источник истины, метаданные, outbox)
|
||||
# + Valkey (общий кэш сессий) + S3 SeaweedFS (байты: staging, оригиналы, варианты)
|
||||
# + RabbitMQ (очередь заданий) -> worker (обработка картинок, отдельный процесс).
|
||||
# Запуск: docker compose up -d --build --wait
|
||||
# Секреты: sh scripts/init-secrets.sh (создаёт каталог secrets/, он в .gitignore)
|
||||
#
|
||||
# Сети: edge (lb <-> api) и backend (api, worker, migrate, s3-init <-> postgres, valkey, s3, broker;
|
||||
# internal = без выхода наружу). Наружу опубликованы только порты балансировщика и только на 127.0.0.1.
|
||||
# У api и worker нет ports и container_name: реплик может быть сколько угодно (deploy.replicas).
|
||||
name: mtusi-lab5
|
||||
|
||||
# Сборка образа приложения (один образ для api, worker, migrate, s3-init).
|
||||
# APP_VERSION меняет только student-tests/rolling_update.py.
|
||||
x-build: &build
|
||||
context: .
|
||||
args:
|
||||
APP_VERSION: ${APP_VERSION:-dev}
|
||||
|
||||
# Docker-статус healthy/unhealthy для API (для `up --wait` и rolling update).
|
||||
# Из балансировки реплику выводит HAProxy по своим, более частым проверкам (infra/haproxy/haproxy.cfg).
|
||||
x-api-healthcheck: &api-healthcheck
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
start_period: 30s
|
||||
start_interval: 1s
|
||||
|
||||
# Общие настройки процессов API (реплики, API с коротким TTL, тесты БД).
|
||||
x-app: &app
|
||||
image: mtusi-messenger:lab5
|
||||
env_file: .env
|
||||
# С lab4 — ключи отдельного S3-пользователя API, с lab5 — адрес брокера (relay outbox).
|
||||
secrets: [database_url, cache_url, s3_access_key_id, s3_secret_access_key, broker_url]
|
||||
networks: [edge, backend]
|
||||
|
||||
services:
|
||||
# Одноразовый сервис: применяет migrations/*.sql и завершается с кодом 0.
|
||||
# Реплики API и worker стартуют только после него и схему не меняют (нет гонки миграций).
|
||||
migrate:
|
||||
image: mtusi-messenger:lab5
|
||||
build: *build
|
||||
env_file: .env
|
||||
command: ["python", "-m", "messenger.migrate"]
|
||||
# Миграциям нужен только адрес PostgreSQL: остальные секреты сюда не монтируются (минимум прав),
|
||||
# а пустые пути говорят config.py, что искать эти файлы не нужно.
|
||||
environment:
|
||||
CACHE_URL_FILE: ""
|
||||
S3_ACCESS_KEY_ID_FILE: ""
|
||||
S3_SECRET_ACCESS_KEY_FILE: ""
|
||||
BROKER_URL_FILE: ""
|
||||
secrets: [database_url]
|
||||
networks: [backend]
|
||||
depends_on:
|
||||
postgres: {condition: service_healthy}
|
||||
healthcheck:
|
||||
disable: true
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "0.50", memory: 128M}
|
||||
|
||||
api:
|
||||
<<: *app
|
||||
build: *build
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
s3-init: {condition: service_completed_successfully} # bucket создан
|
||||
postgres: {condition: service_healthy}
|
||||
valkey: {condition: service_healthy}
|
||||
# Брокер нужен relay, но не приёму файлов: если брокер упадёт позже, API продолжит работать,
|
||||
# а задания подождут в outbox. Условие здесь — только порядок первого запуска.
|
||||
broker: {condition: service_healthy}
|
||||
healthcheck: *api-healthcheck
|
||||
restart: unless-stopped
|
||||
# SIGTERM -> 3 с readiness 503 (уход из балансировки) -> до 8 с на начатые запросы -> выход.
|
||||
# Docker ждёт 15 с и только потом SIGKILL.
|
||||
stop_grace_period: 15s
|
||||
deploy:
|
||||
replicas: ${API_REPLICAS:-2}
|
||||
resources:
|
||||
# 512 МиБ: Argon2id берёт 19 МиБ на каждую одновременную проверку пароля.
|
||||
limits: {cpus: "1.00", memory: 512M}
|
||||
|
||||
# Worker (с lab5): обрабатывает картинки из очереди. Отдельный процесс и отдельный контейнер:
|
||||
# его остановка не мешает API принимать файлы (они ждут в очереди со статусом queued).
|
||||
# Портов нет; в сеть edge не входит — до него нельзя достучаться снаружи.
|
||||
worker:
|
||||
image: mtusi-messenger:lab5
|
||||
pull_policy: never # образ собирается сервисом api, а не скачивается
|
||||
env_file: .env
|
||||
command: ["python", "-m", "messenger.worker"]
|
||||
environment:
|
||||
CACHE_URL_FILE: "" # кэш сессий worker не нужен
|
||||
secrets: [database_url, s3_access_key_id, s3_secret_access_key, broker_url]
|
||||
networks: [backend]
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
s3-init: {condition: service_completed_successfully}
|
||||
postgres: {condition: service_healthy}
|
||||
broker: {condition: service_healthy}
|
||||
# Главный цикл worker раз в секунду обновляет /tmp/worker.alive. Нет обновления 30 с —
|
||||
# процесс завис: контейнер unhealthy (видно в `make ps`).
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import os, sys, time; sys.exit(0 if time.time() - os.path.getmtime('/tmp/worker.alive') < 30 else 1)"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
start_period: 30s
|
||||
start_interval: 1s
|
||||
restart: unless-stopped
|
||||
# SIGTERM -> новые сообщения не берутся, начатые задания доделываются (до 20 с) -> выход.
|
||||
stop_grace_period: 30s
|
||||
deploy:
|
||||
replicas: ${WORKER_REPLICAS:-1}
|
||||
resources:
|
||||
# WORKER_CONCURRENCY=2 задания одновременно, каждое — дочерний процесс до 640 МиБ адресного
|
||||
# пространства (реальный пик самой тяжёлой картинки ~380 МиБ, см. REPORT.md).
|
||||
limits: {cpus: "1.00", memory: 1G}
|
||||
|
||||
# RabbitMQ (с lab5): очередь заданий. Quorum queue хранится на диске в volume rabbitmqdata,
|
||||
# поэтому принятые сообщения переживают перезапуск брокера. Веб-консоли нет (образ без management).
|
||||
broker:
|
||||
image: rabbitmq:4.2.9-alpine
|
||||
# Данные RabbitMQ лежат в каталоге, названном по имени узла rabbit@<hostname>. Постоянный hostname —
|
||||
# чтобы после пересоздания контейнера брокер нашёл свои очереди в том же volume.
|
||||
hostname: broker
|
||||
environment:
|
||||
RABBITMQ_CONFIG_FILES: /etc/rabbitmq/conf.d
|
||||
volumes:
|
||||
- rabbitmqdata:/var/lib/rabbitmq
|
||||
- ./infra/rabbitmq/20-messenger.conf:/etc/rabbitmq/conf.d/20-messenger.conf:ro
|
||||
# Пользователь, пароль, vhost и права — файлом-секретом, а не переменными окружения
|
||||
# (переменные видны в `docker inspect`).
|
||||
secrets:
|
||||
- source: broker_credentials
|
||||
target: /etc/rabbitmq/conf.d/30-credentials.conf
|
||||
healthcheck:
|
||||
test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
|
||||
interval: 10s
|
||||
timeout: 10s
|
||||
retries: 6
|
||||
start_period: 60s
|
||||
start_interval: 2s
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 30s # брокер успевает корректно закрыть очереди
|
||||
networks: [backend]
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "1.00", memory: 512M}
|
||||
|
||||
lb:
|
||||
image: haproxy:3.2.25-alpine
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080" # единственная точка входа API
|
||||
- "127.0.0.1:8081:8081" # API с коротким TTL (make expiry), тоже через балансировщик
|
||||
- "127.0.0.1:8404:8404" # статистика HAProxy: http://127.0.0.1:8404/stats
|
||||
volumes:
|
||||
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
|
||||
networks: [edge]
|
||||
depends_on:
|
||||
api: {condition: service_started}
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-q", "-T", "2", "-O", "/dev/null", "http://127.0.0.1:8404/lb-health"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
start_period: 20s
|
||||
start_interval: 1s
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 15s
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "0.50", memory: 128M}
|
||||
|
||||
# Второй экземпляр API с SESSION_TTL_SECONDS=2 — только для проверки истечения сессии.
|
||||
# Та же база, тот же код; запускается явно (make expiry). Порт наружу не публикуется:
|
||||
# доступ через балансировщик, 127.0.0.1:8081.
|
||||
api-short-ttl:
|
||||
<<: *app
|
||||
profiles: [ttl]
|
||||
pull_policy: never # образ собирается сервисом api, а не скачивается
|
||||
environment:
|
||||
SESSION_TTL_SECONDS: "2"
|
||||
depends_on:
|
||||
postgres: {condition: service_healthy}
|
||||
valkey: {condition: service_healthy}
|
||||
healthcheck: *api-healthcheck
|
||||
restart: unless-stopped
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "0.50", memory: 256M}
|
||||
|
||||
# Интеграционные тесты хранилища и заданий (откат транзакций, гонки, идемпотентность, lease).
|
||||
# Запуск: docker compose --profile tools run --rm db-test
|
||||
db-test:
|
||||
<<: *app
|
||||
profiles: [tools]
|
||||
pull_policy: never
|
||||
networks: [backend]
|
||||
volumes: ["./student-tests:/srv/student-tests:ro"]
|
||||
command: ["python", "-m", "unittest", "discover", "-s", "student-tests/db", "-v"]
|
||||
depends_on:
|
||||
postgres: {condition: service_healthy}
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "1.00", memory: 512M}
|
||||
|
||||
# Проверки обработки картинок внутри образа worker (Pillow есть только там): размеры вариантов,
|
||||
# ориентация EXIF, прозрачность, удаление метаданных, лимиты времени и памяти.
|
||||
# Запуск: docker compose --profile tools run --rm imaging-test
|
||||
imaging-test:
|
||||
image: mtusi-messenger:lab5
|
||||
profiles: [tools]
|
||||
pull_policy: never
|
||||
network_mode: none # проверкам сеть не нужна
|
||||
volumes: ["./student-tests:/srv/student-tests:ro", "./tests/fixtures:/srv/tests/fixtures:ro"]
|
||||
command: ["python", "-m", "unittest", "discover", "-s", "student-tests/worker", "-v"]
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "1.00", memory: 1G}
|
||||
|
||||
postgres:
|
||||
image: postgres:17.10-bookworm
|
||||
environment:
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password # пароль из файла, не из переменной
|
||||
# Значения по умолчанию, выписанные явно: COMMIT возвращается только после записи WAL на диск.
|
||||
command: ["postgres", "-c", "fsync=on", "-c", "synchronous_commit=on", "-c", "full_page_writes=on"]
|
||||
secrets: [postgres_password]
|
||||
volumes: ["pgdata:/var/lib/postgresql/data"] # именованный volume: данные переживают пересоздание контейнера
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U messenger -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
start_period: 10s
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 30s # PostgreSQL успевает корректно завершиться (checkpoint)
|
||||
networks: [backend]
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "1.00", memory: 512M}
|
||||
|
||||
valkey:
|
||||
image: valkey/valkey:8.1.9
|
||||
command: ["valkey-server", "/usr/local/etc/valkey/valkey.conf"]
|
||||
volumes: ["./infra/valkey/valkey.conf:/usr/local/etc/valkey/valkey.conf:ro"]
|
||||
secrets: [valkey_acl] # пользователи и пароль Valkey (ACL), генерируются init-secrets.sh
|
||||
healthcheck:
|
||||
# Пользователь health без пароля может только ping/info/dbsize — данных он не видит.
|
||||
test: ["CMD-SHELL", "valkey-cli --user health --pass none --no-auth-warning ping | grep -q PONG"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
restart: unless-stopped
|
||||
networks: [backend]
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "0.50", memory: 128M}
|
||||
|
||||
# S3-совместимое хранилище SeaweedFS: байты вложений в приватном bucket. Портов наружу нет.
|
||||
# Внутренние части SeaweedFS (master :9333, volume :8080, filer :8888 — у filer и master есть
|
||||
# веб-интерфейсы) слушают только 127.0.0.1 ВНУТРИ контейнера: из сети доступен лишь S3 API (:9000),
|
||||
# и он требует подписи. Встроенный IAM API выключен (-s3.iam=false): пользователи задаются
|
||||
# только файлом-секретом s3_config.json (scripts/init-secrets.sh).
|
||||
s3:
|
||||
image: chrislusf/seaweedfs:4.44
|
||||
entrypoint: ["/usr/bin/weed"]
|
||||
command: ["server", "-dir=/data", "-ip=127.0.0.1", "-ip.bind=127.0.0.1",
|
||||
"-master.volumeSizeLimitMB=1024", "-volume.max=0",
|
||||
"-s3", "-s3.ip.bind=0.0.0.0", "-s3.port=9000", "-s3.iam=false",
|
||||
"-s3.config=/run/secrets/s3_config"]
|
||||
secrets: [s3_config]
|
||||
volumes: ["s3data:/data"] # именованный volume: объекты переживают пересоздание контейнера
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "-fsS", "-o", "/dev/null", "http://127.0.0.1:9000/healthz"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 12
|
||||
start_period: 15s
|
||||
restart: unless-stopped
|
||||
stop_grace_period: 15s
|
||||
networks: [backend]
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "0.50", memory: 512M}
|
||||
|
||||
# Одноразовая настройка S3 (как migrate для БД): создать bucket, если его нет, и проверить,
|
||||
# что он не публичный. Идемпотентна. Ключи администратора S3 есть только здесь (у API — свои).
|
||||
s3-init:
|
||||
image: mtusi-messenger:lab5
|
||||
build: *build
|
||||
command: ["python", "-m", "messenger.s3bootstrap"]
|
||||
environment:
|
||||
S3_ENDPOINT: ${S3_ENDPOINT:-http://s3:9000}
|
||||
S3_REGION: ${S3_REGION:-us-east-1}
|
||||
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
|
||||
S3_ADMIN_ACCESS_KEY_ID_FILE: /run/secrets/s3_root_user
|
||||
S3_ADMIN_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_root_password
|
||||
secrets: [s3_root_user, s3_root_password]
|
||||
networks: [backend]
|
||||
depends_on:
|
||||
s3: {condition: service_healthy}
|
||||
healthcheck:
|
||||
disable: true
|
||||
restart: "no"
|
||||
deploy:
|
||||
resources:
|
||||
limits: {cpus: "0.50", memory: 128M}
|
||||
|
||||
volumes:
|
||||
pgdata: {}
|
||||
s3data: {}
|
||||
rabbitmqdata: {}
|
||||
|
||||
secrets:
|
||||
postgres_password: {file: ./secrets/postgres_password}
|
||||
database_url: {file: ./secrets/database_url}
|
||||
cache_url: {file: ./secrets/cache_url}
|
||||
valkey_acl: {file: ./secrets/valkey_users.acl}
|
||||
s3_root_user: {file: ./secrets/s3_root_user}
|
||||
s3_config: {file: ./secrets/s3_config.json}
|
||||
s3_root_password: {file: ./secrets/s3_root_password}
|
||||
s3_access_key_id: {file: ./secrets/s3_access_key_id}
|
||||
s3_secret_access_key: {file: ./secrets/s3_secret_access_key}
|
||||
broker_url: {file: ./secrets/broker_url}
|
||||
broker_credentials: {file: ./secrets/rabbitmq_credentials.conf}
|
||||
|
||||
networks:
|
||||
edge: {}
|
||||
backend:
|
||||
internal: true # хранилища и брокер недоступны снаружи и сами не ходят в интернет
|
||||
@@ -0,0 +1,29 @@
|
||||
python student-tests/attachment_failover.py
|
||||
uploaded 111817 bytes -> 202 queued, sha256 99ea7533c441f79c..., served by api replica 48dc392933dc
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:18:45.196
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:15:17.826
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
stopped 48dc392933dc (docker stop) right after 202; HAProxy: api1 UP, api2 DOWN
|
||||
the worker finished the job without that replica: status ready, variants ['thumbnail', 'crop', 'optimized']
|
||||
downloaded 4 times through ['c1b7e1ab5673']: same SHA-256 as uploaded
|
||||
restored 48dc392933dc; HAProxy: api1 UP, api2 UP
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:24:32.726
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:15:17.826
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
PASS: the replica that accepted the upload was stopped right after 202; the job still became ready and another replica returned the same bytes (the original lives in S3, not on the replica)
|
||||
@@ -0,0 +1,2 @@
|
||||
python scripts/check_contract.py
|
||||
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
|
||||
@@ -0,0 +1,14 @@
|
||||
python student-tests/cleanup_race.py
|
||||
A. failed b2299717-daa4-4704-afd1-19efe898e821 (retention expired); the janitor read the references and stopped
|
||||
operator replay while the janitor waits -> {'result': 'queued', 'attempt': 2, 'previous_error': 'retry_exhausted'}
|
||||
janitor continued: deleted 0, re-checked under the lock -> kept {'current_work': 1}; staging/b2299717... is still in S3
|
||||
B. failed 6c7228dc-9d9f-4b3c-9f3d-aa6692124418 (retention expired); the janitor holds the lock: staging marked deleted, no COMMIT yet
|
||||
replay waited 8.0 s for the lock -> refused (source_missing); job stays failed; journal: staging_expired -> replay_refused
|
||||
A: worker started -> ready with ['thumbnail', 'crop', 'optimized'] (before the fix: failed / source_missing)
|
||||
C. upload e0578869-000a-4a70-b43b-ab12f6d5ff49: staging written, no row in the database yet (API paused before COMMIT)
|
||||
janitor (grace 0): skipped_busy 1, deleted 0 — the upload holds the attachment lock
|
||||
upload -> 202, then ready with 3 variants
|
||||
D. d4abfa4b-af5e-4208-8d4e-f69a1783891b: worker wrote the original and 3 variants, COMMIT not yet (status processing)
|
||||
janitor (grace 0): the snapshot marked the original and 3 variants as unreferenced; re-checked under the lock -> kept {'current_work': 4}, deleted 0
|
||||
worker committed -> ready; the original and all variants download with the same SHA-256
|
||||
PASS: the janitor re-checks the state under the attachment lock before deleting: a replay accepted after its snapshot keeps the staging (A), a replay after the janitor's decision is refused safely (B), an upload in progress (C) and objects of a job in processing (D) are not deleted
|
||||
@@ -0,0 +1,13 @@
|
||||
python student-tests/concurrency.py
|
||||
time s | processing (DB) | unacked (broker) | waiting in queue
|
||||
2.4 | 2 | 0 | 0
|
||||
5.0 | 2 | 2 | 4
|
||||
7.6 | 2 | 2 | 4
|
||||
11.6 | 2 | 2 | 4
|
||||
14.3 | 2 | 2 | 2
|
||||
17.1 | 2 | 2 | 2
|
||||
19.7 | 2 | 2 | 0
|
||||
23.8 | 2 | 2 | 0
|
||||
26.5 | 0 | 2 | 0
|
||||
peak: 2 jobs in processing, 2 unacknowledged messages, up to 4 waiting in the queue; all 6 ready after 26.5 s
|
||||
PASS: at most WORKER_CONCURRENCY=2 jobs run at once and the broker gives the worker at most prefetch=2 messages; the rest wait in the durable queue
|
||||
@@ -0,0 +1,61 @@
|
||||
docker compose --profile tools run --rm db-test
|
||||
Container mtusi-lab5-postgres-1 Running
|
||||
Container mtusi-lab5-postgres-1 Waiting
|
||||
Container mtusi-lab5-postgres-1 Healthy
|
||||
Container mtusi-lab5-db-test-run-dcea39c16e25 Creating
|
||||
Container mtusi-lab5-db-test-run-dcea39c16e25 Created
|
||||
test_1_replay_after_snapshot_keeps_staging (test_cleanup.CleanupRaceTest.test_1_replay_after_snapshot_keeps_staging) ...
|
||||
snapshot -> replay (queued) -> cleanup: kept [('staging/224e34a0-91da-415f-acc4-ecc686b36842', 'current_work')], nothing deleted
|
||||
ok
|
||||
test_2_cleanup_first_then_replay_waits_and_refuses (test_cleanup.CleanupRaceTest.test_2_cleanup_first_then_replay_waits_and_refuses) ...
|
||||
cleanup marked the staging deleted, holds the lock -> replay waited 1 s+ -> refused (source_missing); job stays failed; journal: staging_expired, replay_refused
|
||||
ok
|
||||
test_3_replay_first_then_cleanup_waits_and_keeps (test_cleanup.CleanupRaceTest.test_3_replay_first_then_cleanup_waits_and_keeps) ... ok
|
||||
test_4_upload_in_progress_is_skipped (test_cleanup.CleanupRaceTest.test_4_upload_in_progress_is_skipped)
|
||||
replay holds the lock -> cleanup waited -> kept [('staging/34b4b519-0cbc-4edb-baab-e86b337fdf38', 'current_work')]
|
||||
...
|
||||
upload between PUT and COMMIT -> cleanup skipped it (busy); after COMMIT -> current work, kept
|
||||
ok
|
||||
test_5_objects_of_processing_job_are_kept (test_cleanup.CleanupRaceTest.test_5_objects_of_processing_job_are_kept) ... ok
|
||||
test_6_regular_cleanup_still_works (test_cleanup.CleanupRaceTest.test_6_regular_cleanup_still_works) ...
|
||||
processing job (worker writes the original and variants before COMMIT) -> all 3 objects kept
|
||||
|
||||
orphan, staging after ready, objects of a failed attachment after retention -> deleted; published original and variants, a failed attachment within retention -> kept; dry-run deletes nothing
|
||||
ok
|
||||
test_backoff_bounds (test_jobs.JobsIntegrationTest.test_backoff_bounds) ... ok
|
||||
test_claim_once_and_concurrent_claims (test_jobs.JobsIntegrationTest.test_claim_once_and_concurrent_claims) ...
|
||||
10 concurrent claims of one job: 1 claimed, 9 in_progress
|
||||
ok
|
||||
test_expired_lease_and_dead_predecessor (test_jobs.JobsIntegrationTest.test_expired_lease_and_dead_predecessor) ... ok
|
||||
test_fencing_and_duplicates (test_jobs.JobsIntegrationTest.test_fencing_and_duplicates) ... ok
|
||||
test_outbox_rows_are_taken_by_one_relay (test_jobs.JobsIntegrationTest.test_outbox_rows_are_taken_by_one_relay) ... ok
|
||||
test_permanent_error_fails_at_once (test_jobs.JobsIntegrationTest.test_permanent_error_fails_at_once) ... ok
|
||||
test_replay_rules (test_jobs.JobsIntegrationTest.test_replay_rules) ... ok
|
||||
test_retry_backoff_then_exhausted (test_jobs.JobsIntegrationTest.test_retry_backoff_then_exhausted) ... ok
|
||||
test_upload_creates_job_and_outbox_in_one_transaction (test_jobs.JobsIntegrationTest.test_upload_creates_job_and_outbox_in_one_transaction) ... ok
|
||||
test_concurrent_registration_has_one_winner (test_store.StoreIntegrationTest.test_concurrent_registration_has_one_winner) ...
|
||||
20 параллельных create_user: 1 создан, 19 получили Conflict (409)
|
||||
ok
|
||||
test_concurrent_same_idempotency_key_creates_one_row (test_store.StoreIntegrationTest.test_concurrent_same_idempotency_key_creates_one_row) ...
|
||||
20 одновременных add_message с одним ключом: 1 строка, 1 новое + 19 повторов с тем же сообщением
|
||||
ok
|
||||
test_create_chat_rolls_back_when_failing_midway (test_store.StoreIntegrationTest.test_create_chat_rolls_back_when_failing_midway) ... ok
|
||||
test_database_rejects_message_from_non_member (test_store.StoreIntegrationTest.test_database_rejects_message_from_non_member) ...
|
||||
чат с несуществующим участником: транзакция откатилась, строк chats/chat_members не осталось
|
||||
ok
|
||||
|
||||
INSERT сообщения от не-участника напрямую в БД: ForeignKeyViolation
|
||||
test_migrations_rerun_is_noop (test_store.StoreIntegrationTest.test_migrations_rerun_is_noop) ... ok
|
||||
test_old_version_insert_without_key_still_works (test_store.StoreIntegrationTest.test_old_version_insert_without_key_still_works) ...
|
||||
schema_migrations: ['001_core', '002_sessions', '003_text_as_bytes', '004_message_idempotency', '005_attachments', '006_jobs']; повторный migrate() ничего не применил
|
||||
ok
|
||||
|
||||
INSERT как в lab2 (без ключа) после миграции 004 работает: старая версия совместима со схемой
|
||||
test_same_key_other_body_is_conflict (test_store.StoreIntegrationTest.test_same_key_other_body_is_conflict) ...
|
||||
тот же ключ с другим телом: Conflict (409), в базе по-прежнему одна строка
|
||||
ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 22 tests in 2.833s
|
||||
|
||||
OK
|
||||
@@ -0,0 +1,64 @@
|
||||
python student-tests/run_failover.py
|
||||
hook: scripts/stop-one.cmd; api replicas: ['48dc392933dc', 'c1b7e1ab5673']
|
||||
|
||||
=== run 1: containers before (HAProxy: api1 UP, api2 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:24:32.726
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.␍
|
||||
{"observed_instances_before": 2, "successful_writes": 124, "failed_attempts": 0, "first_recovery_seconds": 4.531}␍
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
containers after (HAProxy: api1 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc exited 2026-10-26T16:24:32.726
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
the hook stopped 48dc392933dc (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
|
||||
restored: docker start 48dc392933dc -> healthy and back in HAProxy (api1 UP, api2 UP)
|
||||
|
||||
=== run 2: containers before (HAProxy: api1 UP, api2 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.␍
|
||||
{"observed_instances_before": 2, "successful_writes": 124, "failed_attempts": 0, "first_recovery_seconds": 4.594}␍
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
containers after (HAProxy: api2 UP)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
|
||||
api c1b7e1ab5673 exited 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
the hook stopped c1b7e1ab5673 (X-Instance-Id of that replica = container ID); other api containers, postgres, valkey, s3 and lb kept running
|
||||
restored: docker start c1b7e1ab5673 -> healthy and back in HAProxy (api1 UP, api2 UP)
|
||||
|
||||
PASS: public failover test passed 2 times; every api replica was stopped once and restored
|
||||
@@ -0,0 +1,36 @@
|
||||
python student-tests/failure_s3.py
|
||||
=== s3 stopped
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:24:32.726
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 exited 2026-10-26T16:15:17.826
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
both api replicas are out of the balancer after 0.9 s: api1 DOWN, api2 DOWN
|
||||
replica 48dc392933dc: /health/live 200, /health/ready 503
|
||||
replica c1b7e1ab5673: /health/live 200, /health/ready 503
|
||||
GET /health/ready -> 503 unavailable in 0.05 s (answered by the balancer)
|
||||
POST /api/v1/chats/c3165ff5-5952-4666-84df-aa7e4dab7fb9/attachments -> 503 unavailable in 0.00 s (answered by the balancer)
|
||||
GET /api/v1/attachments/bfbc3aa5-81f0-46d0-a26d-f901b8d9ee86/content -> 503 unavailable in 0.00 s (answered by the balancer)
|
||||
GET /api/v1/chats/c3165ff5-5952-4666-84df-aa7e4dab7fb9/messages -> 503 unavailable in 0.02 s (answered by the balancer)
|
||||
=== s3 started
|
||||
replicas are back in the balancer after 18.0 s: api1 UP, api2 UP
|
||||
the file uploaded before the outage is intact (sha256 99ea7533c441f79c...)
|
||||
new upload -> 202 -> ready (59e03ee4-d3ff-40e9-b1e6-6a1d6fee4720)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (unhealthy) 2026-10-26T16:24:32.726
|
||||
api c1b7e1ab5673 running (unhealthy) 2026-10-26T16:18:45.657
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (unhealthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (starting) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
PASS: S3 down -> replicas not ready (live 200, ready 503), the balancer answers 503 in the contract format, no 500 and no hanging; after S3 is back the original is intact and uploads work again
|
||||
@@ -0,0 +1,29 @@
|
||||
docker compose --profile tools run --rm imaging-test
|
||||
Container mtusi-lab5-imaging-test-run-7b65aee97073 Creating
|
||||
Container mtusi-lab5-imaging-test-run-7b65aee97073 Created
|
||||
test_alpha_is_white_in_jpeg_and_kept_in_webp (test_imaging.ImagingTest.test_alpha_is_white_in_jpeg_and_kept_in_webp) ... ok
|
||||
test_broken_jpeg_scan_is_invalid (test_imaging.ImagingTest.test_broken_jpeg_scan_is_invalid) ... ok
|
||||
test_exif_orientation_is_applied (test_imaging.ImagingTest.test_exif_orientation_is_applied) ...
|
||||
EXIF orientation 6: stored 400×200 -> variants 128×256 / 200×400, upright like a viewer shows it
|
||||
ok
|
||||
test_fixture_variants (test_imaging.ImagingTest.test_fixture_variants) ...
|
||||
fixture 320×200 -> thumbnail JPEG 256×160, crop JPEG 128×128, optimized WebP 320×200
|
||||
ok
|
||||
test_geometry (test_imaging.ImagingTest.test_geometry) ... ok
|
||||
test_jpeg_header_check_matches_strict_decoder (test_imaging.ImagingTest.test_jpeg_header_check_matches_strict_decoder) ...
|
||||
800 random header mutations: {'both accept': 318, 'both reject': 427, 'accepted, entropy error in worker': 55}
|
||||
ok
|
||||
test_limits_in_child_process (test_imaging.ImagingTest.test_limits_in_child_process) ...
|
||||
36 Mpx RGBA in a child process: ok in 3.93 s with 640 MiB; MemoryError -> image_too_large with 200 MiB; timeout 0.2 s -> killed after 0.21 s; 1000 px limit -> image_too_large
|
||||
ok
|
||||
test_metadata_is_stripped (test_imaging.ImagingTest.test_metadata_is_stripped) ... ok
|
||||
test_modes (test_imaging.ImagingTest.test_modes) ... ok
|
||||
test_same_input_same_bytes (test_imaging.ImagingTest.test_same_input_same_bytes) ... ok
|
||||
test_subsampling_rule_matches_turbojpeg (test_imaging.ImagingTest.test_subsampling_rule_matches_turbojpeg) ...
|
||||
8208 sampling-factor combinations: API and TurboJPEG agree on every one
|
||||
ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 11 tests in 6.036s
|
||||
|
||||
OK
|
||||
@@ -0,0 +1,9 @@
|
||||
python student-tests/lease_takeover.py
|
||||
1. long job (35 s > lease 30 s) on 292a36c54a41/4b7735c2: lease_until moved forward 2 times: 16:21:03 -> 16:21:13 -> 16:21:23
|
||||
2. worker B fa1bafe61888 started (the job is still held by A's lease)
|
||||
worker A 292a36c54a41 frozen (docker pause): no more renewals
|
||||
lease expired -> attempt 2 -> ready 33 s after the freeze; result committed by worker-fa1bafe61888/279ac631
|
||||
events: queued(1) -> claimed(1) -> lease_expired(1) -> retry_scheduled(1) -> claimed(2) -> ready(2)
|
||||
3. worker A unpaused: Задание d08bfc08-1460-4633-bbfd-6b3f69088ca3: lease забрал другой worker — работа брошена
|
||||
still exactly one result: status ready, attempt 2, 3 variant rows, metadata unchanged
|
||||
PASS: a running worker keeps its lease by renewing it; a frozen one loses it, the job moves to another worker, and the stale worker cannot overwrite the result (fencing token)
|
||||
@@ -0,0 +1,19 @@
|
||||
python student-tests/outbox_crash.py
|
||||
A. api_after_commit: the client got 502 instead of 202, but the attachment 68ccecb0-ae64-4a1d-a235-63219f66c403 and its outbox row were committed before the crash
|
||||
ready without creating a new job by hand; api restarted by Docker: ['48dc392933dc']
|
||||
outbox: row 130 published 2026-10-26T16:18:31.010950+00:00 by relay-c1b7e1ab5673
|
||||
events: queued -> claimed -> ready
|
||||
B. relay_before_publish: upload -> 202 (780f7bd8-df89-4c70-84fa-9d90f35879fa); every relay that takes the row crashes before publishing
|
||||
crashed and restarted: ['48dc392933dc', 'c1b7e1ab5673']; after restart the row was published once -> ready
|
||||
outbox: row 131 published 2026-10-26T16:18:40.873234+00:00 by relay-48dc392933dc
|
||||
events: queued -> claimed -> ready
|
||||
C. relay_after_publish: upload -> 202 (87559a9a-a61c-4a10-999c-516b5e1f481a); the broker confirms, the relay crashes before marking the row
|
||||
crashed and restarted: ['48dc392933dc', 'c1b7e1ab5673']; the same message was delivered again 1 time(s): duplicate_ignored
|
||||
outbox: row 132 published 2026-10-26T16:18:48.678466+00:00 by relay-48dc392933dc
|
||||
events: queued -> claimed -> ready -> duplicate_ignored
|
||||
still one set of variants: 3 rows, 3 objects
|
||||
D. broker stopped: upload -> 202 (87e3efc2-e44b-4260-8129-7fadffec4811), after 5 s status queued, outbox row 133 not published yet (it waits in PostgreSQL)
|
||||
broker started: the relay published the row, ready 11.8 s later
|
||||
outbox: row 133 published 2026-10-26T16:19:07.785521+00:00 by relay-48dc392933dc
|
||||
events: queued -> claimed -> ready
|
||||
PASS: a crash between COMMIT and publish (A, B) loses nothing — the outbox row is published later and the job becomes ready without manual action; a crash after publish (C) only causes a duplicate delivery, which the worker acknowledges without a second set of variants; while the broker is down (D) uploads are still accepted and the jobs wait in the outbox
|
||||
@@ -0,0 +1,37 @@
|
||||
python student-tests/run_persistence.py
|
||||
hook: scripts/restart.cmd
|
||||
=== containers before
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:25:57.020
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:26:21.371
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:19:00.163
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:15:42.154
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:23:38.842
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:15:17.840
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:24:57.683
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:23:38.843
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:15:17.820
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:23:41.416
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.␍
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
=== containers after (test took 49.6 s: hook + waiting for readiness + data checks)
|
||||
SERVICE CONTAINER STATE STARTED AT (UTC)
|
||||
api 48dc392933dc running (healthy) 2026-10-26T16:27:12.404
|
||||
api c1b7e1ab5673 running (healthy) 2026-10-26T16:27:12.751
|
||||
broker 9f909ed7ecea running (healthy) 2026-10-26T16:26:35.888
|
||||
lb 8be67a2e86b7 running (healthy) 2026-10-26T16:27:16.490
|
||||
migrate a5a9934b4d6b exited 2026-10-26T16:26:50.586
|
||||
postgres d2bfd48385f1 running (healthy) 2026-10-26T16:26:34.837
|
||||
s3 892c7ca290f2 running (healthy) 2026-10-26T16:26:49.628
|
||||
s3-init deab1aa2b022 exited 2026-10-26T16:27:10.098
|
||||
valkey 4e223cb9301e running (healthy) 2026-10-26T16:26:34.974
|
||||
worker 292a36c54a41 running (healthy) 2026-10-26T16:27:12.399
|
||||
api 48dc392933dc: same container, start time 16:25:57 -> 16:27:12
|
||||
api c1b7e1ab5673: same container, start time 16:26:21 -> 16:27:12
|
||||
broker 9f909ed7ecea: same container, start time 16:19:00 -> 16:26:35
|
||||
lb 8be67a2e86b7: same container, start time 16:15:42 -> 16:27:16
|
||||
postgres d2bfd48385f1: same container, start time 16:15:17 -> 16:26:34
|
||||
s3 892c7ca290f2: same container, start time 16:24:57 -> 16:26:49
|
||||
valkey 4e223cb9301e: same container, start time 16:15:17 -> 16:26:34
|
||||
worker 292a36c54a41: same container, start time 16:23:41 -> 16:27:12
|
||||
PASS: api replicas, worker, postgres, valkey, s3, broker and lb were restarted (same containers and volumes, new start time); data, the attachment bytes and the existing token survived
|
||||
@@ -0,0 +1,8 @@
|
||||
python student-tests/redelivery.py
|
||||
1. attachment 0e1796c4-b771-4b97-a8d6-27f3d24d5dd4 ready: 3 variant rows, objects ['variants/0e1796c4-b771-4b97-a8d6-27f3d24d5dd4/v1/crop.jpg', 'variants/0e1796c4-b771-4b97-a8d6-27f3d24d5dd4/v1/optimized.webp', 'variants/0e1796c4-b771-4b97-a8d6-27f3d24d5dd4/v1/thumbnail.jpg']
|
||||
2. the same message (same job_id and attempt) published twice more
|
||||
3. both duplicates acknowledged without processing: duplicate_ignored(задание уже ready: повторная доставка, ack без обработки), duplicate_ignored(задание уже ready: повторная доставка, ack без обработки)
|
||||
variants: [('crop', '97bf1400b30a'), ('optimized', '1090d84ed841'), ('thumbnail', '7bc40bf315c8')] — same rows, same objects, status ready, attempt 1
|
||||
4. 3 messages that do not match jobs.schema.json -> reject -> DLQ attachments.dead: 34 -> 37
|
||||
the worker keeps working: a new upload became ready
|
||||
PASS: redelivery of a finished job is a no-op with ack (no second set of variants); malformed messages go to the DLQ without crashing the worker
|
||||
@@ -0,0 +1,12 @@
|
||||
python student-tests/retry_replay.py
|
||||
A. transient errors twice, then success: ready at attempt 3
|
||||
pauses before attempts: #2: 1.98 s, #3: 2.19 s (backoff 2^n with random jitter in [d/2, d])
|
||||
events: queued(1) -> claimed(1) -> retry_scheduled(1) -> claimed(2) -> retry_scheduled(2) -> claimed(3) -> ready(3)
|
||||
B. transient error every time: 5 attempts -> failed, error_code=retry_exhausted (last error storage_unavailable)
|
||||
pauses: #2: 1.96 s, #3: 2.31 s, #4: 5.86 s, #5: 13.62 s
|
||||
DLQ attachments.dead: 30 -> 31; registry: python -m messenger.jobs failed lists it; content -> 409, attach -> 409
|
||||
C. permanent error: broken JPEG scan -> failed at attempt 1, error_code=invalid_image (no retries)
|
||||
D. replay of the failed job: {'result': 'queued', 'attempt': 6, 'previous_error': 'retry_exhausted'} -> ready at attempt 6; audit: operator:student-test: replay оператора: было retry_exhausted (последняя ошибка storage_unavailable); новая попытка 6, ещё 5 попыток
|
||||
replay of the now ready job: {'result': 'noop', 'reason': 'ready'} — no new message, variants unchanged (3 rows), status ready
|
||||
replay of the permanent failure: {'result': 'queued', 'attempt': 2, 'previous_error': 'invalid_image'} -> failed again with invalid_image
|
||||
PASS: bounded retries with backoff and jitter; permanent errors fail at once; final failures go to the DLQ and the failed registry; replay re-runs only failed jobs and is audited
|
||||
@@ -0,0 +1,23 @@
|
||||
python student-tests/s3_checks.py
|
||||
object keys are server-generated: staging/<attachment uuid> -> originals/<attachment uuid>, variants/<attachment uuid>/v1/<variant> (filename is not used in keys)
|
||||
anonymous_get_object: HTTP 403
|
||||
anonymous_list_bucket: HTTP 403
|
||||
anonymous_list_buckets: HTTP 403
|
||||
API key GetObject: same SHA-256 as uploaded (the bytes are in the bucket)
|
||||
API key list_buckets: ['messenger-attachments']
|
||||
API key create_bucket: AccessDenied
|
||||
API key make_bucket_public: AccessDenied
|
||||
API key delete_bucket: AccessDenied
|
||||
SeaweedFS admin/UI port 9333 inside the network: closed
|
||||
SeaweedFS admin/UI port 8888 inside the network: closed
|
||||
SeaweedFS admin/UI port 8080 inside the network: closed
|
||||
host 127.0.0.1:9000, :9333, :8888: closed (S3 is not published)
|
||||
attachments columns: id:uuid, chat_id:uuid, owner_id:uuid, filename:text, content_type:text, size_bytes:bigint, sha256:text, width:integer, height:integer, storage_key:text, status:text, created_at:timestamp with time zone, updated_at:timestamp with time zone, error_code:text, staging_key:text
|
||||
api 48dc392933dc: files with the same SHA-256 on disk: 0
|
||||
api c1b7e1ab5673: files with the same SHA-256 on disk: 0
|
||||
worker 292a36c54a41: files with the same SHA-256 on disk: 0
|
||||
broker message (243 bytes): ['attachment_id', 'attempt', 'created_at', 'job_id', 'pipeline_version', 'schema_version', 'type'] — only IDs and service fields
|
||||
s3-init run 1: exit 0: s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
|
||||
s3-init run 2: exit 0: s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
|
||||
objects in bucket before/after bootstrap: 360/360; the file still downloads
|
||||
PASS: bucket is private outside the API, the API S3 user has least privilege, the console is closed, bytes are only in S3, bucket bootstrap is idempotent
|
||||
@@ -0,0 +1,39 @@
|
||||
python student-tests/check_stack.py
|
||||
docker: 29.6.2
|
||||
compose: 5.3.1
|
||||
container_name: not set for any service (replicas of one service are possible)
|
||||
api replicas running: 2 -> ['48dc392933dc', 'c1b7e1ab5673'] (deploy.replicas = 2)
|
||||
|
||||
service container cpus memory published ports networks
|
||||
worker 292a36c54a41 1.00 1024Mi - backend
|
||||
api 48dc392933dc 1.00 512Mi - backend, edge
|
||||
valkey 4e223cb9301e 0.50 128Mi - backend
|
||||
s3 892c7ca290f2 0.50 512Mi - backend
|
||||
lb 8be67a2e86b7 0.50 128Mi 127.0.0.1:8080->8080/tcp, 127.0.0.1:8081->8081/tcp, 127.0.0.1:8404->8404/tcp edge
|
||||
broker 9f909ed7ecea 1.00 512Mi - backend
|
||||
api c1b7e1ab5673 1.00 512Mi - backend, edge
|
||||
postgres d2bfd48385f1 1.00 512Mi - backend
|
||||
|
||||
published: only lb, only on 127.0.0.1 (api replicas have no ports)
|
||||
balancer: every api server is under the /health/ready check, no backup servers -> api1 UP (L7OK), api2 UP (L7OK)
|
||||
limits: every running container has CPU and RAM limits
|
||||
networks: lb -> edge; api -> edge + backend; postgres, valkey, s3, broker, worker -> backend (internal: no way out)
|
||||
broker: rabbitmq:4.2.9-alpine, volume rabbitmqdata, hostname broker, no ports, no web console; worker: separate service (1 running), no ports
|
||||
s3: no published ports; master/filer web UIs only on 127.0.0.1 inside the container; IAM API off; pinned image; volume s3data
|
||||
secrets: api -> broker_url, cache_url, database_url, s3_access_key_id, s3_secret_access_key; worker -> broker_url, database_url, s3_access_key_id, s3_secret_access_key; broker -> broker_credentials; migrate -> database_url; lb -> none; postgres -> postgres_password; valkey -> valkey_acl; s3 -> s3_config; s3-init -> s3_root_password, s3_root_user
|
||||
images: lb haproxy:3.2.25-alpine; api mtusi-messenger:lab5; worker mtusi-messenger:lab5; postgres postgres:17.10-bookworm; valkey valkey/valkey:8.1.9; s3 chrislusf/seaweedfs:4.44; broker rabbitmq:4.2.9-alpine
|
||||
PASS: one entry point (lb on 127.0.0.1), >= 2 api replicas without ports and container_name, only ready replicas get traffic, CPU/RAM limits everywhere, stores (incl. S3) only on the internal network, S3 admin credentials only in s3-init; broker and worker are separate services
|
||||
docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}"
|
||||
SERVICE CONTAINER ID STATUS
|
||||
api 48dc392933dc Up 49 seconds (healthy)
|
||||
api c1b7e1ab5673 Up 49 seconds (healthy)
|
||||
broker 9f909ed7ecea Up About a minute (healthy)
|
||||
lb 8be67a2e86b7 Up 48 seconds (healthy)
|
||||
migrate a5a9934b4d6b Exited (0) About a minute ago
|
||||
postgres d2bfd48385f1 Up About a minute (healthy)
|
||||
s3 892c7ca290f2 Up About a minute (healthy)
|
||||
s3-init deab1aa2b022 Exited (0) 50 seconds ago
|
||||
valkey 4e223cb9301e Up About a minute (healthy)
|
||||
worker 292a36c54a41 Up 49 seconds (healthy)
|
||||
s3-init-1 | s3-init: bucket messenger-attachments already exists; anonymous access: 403 (private)
|
||||
migrate-1 | 2026-10-26 16:15:25,625 INFO messenger.db: Миграции: новых нет, схема актуальна
|
||||
@@ -0,0 +1,10 @@
|
||||
python student-tests/staging_cleanup.py
|
||||
1. ready a285845a-2a6d-438d-a37c-f5ce252e5ce6: staging removed by the worker right after COMMIT; original and variants kept
|
||||
2. prepared: staging leftover of a ready attachment, orphan staging, orphan variant, staging of a failed attachment, staging of a queued job (worker stopped)
|
||||
3. dry-run: {"staging_after_ready": 2, "staging_failed_expired": 0, "orphan": 2} found, deleted 0
|
||||
grace 900 s: deleted 0 — everything is younger than the grace period
|
||||
grace 2 s: {"staging_after_ready": 2, "staging_failed_expired": 0, "orphan": 2}, deleted 4; kept: ready original and variants, staging of the queued job, staging of the failed attachment (retention)
|
||||
retention 0 s: failed staging deleted ({"staging_after_ready": 0, "staging_failed_expired": 3, "orphan": 0}); replay now: {'result': 'refused', 'reason': 'source_missing', 'detail': 'оригинал в staging уже удалён (истёк STAGING_RETENTION_SECONDS)'}
|
||||
repeated run: deleted 0
|
||||
4. worker started: 002336e3-fb36-4738-b420-29d5362140cb ready, its staging removed
|
||||
PASS: staging is removed after the result is committed; objects without a reference in the database are removed only after the grace period; the staging of failed uploads is kept for replay until retention ends; dry-run and repeated runs are safe
|
||||
@@ -0,0 +1,92 @@
|
||||
python -m unittest discover -s student-tests -p "test_*.py" -v
|
||||
test_auth_checked_before_access_and_body (test_api.MessengerApiTest.test_auth_checked_before_access_and_body) ... ok
|
||||
test_bad_cursor_returns_400 (test_api.MessengerApiTest.test_bad_cursor_returns_400) ... ok
|
||||
test_chat_list_pagination (test_api.MessengerApiTest.test_chat_list_pagination) ... ok
|
||||
test_chat_membership_rules (test_api.MessengerApiTest.test_chat_membership_rules) ... ok
|
||||
test_duplicate_username_returns_409 (test_api.MessengerApiTest.test_duplicate_username_returns_409) ... ok
|
||||
test_empty_blank_and_too_long_messages_return_400 (test_api.MessengerApiTest.test_empty_blank_and_too_long_messages_return_400) ... ok
|
||||
test_malformed_json_returns_400 (test_api.MessengerApiTest.test_malformed_json_returns_400) ... ok
|
||||
test_nul_character_is_stored (test_api.MessengerApiTest.test_nul_character_is_stored) ... ok
|
||||
test_outsider_gets_404_for_foreign_chat (test_api.MessengerApiTest.test_outsider_gets_404_for_foreign_chat) ... ok
|
||||
test_pagination_walks_several_pages (test_api.MessengerApiTest.test_pagination_walks_several_pages) ... ok
|
||||
test_unicode_roundtrip (test_api.MessengerApiTest.test_unicode_roundtrip) ... ok
|
||||
test_wrong_types_and_extra_fields_return_400 (test_api.MessengerApiTest.test_wrong_types_and_extra_fields_return_400) ... ok
|
||||
test_attachment_rules_without_500 (test_attachments.AttachmentTest.test_attachment_rules_without_500) ... ok
|
||||
test_broken_scan_becomes_failed_and_cannot_be_attached (test_attachments.AttachmentTest.test_broken_scan_becomes_failed_and_cannot_be_attached) ... ok
|
||||
test_corrupted_images_are_415 (test_attachments.AttachmentTest.test_corrupted_images_are_415) ... ok
|
||||
test_dangerous_filenames_are_400 (test_attachments.AttachmentTest.test_dangerous_filenames_are_400) ... ok
|
||||
test_exact_limits (test_attachments.AttachmentTest.test_exact_limits) ... ok
|
||||
test_idempotency_with_attachments (test_attachments.AttachmentTest.test_idempotency_with_attachments) ... ok
|
||||
test_large_real_image_within_limits_is_accepted (test_attachments.AttachmentTest.test_large_real_image_within_limits_is_accepted) ... ok
|
||||
test_message_with_attachments (test_attachments.AttachmentTest.test_message_with_attachments) ... ok
|
||||
test_mime_spoofing_is_415 (test_attachments.AttachmentTest.test_mime_spoofing_is_415) ... ok
|
||||
test_outsider_and_anonymous_cannot_upload (test_attachments.AttachmentTest.test_outsider_and_anonymous_cannot_upload) ... ok
|
||||
test_pixel_bomb_is_413 (test_attachments.AttachmentTest.test_pixel_bomb_is_413) ... ok
|
||||
test_png_and_jpeg_roundtrip_for_member (test_attachments.AttachmentTest.test_png_and_jpeg_roundtrip_for_member) ... ok
|
||||
test_structurally_broken_jpeg_is_415 (test_attachments.AttachmentTest.test_structurally_broken_jpeg_is_415) ... ok
|
||||
test_too_large_is_413_before_reading (test_attachments.AttachmentTest.test_too_large_is_413_before_reading) ... ok
|
||||
test_too_large_stream_is_413 (test_attachments.AttachmentTest.test_too_large_stream_is_413) ... ok
|
||||
test_valid_jpeg_variants_are_accepted (test_attachments.AttachmentTest.test_valid_jpeg_variants_are_accepted) ... ok
|
||||
test_variants_and_bad_ids (test_attachments.AttachmentTest.test_variants_and_bad_ids) ... ok
|
||||
test_variants_follow_the_contract (test_attachments.AttachmentTest.test_variants_follow_the_contract) ... ok
|
||||
test_bearer_required_on_business_endpoints (test_auth.AuthTest.test_bearer_required_on_business_endpoints) ... ok
|
||||
test_login_returns_opaque_token_with_expiry (test_auth.AuthTest.test_login_returns_opaque_token_with_expiry) ... ok
|
||||
test_logout_revokes_only_current_session (test_auth.AuthTest.test_logout_revokes_only_current_session) ... ok
|
||||
test_malformed_basic_returns_401 (test_auth.AuthTest.test_malformed_basic_returns_401) ... ok
|
||||
test_password_length_rules (test_auth.AuthTest.test_password_length_rules) ... ok
|
||||
test_password_with_colon_and_unicode (test_auth.AuthTest.test_password_with_colon_and_unicode) ... ok
|
||||
test_relogin_after_logout (test_auth.AuthTest.test_relogin_after_logout) ... ok
|
||||
test_user_never_contains_password (test_auth.AuthTest.test_user_never_contains_password) ... ok
|
||||
test_wrong_password_and_unknown_user_look_the_same (test_auth.AuthTest.test_wrong_password_and_unknown_user_look_the_same) ... ok
|
||||
test_x_user_id_does_not_change_identity (test_auth.AuthTest.test_x_user_id_does_not_change_identity) ... ok
|
||||
test_instance_id_on_errors_and_health (test_balancing.BalancingTest.test_instance_id_on_errors_and_health) ... ok
|
||||
test_logout_applies_on_every_replica (test_balancing.BalancingTest.test_logout_applies_on_every_replica) ... ok
|
||||
test_one_session_is_served_by_every_replica (test_balancing.BalancingTest.test_one_session_is_served_by_every_replica) ... ok
|
||||
test_session_cache_is_shared_between_replicas (test_balancing.BalancingTest.test_session_cache_is_shared_between_replicas) ... ok
|
||||
test_write_on_one_replica_read_on_another (test_balancing.BalancingTest.test_write_on_one_replica_read_on_another) ... ok
|
||||
test_failed_request_does_not_burn_key (test_idempotency.IdempotencyTest.test_failed_request_does_not_burn_key) ... ok
|
||||
test_json_formatting_does_not_matter (test_idempotency.IdempotencyTest.test_json_formatting_does_not_matter) ... ok
|
||||
test_key_is_required_and_validated (test_idempotency.IdempotencyTest.test_key_is_required_and_validated) ... ok
|
||||
test_key_scope_is_user_and_chat (test_idempotency.IdempotencyTest.test_key_scope_is_user_and_chat) ... ok
|
||||
test_parallel_different_bodies_same_key (test_idempotency.IdempotencyTest.test_parallel_different_bodies_same_key) ... ok
|
||||
test_parallel_same_key_through_replicas_creates_one_message (test_idempotency.IdempotencyTest.test_parallel_same_key_through_replicas_creates_one_message) ... ok
|
||||
test_replay_rechecks_session_and_access (test_idempotency.IdempotencyTest.test_replay_rechecks_session_and_access) ... ok
|
||||
test_replay_through_another_replica_returns_same_message (test_idempotency.IdempotencyTest.test_replay_through_another_replica_returns_same_message) ... ok
|
||||
test_same_key_other_body_is_409 (test_idempotency.IdempotencyTest.test_same_key_other_body_is_409) ... ok
|
||||
|
||||
----------------------------------------------------------------------
|
||||
Ran 54 tests in 25.793s
|
||||
|
||||
OK
|
||||
|
||||
10 485 760 байт и 6400×6250 = 40 000 000 px: 202 -> ready; на 1 байт/пиксель больше: 413
|
||||
|
||||
fixture 320×200 -> thumbnail 256×160 JPEG, crop 128×128 JPEG, optimized 320×200 WebP; 48×32 -> {'thumbnail': (48, 32), 'crop': (128, 128), 'optimized': (48, 32)}
|
||||
|
||||
X-Instance-Id есть в health, 404, 401 и 400
|
||||
|
||||
logout через одну реплику -> 401 на ['48dc392933dc', 'c1b7e1ab5673']
|
||||
|
||||
20 x GET /users/me с одним токеном -> реплики {'c1b7e1ab5673': 10, '48dc392933dc': 10}; это ID запущенных контейнеров api, повторный вход не нужен
|
||||
|
||||
10 x GET /users/me через реплики {'c1b7e1ab5673': 5, '48dc392933dc': 5}: попаданий в кэш +20, промахов +0 — кэш общий
|
||||
|
||||
сообщение записала реплика c1b7e1ab5673, сразу прочитали ['48dc392933dc', 'c1b7e1ab5673']
|
||||
|
||||
с тем же ключом: сначала 400 (пустой текст), потом 201 — ошибка ключ не заняла
|
||||
|
||||
тот же JSON с другими пробелами и переносами -> тот же 201 и то же сообщение
|
||||
|
||||
нет ключа, пустой, 129 символов, пробел, '/', кириллица -> 400; 128 символов и ._:- -> 201
|
||||
|
||||
тот же ключ у другого пользователя и в другом чате -> независимые сообщения
|
||||
|
||||
10 одновременных разных тел с одним ключом: 201 x1, 409 x9, в истории 1 сообщение
|
||||
|
||||
20 одновременных POST с одним ключом через реплики {'48dc392933dc': 10, 'c1b7e1ab5673': 10}: все 201 с одним id, в истории 1 сообщение
|
||||
|
||||
повтор: посторонний -> 404, после logout -> 401, после нового входа -> то же сообщение
|
||||
|
||||
1 запрос + 4 повтора через реплики ['48dc392933dc', 'c1b7e1ab5673']: 201 и то же сообщение, в истории 1
|
||||
|
||||
другой текст с тем же ключом -> 409 conflict, второе сообщение не создано
|
||||
@@ -0,0 +1,2 @@
|
||||
python tests/smoke.py --base-url "http://127.0.0.1:8080"
|
||||
PASS: lab5 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,9 @@
|
||||
python student-tests/worker_crash.py
|
||||
A. worker_after_objects armed; upload -> 202 (29951699-589c-4919-8291-a58289f70dff)
|
||||
the worker crashed after writing objects (restart count 0 -> 1); objects left by the crashed attempt: 3
|
||||
events: queued(1) -> claimed(1) -> lease_expired(1) -> retry_scheduled(1) -> claimed(2) -> ready(2)
|
||||
ready at attempt 2; same keys and the same SHA-256 as the crashed attempt wrote: ['crop.jpg', 'optimized.webp', 'thumbnail.jpg']; 3 variant rows
|
||||
B. worker_after_commit armed; upload -> 202 (50d85920-ab49-4658-9bf8-f61e1ac50181)
|
||||
events: queued(1) -> claimed(1) -> ready(1) -> duplicate_ignored(1)
|
||||
the redelivered message found the job ready and was acknowledged without processing
|
||||
PASS: a worker crash after writing objects but before ack is finished by a retry with the same result; a crash after COMMIT but before ack ends with a no-op redelivery
|
||||
@@ -0,0 +1,13 @@
|
||||
python student-tests/worker_outage.py
|
||||
1. worker stopped: no running worker containers
|
||||
2. upload -> 202 queued, attachment_id=514906d6-77b8-4dec-a73f-a43670fc65ab
|
||||
GET -> queued, /content -> 409, /content?variant=thumbnail -> 409
|
||||
3. message with the queued attachment -> 201 (97507e33-6eca-4009-aa8e-4239ddece625); text message -> 201 (1296cc2b-4850-4695-93bc-07411472f7a7)
|
||||
4. after 5 s still queued: the API does not resize synchronously
|
||||
5. job 296f84cb-b2cd-49b6-9080-2e460df42764 attempt 1: outbox row published at 2026-10-26T16:37:37.645701+00:00 by relay-c1b7e1ab5673; queues: {'attachments.process': (1, 0), 'attachments.dead': (34, 0)}
|
||||
6. api replicas restarted (same containers, volumes kept)
|
||||
broker restarted with volume rabbitmqdata; queues after restart: {'attachments.process': (1, 0), 'attachments.dead': (34, 0)}
|
||||
7. worker started -> ready after 3.8 s
|
||||
thumbnail 256×160 JPEG, original SHA-256 unchanged, message 97507e33-6eca-4009-aa8e-4239ddece625 keeps the attachment; outbox rows for the job: 1 (published once, before the broker restart)
|
||||
job events: queued(1) -> claimed(1) -> ready(1)
|
||||
PASS: with the worker down uploads are accepted (202) and wait; the accepted job survives API and broker restarts and becomes ready once the worker is started
|
||||
@@ -0,0 +1,91 @@
|
||||
# HAProxy — балансировщик и единственная точка входа стенда lab5.
|
||||
# Клиент -> 127.0.0.1:8080 -> HAProxy -> одна из реплик api (порт 8080 внутри сети edge).
|
||||
# Данные и сессии общие (PostgreSQL, Valkey), поэтому любой запрос может обслужить любая
|
||||
# реплика: балансировка round robin, без привязки клиента к реплике (без sticky session).
|
||||
|
||||
global
|
||||
log stdout format raw local0 info
|
||||
maxconn 2000
|
||||
# При остановке контейнера (SIGUSR1, мягкая остановка) доделать начатые запросы, но не дольше 10 с.
|
||||
hard-stop-after 10s
|
||||
|
||||
# Список реплик берётся из DNS Docker: имя сервиса "api" -> IP всех ЗАПУЩЕННЫХ реплик.
|
||||
# Остановили реплику или добавили новую — HAProxy увидит это сам, без перезапуска.
|
||||
resolvers docker
|
||||
nameserver dns 127.0.0.11:53
|
||||
resolve_retries 3
|
||||
timeout resolve 1s
|
||||
timeout retry 1s
|
||||
hold valid 2s # перечитывать список реплик раз в 2 с
|
||||
hold obsolete 2s # IP, пропавший из DNS (контейнер остановлен), убрать через 2 с
|
||||
hold nx 2s
|
||||
hold other 2s
|
||||
hold refused 2s
|
||||
hold timeout 2s
|
||||
accepted_payload_size 8192
|
||||
|
||||
defaults
|
||||
mode http
|
||||
log global
|
||||
option httplog
|
||||
option dontlog-normal # в лог только ошибки и смены состояния реплик, а не каждый запрос
|
||||
timeout connect 1s # сеть внутри Docker быстрая: мёртвый адрес не держит запрос дольше 1 с
|
||||
timeout client 30s
|
||||
timeout server 30s # дольше самого долгого ответа API: загрузка файла (очередь проверки до 10 с + S3 до 6 с)
|
||||
timeout http-request 10s
|
||||
timeout http-keep-alive 5s
|
||||
timeout queue 5s
|
||||
timeout check 1s
|
||||
# Ошибка СОЕДИНЕНИЯ (запрос ещё не отправлен) — повторить, причём на другой реплике.
|
||||
# Это безопасно для любого метода. Запрос, который уже ушёл в API, HAProxy сам НЕ повторяет:
|
||||
# POST сообщения повторяет клиент с тем же Idempotency-Key.
|
||||
retries 2
|
||||
option redispatch 1
|
||||
# Ошибки, которые создаёт сам балансировщик (нет ни одной готовой реплики — 503, реплика оборвала
|
||||
# соединение — 502, не ответила вовремя — 504), отдаются в формате ошибки из контракта
|
||||
# с X-Request-Id. X-Instance-Id у них нет: ни одна реплика API этот ответ не создавала.
|
||||
unique-id-format %[uuid]
|
||||
http-error status 503 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Нет готовой реплики API, повторите запрос позже","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
http-error status 502 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Реплика API оборвала соединение, повторите запрос","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
http-error status 504 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Реплика API не ответила вовремя, повторите запрос","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
|
||||
|
||||
frontend api_in
|
||||
bind :8080
|
||||
default_backend api
|
||||
|
||||
backend api
|
||||
balance roundrobin
|
||||
# Проверка готовности: /health/ready = процесс отвечает, PostgreSQL и S3 доступны, нет SIGTERM.
|
||||
option httpchk
|
||||
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host lb
|
||||
http-check expect status 200
|
||||
# До 6 реплик (обычно 2, во время rolling update 3); пустые слоты стоят в MAINT.
|
||||
# Проверка раз в 1 с, при смене состояния раз в 0,5 с; 2 неудачи подряд -> DOWN, 2 удачи -> UP.
|
||||
# observe layer4: первая же ошибка соединения у живого запроса сразу выводит реплику из балансировки.
|
||||
# Запросы получают ТОЛЬКО реплики, прошедшие проверку готовности. Резервных слотов без проверки нет:
|
||||
# если не готова ни одна реплика (например, недоступна PostgreSQL), балансировщик сам отвечает 503
|
||||
# и никуда запрос не передаёт, даже если реплика могла бы ответить из кэша.
|
||||
server-template api 6 api:8080 check inter 1s fastinter 500ms downinter 2s fall 2 rise 2 observe layer4 error-limit 1 on-error mark-down resolvers docker resolve-prefer ipv4 init-addr none
|
||||
|
||||
# Второй вход только для проверки истечения сессии (make expiry): API с SESSION_TTL_SECONDS=2
|
||||
# (сервис api-short-ttl, профиль ttl). Он тоже доступен только через балансировщик.
|
||||
frontend ttl_in
|
||||
bind :8081
|
||||
default_backend api_short_ttl
|
||||
|
||||
backend api_short_ttl
|
||||
option httpchk
|
||||
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host lb
|
||||
http-check expect status 200
|
||||
server-template ttl 2 api-short-ttl:8080 check inter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none
|
||||
|
||||
# Статистика HAProxy: http://127.0.0.1:8404/stats (только на 127.0.0.1 хоста, только чтение).
|
||||
# Там видно, какие реплики UP/DOWN. /lb-health — healthcheck контейнера lb:
|
||||
# 503, пока в backend api нет ни одной готовой реплики.
|
||||
frontend stats
|
||||
bind :8404
|
||||
monitor-uri /lb-health
|
||||
monitor fail if { nbsrv(api) lt 1 }
|
||||
stats enable
|
||||
stats uri /stats
|
||||
stats refresh 2s
|
||||
@@ -0,0 +1,21 @@
|
||||
# RabbitMQ стенда lab5: общие настройки (без паролей).
|
||||
# Пользователь, пароль, vhost и права задаются отдельным файлом-секретом
|
||||
# secrets/rabbitmq_credentials.conf (его создаёт scripts/init-secrets.sh), он монтируется рядом,
|
||||
# в /etc/rabbitmq/conf.d/30-credentials.conf. Файлы conf.d читаются по алфавиту.
|
||||
|
||||
listeners.tcp.default = 5672
|
||||
|
||||
# Лимиты: при нехватке памяти или диска брокер не падает, а временно блокирует публикацию.
|
||||
# Publisher confirm тогда не приходит, relay ждёт и повторяет: строки остаются в outbox.
|
||||
# Память задана абсолютным числом: относительный лимит RabbitMQ считал бы от памяти всей машины,
|
||||
# а не от лимита контейнера (512 МиБ в compose.yaml).
|
||||
vm_memory_high_watermark.absolute = 256MiB
|
||||
disk_free_limit.absolute = 256MiB
|
||||
|
||||
# Потребитель, который держит сообщение без ack дольше 5 минут, считается зависшим:
|
||||
# брокер закрывает его канал и возвращает сообщение в очередь. Наша попытка — не дольше 60 с.
|
||||
consumer_timeout = 300000
|
||||
|
||||
# Веб-консоль (management plugin) в этом образе не включена: управлять брокером по HTTP нельзя.
|
||||
log.console = true
|
||||
log.console.level = info
|
||||
@@ -0,0 +1,74 @@
|
||||
-- Обоснование индекса истории сообщений: EXPLAIN (ANALYZE, BUFFERS) на синтетических данных.
|
||||
-- Запуск: make explain > evidence/explain-history.txt
|
||||
-- (= docker compose exec -T postgres psql -U messenger -d messenger < infra/sql/explain_history.sql)
|
||||
--
|
||||
-- Всё выполняется в одной транзакции и в конце откатывается (ROLLBACK):
|
||||
-- синтетические данные не остаются в базе, скрипт можно запускать сколько угодно раз.
|
||||
-- DROP INDEX внутри транзакции на время скрипта блокирует запись в messages — запускать на учебном стенде.
|
||||
|
||||
\pset footer off
|
||||
BEGIN;
|
||||
|
||||
-- 1 «большой» чат на 12 000 сообщений и 19 чатов по 500 (всего 21 500 сообщений):
|
||||
-- в таблице есть чужие сообщения, как в настоящей базе.
|
||||
CREATE TEMP TABLE seed_chats AS
|
||||
SELECT gen_random_uuid() AS chat_id, n, CASE WHEN n = 0 THEN 12000 ELSE 500 END AS size
|
||||
FROM generate_series(0, 19) AS n;
|
||||
CREATE TEMP TABLE seed_user AS SELECT gen_random_uuid() AS user_id;
|
||||
|
||||
INSERT INTO users (id, username, display_name, password_hash)
|
||||
SELECT user_id, 'explain_' || substr(md5(random()::text), 1, 12), convert_to('EXPLAIN', 'UTF8'), 'not-a-real-hash' FROM seed_user;
|
||||
INSERT INTO chats (id, title) SELECT chat_id, convert_to('explain ' || n, 'UTF8') FROM seed_chats;
|
||||
INSERT INTO chat_members (chat_id, user_id) SELECT chat_id, user_id FROM seed_chats, seed_user;
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
SELECT gen_random_uuid(), c.chat_id, u.user_id, convert_to('synthetic message ' || g, 'UTF8'),
|
||||
timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second'
|
||||
FROM seed_chats c, seed_user u, generate_series(1, c.size) AS g;
|
||||
ANALYZE messages;
|
||||
|
||||
SELECT chat_id AS big_chat FROM seed_chats WHERE n = 0 \gset
|
||||
-- Курсор «середины истории»: ключ (created_at, id) 6000-го сообщения большого чата.
|
||||
SELECT created_at AS cur_ts, id AS cur_id FROM messages
|
||||
WHERE chat_id = :'big_chat' ORDER BY created_at, id OFFSET 5999 LIMIT 1 \gset
|
||||
|
||||
\echo '=== Объём данных'
|
||||
SELECT count(*) AS messages_total,
|
||||
count(*) FILTER (WHERE chat_id = :'big_chat') AS messages_in_big_chat
|
||||
FROM messages;
|
||||
|
||||
\echo ''
|
||||
\echo '=== Индекс истории (migrations/001_core.sql)'
|
||||
SELECT indexdef FROM pg_indexes WHERE indexname = 'messages_chat_history_idx';
|
||||
|
||||
\echo ''
|
||||
\echo '=== 1. Первая страница (limit=50, приложение просит 51 строку, чтобы понять, есть ли следующая)'
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
\echo ''
|
||||
\echo '=== 2. Страница из середины истории по keyset-курсору (после 6000-го сообщения)'
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
\echo ''
|
||||
\echo '=== 3. Для сравнения: та же страница через OFFSET (так приложение НЕ делает)'
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = :'big_chat'
|
||||
ORDER BY created_at, id OFFSET 6000 LIMIT 51;
|
||||
|
||||
\echo ''
|
||||
\echo '=== 4. Для сравнения: запрос 2 без индекса (индекс удалён только внутри этой транзакции)'
|
||||
DROP INDEX messages_chat_history_idx;
|
||||
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
|
||||
SELECT id, chat_id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
|
||||
ORDER BY created_at, id LIMIT 51;
|
||||
|
||||
ROLLBACK;
|
||||
\echo ''
|
||||
\echo '=== ROLLBACK: синтетические данные удалены, индекс на месте'
|
||||
@@ -0,0 +1,22 @@
|
||||
# Valkey в этой работе — КЭШ сессий, один на все реплики API. Источник истины — таблица
|
||||
# sessions в PostgreSQL. Поэтому persistence выключена: после рестарта кэш пустой,
|
||||
# данные заново берутся из БД.
|
||||
|
||||
bind 0.0.0.0
|
||||
port 6379
|
||||
protected-mode yes
|
||||
|
||||
# Пользователи и пароли — в секрете (scripts/init-secrets.sh создаёт secrets/valkey_users.acl):
|
||||
# default — выключен (анонимный доступ запрещён);
|
||||
# health — без пароля, только ping/info/dbsize (для healthcheck и наблюдения);
|
||||
# messenger — пароль, только ключи sess:* и только команды get/mget/set/del/ping.
|
||||
aclfile /run/secrets/valkey_acl
|
||||
|
||||
# Без сохранения на диск: ни RDB-снимков, ни AOF.
|
||||
save ""
|
||||
appendonly no
|
||||
|
||||
# Ограничение памяти. При нехватке выбрасываются давно не читанные записи С TTL (это все
|
||||
# записи о сессиях). Ключ sess:gen (общее поколение кэша) без TTL и поэтому не выбрасывается.
|
||||
maxmemory 64mb
|
||||
maxmemory-policy volatile-lru
|
||||
@@ -0,0 +1,45 @@
|
||||
-- 001: пользователи, чаты, участники, сообщения.
|
||||
-- Применяется один раз; номер версии записывается в schema_migrations (см. src/messenger/db.py).
|
||||
-- Все проверки, которые важны для целостности, продублированы в базе: даже если в коде
|
||||
-- появится ошибка, PostgreSQL не даст записать некорректные данные.
|
||||
|
||||
CREATE TABLE users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL, -- строка Argon2id ($argon2id$...), не сам пароль
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT users_username_key UNIQUE (username), -- защищает от гонки двух регистраций
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
-- Членство: какой пользователь в каком чате. Первичный ключ исключает дубликаты.
|
||||
CREATE TABLE chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
-- «Список чатов пользователя»: поиск по user_id (PK начинается с chat_id и тут не помогает).
|
||||
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL,
|
||||
sender_id uuid NOT NULL,
|
||||
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
-- Отправитель обязан быть участником этого чата: внешний ключ на пару (чат, участник).
|
||||
CONSTRAINT messages_sender_is_member FOREIGN KEY (chat_id, sender_id)
|
||||
REFERENCES chat_members (chat_id, user_id)
|
||||
);
|
||||
-- История чата: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id LIMIT ?
|
||||
-- Индекс уже отсортирован в нужном порядке, поэтому страница читается без сортировки
|
||||
-- и без просмотра всей истории. Обоснование и EXPLAIN: evidence/explain-history.txt.
|
||||
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
|
||||
@@ -0,0 +1,13 @@
|
||||
-- 002: серверные сессии (источник истины для Bearer-токенов).
|
||||
-- Хранится не сам токен, а его SHA-256: утечка таблицы не даёт рабочих токенов.
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
expires_at timestamptz NOT NULL, -- абсолютное время: рестарт не продлевает сессию
|
||||
revoked_at timestamptz, -- заполнено = logout
|
||||
CONSTRAINT sessions_expiry_after_creation CHECK (expires_at > created_at)
|
||||
);
|
||||
-- Очистка старых сессий пользователя при входе (DELETE ... WHERE user_id = ?).
|
||||
CREATE INDEX sessions_user_idx ON sessions (user_id);
|
||||
@@ -0,0 +1,28 @@
|
||||
-- 003: свободный текст хранится как байты UTF-8 (bytea), а не как text.
|
||||
--
|
||||
-- Причина: тип text в PostgreSQL не может содержать символ U+0000 (байт 0x00), а контракт
|
||||
-- этот символ в display_name, title и text не запрещает. Строка "hello\u0000world" давала 500.
|
||||
-- В bytea байт 0x00 допустим, поэтому такие строки теперь сохраняются и возвращаются без изменений.
|
||||
-- Кодирование/декодирование UTF-8 — в src/messenger/store.py (to_db/from_db).
|
||||
--
|
||||
-- Это новая миграция, а не правка 001: 001 уже применена на существующих стендах.
|
||||
-- Уже сохранённые данные переводятся через convert_to и не теряются.
|
||||
--
|
||||
-- Точное число символов (1–100, 1–4000) проверяет API. Функции PostgreSQL, которые считают
|
||||
-- символы в bytea, отвергают байт 0x00, поэтому CHECK в базе ограничивает длину в байтах:
|
||||
-- не пусто и не больше 4 байт на символ (максимальный размер символа в UTF-8).
|
||||
|
||||
ALTER TABLE users DROP CONSTRAINT users_display_name_len;
|
||||
ALTER TABLE users ALTER COLUMN display_name TYPE bytea USING convert_to(display_name, 'UTF8');
|
||||
ALTER TABLE users ADD CONSTRAINT users_display_name_len
|
||||
CHECK (octet_length(display_name) BETWEEN 1 AND 400);
|
||||
|
||||
ALTER TABLE chats DROP CONSTRAINT chats_title_check;
|
||||
ALTER TABLE chats ALTER COLUMN title TYPE bytea USING convert_to(title, 'UTF8');
|
||||
ALTER TABLE chats ADD CONSTRAINT chats_title_len
|
||||
CHECK (octet_length(title) BETWEEN 1 AND 400);
|
||||
|
||||
ALTER TABLE messages DROP CONSTRAINT messages_text_check;
|
||||
ALTER TABLE messages ALTER COLUMN text TYPE bytea USING convert_to(text, 'UTF8');
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_text_len
|
||||
CHECK (octet_length(text) BETWEEN 1 AND 16000);
|
||||
@@ -0,0 +1,30 @@
|
||||
-- 004 (lab3): идемпотентность отправки сообщения (заголовок Idempotency-Key).
|
||||
--
|
||||
-- Ключ и SHA-256 тела запроса хранятся прямо в строке сообщения. Уникальное ограничение
|
||||
-- (chat_id, sender_id, idempotency_key) = область ключа из контракта: пользователь + чат
|
||||
-- (метод и путь у этого ключа всегда POST /chats/{id}/messages). Повтор с тем же ключом
|
||||
-- не может создать второе сообщение даже при одновременных запросах через разные реплики.
|
||||
-- Ключ живёт столько же, сколько сообщение (бессрочно; контракт требует не меньше 24 ч).
|
||||
--
|
||||
-- Совместимость с уже работающей версией (lab2): добавляются только НОВЫЕ столбцы,
|
||||
-- которые могут быть NULL. Старый код пишет сообщения без ключа (NULL) и читает только
|
||||
-- свои столбцы — он продолжает работать с новой схемой. Строки без ключа уникальность
|
||||
-- не нарушают: в PostgreSQL значения NULL не считаются одинаковыми.
|
||||
-- Ограничение: на большой таблице построение уникального индекса блокирует запись в messages.
|
||||
-- Для большой базы индекс строят заранее через CREATE UNIQUE INDEX CONCURRENTLY (вне транзакции),
|
||||
-- а затем добавляют ограничение USING INDEX. На учебной базе это доли секунды.
|
||||
|
||||
ALTER TABLE messages
|
||||
ADD COLUMN idempotency_key text,
|
||||
ADD COLUMN request_hash bytea;
|
||||
|
||||
ALTER TABLE messages
|
||||
ADD CONSTRAINT messages_idempotency_key_format
|
||||
CHECK (idempotency_key ~ '^[A-Za-z0-9._:-]{1,128}$'),
|
||||
ADD CONSTRAINT messages_request_hash_len
|
||||
CHECK (octet_length(request_hash) = 32),
|
||||
-- ключ и отпечаток тела всегда вместе: оба заданы или оба NULL
|
||||
ADD CONSTRAINT messages_key_with_hash
|
||||
CHECK ((idempotency_key IS NULL) = (request_hash IS NULL)),
|
||||
ADD CONSTRAINT messages_idempotency_unique
|
||||
UNIQUE (chat_id, sender_id, idempotency_key);
|
||||
@@ -0,0 +1,50 @@
|
||||
-- lab4: вложения (картинки PNG/JPEG).
|
||||
-- В PostgreSQL лежат только МЕТАДАННЫЕ: чей файл, в каком чате, имя для показа, размер, SHA-256.
|
||||
-- Сами байты лежат в приватном bucket S3 (MinIO); здесь хранится только ключ объекта storage_key.
|
||||
-- Столбца с байтами файла в таблице нет.
|
||||
--
|
||||
-- status — внутреннее состояние загрузки, наружу API показывает только ready:
|
||||
-- pending — строка записана ДО загрузки байтов в S3 («намерение»). Если после этого
|
||||
-- что-то сломалось (S3 недоступен, база не подтвердила ready, процесс убит),
|
||||
-- строка остаётся pending, и уборщик (src/messenger/cleanup.py) после grace period
|
||||
-- удаляет объект (если он успел записаться) и саму строку;
|
||||
-- ready — байты в S3 и метаданные в БД, файл можно скачивать и прикреплять.
|
||||
|
||||
CREATE TABLE attachments (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id),
|
||||
owner_id uuid NOT NULL REFERENCES users (id),
|
||||
filename text NOT NULL CHECK (char_length(filename) BETWEEN 1 AND 255), -- только для показа
|
||||
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')), -- по содержимому
|
||||
size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
|
||||
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
|
||||
width integer NOT NULL CHECK (width > 0),
|
||||
height integer NOT NULL CHECK (height > 0),
|
||||
storage_key text NOT NULL UNIQUE, -- ключ в bucket, назначает сервер
|
||||
status text NOT NULL CHECK (status IN ('pending', 'ready')),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
updated_at timestamptz NOT NULL DEFAULT now(),
|
||||
-- Загрузил участник этого чата: внешний ключ на пару (чат, участник), как у messages.
|
||||
CONSTRAINT attachments_owner_is_member FOREIGN KEY (chat_id, owner_id)
|
||||
REFERENCES chat_members (chat_id, user_id)
|
||||
);
|
||||
CREATE INDEX attachments_chat_idx ON attachments (chat_id);
|
||||
-- Уборщику нужны только старые pending-строки: частичный индекс маленький.
|
||||
CREATE INDEX attachments_pending_idx ON attachments (created_at) WHERE status = 'pending';
|
||||
|
||||
-- Какие вложения у сообщения и в каком порядке (как в attachment_ids запроса).
|
||||
-- Одно вложение могут использовать несколько сообщений этого же чата.
|
||||
CREATE TABLE message_attachments (
|
||||
message_id uuid NOT NULL REFERENCES messages (id),
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
position smallint NOT NULL CHECK (position BETWEEN 0 AND 9), -- не больше 10 вложений
|
||||
PRIMARY KEY (message_id, position),
|
||||
CONSTRAINT message_attachments_unique UNIQUE (message_id, attachment_id)
|
||||
);
|
||||
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id);
|
||||
|
||||
-- С lab4 текст сообщения может быть пустым, если есть хотя бы одно вложение
|
||||
-- (это проверяет API). Ограничение длины остаётся, нижняя граница снимается.
|
||||
-- Изменение только ослабляет проверку, поэтому совместимо с уже работающей версией lab3.
|
||||
ALTER TABLE messages DROP CONSTRAINT messages_text_len;
|
||||
ALTER TABLE messages ADD CONSTRAINT messages_text_len CHECK (octet_length(text) <= 16000);
|
||||
@@ -0,0 +1,111 @@
|
||||
-- 006 (lab5): асинхронная обработка вложений — задания, transactional outbox, варианты, журнал.
|
||||
--
|
||||
-- Что меняется по сравнению с lab4:
|
||||
-- * загрузка больше не делает вложение готовым сразу. API кладёт оригинал в staging S3
|
||||
-- (staging/<id>) и в ОДНОЙ транзакции пишет: строку вложения (queued), задание и строку outbox.
|
||||
-- Только после COMMIT отвечает 202. Сообщение в брокер отправляет отдельный цикл (relay):
|
||||
-- так «намерение обработать» не теряется, даже если брокер недоступен или API упал сразу
|
||||
-- после COMMIT (transactional outbox);
|
||||
-- * worker переводит задание queued -> processing -> ready/failed и пишет варианты.
|
||||
--
|
||||
-- Состояния вложения (attachments.status, наружу отдаются как есть):
|
||||
-- queued — оригинал в staging, задание сохранено, ждёт worker (или повтора после паузы);
|
||||
-- processing — worker взял задание под lease (аренду) с крайним сроком;
|
||||
-- ready — оригинал опубликован в originals/<id>, все варианты записаны и закоммичены;
|
||||
-- failed — постоянная ошибка или исчерпаны попытки; error_code — краткий машинный код.
|
||||
-- Старый статус pending (lab4: загрузка, прерванная между S3 и COMMIT) больше не нужен:
|
||||
-- такие строки никогда не были видны клиенту, их объекты уберёт уборщик как «сироты».
|
||||
|
||||
DELETE FROM attachments a
|
||||
WHERE a.status = 'pending'
|
||||
AND NOT EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id);
|
||||
|
||||
ALTER TABLE attachments DROP CONSTRAINT attachments_status_check;
|
||||
ALTER TABLE attachments ADD CONSTRAINT attachments_status_check
|
||||
CHECK (status IN ('queued', 'processing', 'ready', 'failed'));
|
||||
ALTER TABLE attachments
|
||||
ADD COLUMN error_code text CHECK (error_code ~ '^[a-z_]{1,64}$'),
|
||||
-- staging/<id>: где лежит принятый оригинал до обработки. NULL у вложений lab4 (их не было).
|
||||
ADD COLUMN staging_key text UNIQUE;
|
||||
-- error_code заполнен ровно у failed.
|
||||
ALTER TABLE attachments ADD CONSTRAINT attachments_error_only_when_failed
|
||||
CHECK ((status = 'failed') = (error_code IS NOT NULL));
|
||||
DROP INDEX IF EXISTS attachments_pending_idx;
|
||||
|
||||
-- Задание обработки: одна строка на (вложение, версия pipeline). job_id не меняется при повторах.
|
||||
CREATE TABLE attachment_jobs (
|
||||
job_id uuid PRIMARY KEY,
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
pipeline_version integer NOT NULL CHECK (pipeline_version >= 1),
|
||||
status text NOT NULL CHECK (status IN ('queued', 'processing', 'ready', 'failed')),
|
||||
-- Номер управляемой попытки. Растёт при каждом повторе (временная ошибка, истёк lease, replay);
|
||||
-- сообщение брокера несёт этот номер, и сообщение со старым номером считается устаревшим дублем.
|
||||
attempt integer NOT NULL CHECK (attempt >= 1),
|
||||
max_attempts integer NOT NULL CHECK (max_attempts >= 1),
|
||||
next_attempt_at timestamptz NOT NULL DEFAULT now(),
|
||||
-- Lease: кто обрабатывает, «жетон» аренды и до какого времени аренда действует.
|
||||
-- Результат принимается, только если жетон совпадает (fencing): опоздавший worker,
|
||||
-- у которого аренду уже забрали, ничего не перезапишет.
|
||||
lease_owner text,
|
||||
lease_token uuid,
|
||||
lease_until timestamptz,
|
||||
last_error_code text CHECK (last_error_code ~ '^[a-z_]{1,64}$'),
|
||||
last_error text CHECK (char_length(last_error) <= 300), -- без stack trace и секретов
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
updated_at timestamptz NOT NULL DEFAULT now(),
|
||||
finished_at timestamptz,
|
||||
CONSTRAINT attachment_jobs_one_per_version UNIQUE (attachment_id, pipeline_version),
|
||||
CONSTRAINT attachment_jobs_lease_only_when_processing
|
||||
CHECK ((status = 'processing') = (lease_token IS NOT NULL AND lease_until IS NOT NULL AND lease_owner IS NOT NULL))
|
||||
);
|
||||
-- Поиск «зависших» заданий (истёк lease) и заданий в очереди.
|
||||
CREATE INDEX attachment_jobs_lease_idx ON attachment_jobs (lease_until) WHERE status = 'processing';
|
||||
CREATE INDEX attachment_jobs_queued_idx ON attachment_jobs (next_attempt_at) WHERE status = 'queued';
|
||||
|
||||
-- Transactional outbox: сообщения для брокера, записанные в той же транзакции, что и задание.
|
||||
-- payload — ровно тело сообщения по contracts/jobs.schema.json: только ID и служебные поля,
|
||||
-- без байтов файла, ключей S3, URL и паролей.
|
||||
CREATE TABLE outbox (
|
||||
id bigserial PRIMARY KEY,
|
||||
job_id uuid NOT NULL REFERENCES attachment_jobs (job_id),
|
||||
attempt integer NOT NULL CHECK (attempt >= 1),
|
||||
payload jsonb NOT NULL,
|
||||
available_at timestamptz NOT NULL DEFAULT now(), -- не раньше (отложенный повтор с backoff)
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
published_at timestamptz, -- брокер подтвердил приём (publisher confirm)
|
||||
published_by text
|
||||
);
|
||||
-- Relay читает только неотправленные строки, у которых подошло время: частичный индекс маленький.
|
||||
CREATE INDEX outbox_unpublished_idx ON outbox (available_at, id) WHERE published_at IS NULL;
|
||||
CREATE INDEX outbox_job_idx ON outbox (job_id);
|
||||
|
||||
-- Варианты. Первичный ключ = ключ эффекта из контракта (attachment_id, pipeline_version, variant):
|
||||
-- повтор задания не может создать второй набор вариантов.
|
||||
CREATE TABLE attachment_variants (
|
||||
attachment_id uuid NOT NULL REFERENCES attachments (id),
|
||||
pipeline_version integer NOT NULL CHECK (pipeline_version >= 1),
|
||||
name text NOT NULL CHECK (name IN ('thumbnail', 'crop', 'optimized')),
|
||||
storage_key text NOT NULL UNIQUE,
|
||||
content_type text NOT NULL CHECK (content_type IN ('image/jpeg', 'image/png', 'image/webp')),
|
||||
size_bytes bigint NOT NULL CHECK (size_bytes > 0),
|
||||
width integer NOT NULL CHECK (width > 0),
|
||||
height integer NOT NULL CHECK (height > 0),
|
||||
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
|
||||
job_id uuid NOT NULL REFERENCES attachment_jobs (job_id),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (attachment_id, pipeline_version, name)
|
||||
);
|
||||
|
||||
-- Журнал заданий: что и когда происходило (взято, повтор, lease истёк, дубль, replay оператора).
|
||||
-- Нужен для расследования и для аудита ручного replay. Без секретов и содержимого файлов.
|
||||
CREATE TABLE job_events (
|
||||
id bigserial PRIMARY KEY,
|
||||
job_id uuid NOT NULL,
|
||||
attachment_id uuid NOT NULL,
|
||||
attempt integer,
|
||||
event text NOT NULL CHECK (event ~ '^[a-z_]{1,40}$'),
|
||||
actor text NOT NULL,
|
||||
detail text CHECK (char_length(detail) <= 300),
|
||||
created_at timestamptz NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE INDEX job_events_job_idx ON job_events (job_id, id);
|
||||
@@ -0,0 +1,33 @@
|
||||
# Все зависимости закреплены точными версиями (включая транзитивные),
|
||||
# чтобы сборка образа через месяц дала то же самое, что сегодня.
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
argon2-cffi==25.1.0 # Argon2id для паролей
|
||||
argon2-cffi-bindings==26.1.0
|
||||
boto3==1.43.116 # клиент S3 (SeaweedFS) — с lab4
|
||||
botocore==1.43.116
|
||||
cffi==2.1.1
|
||||
click==8.5.0
|
||||
fastapi==0.115.12
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
jmespath==1.1.0
|
||||
numpy==2.3.5 # нужен simplejpeg — с lab5
|
||||
pika==1.4.4 # клиент RabbitMQ (relay и worker) — с lab5
|
||||
pillow==13.0.0 # заголовок картинки в API, обработка в worker — с lab4
|
||||
psycopg==3.3.6 # драйвер PostgreSQL
|
||||
psycopg-binary==3.3.6
|
||||
psycopg-pool==3.3.3 # пул соединений
|
||||
pycparser==3.1
|
||||
pydantic==2.13.5
|
||||
pydantic_core==2.46.5
|
||||
python-dateutil==2.9.0.post0
|
||||
s3transfer==0.19.3
|
||||
simplejpeg==1.9.0 # строгая проверка JPEG (libjpeg-turbo) в worker — с lab5
|
||||
six==1.17.0
|
||||
starlette==0.46.2
|
||||
typing-inspection==0.4.4
|
||||
typing_extensions==4.16.0
|
||||
urllib3==2.8.0
|
||||
uvicorn==0.34.3
|
||||
valkey==6.1.1 # клиент Valkey (кэш сессий)
|
||||
Executable
+71
@@ -0,0 +1,71 @@
|
||||
#!/bin/sh
|
||||
# Создаёт локальные секреты стенда в каталоге secrets/ (он в .gitignore и в Git не попадает).
|
||||
# Запуск один раз: sh scripts/init-secrets.sh
|
||||
# Повторный запуск безопасен: существующие файлы не меняются, недостающие досоздаются.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
umask 077 # каталог secrets/ доступен только владельцу
|
||||
mkdir -p secrets
|
||||
|
||||
# 24 случайных байта -> 48 hex-символов. /dev/urandom есть и в Linux/macOS, и в Git Bash.
|
||||
random_hex() { od -An -tx1 -N24 /dev/urandom | tr -d ' \n'; }
|
||||
|
||||
# Каждый файл создаётся, только если его ещё нет: повторный запуск ничего не меняет
|
||||
# (у уже созданного volume PostgreSQL пароль так не сменить), но досоздаёт недостающие.
|
||||
if [ ! -e secrets/postgres_password ]; then
|
||||
PG_PASSWORD=$(random_hex)
|
||||
CACHE_PASSWORD=$(random_hex)
|
||||
# printf без перевода строки в конце: в файле только значение.
|
||||
printf '%s' "$PG_PASSWORD" > secrets/postgres_password
|
||||
printf 'postgresql://messenger:%s@postgres:5432/messenger' "$PG_PASSWORD" > secrets/database_url
|
||||
printf 'valkey://messenger:%s@valkey:6379/0' "$CACHE_PASSWORD" > secrets/cache_url
|
||||
printf '%s\n' \
|
||||
'user default off' \
|
||||
'user health on nopass -@all +ping +info +dbsize' \
|
||||
"user messenger on >$CACHE_PASSWORD ~sess:* resetchannels -@all +get +mget +set +del +ping" \
|
||||
> secrets/valkey_users.acl
|
||||
else
|
||||
echo "PostgreSQL/Valkey: secrets уже есть, оставляю как есть."
|
||||
fi
|
||||
|
||||
# С lab4: S3 (SeaweedFS). root — администратор S3 (только для s3-init, создаёт bucket),
|
||||
# отдельная пара ключей — пользователь API с правами только на свой bucket.
|
||||
# Каждый файл создаётся, только если его ещё нет.
|
||||
make_secret() { [ -e "secrets/$1" ] || printf '%s%s' "$2" "$(random_hex | cut -c1-"$3")" > "secrets/$1"; }
|
||||
make_secret s3_root_user admin 12
|
||||
make_secret s3_root_password "" 32
|
||||
make_secret s3_access_key_id api 16
|
||||
make_secret s3_secret_access_key "" 32
|
||||
|
||||
# Конфигурация пользователей SeaweedFS (s3.json): у API действия только для своего bucket,
|
||||
# анонимного пользователя нет — запрос без подписи получает AccessDenied. Пересобирается из ключей выше.
|
||||
BUCKET=$(sed -n 's/^S3_BUCKET=//p' .env 2>/dev/null | tr -d '\r')
|
||||
BUCKET=${BUCKET:-messenger-attachments}
|
||||
printf '{"identities":[{"name":"admin","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":["Admin","Read","List","Tagging","Write"]},{"name":"messenger-api","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":["Read:%s","Write:%s","List:%s"]}]}\n' \
|
||||
"$(cat secrets/s3_root_user)" "$(cat secrets/s3_root_password)" \
|
||||
"$(cat secrets/s3_access_key_id)" "$(cat secrets/s3_secret_access_key)" \
|
||||
"$BUCKET" "$BUCKET" "$BUCKET" > secrets/s3_config.json
|
||||
|
||||
# С lab5: брокер RabbitMQ. Один пароль в двух местах: в конфиге брокера (по нему RabbitMQ создаёт
|
||||
# пользователя при ПЕРВОМ запуске с пустым volume) и в адресе для API (relay) и worker.
|
||||
# Права пользователя — только на свои exchange и очереди (attachments, attachments.*).
|
||||
if [ ! -e secrets/broker_url ]; then
|
||||
BROKER_PASSWORD=$(random_hex)
|
||||
printf 'amqp://messenger:%s@broker:5672/messenger' "$BROKER_PASSWORD" > secrets/broker_url
|
||||
printf '%s\n' \
|
||||
'default_user = messenger' \
|
||||
"default_pass = $BROKER_PASSWORD" \
|
||||
'default_vhost = messenger' \
|
||||
'default_permissions.configure = ^attachments(\..*)?$' \
|
||||
'default_permissions.read = ^attachments(\..*)?$' \
|
||||
'default_permissions.write = ^attachments(\..*)?$' \
|
||||
> secrets/rabbitmq_credentials.conf
|
||||
else
|
||||
echo "RabbitMQ: secrets уже есть, оставляю как есть."
|
||||
fi
|
||||
|
||||
# Файлы читают процессы в контейнерах под своими пользователями (postgres, valkey, app, seaweedfs, rabbitmq),
|
||||
# поэтому сами файлы доступны на чтение; посторонних на хосте не пускает каталог (700).
|
||||
chmod 644 secrets/*
|
||||
echo "Готово: secrets/ (PostgreSQL, Valkey, S3 root и S3 для API, RabbitMQ; значения не выводятся)."
|
||||
@@ -0,0 +1,11 @@
|
||||
@echo off
|
||||
rem Windows restart hook for make test-persistence: same steps as scripts/restart.sh.
|
||||
rem Python on Windows cannot run .sh directly (WinError 193), so this .cmd is used instead.
|
||||
rem Restarts ALL api replicas, the worker and ALL stores (PostgreSQL, Valkey, S3 SeaweedFS, RabbitMQ),
|
||||
rem then the balancer. Volumes are kept (no down -v, no queue purge). Same containers, new start time.
|
||||
cd /d "%~dp0.."
|
||||
docker compose stop api worker || exit /b 1
|
||||
docker compose restart postgres valkey s3 broker || exit /b 1
|
||||
docker compose start worker api || exit /b 1
|
||||
docker compose restart lb || exit /b 1
|
||||
exit /b 0
|
||||
Executable
+12
@@ -0,0 +1,12 @@
|
||||
#!/bin/sh
|
||||
# Restart hook для make test-persistence (Linux/macOS).
|
||||
# Перезапускает ВСЕ реплики API, worker и ВСЕ используемые хранилища (PostgreSQL, Valkey, S3, RabbitMQ),
|
||||
# а затем балансировщик. Volumes сохраняются: нет down -v, flush, purge очереди или повторного seed.
|
||||
# Контейнеры те же (restart/stop/start, не recreate): ID не меняется, меняется время старта.
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
docker compose stop api worker # API: readiness 503 -> уход из балансировки; worker доделывает задания
|
||||
docker compose restart postgres valkey s3 broker # корректная остановка (SIGINT/SIGTERM) и запуск тех же контейнеров
|
||||
docker compose start worker api # ждут PostgreSQL и брокер сами (повторные подключения)
|
||||
docker compose restart lb # балансировщик заново находит реплики по DNS
|
||||
@@ -0,0 +1,6 @@
|
||||
@echo off
|
||||
rem Failover hook for make test-failover on Windows (same as scripts/stop-one.sh).
|
||||
rem Python on Windows cannot start .sh files directly (WinError 193), a .cmd file works.
|
||||
rem Stops ONE api replica from TARGET_INSTANCE_ID; the logic is in scripts\stop_one.py.
|
||||
python "%~dp0stop_one.py"
|
||||
exit /b %ERRORLEVEL%
|
||||
Executable
+9
@@ -0,0 +1,9 @@
|
||||
#!/bin/sh
|
||||
# Failover hook для make test-failover (Linux/macOS): останавливает ОДНУ реплику API —
|
||||
# ту, чей X-Instance-Id тест передал в TARGET_INSTANCE_ID, и оставляет её остановленной.
|
||||
# Логика (проверка значения, поиск контейнера, docker stop) — в scripts/stop_one.py,
|
||||
# общем для этого скрипта и для scripts/stop-one.cmd (Windows).
|
||||
# Восстановить реплику после теста: make restore (docker compose up -d --wait).
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
exec "${PYTHON:-python3}" "$(dirname "$0")/stop_one.py"
|
||||
@@ -0,0 +1,49 @@
|
||||
"""Failover hook logic for tests/resilience.py --mode failover (lab3).
|
||||
|
||||
Called by scripts/stop-one.sh (Linux/macOS) and scripts/stop-one.cmd (Windows).
|
||||
The test puts X-Instance-Id of the replica that served its first message into
|
||||
TARGET_INSTANCE_ID. In this solution X-Instance-Id is the container hostname, and
|
||||
Docker sets the hostname to the short container ID. So the script finds that ID
|
||||
among the RUNNING containers of the "api" service of this Compose project and
|
||||
stops only that one container. Postgres, Valkey, the balancer and volumes are not
|
||||
touched. The replica stays stopped; restore it with `make restore`
|
||||
(docker compose up -d --wait) or `docker start <id>`.
|
||||
|
||||
docker stop sends SIGTERM: the replica first answers 503 on /health/ready for
|
||||
SHUTDOWN_DRAIN_SECONDS (HAProxy takes it out of rotation), then finishes started
|
||||
requests and exits. --time 8: SIGKILL after 8 s at most, so the hook always returns
|
||||
within the 10 s the test allows.
|
||||
|
||||
This file is plain ASCII on purpose: scripts/check_contract.py reads every
|
||||
scripts/*.py with the default encoding, which is cp1251 on a Russian Windows.
|
||||
"""
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
STOP_TIMEOUT_SECONDS = 8
|
||||
|
||||
|
||||
def main() -> int:
|
||||
target = os.environ.get("TARGET_INSTANCE_ID", "").strip().lower()
|
||||
# The value comes from an HTTP header: accept only a hex container ID, nothing else.
|
||||
if not re.fullmatch(r"[0-9a-f]{12,64}", target):
|
||||
print("TARGET_INSTANCE_ID must be a container id (X-Instance-Id)", file=sys.stderr)
|
||||
return 2
|
||||
running = subprocess.run(["docker", "compose", "ps", "-q", "api"], cwd=ROOT,
|
||||
capture_output=True, text=True, check=True).stdout.split()
|
||||
matches = [container for container in running if container.startswith(target)]
|
||||
if len(matches) != 1:
|
||||
print("no running api container with id " + target, file=sys.stderr)
|
||||
return 1
|
||||
subprocess.run(["docker", "stop", "--time", str(STOP_TIMEOUT_SECONDS), matches[0]],
|
||||
cwd=ROOT, check=True, stdout=subprocess.DEVNULL)
|
||||
print("stopped api container " + matches[0][:12])
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1 @@
|
||||
"""Учебный мессенджер МТУСИ: REST API по contracts/openapi.json, данные в PostgreSQL."""
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Точка входа: `python -m messenger`.
|
||||
|
||||
В контейнере этот процесс — главный (PID 1) и сам получает SIGTERM от `docker stop`.
|
||||
С lab3 остановка идёт в два шага, чтобы балансировщик успел увести трафик:
|
||||
|
||||
1. SIGTERM -> флаг draining: /health/ready сразу отвечает 503, но запросы ещё обслуживаются.
|
||||
HAProxy видит 503 (проверка раз в 1 с, 2 неудачи подряд) и перестаёт слать сюда запросы.
|
||||
2. Через SHUTDOWN_DRAIN_SECONDS — обычная остановка uvicorn: закрыть приём соединений,
|
||||
доделать начатые запросы (не дольше GRACEFUL_SHUTDOWN_SECONDS) и выйти.
|
||||
|
||||
Без шага 1 запрос, пришедший в момент остановки, получил бы от балансировщика 502.
|
||||
Повторный сигнал останавливает процесс сразу, без ожидания.
|
||||
"""
|
||||
import logging
|
||||
import threading
|
||||
|
||||
import uvicorn
|
||||
|
||||
from . import config
|
||||
from .api import app, draining
|
||||
|
||||
log = logging.getLogger("messenger")
|
||||
|
||||
|
||||
class DrainingServer(uvicorn.Server):
|
||||
def handle_exit(self, sig, frame):
|
||||
if draining.is_set() or config.SHUTDOWN_DRAIN_SECONDS == 0:
|
||||
return super().handle_exit(sig, frame)
|
||||
draining.set()
|
||||
log.info("Сигнал %s: /health/ready -> 503, ухожу из балансировки, остановка через %s с",
|
||||
sig, config.SHUTDOWN_DRAIN_SECONDS)
|
||||
# Таймер в отдельном потоке: обработчик сигнала должен вернуться сразу.
|
||||
threading.Timer(config.SHUTDOWN_DRAIN_SECONDS, super().handle_exit, (sig, frame)).start()
|
||||
|
||||
|
||||
def main():
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
|
||||
DrainingServer(uvicorn.Config(
|
||||
app,
|
||||
host=config.APP_HOST,
|
||||
port=config.APP_PORT,
|
||||
access_log=False, # строку на каждый запрос пишет наш middleware (без тел и query)
|
||||
timeout_graceful_shutdown=config.GRACEFUL_SHUTDOWN_SECONDS,
|
||||
# Соединение от HAProxy держим дольше, чем HAProxy держит свои простаивающие соединения:
|
||||
# тогда закрывает их HAProxy, и запрос не попадёт в соединение, которое закрывает API.
|
||||
timeout_keep_alive=65,
|
||||
)).run()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,392 @@
|
||||
"""HTTP-слой: маршруты из contracts/openapi.json, проверка входных данных, единый формат ошибок.
|
||||
|
||||
Здесь нет правил предметной области (кто может писать в чат и т.п.) — они в store.py.
|
||||
Что изменилось с lab2:
|
||||
- в каждом ответе заголовок X-Instance-Id: какая реплика API обслужила запрос;
|
||||
- POST сообщения требует Idempotency-Key: повтор того же запроса не создаёт второе сообщение;
|
||||
- миграции больше не применяются при старте: их применяет отдельный сервис migrate,
|
||||
а реплика только ждёт актуальную схему (db.wait_for_schema);
|
||||
- по SIGTERM /health/ready сразу отвечает 503 (флаг draining, см. __main__.py).
|
||||
В памяти процесса нет ничего, от чего зависит правильность ответа: данные и сессии —
|
||||
в PostgreSQL, кэш сессий — в общем Valkey. Поэтому любой запрос может обслужить любая реплика.
|
||||
Что добавилось в lab4:
|
||||
- вложения: POST /chats/{id}/attachments (сырые байты PNG/JPEG), GET /attachments/{id}
|
||||
и /content. Байты — в приватном S3 (objects.py), метаданные — в PostgreSQL (store.py),
|
||||
на диске реплики оригинала нет;
|
||||
- в сообщении поле attachment_ids; текст может быть пустым, если есть вложение;
|
||||
- фоновый уборщик незавершённых загрузок (cleanup.py).
|
||||
Что изменилось в lab5:
|
||||
- POST вложения отвечает 202 queued: оригинал в staging S3, задание и outbox в PostgreSQL
|
||||
(attachments.py). Картинку обрабатывает отдельный процесс worker (worker.py);
|
||||
- в каждой реплике фоновый relay отправляет outbox в брокер (relay.py);
|
||||
- GET вложения показывает любое состояние (queued/processing/ready/failed), варианты и error_code;
|
||||
/content отвечает 409, пока вложение не готово, и умеет variant=thumbnail|crop|optimized;
|
||||
- /health/ready проверяет и S3: без него не принять файл в staging (обязательный путь).
|
||||
Брокер в readiness не входит: благодаря outbox его недоступность не мешает приёму;
|
||||
- уборщик объектов S3 переехал в worker.
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
from dataclasses import asdict
|
||||
from typing import Annotated
|
||||
|
||||
from fastapi import BackgroundTasks, Depends, FastAPI, Header, Query, Request, Response
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from fastapi.responses import JSONResponse, StreamingResponse
|
||||
from pydantic import AfterValidator, BaseModel, ConfigDict, Field, model_validator
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
|
||||
from . import attachments, config, db, images, objects, security
|
||||
from .cursor import decode_cursor, encode_cursor
|
||||
from .errors import AppError, InvalidRequest, Unauthorized, Unavailable
|
||||
from .relay import OutboxRelay
|
||||
from .sessions import AuthContext, SessionCache, Sessions
|
||||
from .store import VARIANT_ORDER, PostgresStore, User, sort_key
|
||||
|
||||
log = logging.getLogger("messenger")
|
||||
|
||||
# Один набор объектов на процесс. Пул соединений открывается при старте (lifespan).
|
||||
pool = db.create_pool()
|
||||
store = PostgresStore(pool)
|
||||
cache = SessionCache(config.CACHE_URL)
|
||||
sessions = Sessions(store, cache, config.SESSION_TTL_SECONDS)
|
||||
|
||||
relay = OutboxRelay() # outbox -> брокер (с lab5)
|
||||
|
||||
# Выставляется по SIGTERM (__main__.py): реплика уходит из балансировки, но ещё отвечает.
|
||||
draining = threading.Event()
|
||||
monitors_stop = threading.Event() # остановка фоновой проверки S3
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app: FastAPI):
|
||||
config.validate()
|
||||
config.validate_s3()
|
||||
config.validate_broker()
|
||||
await run_in_threadpool(db.wait_for_schema) # миграции применяет сервис migrate, мы только ждём
|
||||
pool.open()
|
||||
cache.start_monitor() # фоновая проверка Valkey раз в CACHE_CHECK_INTERVAL_SECONDS
|
||||
objects.start_monitor(monitors_stop) # фоновая проверка S3 для /health/ready (с lab5)
|
||||
relay.start() # отправка outbox в брокер (с lab5)
|
||||
log.info("Реплика %s запущена: версия %s, env=%s, TTL сессии=%s c, кэш сессий: %s",
|
||||
config.INSTANCE_ID, config.APP_VERSION, config.APP_ENV, config.SESSION_TTL_SECONDS,
|
||||
"Valkey" if cache.enabled else "выключен")
|
||||
yield
|
||||
relay.stop() # строки, которые не успели отправить, остаются в outbox
|
||||
monitors_stop.set()
|
||||
pool.close() # аккуратно закрываем соединения с БД при остановке
|
||||
log.info("Реплика %s остановлена: соединения с PostgreSQL закрыты, данные остаются в базе",
|
||||
config.INSTANCE_ID)
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger, lab5", lifespan=lifespan)
|
||||
|
||||
|
||||
# ---------- ошибки и служебная обёртка каждого запроса ----------
|
||||
|
||||
def error_response(request: Request, status: int, code: str, message: str,
|
||||
headers: dict[str, str] | None = None) -> JSONResponse:
|
||||
body = {"error": {"code": code, "message": message, "request_id": request.state.request_id}}
|
||||
return JSONResponse(body, status_code=status, headers=headers)
|
||||
|
||||
|
||||
# Эти два адреса доступны без токена. Всё остальное под /api/ требует Bearer.
|
||||
PUBLIC_ENDPOINTS = {("POST", "/api/v1/users"), ("POST", "/api/v1/auth/sessions")}
|
||||
|
||||
|
||||
def needs_bearer(request: Request) -> bool:
|
||||
return request.url.path.startswith("/api/") and (request.method, request.url.path) not in PUBLIC_ENDPOINTS
|
||||
|
||||
|
||||
def authenticate(authorization: str | None) -> AuthContext:
|
||||
"""Bearer-токен -> пользователь. Любая проблема с токеном -> 401 с WWW-Authenticate: Bearer."""
|
||||
token = security.parse_bearer(authorization)
|
||||
auth = sessions.authenticate(token) if token else None
|
||||
if auth is None:
|
||||
raise Unauthorized("Нужен действующий Bearer-токен сессии")
|
||||
return auth
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def request_context(request: Request, call_next):
|
||||
"""Выполняется вокруг каждого запроса: X-Request-Id, X-Instance-Id, аутентификация, лог.
|
||||
|
||||
Аутентификация стоит здесь, а не в обработчике: она выполняется ДО разбора тела
|
||||
и поиска чата. Так соблюдается порядок из контракта: сначала «кто ты» (401),
|
||||
потом «можно ли тебе этот объект» (404) и «правильный ли запрос» (400).
|
||||
"""
|
||||
request.state.request_id = uuid.uuid4().hex
|
||||
started = time.perf_counter()
|
||||
try:
|
||||
if needs_bearer(request):
|
||||
# Проверка токена ходит в Valkey/PostgreSQL (блокирующий код) — выполняем в пуле потоков.
|
||||
request.state.auth = await run_in_threadpool(authenticate, request.headers.get("Authorization"))
|
||||
response = await call_next(request)
|
||||
except AppError as exc: # 401 от аутентификации или 503, если хранилище недоступно
|
||||
response = error_response(request, exc.status, exc.code, exc.message, exc.headers)
|
||||
except Exception:
|
||||
# Подробности (stack trace) — только в лог сервера, клиенту — общий ответ 500.
|
||||
log.exception("Необработанная ошибка, request_id=%s", request.state.request_id)
|
||||
response = error_response(request, 500, "internal_error", "Внутренняя ошибка сервера")
|
||||
response.headers["X-Request-Id"] = request.state.request_id
|
||||
# С lab3: в каждом ответе (и в ошибках, и в health) — какая реплика его создала.
|
||||
response.headers["X-Instance-Id"] = config.INSTANCE_ID
|
||||
# В лог не пишем тела, query-параметры и заголовки: там тексты сообщений, пароли и токены.
|
||||
log.info("%s %s -> %d (%.1f ms) request_id=%s", request.method, request.url.path,
|
||||
response.status_code, (time.perf_counter() - started) * 1000, request.state.request_id)
|
||||
return response
|
||||
|
||||
|
||||
@app.exception_handler(AppError)
|
||||
async def handle_app_error(request: Request, exc: AppError):
|
||||
return error_response(request, exc.status, exc.code, exc.message, exc.headers)
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def handle_validation_error(request: Request, exc: RequestValidationError):
|
||||
# FastAPI по умолчанию отвечает 422 со своим форматом; контракт требует 400 и наш формат.
|
||||
# Детали pydantic клиенту не отдаём: в них может быть эхо входных данных (например, пароль).
|
||||
first = exc.errors()[0]
|
||||
if first["type"] == "json_invalid":
|
||||
message = "Тело запроса не является корректным JSON"
|
||||
else:
|
||||
message = "Неверное значение: " + ".".join(str(part) for part in first["loc"])
|
||||
return error_response(request, 400, "invalid_request", message)
|
||||
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def handle_http_error(request: Request, exc: StarletteHTTPException):
|
||||
# Ошибки, которые создаёт сам фреймворк: неизвестный путь (404), не тот метод (405) и т.п.
|
||||
if exc.status_code == 404:
|
||||
return error_response(request, 404, "not_found", "Ресурс не найден")
|
||||
return error_response(request, exc.status_code, "invalid_request", "Запрос не может быть обработан")
|
||||
|
||||
|
||||
# ---------- входные данные (схемы из contracts/openapi.json) ----------
|
||||
|
||||
def _not_blank(value: str) -> str:
|
||||
if not value.strip():
|
||||
raise ValueError("строка состоит только из пробелов")
|
||||
return value
|
||||
|
||||
|
||||
# Длины в символах Unicode (code points): len("👋") == 1 в Python.
|
||||
Name = Annotated[str, Field(min_length=1, max_length=100), AfterValidator(_not_blank)]
|
||||
Text = Annotated[str, Field(min_length=1, max_length=4000), AfterValidator(_not_blank)]
|
||||
Password = Annotated[str, Field(min_length=security.PASSWORD_MIN, max_length=security.PASSWORD_MAX),
|
||||
AfterValidator(_not_blank)]
|
||||
|
||||
|
||||
class StrictModel(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid") # лишние поля в JSON -> 400
|
||||
|
||||
|
||||
class CreateUser(StrictModel):
|
||||
username: Annotated[str, Field(pattern=r"^[a-z0-9_]{3,32}$")]
|
||||
display_name: Name
|
||||
password: Password
|
||||
|
||||
|
||||
class CreateChat(StrictModel):
|
||||
title: Name
|
||||
member_ids: Annotated[list[uuid.UUID], Field(min_length=1, max_length=100)]
|
||||
|
||||
|
||||
class CreateMessage(StrictModel):
|
||||
# Поля sender_id нет: прислать его = лишнее поле = 400.
|
||||
# С lab4 текст может быть пустым, но только если есть хотя бы одно вложение.
|
||||
text: Annotated[str, Field(max_length=4000)]
|
||||
# Отсутствующий attachment_ids равен []: model_dump даёт одинаковый отпечаток для повтора.
|
||||
attachment_ids: Annotated[list[uuid.UUID], Field(max_length=10)] = []
|
||||
|
||||
@model_validator(mode="after")
|
||||
def text_or_attachments(self):
|
||||
if len(set(self.attachment_ids)) != len(self.attachment_ids):
|
||||
raise ValueError("attachment_ids повторяются")
|
||||
if not self.attachment_ids and not self.text.strip():
|
||||
raise ValueError("нужен непустой текст или хотя бы одно вложение")
|
||||
return self
|
||||
|
||||
|
||||
# Ключ идемпотентности (с lab3): ASCII [A-Za-z0-9._:-], 1–128 символов. Нет или неверный -> 400.
|
||||
IdempotencyKey = Annotated[str, Header(alias="Idempotency-Key", min_length=1, max_length=128,
|
||||
pattern=r"^[A-Za-z0-9._:-]+$")]
|
||||
|
||||
|
||||
def request_fingerprint(body: BaseModel) -> bytes:
|
||||
"""SHA-256 «смысла» запроса: тело после разбора, ключи по алфавиту, без лишних пробелов.
|
||||
|
||||
Поэтому порядок полей и форматирование JSON не важны: {"text":"a"} и { "text" : "a" }
|
||||
дают одинаковый отпечаток. Сравнивается при повторе с тем же Idempotency-Key.
|
||||
"""
|
||||
canonical = json.dumps(body.model_dump(mode="json"), sort_keys=True, ensure_ascii=False,
|
||||
separators=(",", ":"))
|
||||
return hashlib.sha256(canonical.encode("utf-8")).digest()
|
||||
|
||||
|
||||
# ---------- текущий пользователь ----------
|
||||
|
||||
def current_auth(request: Request) -> AuthContext:
|
||||
"""Сессия, которую middleware уже проверил для этого запроса."""
|
||||
auth = getattr(request.state, "auth", None)
|
||||
if auth is None: # защита от ошибки в PUBLIC_ENDPOINTS: без проверки токена доступа нет
|
||||
raise Unauthorized("Нужен действующий Bearer-токен сессии")
|
||||
return auth
|
||||
|
||||
|
||||
def current_user(auth: Annotated[AuthContext, Depends(current_auth)]) -> User:
|
||||
return auth.user
|
||||
|
||||
|
||||
CurrentAuth = Annotated[AuthContext, Depends(current_auth)]
|
||||
CurrentUser = Annotated[User, Depends(current_user)]
|
||||
Limit = Annotated[int, Query(ge=1, le=100)]
|
||||
Cursor = Annotated[str | None, Query(min_length=1)]
|
||||
|
||||
|
||||
def page_response(scope: str, items: list, has_more: bool) -> dict:
|
||||
next_cursor = encode_cursor(scope, sort_key(items[-1])) if has_more else None
|
||||
return {"items": [asdict(item) for item in items], "next_cursor": next_cursor}
|
||||
|
||||
|
||||
# ---------- маршруты ----------
|
||||
# Обработчики объявлены через def (не async def): FastAPI запускает их в пуле потоков,
|
||||
# поэтому запросы обрабатываются параллельно. Согласованность данных обеспечивает
|
||||
# PostgreSQL (транзакции и ограничения), а не замок в памяти процесса.
|
||||
|
||||
@app.get("/health/live")
|
||||
def health_live():
|
||||
return {"status": "ok"} # процесс жив; от зависимостей не зависит
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
def health_ready():
|
||||
# Готовность = можно обслужить обязательный синхронный путь. Критичны:
|
||||
# - PostgreSQL (всё, что API хранит, и outbox);
|
||||
# - S3 (с lab5): без него нельзя принять файл в staging, а без staging нельзя честно ответить 202.
|
||||
# Не критичны: Valkey (без кэша сессий API работает через PostgreSQL) и брокер
|
||||
# (задания копятся в outbox и уйдут в брокер, когда он вернётся), worker (задания ждут в очереди).
|
||||
if draining.is_set():
|
||||
# Получен SIGTERM: просим балансировщик больше не присылать запросы (см. __main__.py).
|
||||
raise Unavailable("Реплика останавливается")
|
||||
store.ping() # если БД недоступна -> Unavailable -> 503 в общем формате ошибки
|
||||
if not objects.healthy():
|
||||
raise Unavailable("Хранилище файлов недоступно")
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
def register_user(body: CreateUser):
|
||||
password_hash = security.hash_password(body.password) # сам пароль нигде не сохраняется
|
||||
return asdict(store.create_user(body.username, body.display_name, password_hash))
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
def create_session(response: Response, authorization: Annotated[str | None, Header()] = None):
|
||||
credentials = security.parse_basic(authorization)
|
||||
result = sessions.login(*credentials) if credentials else None
|
||||
if result is None:
|
||||
# Один и тот же ответ для «нет такого пользователя», «неверный пароль» и «кривой заголовок».
|
||||
raise Unauthorized("Неверное имя пользователя или пароль", Unauthorized.BASIC)
|
||||
token, expires_at, user = result
|
||||
response.headers["Cache-Control"] = "no-store" # ответ с токеном нельзя кэшировать
|
||||
return {"token": token, "token_type": "Bearer", "expires_at": expires_at, "user": asdict(user)}
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
def revoke_session(auth: CurrentAuth):
|
||||
sessions.logout(auth)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
def get_me(user: CurrentUser):
|
||||
return asdict(user)
|
||||
|
||||
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
def create_chat(body: CreateChat, user: CurrentUser):
|
||||
member_ids = [str(member_id) for member_id in body.member_ids]
|
||||
return asdict(store.create_chat(user.id, body.title, member_ids))
|
||||
|
||||
|
||||
@app.get("/api/v1/chats")
|
||||
def list_chats(user: CurrentUser, limit: Limit = 50, cursor: Cursor = None):
|
||||
scope = f"chats:{user.id}"
|
||||
items, has_more = store.list_chats(user.id, decode_cursor(scope, cursor), limit)
|
||||
return page_response(scope, items, has_more)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
def get_chat(chat_id: uuid.UUID, user: CurrentUser):
|
||||
return asdict(store.get_chat(user.id, str(chat_id)))
|
||||
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
def send_message(chat_id: uuid.UUID, body: CreateMessage, user: CurrentUser,
|
||||
idempotency_key: IdempotencyKey):
|
||||
# Область ключа из контракта: пользователь + метод + путь чата + ключ.
|
||||
# Метод и путь у этого обработчика всегда одни, поэтому в БД ключ уникален в паре (чат, отправитель).
|
||||
message, replayed = store.add_message(user.id, str(chat_id), body.text,
|
||||
idempotency_key, request_fingerprint(body),
|
||||
tuple(str(a) for a in body.attachment_ids))
|
||||
if replayed:
|
||||
log.info("Повтор с тем же Idempotency-Key: возвращаю уже сохранённое сообщение %s", message.id)
|
||||
return asdict(message)
|
||||
|
||||
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
def list_messages(chat_id: uuid.UUID, user: CurrentUser, limit: Limit = 50, cursor: Cursor = None):
|
||||
scope = f"messages:{chat_id}"
|
||||
items, has_more = store.list_messages(user.id, str(chat_id), decode_cursor(scope, cursor), limit)
|
||||
return page_response(scope, items, has_more)
|
||||
|
||||
|
||||
# ---------- вложения (с lab4; с lab5 — асинхронная обработка) ----------
|
||||
|
||||
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=202)
|
||||
async def upload_attachment(request: Request, chat_id: uuid.UUID, user: CurrentUser, background: BackgroundTasks,
|
||||
filename: Annotated[str | None, Query()] = None):
|
||||
# async: тело читается потоком (attachments.receive_body), а блокирующие шаги
|
||||
# (проверка структуры, S3, БД) идут в пуле потоков. Дешёвые проверки — до чтения тела.
|
||||
# 202 = файл принят на обработку (staging + задание сохранены), а не «готов».
|
||||
chat = str(chat_id)
|
||||
await run_in_threadpool(store.get_chat, user.id, chat) # посторонний -> 404, тело не читаем
|
||||
name = images.check_filename(filename) # 400
|
||||
declared = images.declared_type(request.headers.get("Content-Type")) # 415
|
||||
attachments.check_content_length(request.headers.get("Content-Length")) # 413 до чтения тела
|
||||
attachment = await attachments.upload(request, store, user.id, chat, name, declared)
|
||||
# Разбудить relay ПОСЛЕ отправки ответа: задание уже в outbox, отправка в брокер — следующий шаг.
|
||||
background.add_task(relay.nudge)
|
||||
return asdict(attachment)
|
||||
|
||||
|
||||
@app.get("/api/v1/attachments/{attachment_id}")
|
||||
def get_attachment(attachment_id: uuid.UUID, user: CurrentUser):
|
||||
attachment, _key = store.get_attachment(user.id, str(attachment_id))
|
||||
return asdict(attachment)
|
||||
|
||||
|
||||
@app.get("/api/v1/attachments/{attachment_id}/content")
|
||||
def download_attachment(attachment_id: uuid.UUID, user: CurrentUser, variant: str = "original"):
|
||||
if variant != "original" and variant not in VARIANT_ORDER:
|
||||
raise InvalidRequest("Неверное значение: variant")
|
||||
# Не участник -> 404; не готово (queued/processing/failed) -> 409; нет такого варианта -> 404.
|
||||
key, content_type, size = store.get_content(user.id, str(attachment_id), variant)
|
||||
try:
|
||||
body = objects.open_stream(key)
|
||||
except objects.MissingObject:
|
||||
log.error("Нет объекта в S3 для готового вложения %s (%s)", attachment_id, variant)
|
||||
raise Unavailable("Файл временно недоступен") from None
|
||||
# Через API, без redirect на S3: доступ проверен выше. Отдаём кусками, без чтения в память целиком.
|
||||
return StreamingResponse(objects.iter_chunks(body), media_type=content_type, headers={
|
||||
"Content-Length": str(size),
|
||||
"Cache-Control": "private, no-store",
|
||||
"X-Content-Type-Options": "nosniff",
|
||||
})
|
||||
@@ -0,0 +1,119 @@
|
||||
"""Приём вложения (с lab5 — асинхронный): POST /chats/{id}/attachments -> 202 queued.
|
||||
|
||||
Что именно сохранено в момент 202 (contracts/attachment-states.md, переход «нет -> queued»):
|
||||
1. полный проверенный оригинал — в staging S3 (staging/<id>): PUT вернул 200, объект виден
|
||||
всем репликам и worker и лежит в volume s3data, а не в памяти или на диске реплики API;
|
||||
2. в PostgreSQL одной транзакцией (COMMIT с записью WAL на диск): строка вложения (queued),
|
||||
задание (attempt=1) и строка outbox — «намерение обработать».
|
||||
В брокер в этот момент сообщение может быть ещё не отправлено: это делает relay (relay.py)
|
||||
через миллисекунды или позже, если брокер недоступен. Намерение уже не потеряется: оно в БД.
|
||||
|
||||
Шаги:
|
||||
0. (api.py) токен, формат chat_id, участник ли чата, filename, Content-Type, Content-Length;
|
||||
1. тело читается потоком: кусок за куском, с подсчётом размера и SHA-256. Как только размер
|
||||
превысил 10 MiB — 413, дальше не читаем. В памяти не больше UPLOAD_SPOOL_BYTES (1 МиБ),
|
||||
остальное во временном файле (SpooledTemporaryFile), который удаляется в конце запроса;
|
||||
2. проверка картинки (images.py): тип по содержимому, пиксели по заголовку, структура файла.
|
||||
Картинка НЕ декодируется и не уменьшается — это работа worker;
|
||||
3. PUT оригинала в staging/<id> (ключ назначает сервер);
|
||||
4. COMMIT: вложение + задание + outbox -> 202. После ответа будится relay этого же процесса.
|
||||
Шаги 3–4 — одна транзакция под блокировкой ID вложения (store.receiving): пока она идёт,
|
||||
уборщик этот staging не трогает (замечание к MR: уборка не должна удалять текущую работу).
|
||||
|
||||
Сбои:
|
||||
- S3 недоступен на шаге 3 -> 503, в БД ничего нет; объект мог успеть записаться — тогда это
|
||||
«сирота» без строки, его уберёт уборщик через grace period (cleanup.py);
|
||||
- PostgreSQL недоступен на шаге 4 -> 503, то же самое;
|
||||
- процесс API упал сразу после COMMIT -> клиент не получил ответ, но работа принята:
|
||||
relay другой реплики отправит задание, worker его выполнит (проверка: make outbox-crash).
|
||||
Клиент, прервавший передачу на шаге 1, ничего после себя не оставляет.
|
||||
"""
|
||||
import asyncio
|
||||
import hashlib
|
||||
import logging
|
||||
import tempfile
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from starlette.concurrency import run_in_threadpool
|
||||
from starlette.requests import ClientDisconnect, Request
|
||||
|
||||
from . import config, faults, images, objects
|
||||
from .errors import InvalidRequest, PayloadTooLarge
|
||||
from .store import Attachment, PostgresStore
|
||||
|
||||
log = logging.getLogger("messenger.attachments")
|
||||
|
||||
|
||||
def check_content_length(header: str | None) -> None:
|
||||
"""Если клиент заранее сообщил размер больше лимита — 413 сразу, тело не читаем вовсе."""
|
||||
if header is None:
|
||||
return
|
||||
if not header.strip().isdigit():
|
||||
raise InvalidRequest("Неверный Content-Length")
|
||||
if int(header) > config.MAX_UPLOAD_BYTES:
|
||||
raise PayloadTooLarge(f"Файл больше {config.MAX_UPLOAD_BYTES} байт")
|
||||
|
||||
|
||||
async def receive_body(request: Request):
|
||||
"""Принять тело потоком. Возвращает (временный файл, размер, sha256). Память ограничена."""
|
||||
spool = tempfile.SpooledTemporaryFile(max_size=config.UPLOAD_SPOOL_BYTES)
|
||||
digest, size = hashlib.sha256(), 0
|
||||
deadline = time.monotonic() + config.UPLOAD_TIMEOUT_SECONDS
|
||||
stream = request.stream().__aiter__()
|
||||
try:
|
||||
while True:
|
||||
left = deadline - time.monotonic()
|
||||
if left <= 0:
|
||||
raise InvalidRequest(f"Файл не получен за {config.UPLOAD_TIMEOUT_SECONDS} с")
|
||||
try:
|
||||
chunk = await asyncio.wait_for(stream.__anext__(), timeout=left)
|
||||
except StopAsyncIteration:
|
||||
break
|
||||
except asyncio.TimeoutError:
|
||||
raise InvalidRequest(f"Файл не получен за {config.UPLOAD_TIMEOUT_SECONDS} с") from None
|
||||
size += len(chunk)
|
||||
if size > config.MAX_UPLOAD_BYTES:
|
||||
raise PayloadTooLarge(f"Файл больше {config.MAX_UPLOAD_BYTES} байт")
|
||||
digest.update(chunk)
|
||||
spool.write(chunk)
|
||||
except ClientDisconnect:
|
||||
spool.close()
|
||||
log.info("Клиент прервал загрузку на %d байтах: ничего не сохранено", size)
|
||||
raise InvalidRequest("Загрузка прервана клиентом") from None
|
||||
except BaseException:
|
||||
spool.close()
|
||||
raise
|
||||
if size == 0:
|
||||
spool.close()
|
||||
raise InvalidRequest("Пустое тело запроса: нужен файл PNG или JPEG")
|
||||
return spool, size, digest.hexdigest()
|
||||
|
||||
|
||||
def accept(store: PostgresStore, user_id: str, chat_id: str, filename: str,
|
||||
spool, size: int, sha256: str, declared: str) -> Attachment:
|
||||
"""Шаги 2–4 (блокирующий код, выполняется в пуле потоков)."""
|
||||
info = images.inspect(spool, declared)
|
||||
attachment_id = str(uuid.uuid4())
|
||||
staging = objects.staging_key(attachment_id)
|
||||
# Одна транзакция от PUT до COMMIT под блокировкой ID вложения (store.receiving): уборщик
|
||||
# не тронет staging, пока загрузка не закончилась, даже если строки в БД ещё нет.
|
||||
with store.receiving(attachment_id) as conn:
|
||||
objects.put(staging, spool, size, info.content_type, sha256) # сбой -> 503, транзакция откатывается
|
||||
faults.pause("api_pause_after_staging") # проверка окна «staging записан, строки ещё нет»
|
||||
attachment = store.create_queued_attachment(
|
||||
attachment_id, user_id, chat_id, filename, info.content_type, size, sha256, info.width, info.height,
|
||||
staging_key=staging, storage_key=objects.original_key(attachment_id),
|
||||
actor="api-" + config.INSTANCE_ID, conn=conn)
|
||||
faults.hit("api_after_commit") # проверка окна «COMMIT прошёл, до отправки в брокер» (faults.py)
|
||||
log.info("Вложение %s принято: %d байт, %s, задание в outbox", attachment_id, size, info.content_type)
|
||||
return attachment
|
||||
|
||||
|
||||
async def upload(request: Request, store: PostgresStore, user_id: str, chat_id: str,
|
||||
filename: str, declared: str) -> Attachment:
|
||||
spool, size, sha256 = await receive_body(request)
|
||||
try:
|
||||
return await run_in_threadpool(accept, store, user_id, chat_id, filename, spool, size, sha256, declared)
|
||||
finally:
|
||||
spool.close() # временный буфер удаляется в любом случае: оригинал живёт только в S3
|
||||
@@ -0,0 +1,209 @@
|
||||
"""Брокер сообщений RabbitMQ (с lab5): топология, формат сообщения, публикация с подтверждением.
|
||||
|
||||
Топология (объявляется идемпотентно и relay, и worker — с одинаковыми параметрами):
|
||||
- exchange `attachments` (direct) -> очередь `attachments.process` по ключу attachment.process.v1;
|
||||
- очередь `attachments.process` — quorum queue: хранится на диске (volume брокера), переживает
|
||||
перезапуск брокера; у каждого сообщения считается число неудачных доставок, после
|
||||
BROKER_DELIVERY_LIMIT сообщение уходит в DLQ (защита от «ядовитого» сообщения, которое
|
||||
раз за разом роняет обработчик);
|
||||
- exchange `attachments.dlx` -> очередь `attachments.dead` (DLQ): сюда попадают сообщения,
|
||||
которые worker отклонил окончательно (failed, исчерпаны попытки, неверный формат).
|
||||
Подробности (error_code, попытки) — в PostgreSQL: таблица attachment_jobs — это реестр failed.
|
||||
|
||||
Две разные границы надёжности:
|
||||
- publisher confirm: брокер -> отправитель «сообщение записано в очередь». Только после него
|
||||
relay отмечает строку outbox отправленной;
|
||||
- consumer ack: worker -> брокер «результат обработки уже сохранён, сообщение можно удалить».
|
||||
Ack идёт только после COMMIT результата в PostgreSQL.
|
||||
|
||||
В сообщении только идентификаторы и служебные поля (contracts/jobs.schema.json): ни байтов
|
||||
файла, ни ключей S3, ни URL, ни паролей. Worker берёт всё остальное из БД.
|
||||
"""
|
||||
import json
|
||||
import re
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
|
||||
import pika
|
||||
from pika.exceptions import AMQPError
|
||||
|
||||
from . import config
|
||||
|
||||
EXCHANGE = "attachments"
|
||||
ROUTING_KEY = "attachment.process.v1"
|
||||
QUEUE = "attachments.process"
|
||||
DEAD_EXCHANGE = "attachments.dlx"
|
||||
DEAD_QUEUE = "attachments.dead"
|
||||
DEAD_ROUTING_KEY = "attachment.dead"
|
||||
MESSAGE_TYPE = "attachment.process.v1"
|
||||
SCHEMA_VERSION = 1
|
||||
DELIVERY_LIMIT = 10
|
||||
MAX_MESSAGE_BYTES = 4096
|
||||
|
||||
QUEUE_ARGUMENTS = {
|
||||
"x-queue-type": "quorum",
|
||||
"x-delivery-limit": DELIVERY_LIMIT,
|
||||
"x-dead-letter-exchange": DEAD_EXCHANGE,
|
||||
"x-dead-letter-routing-key": DEAD_ROUTING_KEY,
|
||||
}
|
||||
DEAD_QUEUE_ARGUMENTS = {"x-queue-type": "quorum", "x-max-length": 100_000}
|
||||
|
||||
_FIELDS = {"schema_version", "job_id", "type", "attachment_id", "pipeline_version", "attempt",
|
||||
"created_at", "traceparent", "tracestate"}
|
||||
_REQUIRED = _FIELDS - {"traceparent", "tracestate"}
|
||||
_TRACEPARENT = re.compile(r"^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$")
|
||||
|
||||
# Ошибки связи с брокером: при любой из них соединение пересоздаётся.
|
||||
BrokerError = (AMQPError, OSError)
|
||||
|
||||
|
||||
class InvalidMessage(Exception):
|
||||
"""Тело сообщения не соответствует jobs.schema.json (ошибка отправителя, повтор не поможет)."""
|
||||
|
||||
|
||||
def iso_now() -> str:
|
||||
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
||||
|
||||
|
||||
def build_message(job_id: str, attachment_id: str, pipeline_version: int, attempt: int,
|
||||
created_at: str | None = None) -> dict:
|
||||
return {"schema_version": SCHEMA_VERSION, "job_id": str(job_id), "type": MESSAGE_TYPE,
|
||||
"attachment_id": str(attachment_id), "pipeline_version": int(pipeline_version),
|
||||
"attempt": int(attempt), "created_at": created_at or iso_now()}
|
||||
|
||||
|
||||
def encode(message: dict) -> bytes:
|
||||
return json.dumps(message, sort_keys=True, separators=(",", ":")).encode("ascii")
|
||||
|
||||
|
||||
def _uuid(value) -> str:
|
||||
if not isinstance(value, str):
|
||||
raise InvalidMessage("uuid должен быть строкой")
|
||||
try:
|
||||
return str(uuid.UUID(value))
|
||||
except ValueError:
|
||||
raise InvalidMessage("неверный uuid") from None
|
||||
|
||||
|
||||
def _positive_int(value, name: str) -> int:
|
||||
if not isinstance(value, int) or isinstance(value, bool) or value < 1:
|
||||
raise InvalidMessage(name + " должен быть целым >= 1")
|
||||
return value
|
||||
|
||||
|
||||
def parse(body: bytes) -> dict:
|
||||
"""Разобрать и проверить сообщение по contracts/jobs.schema.json. Ошибка -> InvalidMessage."""
|
||||
if len(body) > MAX_MESSAGE_BYTES:
|
||||
raise InvalidMessage("слишком большое сообщение")
|
||||
try:
|
||||
message = json.loads(body.decode("utf-8"))
|
||||
except (UnicodeDecodeError, ValueError, RecursionError):
|
||||
raise InvalidMessage("не JSON") from None
|
||||
if not isinstance(message, dict):
|
||||
raise InvalidMessage("ожидался объект")
|
||||
if set(message) - _FIELDS:
|
||||
raise InvalidMessage("лишние поля")
|
||||
if _REQUIRED - set(message):
|
||||
raise InvalidMessage("нет обязательных полей")
|
||||
if message["schema_version"] != SCHEMA_VERSION or isinstance(message["schema_version"], bool):
|
||||
raise InvalidMessage("schema_version")
|
||||
if message["type"] != MESSAGE_TYPE:
|
||||
raise InvalidMessage("type")
|
||||
result = {"schema_version": SCHEMA_VERSION, "type": MESSAGE_TYPE,
|
||||
"job_id": _uuid(message["job_id"]), "attachment_id": _uuid(message["attachment_id"]),
|
||||
"pipeline_version": _positive_int(message["pipeline_version"], "pipeline_version"),
|
||||
"attempt": _positive_int(message["attempt"], "attempt")}
|
||||
created = message["created_at"]
|
||||
if not isinstance(created, str):
|
||||
raise InvalidMessage("created_at")
|
||||
try:
|
||||
parsed = datetime.fromisoformat(created.replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
raise InvalidMessage("created_at") from None
|
||||
if parsed.tzinfo is None:
|
||||
raise InvalidMessage("created_at без часового пояса")
|
||||
result["created_at"] = created
|
||||
if "traceparent" in message:
|
||||
if not isinstance(message["traceparent"], str) or not _TRACEPARENT.match(message["traceparent"]):
|
||||
raise InvalidMessage("traceparent")
|
||||
result["traceparent"] = message["traceparent"]
|
||||
if "tracestate" in message:
|
||||
if not isinstance(message["tracestate"], str) or len(message["tracestate"]) > 512:
|
||||
raise InvalidMessage("tracestate")
|
||||
result["tracestate"] = message["tracestate"]
|
||||
return result
|
||||
|
||||
|
||||
def parameters(role: str) -> pika.URLParameters:
|
||||
params = pika.URLParameters(config.BROKER_URL)
|
||||
# Heartbeat 10 с: брокер закрывает соединение зависшего процесса примерно через 20 с и возвращает
|
||||
# в очередь выданные ему сообщения. Иначе замороженный worker продолжал бы «получать» задания
|
||||
# (до prefetch) и держать их минуту и дольше. Наш цикл обслуживает heartbeat раз в секунду.
|
||||
params.heartbeat = 10
|
||||
params.blocked_connection_timeout = 10 # брокер заблокировал публикацию (нет памяти/диска) -> ошибка
|
||||
params.socket_timeout = 5
|
||||
params.stack_timeout = 10
|
||||
params.connection_attempts = 1 # повторы подключения делает наш цикл, с паузами
|
||||
params.client_properties = {"connection_name": f"{role}-{config.INSTANCE_ID}"}
|
||||
return params
|
||||
|
||||
|
||||
def connect(role: str) -> pika.BlockingConnection:
|
||||
return pika.BlockingConnection(parameters(role))
|
||||
|
||||
|
||||
def declare(channel) -> None:
|
||||
"""Объявить топологию. Повторное объявление с теми же параметрами ничего не меняет."""
|
||||
channel.exchange_declare(EXCHANGE, exchange_type="direct", durable=True)
|
||||
channel.exchange_declare(DEAD_EXCHANGE, exchange_type="direct", durable=True)
|
||||
channel.queue_declare(QUEUE, durable=True, arguments=QUEUE_ARGUMENTS)
|
||||
channel.queue_bind(QUEUE, EXCHANGE, routing_key=ROUTING_KEY)
|
||||
channel.queue_declare(DEAD_QUEUE, durable=True, arguments=DEAD_QUEUE_ARGUMENTS)
|
||||
channel.queue_bind(DEAD_QUEUE, DEAD_EXCHANGE, routing_key=DEAD_ROUTING_KEY)
|
||||
|
||||
|
||||
class Publisher:
|
||||
"""Соединение для публикации с publisher confirms. Используется одним потоком (relay)."""
|
||||
|
||||
def __init__(self, role: str):
|
||||
self.role = role
|
||||
self.connection = None
|
||||
self.channel = None
|
||||
|
||||
def _open(self):
|
||||
if self.channel is not None and self.channel.is_open and self.connection.is_open:
|
||||
return self.channel
|
||||
self.close()
|
||||
self.connection = connect(self.role)
|
||||
channel = self.connection.channel()
|
||||
declare(channel)
|
||||
channel.confirm_delivery() # каждая публикация ждёт подтверждения брокера
|
||||
self.channel = channel
|
||||
return channel
|
||||
|
||||
def publish(self, message: dict) -> None:
|
||||
"""Отправить и дождаться publisher confirm. Без подтверждения — исключение."""
|
||||
channel = self._open()
|
||||
properties = pika.BasicProperties(
|
||||
content_type="application/json",
|
||||
delivery_mode=pika.DeliveryMode.Persistent,
|
||||
message_id=f"{message['job_id']}:{message['attempt']}",
|
||||
type=MESSAGE_TYPE,
|
||||
app_id="messenger-relay",
|
||||
)
|
||||
# mandatory=True: если сообщение не попало ни в одну очередь, брокер вернёт его,
|
||||
# и pika бросит UnroutableError — строка outbox останется неотправленной.
|
||||
channel.basic_publish(EXCHANGE, ROUTING_KEY, encode(message), properties=properties, mandatory=True)
|
||||
|
||||
def service(self) -> None:
|
||||
"""Обслужить соединение между публикациями (heartbeat), если оно открыто."""
|
||||
if self.connection is not None and self.connection.is_open:
|
||||
self.connection.process_data_events(time_limit=0)
|
||||
|
||||
def close(self) -> None:
|
||||
try:
|
||||
if self.connection is not None and self.connection.is_open:
|
||||
self.connection.close()
|
||||
except BrokerError:
|
||||
pass
|
||||
self.connection = self.channel = None
|
||||
@@ -0,0 +1,136 @@
|
||||
"""Уборка объектов S3 (с lab4; с lab5 — staging и варианты): фоновый поток worker и команда.
|
||||
|
||||
Зачем. Между записью байтов в S3 и COMMIT в PostgreSQL может случиться сбой, а staging после
|
||||
обработки больше не нужен. Уборщик сверяет содержимое bucket с базой и удаляет то, на что
|
||||
база не ссылается.
|
||||
|
||||
Что нужно и не удаляется:
|
||||
- оригинал ready-вложения (originals/<id>) и все его варианты (variants/<id>/...);
|
||||
- ВСЕ объекты вложения в работе (queued, processing): staging читает worker, а оригинал и
|
||||
варианты он, возможно, пишет прямо сейчас, до COMMIT результата;
|
||||
- все объекты failed-вложения, пока не прошёл STAGING_RETENTION_SECONDS (24 ч): оператор может
|
||||
сделать replay, и worker запишет оригинал и варианты заново в те же ключи;
|
||||
- staging загрузки, которая ещё идёт (PUT уже был, COMMIT строки вложения — ещё нет).
|
||||
Под удаление попадают объекты старше grace period (ATTACHMENT_GRACE_SECONDS, 15 мин):
|
||||
- staging уже готового вложения (worker удаляет его сам сразу после COMMIT, сюда попадает,
|
||||
только если тогда не получилось);
|
||||
- объекты failed-вложения после retention (сначала staging помечается удалённым в БД);
|
||||
- «сироты»: объекты без строки в БД (API упал между PUT в staging и COMMIT).
|
||||
|
||||
Как уборщик не удаляет текущую работу (замечание к MR). Прежняя версия читала ссылки из БД
|
||||
один раз и удаляла по этому снимку: если между чтением и удалением оператор делал replay,
|
||||
staging уже queued-задания удалялся, и worker получал source_missing. Теперь:
|
||||
1. список объектов и снимок ссылок из БД только отбирают кандидатов (заведомо нужное не трогаем);
|
||||
2. по каждому вложению-кандидату решение принимается заново, в короткой транзакции под
|
||||
блокировками (PostgresStore.cleanup_attachment): advisory-блокировка ID вложения (её держит
|
||||
идущая загрузка), затем строки задания и вложения (их меняют worker и replay). Пока блокировки
|
||||
у уборщика, состояние не может поменяться;
|
||||
3. у failed-вложения после retention сначала в БД помечается, что исходника нет
|
||||
(staging_key = NULL, запись в журнале), и только после COMMIT объекты удаляются из S3:
|
||||
replay, ждавший блокировку или пришедший позже, видит это и безопасно отказывает;
|
||||
4. из S3 удаляется только то, что после COMMIT уже не может понадобиться никогда (сирота без
|
||||
загрузки, staging готового, объекты failed без исходника). Поэтому медленный S3 не держит
|
||||
блокировки, а оборванная сессия БД не открывает окно для гонки.
|
||||
Готовые вложения без объекта (missing) только считаются и пишутся в лог: решает человек.
|
||||
Повторный и одновременный запуск безопасен: удаление идемпотентно, вложение обрабатывает
|
||||
только тот, кто взял его блокировку.
|
||||
|
||||
Запуск вручную (внутри контейнера api или worker):
|
||||
python -m messenger.cleanup --dry-run # только показать, ничего не удалять
|
||||
python -m messenger.cleanup # удалить по правилам выше
|
||||
python -m messenger.cleanup --grace-seconds 5 # для теста: меньший grace period
|
||||
python -m messenger.cleanup --attachment <id> # только объекты одного вложения
|
||||
Вывод — одна строка JSON со счётчиками, без ключей доступа.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from collections import Counter, defaultdict
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from . import config, faults, objects
|
||||
from .errors import AppError
|
||||
from .store import PostgresStore
|
||||
|
||||
log = logging.getLogger("messenger.cleanup")
|
||||
|
||||
|
||||
def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, dry_run: bool = False,
|
||||
attachment_id: str | None = None) -> dict:
|
||||
started = time.monotonic()
|
||||
if attachment_id is None:
|
||||
listed = objects.list_objects("")
|
||||
else:
|
||||
listed = [item for prefix in objects.prefixes_of(attachment_id) for item in objects.list_objects(prefix)]
|
||||
refs = store.storage_references(retention_seconds)
|
||||
faults.pause("cleanup_pause") # проверка гонки: окно между чтением ссылок и удалением
|
||||
border = datetime.now(timezone.utc) - timedelta(seconds=grace_seconds)
|
||||
candidates = defaultdict(list) # ID вложения -> его объекты, которые МОГУТ быть лишними
|
||||
for key, modified in listed:
|
||||
if key not in refs["needed"] and modified < border:
|
||||
candidates[objects.attachment_of(key)].append(key)
|
||||
counts = {"staging_after_ready": 0, "staging_failed_expired": 0, "orphan": 0}
|
||||
kept, busy, deleted = Counter(), 0, 0
|
||||
for owner, keys in candidates.items():
|
||||
if owner is None:
|
||||
# Ключ не того вида, что пишут API и worker: никакая текущая работа на него не ссылается.
|
||||
counts["orphan"] += len(keys)
|
||||
if not dry_run:
|
||||
for key in keys:
|
||||
objects.delete(key)
|
||||
deleted += len(keys)
|
||||
continue
|
||||
outcome = store.cleanup_attachment(owner, keys, retention_seconds, None if dry_run else objects.delete)
|
||||
if outcome is None:
|
||||
busy += len(keys) # идёт загрузка или переход состояния: в следующий раз
|
||||
continue
|
||||
for _key, reason in outcome["delete"]:
|
||||
counts[reason] += 1
|
||||
for _key, why in outcome["keep"]:
|
||||
kept[why] += 1 # снимок говорил «лишний», а текущее состояние — «нужен»
|
||||
if not dry_run:
|
||||
deleted += len(outcome["delete"])
|
||||
in_bucket = {key for key, _ in listed}
|
||||
missing = len(refs["ready_originals"] - in_bucket) if attachment_id is None else 0
|
||||
if missing:
|
||||
log.error("В БД есть %d готовых вложений без оригинала в S3 (нужна ручная проверка)", missing)
|
||||
outbox_deleted = 0 if dry_run else store.delete_old_outbox(config.OUTBOX_RETENTION_SECONDS)
|
||||
by_prefix = {}
|
||||
for key, _ in listed:
|
||||
prefix = key.split("/", 1)[0] + "/"
|
||||
by_prefix[prefix] = by_prefix.get(prefix, 0) + 1
|
||||
return {"dry_run": dry_run, "grace_seconds": grace_seconds, "retention_seconds": retention_seconds,
|
||||
"to_delete": counts, "deleted": deleted, "kept_after_recheck": dict(kept), "skipped_busy": busy,
|
||||
"missing_ready_originals": missing, "objects_in_bucket": len(listed), "by_prefix": by_prefix,
|
||||
"outbox_rows_deleted": outbox_deleted, "seconds": round(time.monotonic() - started, 3)}
|
||||
|
||||
|
||||
def main(argv=None) -> int:
|
||||
parser = argparse.ArgumentParser(description="Уборка объектов S3 и сверка с БД")
|
||||
parser.add_argument("--dry-run", action="store_true", help="только посчитать, ничего не удалять")
|
||||
parser.add_argument("--grace-seconds", type=int, default=config.ATTACHMENT_GRACE_SECONDS)
|
||||
parser.add_argument("--retention-seconds", type=int, default=config.STAGING_RETENTION_SECONDS)
|
||||
parser.add_argument("--attachment", type=uuid.UUID, help="только объекты одного вложения")
|
||||
args = parser.parse_args(argv)
|
||||
logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(name)s: %(message)s")
|
||||
config.validate()
|
||||
config.validate_s3()
|
||||
from . import db
|
||||
pool = db.create_pool(application_name="messenger-cleanup", max_size=2)
|
||||
pool.open()
|
||||
try:
|
||||
print(json.dumps(run_once(PostgresStore(pool), args.grace_seconds, args.retention_seconds, args.dry_run,
|
||||
str(args.attachment) if args.attachment else None)))
|
||||
except AppError as exc:
|
||||
print(json.dumps({"error": exc.message}, ensure_ascii=False))
|
||||
return 1
|
||||
finally:
|
||||
pool.close()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,217 @@
|
||||
"""Настройки из переменных окружения.
|
||||
|
||||
Конфигурация не зашита в код и в образ: один и тот же образ запускается
|
||||
с разными настройками (API, worker, API с коротким TTL сессии, сервис миграций).
|
||||
Секреты (адреса БД и Valkey с паролями) передаются не значением переменной,
|
||||
а путём к файлу: *_FILE=/run/secrets/... Так пароль не виден в `docker inspect`.
|
||||
"""
|
||||
import os
|
||||
import socket
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def _int(name: str, default: int, minimum: int = 1) -> int:
|
||||
value = int(os.environ.get(name, str(default)))
|
||||
if value < minimum:
|
||||
raise ValueError(f"{name} должен быть не меньше {minimum}")
|
||||
return value
|
||||
|
||||
|
||||
def _float(name: str, default: float, minimum: float = 0.0) -> float:
|
||||
value = float(os.environ.get(name, str(default)))
|
||||
if value < minimum:
|
||||
raise ValueError(f"{name} должен быть не меньше {minimum}")
|
||||
return value
|
||||
|
||||
|
||||
def _secret(file_var: str, plain_var: str) -> str:
|
||||
"""Значение секрета: из файла, указанного в *_FILE, иначе из обычной переменной.
|
||||
|
||||
strip() убирает перевод строки в конце файла, в том числе \\r из Windows-редакторов:
|
||||
иначе он попал бы внутрь пароля и подключение к БД не прошло бы.
|
||||
"""
|
||||
path = os.environ.get(file_var, "").strip()
|
||||
if path:
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
return os.environ.get(plain_var, "").strip()
|
||||
|
||||
|
||||
APP_HOST = os.environ.get("APP_HOST", "0.0.0.0") # 0.0.0.0 = слушать на всех интерфейсах контейнера
|
||||
APP_PORT = _int("APP_PORT", 8080)
|
||||
APP_ENV = os.environ.get("APP_ENV", "lab")
|
||||
# Версия сборки (build arg APP_VERSION в Dockerfile). Пишется в лог при старте;
|
||||
# по ней student-tests/rolling_update.py проверяет, что все реплики заменены новой версией.
|
||||
APP_VERSION = os.environ.get("APP_VERSION", "dev")
|
||||
|
||||
# --- реплики (с lab3) ---
|
||||
# X-Instance-Id: какая реплика обслужила запрос. В Docker hostname контейнера — это первые
|
||||
# 12 символов его ID, поэтому по заголовку контейнер сразу находится в `docker ps`.
|
||||
# Значение не меняется, пока жив процесс. В lab7 его нужно заменить случайным alias.
|
||||
INSTANCE_ID = os.environ.get("INSTANCE_ID", "").strip() or socket.gethostname()
|
||||
|
||||
# Остановка по SIGTERM в два шага (см. __main__.py):
|
||||
# 1) SHUTDOWN_DRAIN_SECONDS: /health/ready уже отвечает 503, но запросы ещё обслуживаются.
|
||||
# HAProxy проверяет готовность раз в 1 с и после 2 неудач подряд (через ~1,5 с)
|
||||
# перестаёт слать сюда запросы. 3 с — с запасом;
|
||||
# 2) GRACEFUL_SHUTDOWN_SECONDS: uvicorn закрывает приём и доделывает начатые запросы.
|
||||
# Самый долгий запрос: ожидание соединения из пула (3 с) + statement_timeout (5 с) = 8 с.
|
||||
# Docker ждёт дольше суммы (stop_grace_period: 15s в compose.yaml), потом SIGKILL.
|
||||
SHUTDOWN_DRAIN_SECONDS = _int("SHUTDOWN_DRAIN_SECONDS", 3, minimum=0)
|
||||
GRACEFUL_SHUTDOWN_SECONDS = _int("GRACEFUL_SHUTDOWN_SECONDS", 8)
|
||||
|
||||
# --- сессии ---
|
||||
SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600)
|
||||
# Источник истины для сессий. Поддерживается только postgres: Valkey в этой работе — кэш.
|
||||
SESSION_STORE = os.environ.get("SESSION_STORE", "postgres").strip()
|
||||
# Сколько секунд запись о сессии может жить в кэше (не дольше самой сессии).
|
||||
# Это верхняя граница «устаревания»: см. sessions.py и REPORT.md.
|
||||
SESSION_CACHE_TTL_SECONDS = _int("SESSION_CACHE_TTL_SECONDS", 30)
|
||||
|
||||
# --- PostgreSQL ---
|
||||
DATABASE_URL = _secret("DATABASE_URL_FILE", "DATABASE_URL")
|
||||
DB_POOL_MIN_SIZE = _int("DB_POOL_MIN_SIZE", 1)
|
||||
DB_POOL_MAX_SIZE = _int("DB_POOL_MAX_SIZE", 10) # пул ограничен: не больше 10 соединений с БД
|
||||
DB_POOL_TIMEOUT_SECONDS = _int("DB_POOL_TIMEOUT_SECONDS", 3) # ждать свободное соединение не дольше
|
||||
DB_CONNECT_TIMEOUT_SECONDS = _int("DB_CONNECT_TIMEOUT_SECONDS", 3)
|
||||
DB_STATEMENT_TIMEOUT_MS = _int("DB_STATEMENT_TIMEOUT_MS", 5000) # один SQL-запрос не дольше 5 с
|
||||
DB_STARTUP_WAIT_SECONDS = _int("DB_STARTUP_WAIT_SECONDS", 60) # сколько ждать БД и миграции при старте
|
||||
|
||||
# --- Valkey (кэш сессий, общий для всех реплик) ---
|
||||
CACHE_URL = _secret("CACHE_URL_FILE", "CACHE_URL") # пусто = работать без кэша
|
||||
CACHE_TIMEOUT_MS = _int("CACHE_TIMEOUT_MS", 300) # кэш должен отвечать быстро, иначе обходим его
|
||||
CACHE_POOL_MAX_SIZE = _int("CACHE_POOL_MAX_SIZE", 20)
|
||||
# Как часто фоновый поток каждой реплики проверяет Valkey (PING). Так реплика замечает сбой
|
||||
# Valkey, даже если в этот момент через неё не шли запросы (см. sessions.py).
|
||||
CACHE_CHECK_INTERVAL_SECONDS = _int("CACHE_CHECK_INTERVAL_SECONDS", 1)
|
||||
|
||||
# IDEMPOTENCY_TTL_SECONDS из .env.example не используется: ключ идемпотентности хранится
|
||||
# в строке сообщения столько же, сколько само сообщение (бессрочно, то есть дольше 24 ч
|
||||
# из контракта). См. migrations/004_message_idempotency.sql и REPORT.md.
|
||||
|
||||
# --- S3 (с lab4): байты вложений в приватном bucket SeaweedFS, метаданные — в PostgreSQL ---
|
||||
S3_ENDPOINT = os.environ.get("S3_ENDPOINT", "http://s3:9000").strip()
|
||||
S3_REGION = os.environ.get("S3_REGION", "us-east-1").strip()
|
||||
S3_BUCKET = os.environ.get("S3_BUCKET", "messenger-attachments").strip()
|
||||
# Отдельный пользователь S3 только для API: права лишь на объекты своего bucket
|
||||
# (secrets/s3_config.json). Ключи администратора S3 сюда не передаются.
|
||||
S3_ACCESS_KEY_ID = _secret("S3_ACCESS_KEY_ID_FILE", "S3_ACCESS_KEY_ID")
|
||||
S3_SECRET_ACCESS_KEY = _secret("S3_SECRET_ACCESS_KEY_FILE", "S3_SECRET_ACCESS_KEY")
|
||||
# Таймауты S3: недоступный S3 даёт быстрый 503, а не зависший запрос.
|
||||
# Ответ на запрос клиента всё равно не дольше S3_OPERATION_TIMEOUT_SECONDS (6 с), см. ниже.
|
||||
S3_CONNECT_TIMEOUT_SECONDS = _int("S3_CONNECT_TIMEOUT_SECONDS", 2)
|
||||
S3_READ_TIMEOUT_SECONDS = _int("S3_READ_TIMEOUT_SECONDS", 5)
|
||||
S3_MAX_ATTEMPTS = _int("S3_MAX_ATTEMPTS", 2) # 1 попытка + 1 повтор при сетевой ошибке
|
||||
# Общий предел на одну операцию S3 (включая поиск имени в DNS, который таймауты выше не покрывают).
|
||||
S3_OPERATION_TIMEOUT_SECONDS = _int("S3_OPERATION_TIMEOUT_SECONDS", 6)
|
||||
|
||||
# Readiness с lab5 зависит и от S3: без него нельзя принять файл в staging (обязательный путь).
|
||||
# Фоновый поток реплики проверяет bucket раз в S3_HEALTH_INTERVAL_SECONDS; если успешной проверки
|
||||
# не было дольше S3_HEALTH_MAX_AGE_SECONDS, /health/ready отвечает 503.
|
||||
S3_HEALTH_INTERVAL_SECONDS = _float("S3_HEALTH_INTERVAL_SECONDS", 1.0, minimum=0.2)
|
||||
S3_HEALTH_MAX_AGE_SECONDS = _float("S3_HEALTH_MAX_AGE_SECONDS", 3.0, minimum=1.0)
|
||||
|
||||
# --- приём картинок (API) ---
|
||||
MAX_UPLOAD_BYTES = _int("MAX_UPLOAD_BYTES", 10 * 1024 * 1024) # 10 MiB = 10 485 760 байт (контракт)
|
||||
MAX_IMAGE_PIXELS = _int("MAX_IMAGE_PIXELS", 40_000_000) # 40 млн пикселей (контракт)
|
||||
# Тело читается кусками; в памяти держится не больше UPLOAD_SPOOL_BYTES на загрузку,
|
||||
# остальное — во временном файле, который удаляется сразу после запроса (это буфер, а не хранилище).
|
||||
UPLOAD_SPOOL_BYTES = _int("UPLOAD_SPOOL_BYTES", 1024 * 1024)
|
||||
# Если клиент передаёт файл дольше этого, загрузка прерывается (400): медленный клиент
|
||||
# не держит память и соединение бесконечно.
|
||||
UPLOAD_TIMEOUT_SECONDS = _int("UPLOAD_TIMEOUT_SECONDS", 60)
|
||||
# С lab5 API картинку НЕ декодирует (это работа worker), а только проверяет структуру файла
|
||||
# потоком: блоки PNG и их CRC, сжатые данные IDAT, маркеры JPEG. Памяти почти не нужно,
|
||||
# но это работа процессора, поэтому одновременных проверок на реплику не больше этого числа.
|
||||
IMAGE_CHECK_CONCURRENCY = _int("IMAGE_CHECK_CONCURRENCY", 2)
|
||||
IMAGE_CHECK_WAIT_SECONDS = _int("IMAGE_CHECK_WAIT_SECONDS", 10) # дольше ждать очередь — 503
|
||||
|
||||
# --- брокер, outbox и worker (с lab5) ---
|
||||
# amqp://user:password@broker:5672/vhost — секрет, поэтому из файла (BROKER_URL_FILE).
|
||||
BROKER_URL = _secret("BROKER_URL_FILE", "BROKER_URL")
|
||||
# Версия pipeline: часть ключа эффекта (attachment_id, pipeline_version, variant). В курсе одна — 1.
|
||||
PIPELINE_VERSION = 1
|
||||
# Relay (в каждой реплике API) отправляет строки outbox в брокер: сразу после загрузки
|
||||
# (сигнал из того же процесса) и раз в RELAY_POLL_SECONDS — строки других процессов и отложенные повторы.
|
||||
RELAY_POLL_SECONDS = _float("RELAY_POLL_SECONDS", 1.0, minimum=0.1)
|
||||
RELAY_BATCH_SIZE = _int("RELAY_BATCH_SIZE", 50)
|
||||
# Worker: сколько заданий одновременно (= prefetch брокера: больше неподтверждённых сообщений
|
||||
# worker не получает). Каждое задание — отдельный дочерний процесс с лимитами (sandbox.py).
|
||||
WORKER_CONCURRENCY = _int("WORKER_CONCURRENCY", 2)
|
||||
# Лимит времени одной попытки: дочерний процесс, не уложившийся в него, убивается (SIGKILL).
|
||||
JOB_TIMEOUT_SECONDS = _int("JOB_TIMEOUT_SECONDS", 60)
|
||||
# Лимит памяти одной попытки: адресное пространство дочернего процесса (RLIMIT_AS).
|
||||
# Самая тяжёлая допустимая картинка (PNG RGBA 40 Мп) требует ~480 МиБ, см. REPORT.md.
|
||||
WORKER_MEMORY_LIMIT_MB = _int("WORKER_MEMORY_LIMIT_MB", 640, minimum=64)
|
||||
# Ограниченный повтор: всего попыток (первая + повторы). Потом — failed с retry_exhausted.
|
||||
JOB_MAX_ATTEMPTS = _int("JOB_MAX_ATTEMPTS", 5)
|
||||
# Backoff с jitter: пауза перед попыткой n+1 — случайная в [d/2, d], d = min(MAX, BASE * 2^(n-1)).
|
||||
RETRY_BASE_SECONDS = _float("RETRY_BASE_SECONDS", 2.0, minimum=0.1)
|
||||
RETRY_MAX_SECONDS = _float("RETRY_MAX_SECONDS", 60.0, minimum=0.1)
|
||||
# Lease: worker «арендует» задание на JOB_LEASE_SECONDS и продлевает аренду каждые
|
||||
# JOB_HEARTBEAT_SECONDS, пока работает. Долгая задача продлевает аренду, зависший или мёртвый
|
||||
# worker — нет: аренда истекает, и задание возвращается в очередь (новая попытка).
|
||||
JOB_LEASE_SECONDS = _int("JOB_LEASE_SECONDS", 30, minimum=3)
|
||||
JOB_HEARTBEAT_SECONDS = _float("JOB_HEARTBEAT_SECONDS", 10.0, minimum=0.5)
|
||||
# Как часто worker ищет задания с истёкшей арендой.
|
||||
REAPER_INTERVAL_SECONDS = _float("REAPER_INTERVAL_SECONDS", 5.0, minimum=0.5)
|
||||
# Страховка от потерянного сообщения: задание в queued дольше этого без свежей отправки
|
||||
# отправляется ещё раз (дубль безопасен: обработка идемпотентна).
|
||||
QUEUED_REPUBLISH_SECONDS = _int("QUEUED_REPUBLISH_SECONDS", 600, minimum=10)
|
||||
# Качество вариантов (размеры 256 / 128 / 1280 заданы контрактом и не настраиваются).
|
||||
JPEG_QUALITY = _int("JPEG_QUALITY", 85)
|
||||
WEBP_QUALITY = _int("WEBP_QUALITY", 80)
|
||||
WEBP_METHOD = _int("WEBP_METHOD", 4, minimum=0) # 0 — быстро, 6 — медленно и чуть меньше файл
|
||||
|
||||
# --- уборка объектов S3 (cleanup.py, фоновый поток worker) ---
|
||||
# Grace period: объект, на который не ссылается БД, удаляется, только если ему больше 15 минут.
|
||||
# Это намного дольше самой долгой загрузки и самой долгой попытки обработки, поэтому
|
||||
# идущую прямо сейчас работу уборщик не заденет.
|
||||
ATTACHMENT_GRACE_SECONDS = _int("ATTACHMENT_GRACE_SECONDS", 900)
|
||||
CLEANUP_INTERVAL_SECONDS = _int("CLEANUP_INTERVAL_SECONDS", 300)
|
||||
# Staging-оригинал failed-вложения хранится столько, чтобы оператор успел сделать replay.
|
||||
STAGING_RETENTION_SECONDS = _int("STAGING_RETENTION_SECONDS", 86400)
|
||||
# Отправленные строки outbox и журнал заданий хранятся неделю (для расследований), потом удаляются.
|
||||
OUTBOX_RETENTION_SECONDS = _int("OUTBOX_RETENTION_SECONDS", 7 * 86400)
|
||||
|
||||
|
||||
def _migrations_dir() -> Path:
|
||||
"""Каталог SQL-миграций: в образе /srv/migrations, в репозитории ./migrations."""
|
||||
explicit = os.environ.get("MIGRATIONS_DIR")
|
||||
if explicit:
|
||||
return Path(explicit)
|
||||
here = Path(__file__).resolve()
|
||||
for candidate in (here.parents[1] / "migrations", here.parents[2] / "migrations"):
|
||||
if candidate.is_dir():
|
||||
return candidate
|
||||
return here.parents[1] / "migrations"
|
||||
|
||||
|
||||
MIGRATIONS_DIR = _migrations_dir()
|
||||
|
||||
|
||||
def validate() -> None:
|
||||
"""Проверка при старте: лучше упасть сразу с понятной ошибкой, чем на первом запросе."""
|
||||
if not DATABASE_URL:
|
||||
raise RuntimeError("Не задан адрес PostgreSQL: DATABASE_URL_FILE (или DATABASE_URL)")
|
||||
if SESSION_STORE != "postgres":
|
||||
raise RuntimeError("SESSION_STORE поддерживает только значение postgres (Valkey здесь — кэш)")
|
||||
if DB_POOL_MIN_SIZE > DB_POOL_MAX_SIZE:
|
||||
raise RuntimeError("DB_POOL_MIN_SIZE больше DB_POOL_MAX_SIZE")
|
||||
|
||||
|
||||
def validate_s3() -> None:
|
||||
"""Для API и worker (не для migrate): без ключей S3 вложения работать не смогут."""
|
||||
if not (S3_ENDPOINT and S3_BUCKET and S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY):
|
||||
raise RuntimeError("Не заданы S3_ENDPOINT, S3_BUCKET или ключи S3 (S3_*_FILE)")
|
||||
if ATTACHMENT_GRACE_SECONDS < max(UPLOAD_TIMEOUT_SECONDS, JOB_TIMEOUT_SECONDS) + 60:
|
||||
raise RuntimeError("ATTACHMENT_GRACE_SECONDS должен быть заметно больше времени загрузки и обработки")
|
||||
|
||||
|
||||
def validate_broker() -> None:
|
||||
"""Для API (relay) и worker: адрес брокера и согласованность сроков."""
|
||||
if not BROKER_URL:
|
||||
raise RuntimeError("Не задан адрес брокера: BROKER_URL_FILE (или BROKER_URL)")
|
||||
if JOB_HEARTBEAT_SECONDS * 2 >= JOB_LEASE_SECONDS:
|
||||
raise RuntimeError("JOB_HEARTBEAT_SECONDS должен быть меньше половины JOB_LEASE_SECONDS")
|
||||
if RETRY_BASE_SECONDS > RETRY_MAX_SECONDS:
|
||||
raise RuntimeError("RETRY_BASE_SECONDS больше RETRY_MAX_SECONDS")
|
||||
@@ -0,0 +1,44 @@
|
||||
"""Непрозрачный курсор пагинации.
|
||||
|
||||
Внутри курсора: «область» (какой именно список листаем) и ключ последнего
|
||||
элемента страницы (created_at, id). Всё это упаковано в base64, клиент курсор
|
||||
не разбирает, а просто передаёт обратно. Сервер проверяет, что курсор выдан
|
||||
для того же списка: курсор от другого чата даёт 400.
|
||||
|
||||
С lab2 ключ уходит в SQL-запрос, поэтому перед этим он проверяется:
|
||||
испорченное время или UUID должны дать 400, а не ошибку базы данных (500).
|
||||
"""
|
||||
import base64
|
||||
import json
|
||||
import uuid
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from .errors import InvalidRequest
|
||||
|
||||
|
||||
def encode_cursor(scope: str, key: tuple[str, str]) -> str:
|
||||
raw = json.dumps([scope, *key]).encode()
|
||||
return base64.urlsafe_b64encode(raw).decode()
|
||||
|
||||
|
||||
def decode_cursor(scope: str, cursor: str | None) -> tuple[datetime, uuid.UUID] | None:
|
||||
if cursor is None:
|
||||
return None
|
||||
try:
|
||||
data = json.loads(base64.urlsafe_b64decode(cursor.encode("ascii")))
|
||||
except (ValueError, RecursionError): # не ASCII, не base64, не JSON или слишком глубокая вложенность
|
||||
raise InvalidRequest("Неверный cursor") from None
|
||||
well_formed = isinstance(data, list) and len(data) == 3 and all(isinstance(x, str) for x in data)
|
||||
if not well_formed or data[0] != scope:
|
||||
raise InvalidRequest("Неверный cursor")
|
||||
try:
|
||||
created_at = datetime.fromisoformat(data[1].replace("Z", "+00:00"))
|
||||
item_id = uuid.UUID(data[2])
|
||||
if created_at.tzinfo is None:
|
||||
raise ValueError("время без часового пояса")
|
||||
# Перевод в UTC может выйти за пределы годов 1–9999 (например, 0001-01-01T00:00+14:00):
|
||||
# Python бросает OverflowError. Это тоже испорченный курсор -> 400, а не 500.
|
||||
created_at = created_at.astimezone(timezone.utc)
|
||||
except (ValueError, OverflowError):
|
||||
raise InvalidRequest("Неверный cursor") from None
|
||||
return created_at, item_id
|
||||
@@ -0,0 +1,148 @@
|
||||
"""Подключение к PostgreSQL: пул соединений, таймауты и миграции.
|
||||
|
||||
Пул — это набор заранее открытых соединений. Запрос берёт соединение из пула,
|
||||
выполняет SQL и возвращает его обратно. Пул ограничен (DB_POOL_MAX_SIZE), поэтому
|
||||
даже под нагрузкой API не откроет к базе больше соединений, чем она выдержит.
|
||||
|
||||
С lab3 миграции применяет ТОЛЬКО отдельный одноразовый сервис migrate
|
||||
(`python -m messenger.migrate`, см. compose.yaml). Реплики API при старте лишь ждут,
|
||||
пока схема станет актуальной (wait_for_schema), и сами ничего не меняют.
|
||||
Так нет гонки «две реплики одновременно меняют схему».
|
||||
"""
|
||||
import logging
|
||||
import time
|
||||
|
||||
import psycopg
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
from . import config
|
||||
|
||||
log = logging.getLogger("messenger.db")
|
||||
|
||||
# Произвольное постоянное число: «номер замка» для миграций (pg_advisory_lock).
|
||||
# Если миграции всё-таки запустят дважды одновременно (например, два `docker compose run migrate`),
|
||||
# выполнит их только один процесс, второй подождёт и увидит, что всё уже применено.
|
||||
MIGRATION_LOCK_ID = 2026_0002
|
||||
|
||||
|
||||
def connection_kwargs(application_name: str = "messenger-api") -> dict:
|
||||
return {
|
||||
"connect_timeout": config.DB_CONNECT_TIMEOUT_SECONDS,
|
||||
"application_name": application_name,
|
||||
# Таймауты на стороне сервера: зависший запрос или забытая транзакция
|
||||
# не будут держать соединение и блокировки бесконечно.
|
||||
"options": (f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT_MS}"
|
||||
" -c idle_in_transaction_session_timeout=10000"),
|
||||
}
|
||||
|
||||
|
||||
def create_pool(application_name: str = "messenger-api", max_size: int | None = None) -> ConnectionPool:
|
||||
return ConnectionPool(
|
||||
conninfo=config.DATABASE_URL,
|
||||
kwargs=connection_kwargs(application_name),
|
||||
min_size=min(config.DB_POOL_MIN_SIZE, max_size or config.DB_POOL_MAX_SIZE),
|
||||
max_size=max_size or config.DB_POOL_MAX_SIZE,
|
||||
timeout=config.DB_POOL_TIMEOUT_SECONDS, # сколько ждать свободное соединение из пула
|
||||
# Перед выдачей соединение проверяется: после рестарта PostgreSQL старые
|
||||
# соединения «мертвы», и пул заменит их, а не отдаст запросу.
|
||||
check=ConnectionPool.check_connection,
|
||||
open=False,
|
||||
name="messenger",
|
||||
)
|
||||
|
||||
|
||||
def migration_files() -> list:
|
||||
"""Файлы migrations/NNN_*.sql этой версии приложения, по порядку."""
|
||||
files = sorted(config.MIGRATIONS_DIR.glob("*.sql"))
|
||||
if not files:
|
||||
raise RuntimeError(f"Нет файлов миграций в {config.MIGRATIONS_DIR}")
|
||||
return files
|
||||
|
||||
|
||||
def _connect(application_name: str):
|
||||
return psycopg.connect(config.DATABASE_URL, autocommit=True,
|
||||
connect_timeout=config.DB_CONNECT_TIMEOUT_SECONDS,
|
||||
application_name=application_name)
|
||||
|
||||
|
||||
def migrate() -> list[str]:
|
||||
"""Применяет новые файлы migrations/NNN_*.sql по порядку. Возвращает список применённых.
|
||||
|
||||
Каждая миграция и запись о ней выполняются в одной транзакции: либо файл применён
|
||||
полностью и отмечен, либо ничего не изменилось. Повторный запуск ничего не дублирует.
|
||||
"""
|
||||
files = migration_files()
|
||||
applied_now = []
|
||||
# Отдельное соединение без statement_timeout: создание индекса на большой таблице может быть долгим.
|
||||
with _connect("messenger-migrate") as conn:
|
||||
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK_ID,))
|
||||
try:
|
||||
conn.execute("""
|
||||
CREATE TABLE IF NOT EXISTS schema_migrations (
|
||||
version text PRIMARY KEY,
|
||||
applied_at timestamptz NOT NULL DEFAULT now()
|
||||
)""")
|
||||
done = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
|
||||
for path in files:
|
||||
if path.stem in done:
|
||||
continue
|
||||
with conn.transaction():
|
||||
# Без параметров psycopg разрешает несколько SQL-команд в одном вызове.
|
||||
conn.execute(path.read_text(encoding="utf-8"))
|
||||
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.stem,))
|
||||
applied_now.append(path.stem)
|
||||
finally:
|
||||
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK_ID,))
|
||||
return applied_now
|
||||
|
||||
|
||||
def migrate_with_retry() -> None:
|
||||
"""Для сервиса migrate: БД может подниматься дольше — ждём её, а не падаем сразу."""
|
||||
deadline = time.monotonic() + config.DB_STARTUP_WAIT_SECONDS
|
||||
while True:
|
||||
try:
|
||||
applied = migrate()
|
||||
if applied:
|
||||
log.info("Миграции применены: %s", ", ".join(applied))
|
||||
else:
|
||||
log.info("Миграции: новых нет, схема актуальна")
|
||||
return
|
||||
except psycopg.OperationalError as exc:
|
||||
if time.monotonic() > deadline:
|
||||
raise
|
||||
log.warning("PostgreSQL пока недоступен (%s), повтор через 1 с", type(exc).__name__)
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def pending_migrations() -> list[str]:
|
||||
"""Какие миграции этой версии ещё не применены (только чтение, схему не меняет)."""
|
||||
expected = [path.stem for path in migration_files()]
|
||||
with _connect("messenger-api-schema-check") as conn:
|
||||
try:
|
||||
done = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
|
||||
except psycopg.errors.UndefinedTable:
|
||||
done = set() # миграции ещё ни разу не запускались
|
||||
return [version for version in expected if version not in done]
|
||||
|
||||
|
||||
def wait_for_schema() -> None:
|
||||
"""Для реплики API: дождаться, пока сервис migrate применит все миграции этой версии.
|
||||
|
||||
Реплика схему не меняет. Если за DB_STARTUP_WAIT_SECONDS схема так и не стала
|
||||
актуальной, процесс завершается с ошибкой: лучше не стартовать, чем работать
|
||||
со схемой, которой код не понимает.
|
||||
"""
|
||||
deadline = time.monotonic() + config.DB_STARTUP_WAIT_SECONDS
|
||||
while True:
|
||||
try:
|
||||
pending = pending_migrations()
|
||||
if not pending:
|
||||
log.info("Схема БД актуальна (миграции применены сервисом migrate)")
|
||||
return
|
||||
reason = "не применены миграции " + ", ".join(pending)
|
||||
except psycopg.OperationalError as exc:
|
||||
reason = f"PostgreSQL недоступен ({type(exc).__name__})"
|
||||
if time.monotonic() > deadline:
|
||||
raise RuntimeError(f"Схема БД не готова: {reason}. Запустите сервис migrate")
|
||||
log.warning("Жду схему БД: %s; повтор через 1 с", reason)
|
||||
time.sleep(1)
|
||||
@@ -0,0 +1,53 @@
|
||||
"""Ошибки приложения.
|
||||
|
||||
Каждый класс знает свой HTTP-статус и код из контракта, поэтому в api.py
|
||||
достаточно одного обработчика, который превращает любую из них в JSON-ответ.
|
||||
"""
|
||||
|
||||
|
||||
class AppError(Exception):
|
||||
status = 500
|
||||
code = "internal_error"
|
||||
|
||||
def __init__(self, message: str, headers: dict[str, str] | None = None):
|
||||
super().__init__(message)
|
||||
self.message = message
|
||||
self.headers = headers or {}
|
||||
|
||||
|
||||
class InvalidRequest(AppError):
|
||||
status, code = 400, "invalid_request"
|
||||
|
||||
|
||||
class Unauthorized(AppError):
|
||||
"""401. Контракт требует заголовок WWW-Authenticate: какую схему ждёт сервер."""
|
||||
status, code = 401, "unauthorized"
|
||||
|
||||
BASIC = 'Basic realm="messenger", charset="UTF-8"' # только для POST /auth/sessions
|
||||
BEARER = 'Bearer realm="messenger"' # для всех остальных защищённых запросов
|
||||
|
||||
def __init__(self, message: str, challenge: str = BEARER):
|
||||
super().__init__(message, {"WWW-Authenticate": challenge})
|
||||
|
||||
|
||||
class NotFound(AppError):
|
||||
status, code = 404, "not_found"
|
||||
|
||||
|
||||
class Conflict(AppError):
|
||||
status, code = 409, "conflict"
|
||||
|
||||
|
||||
class PayloadTooLarge(AppError):
|
||||
"""413: файл больше MAX_UPLOAD_BYTES или картинка больше MAX_IMAGE_PIXELS (с lab4)."""
|
||||
status, code = 413, "payload_too_large"
|
||||
|
||||
|
||||
class UnsupportedMediaType(AppError):
|
||||
"""415: не PNG/JPEG, повреждённый файл или Content-Type не совпадает с содержимым (с lab4)."""
|
||||
status, code = 415, "unsupported_media_type"
|
||||
|
||||
|
||||
class Unavailable(AppError):
|
||||
"""503: нужная зависимость (PostgreSQL) недоступна. Клиент может повторить позже."""
|
||||
status, code = 503, "unavailable"
|
||||
@@ -0,0 +1,94 @@
|
||||
"""Внедрение отказов для проверок lab5 (только на учебном стенде, FAULTS_ENABLED=1).
|
||||
|
||||
Окна отказа из contracts/attachment-states.md нужно не описать, а воспроизвести: процесс должен
|
||||
упасть ровно в нужном месте. Для этого в коде расставлены «точки отказа» hit("имя"). Точка
|
||||
срабатывает, только если:
|
||||
1. переменная FAULTS_ENABLED=1 (в .env учебного стенда, см. .env.example; в рабочей среде её нет — точки молчат);
|
||||
2. внутри контейнера есть файл /tmp/faults/<имя>. Тест создаёт его через `docker exec`.
|
||||
|
||||
Срабатывание одноразовое: файл удаляется ДО падения, поэтому перезапущенный процесс
|
||||
работает уже нормально. Падение — os._exit(137): мгновенно, без finally, без закрытия соединений
|
||||
и без ack — так же, как при SIGKILL или OOM killer.
|
||||
|
||||
Точки:
|
||||
- api_after_commit API: вложение, задание и outbox закоммичены, ответ 202 не отправлен;
|
||||
- relay_before_publish relay: строки outbox взяты, в брокер ещё ничего не отправлено;
|
||||
- relay_after_publish relay: брокер подтвердил приём, но строки ещё не отмечены отправленными;
|
||||
- worker_after_objects worker: оригинал и варианты записаны в S3, COMMIT результата и ack не было;
|
||||
- worker_after_commit worker: результат закоммичен, ack не отправлен.
|
||||
Ещё два файла не роняют процесс, а меняют поведение (содержимое файла — число):
|
||||
- worker_slow каждая обработка дополнительно «работает» N секунд (долгая задача);
|
||||
- worker_transient следующие N попыток завершаются временной ошибкой (как недоступный S3).
|
||||
Точки-паузы (замечание к MR про уборщика): процесс один раз ждёт N секунд в опасном месте, чтобы
|
||||
тест закрепил порядок событий («барьер») и вклинился в окно между двумя шагами:
|
||||
- cleanup_pause уборщик прочитал ссылки из БД, но ещё ничего не удалял;
|
||||
- cleanup_pause_locked уборщик под блокировкой вложения решил удалить и пометил staging удалённым,
|
||||
COMMIT ещё не сделан (replay в это время ждёт блокировку);
|
||||
- api_pause_after_staging API записал файл в staging, строки вложения в БД ещё нет;
|
||||
- worker_pause_after_objects worker записал оригинал и варианты в S3, COMMIT результата ещё нет.
|
||||
"""
|
||||
import logging
|
||||
import os
|
||||
import time
|
||||
|
||||
log = logging.getLogger("messenger.faults")
|
||||
|
||||
ENABLED = os.environ.get("FAULTS_ENABLED", "").strip() == "1"
|
||||
DIRECTORY = os.environ.get("FAULTS_DIR", "/tmp/faults")
|
||||
|
||||
|
||||
def _path(name: str) -> str:
|
||||
return os.path.join(DIRECTORY, name)
|
||||
|
||||
|
||||
def hit(name: str) -> None:
|
||||
"""Если точка включена — удалить её файл и мгновенно завершить процесс."""
|
||||
if not ENABLED:
|
||||
return
|
||||
path = _path(name)
|
||||
try:
|
||||
os.remove(path)
|
||||
except FileNotFoundError:
|
||||
return
|
||||
log.warning("FAULT %s: процесс завершается без ack/ответа (внедрённый отказ)", name)
|
||||
for handler in logging.getLogger().handlers:
|
||||
handler.flush()
|
||||
os._exit(137)
|
||||
|
||||
|
||||
def number(name: str) -> float:
|
||||
"""Число из файла точки (worker_slow, worker_transient) или 0, если точка выключена."""
|
||||
if not ENABLED:
|
||||
return 0
|
||||
try:
|
||||
with open(_path(name), encoding="ascii") as f:
|
||||
return float(f.read().strip() or 0)
|
||||
except (FileNotFoundError, ValueError):
|
||||
return 0
|
||||
|
||||
|
||||
def pause(name: str) -> None:
|
||||
"""Точка-пауза: если включена, удалить её файл (сработает один раз) и подождать N секунд."""
|
||||
seconds = number(name)
|
||||
if seconds <= 0:
|
||||
return
|
||||
try:
|
||||
os.remove(_path(name))
|
||||
except FileNotFoundError:
|
||||
return
|
||||
log.warning("FAULT %s: пауза %.1f с (внедрённая задержка для проверки гонок)", name, seconds)
|
||||
time.sleep(seconds)
|
||||
|
||||
|
||||
def consume(name: str) -> bool:
|
||||
"""Для worker_transient: уменьшить счётчик на 1. True — эта попытка должна «упасть»."""
|
||||
left = int(number(name))
|
||||
if left <= 0:
|
||||
return False
|
||||
path = _path(name)
|
||||
if left == 1:
|
||||
os.remove(path)
|
||||
else:
|
||||
with open(path, "w", encoding="ascii") as f:
|
||||
f.write(str(left - 1))
|
||||
return True
|
||||
@@ -0,0 +1,641 @@
|
||||
"""Проверка загружаемой картинки в API: имя файла, тип по содержимому, размер в пикселях, структура.
|
||||
|
||||
С lab5 API картинку не декодирует и не уменьшает: это тяжёлая работа, её делает worker
|
||||
(imaging.py) в отдельном процессе с лимитами. Но «заведомо повреждённые и чужие» файлы
|
||||
(contracts/README.md) отклоняются сразу, кодом 415, дешёвыми проверками без пиксельного буфера:
|
||||
|
||||
1. имя файла и заявленный Content-Type — до чтения тела (api.py);
|
||||
2. размер в байтах — пока тело читается кусками (attachments.py);
|
||||
3. тип по первым байтам («магическим числам»): PNG начинается с \\x89PNG, JPEG — с FF D8 FF;
|
||||
Content-Type клиента обязан совпасть с настоящим типом, иначе 415 (подмена MIME);
|
||||
4. ширина и высота — из заголовка, ДО распаковки пикселей: «бомба» (маленький файл
|
||||
на 50 млн пикселей) отклоняется с 413, не заняв память;
|
||||
5. структура файла, потоком, без пиксельного буфера:
|
||||
- PNG: порядок и размеры обязательных блоков (IHDR, PLTE, IDAT, IEND), контрольная сумма
|
||||
CRC каждого блока, допустимые сочетания глубины и типа цвета, размер палитры и tRNS,
|
||||
ничего после IEND. Сжатые данные IDAT распаковываются порциями по 1 МиБ и только
|
||||
считаются: распакованных байт должно быть ровно столько, сколько требуют ширина,
|
||||
высота и формат пикселя (иначе файл обрезан или испорчен), а первый байт каждой строки —
|
||||
допустимый тип фильтра 0–4 (Pillow неверный тип молча пропускает);
|
||||
- JPEG: всё, что строгий декодер worker проверяет по маркерам и заголовкам: маркеры и длины
|
||||
сегментов, кадр SOF, таблицы DQT/DHT, связь каждого скана SOS с компонентами кадра,
|
||||
параметры сканов, порядок и число маркеров RST, маркер конца EOI (подробно — ниже, у check_jpeg).
|
||||
Глубокую проверку (каждый пиксель, строгое декодирование сжатых данных JPEG) делает worker:
|
||||
если файл не декодируется, вложение получает failed с error_code=invalid_image.
|
||||
"""
|
||||
import struct
|
||||
import threading
|
||||
import unicodedata
|
||||
import warnings
|
||||
import zlib
|
||||
from dataclasses import dataclass
|
||||
|
||||
from PIL import Image
|
||||
|
||||
from . import config
|
||||
from .errors import InvalidRequest, PayloadTooLarge, Unavailable, UnsupportedMediaType
|
||||
|
||||
ALLOWED_TYPES = ("image/png", "image/jpeg")
|
||||
_SIGNATURES = {"image/png": b"\x89PNG\r\n\x1a\n", "image/jpeg": b"\xff\xd8\xff"}
|
||||
_PIL_FORMAT = {"image/png": "PNG", "image/jpeg": "JPEG"}
|
||||
# Символы управления направлением текста: позволяют показать «photognp.exe» как «photoexe.png».
|
||||
_BIDI_CONTROLS = set("")
|
||||
|
||||
# Pillow сам считает «бомбой» картинку больше MAX_IMAGE_PIXELS: предупреждение делаем ошибкой.
|
||||
Image.MAX_IMAGE_PIXELS = config.MAX_IMAGE_PIXELS
|
||||
warnings.simplefilter("error", Image.DecompressionBombWarning)
|
||||
|
||||
_check_slots = threading.BoundedSemaphore(config.IMAGE_CHECK_CONCURRENCY)
|
||||
_READ_BLOCK = 1024 * 1024
|
||||
|
||||
|
||||
class Broken(Exception):
|
||||
"""Структура файла нарушена (причина — короткий текст без содержимого файла)."""
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ImageInfo:
|
||||
content_type: str
|
||||
width: int
|
||||
height: int
|
||||
|
||||
|
||||
def check_filename(filename: str | None) -> str:
|
||||
"""filename — только отображаемое имя: в путь или ключ S3 он не попадает, но опасные отклоняем."""
|
||||
if filename is None:
|
||||
raise InvalidRequest("Нужен параметр filename")
|
||||
if not 1 <= len(filename) <= 255 or not filename.strip():
|
||||
raise InvalidRequest("filename: от 1 до 255 символов, не только пробелы")
|
||||
if filename in (".", ".."):
|
||||
raise InvalidRequest("filename не может быть . или ..")
|
||||
for char in filename:
|
||||
# Cc — управляющие символы (C0, DEL, C1); Zl/Zp — разделители строк и абзацев U+2028/U+2029.
|
||||
if (char in "/\\" or unicodedata.category(char) in ("Cc", "Zl", "Zp") or char in _BIDI_CONTROLS):
|
||||
raise InvalidRequest("filename содержит недопустимые символы (/, \\, управляющие)")
|
||||
return filename
|
||||
|
||||
|
||||
def declared_type(content_type_header: str | None) -> str:
|
||||
"""Content-Type запроса: только image/png или image/jpeg (параметры после ; игнорируются)."""
|
||||
media_type = (content_type_header or "").split(";", 1)[0].strip().lower()
|
||||
if media_type not in ALLOWED_TYPES:
|
||||
raise UnsupportedMediaType("Принимаются только image/png и image/jpeg")
|
||||
return media_type
|
||||
|
||||
|
||||
def sniff(head: bytes) -> str | None:
|
||||
for media_type, signature in _SIGNATURES.items():
|
||||
if head.startswith(signature):
|
||||
return media_type
|
||||
return None
|
||||
|
||||
|
||||
def inspect(fileobj, declared: str) -> ImageInfo:
|
||||
"""Проверить содержимое (файл уже целиком принят, размер в байтах проверен). Блокирующий код."""
|
||||
fileobj.seek(0)
|
||||
actual = sniff(fileobj.read(16))
|
||||
if actual is None:
|
||||
raise UnsupportedMediaType("Содержимое не является PNG или JPEG")
|
||||
if actual != declared:
|
||||
raise UnsupportedMediaType("Content-Type не совпадает с содержимым файла")
|
||||
width, height = _header_size(fileobj, _PIL_FORMAT[actual])
|
||||
if width * height > config.MAX_IMAGE_PIXELS:
|
||||
raise PayloadTooLarge(f"Картинка больше {config.MAX_IMAGE_PIXELS} пикселей")
|
||||
if not _check_slots.acquire(timeout=config.IMAGE_CHECK_WAIT_SECONDS):
|
||||
raise Unavailable("Сервер занят проверкой картинок, повторите позже")
|
||||
try:
|
||||
fileobj.seek(0)
|
||||
if actual == "image/png":
|
||||
check_png(fileobj, width, height)
|
||||
else:
|
||||
check_jpeg(fileobj.read(), width, height)
|
||||
except Broken as exc:
|
||||
raise UnsupportedMediaType("Файл повреждён или не является корректной картинкой: " + str(exc)) from None
|
||||
finally:
|
||||
_check_slots.release()
|
||||
return ImageInfo(actual, width, height)
|
||||
|
||||
|
||||
def _header_size(fileobj, fmt: str) -> tuple[int, int]:
|
||||
"""Ширина и высота из заголовка: Image.open читает только заголовок, пиксели не распаковывает."""
|
||||
fileobj.seek(0)
|
||||
try:
|
||||
with Image.open(fileobj, formats=[fmt]) as img:
|
||||
width, height = img.size
|
||||
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
|
||||
raise PayloadTooLarge(f"Картинка больше {config.MAX_IMAGE_PIXELS} пикселей") from None
|
||||
except (OSError, SyntaxError, ValueError, EOFError, struct.error, IndexError, TypeError, zlib.error):
|
||||
raise UnsupportedMediaType("Файл повреждён или не является корректной картинкой") from None
|
||||
if width < 1 or height < 1:
|
||||
raise UnsupportedMediaType("У картинки нулевой размер")
|
||||
return width, height
|
||||
|
||||
|
||||
# ---------- PNG ----------
|
||||
|
||||
_PNG_CHANNELS = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4} # тип цвета -> каналов в пикселе
|
||||
_PNG_DEPTHS = {0: {1, 2, 4, 8, 16}, 2: {8, 16}, 3: {1, 2, 4, 8}, 4: {8, 16}, 6: {8, 16}}
|
||||
_ADAM7 = ((0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2))
|
||||
_PNG_CRITICAL = {b"IHDR", b"PLTE", b"IDAT", b"IEND"}
|
||||
|
||||
|
||||
def png_passes(width: int, height: int, depth: int, color_type: int, interlace: int) -> list[tuple[int, int, int]]:
|
||||
"""Как устроены распакованные данные IDAT: [(смещение прохода, строк, байт в строке с байтом фильтра)].
|
||||
|
||||
Без чересстрочности проход один; с Adam7 — до семи, у каждого свои ширина и высота.
|
||||
"""
|
||||
bits = depth * _PNG_CHANNELS[color_type]
|
||||
sizes = ([(width, height)] if interlace == 0 else
|
||||
[((width - x0 + dx - 1) // dx if width > x0 else 0, (height - y0 + dy - 1) // dy if height > y0 else 0)
|
||||
for x0, y0, dx, dy in _ADAM7])
|
||||
passes, offset = [], 0
|
||||
for w, h in sizes:
|
||||
if w and h:
|
||||
row = 1 + (w * bits + 7) // 8
|
||||
passes.append((offset, h, row))
|
||||
offset += h * row
|
||||
return passes
|
||||
|
||||
|
||||
def png_raw_size(width: int, height: int, depth: int, color_type: int, interlace: int) -> int:
|
||||
"""Сколько байт должно получиться после распаковки IDAT: строки + байт фильтра у каждой строки."""
|
||||
return sum(rows * row for _start, rows, row in png_passes(width, height, depth, color_type, interlace))
|
||||
|
||||
|
||||
def _check_filters(chunk: bytes, position: int, passes) -> None:
|
||||
"""Первый байт каждой строки в этом куске распакованных данных — тип фильтра 0..4.
|
||||
|
||||
Байты фильтра стоят через равные промежутки, поэтому берутся срезом (это делает C-код),
|
||||
без цикла Python по строкам: даже картинка 1×40 000 000 проверяется быстро.
|
||||
"""
|
||||
end = position + len(chunk)
|
||||
for start, rows, row in passes:
|
||||
stop = start + rows * row
|
||||
if stop <= position or start >= end:
|
||||
continue
|
||||
first = max(position, start)
|
||||
k = -(-(first - start) // row) # номер первой строки, начинающейся в этом куске
|
||||
local = start + k * row - position
|
||||
limit = min(end, stop) - position
|
||||
if local < limit and max(chunk[local:limit:row]) > 4:
|
||||
raise Broken("неверный тип фильтра строки")
|
||||
|
||||
|
||||
def check_png(f, width: int, height: int) -> None:
|
||||
f.seek(8)
|
||||
ihdr = None
|
||||
palette = None
|
||||
seen_idat = idat_closed = seen_iend = False
|
||||
inflater = zlib.decompressobj()
|
||||
produced, expected, passes = 0, 0, []
|
||||
|
||||
def inflate(data: bytes) -> None:
|
||||
nonlocal produced
|
||||
if inflater.eof:
|
||||
if data:
|
||||
raise Broken("данные IDAT после конца сжатого потока")
|
||||
return
|
||||
try:
|
||||
while data:
|
||||
out = inflater.decompress(data, _READ_BLOCK) # не больше 1 МиБ за раз: память ограничена
|
||||
if produced + len(out) > expected:
|
||||
raise Broken("сжатых данных больше, чем пикселей")
|
||||
_check_filters(out, produced, passes)
|
||||
produced += len(out)
|
||||
if inflater.eof:
|
||||
if inflater.unused_data or inflater.unconsumed_tail:
|
||||
raise Broken("данные IDAT после конца сжатого потока")
|
||||
return
|
||||
data = inflater.unconsumed_tail
|
||||
except zlib.error:
|
||||
raise Broken("сжатые данные IDAT испорчены") from None
|
||||
|
||||
while True:
|
||||
head = f.read(8)
|
||||
if not head:
|
||||
break
|
||||
if len(head) < 8:
|
||||
raise Broken("файл обрывается внутри блока")
|
||||
length, kind = struct.unpack(">I4s", head)
|
||||
if length > 0x7FFFFFFF or not all(65 <= b <= 90 or 97 <= b <= 122 for b in kind):
|
||||
raise Broken("неверный заголовок блока")
|
||||
if seen_iend:
|
||||
raise Broken("данные после IEND")
|
||||
if ihdr is None and kind != b"IHDR":
|
||||
raise Broken("первым должен быть IHDR")
|
||||
if kind[0] < 97 and kind not in _PNG_CRITICAL: # заглавная первая буква = обязательный блок
|
||||
raise Broken("неизвестный обязательный блок")
|
||||
if kind == b"IDAT":
|
||||
if idat_closed:
|
||||
raise Broken("блоки IDAT идут не подряд")
|
||||
seen_idat = True
|
||||
elif seen_idat:
|
||||
idat_closed = True
|
||||
keep = kind in (b"IHDR", b"PLTE", b"tRNS")
|
||||
if keep and length > 768:
|
||||
raise Broken("слишком длинный служебный блок")
|
||||
crc = zlib.crc32(kind)
|
||||
kept = bytearray()
|
||||
left = length
|
||||
while left:
|
||||
piece = f.read(min(left, _READ_BLOCK))
|
||||
if not piece:
|
||||
raise Broken("файл обрывается внутри блока")
|
||||
left -= len(piece)
|
||||
crc = zlib.crc32(piece, crc)
|
||||
if keep:
|
||||
kept += piece
|
||||
if kind == b"IDAT":
|
||||
inflate(piece)
|
||||
stored = f.read(4)
|
||||
if len(stored) < 4 or struct.unpack(">I", stored)[0] != crc & 0xFFFFFFFF:
|
||||
raise Broken("неверная контрольная сумма блока")
|
||||
|
||||
if kind == b"IHDR":
|
||||
if ihdr is not None or length != 13:
|
||||
raise Broken("неверный IHDR")
|
||||
w, h, depth, color, compression, filter_method, interlace = struct.unpack(">IIBBBBB", bytes(kept))
|
||||
if (w, h) != (width, height) or color not in _PNG_DEPTHS or depth not in _PNG_DEPTHS[color]:
|
||||
raise Broken("недопустимые параметры IHDR")
|
||||
if compression != 0 or filter_method != 0 or interlace not in (0, 1):
|
||||
raise Broken("недопустимые параметры IHDR")
|
||||
ihdr = (depth, color)
|
||||
passes = png_passes(w, h, depth, color, interlace)
|
||||
expected = sum(rows * row for _start, rows, row in passes)
|
||||
elif kind == b"PLTE":
|
||||
depth, color = ihdr
|
||||
if palette is not None or seen_idat or color in (0, 4):
|
||||
raise Broken("неуместный PLTE")
|
||||
entries, rest = divmod(length, 3)
|
||||
if rest or not 1 <= entries <= 256 or (color == 3 and entries > 2 ** depth):
|
||||
raise Broken("неверный размер палитры")
|
||||
palette = entries
|
||||
elif kind == b"tRNS":
|
||||
depth, color = ihdr
|
||||
allowed = {0: 2, 2: 6}.get(color)
|
||||
if seen_idat or color in (4, 6):
|
||||
raise Broken("неуместный tRNS")
|
||||
if color == 3 and (palette is None or length > palette):
|
||||
raise Broken("tRNS длиннее палитры")
|
||||
if allowed is not None and length != allowed:
|
||||
raise Broken("неверный размер tRNS")
|
||||
elif kind == b"IDAT":
|
||||
if ihdr[1] == 3 and palette is None:
|
||||
raise Broken("нет палитры у картинки с палитрой")
|
||||
elif kind == b"IEND":
|
||||
if length != 0:
|
||||
raise Broken("неверный IEND")
|
||||
seen_iend = True
|
||||
|
||||
if not seen_iend:
|
||||
raise Broken("нет IEND: файл обрезан")
|
||||
if not seen_idat:
|
||||
raise Broken("нет данных изображения (IDAT)")
|
||||
if not inflater.eof:
|
||||
raise Broken("сжатый поток IDAT обрывается")
|
||||
if produced != expected:
|
||||
raise Broken("распакованных данных меньше, чем пикселей")
|
||||
|
||||
|
||||
# ---------- JPEG ----------
|
||||
#
|
||||
# Где граница между 415 и failed (contracts/README.md: «заведомо повреждённые/чужие форматы — 415»).
|
||||
# Worker декодирует JPEG библиотекой libjpeg-turbo в строгом режиме (imaging.py): любое её
|
||||
# предупреждение — ошибка. Всё, что она проверяет по маркерам и заголовкам, то есть ДО распаковки
|
||||
# сжатых данных, API проверяет здесь сам, теми же правилами. Поэтому такой файл получает 415 сразу,
|
||||
# а не 202 и потом failed. На worker остаются только ошибки внутри сжатых данных скана: их не найти,
|
||||
# не декодировав каждый блок 8×8 (это и есть тяжёлая работа, которую API не делает).
|
||||
#
|
||||
# Что проверяется (правила libjpeg-turbo: jdmarker.c, jdinput.c, jdhuff.c, jdphuff.c, turbojpeg.c,
|
||||
# и спецификации JPEG ITU-T T.81; совпадение с настоящим декодером проверяет тест в образе,
|
||||
# student-tests/worker/test_imaging.py):
|
||||
# - маркеры: только известные, без мусора между сегментами, длины сегментов, один SOI, EOI в конце;
|
||||
# - кадр SOF: baseline/extended/progressive с кодом Хаффмана, 8 бит, размеры до 65500, 1/3/4 компонента
|
||||
# с разными идентификаторами, коэффициенты субдискретизации 1–4 и схема, которую понимает декодер;
|
||||
# - таблицы DQT/DHT/DAC/DRI: номера, размеры, коды Хаффмана помещаются в свою длину (иначе
|
||||
# «Bogus Huffman table»), символы DC-таблиц 0–15; таблица должна быть определена до скана;
|
||||
# - скан SOS: каждый компонент есть в SOF и не повторяется в скане, блоков в MCU не больше 10,
|
||||
# параметры Ss/Se/Ah/Al (для последовательного JPEG 0/63/0/0, для прогрессивного — допустимая
|
||||
# последовательность сканов), маркеры RST идут по порядку и их ровно столько, сколько задаёт DRI;
|
||||
# - APP0 JFIF версии 1 и допустимый код преобразования Adobe (APP14).
|
||||
|
||||
# Кадры, которые декодирует libjpeg-turbo в Pillow: baseline, extended, progressive (код Хаффмана).
|
||||
_SOF_SUPPORTED = {0xC0, 0xC1, 0xC2}
|
||||
_SOF_OTHER = {0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF} # lossless, arithmetic, hierarchical
|
||||
# Сегменты, которые декодер разбирает или пропускает: DHT, DAC, DQT, DNL, DRI, APP0–APP15, COM.
|
||||
# Остальные маркеры (JPG, DHP, EXP, JPGn, RES, TEM, RSTn вне скана) декодер считает ошибкой.
|
||||
_SEGMENTS = {0xC4, 0xCC, 0xDB, 0xDC, 0xDD, 0xFE} | set(range(0xE0, 0xF0))
|
||||
_JPEG_MAX_DIMENSION = 65500 # JPEG_MAX_DIMENSION libjpeg
|
||||
_MAX_BLOCKS_IN_MCU = 10 # D_MAX_BLOCKS_IN_MCU libjpeg
|
||||
# Схемы субдискретизации, которые понимает декодер worker (TurboJPEG): коэффициенты яркости при
|
||||
# коэффициентах цветности 1×1 — 4:4:4, 4:2:2, 4:2:0, 4:4:0, 4:1:1. Оттенки серого — любые.
|
||||
_LUMA_FACTORS = {(1, 1), (2, 1), (2, 2), (1, 2), (4, 1)}
|
||||
|
||||
|
||||
def _subsampling_supported(factors: list[tuple[int, int]]) -> bool:
|
||||
"""Распознаёт ли TurboJPEG схему субдискретизации (как getSubsamp в turbojpeg.c)."""
|
||||
if len(factors) == 1:
|
||||
return True
|
||||
luma, chroma, black = factors[0], factors[1:3], factors[3:] # black — 4-й канал CMYK/YCCK
|
||||
if luma in _LUMA_FACTORS and all(c == (1, 1) for c in chroma) and all(k == luma for k in black):
|
||||
return True
|
||||
if (luma == (2, 2) and chroma[0] == chroma[1] and chroma[0] in ((1, 2), (2, 1))
|
||||
and all(k == (2, 2) for k in black)):
|
||||
return True # 4:2:2 и 4:4:0, записанные «нестандартно» (яркость 2×2)
|
||||
return luma[0] * luma[1] <= 3 and all(f == luma for f in factors[1:]) # 4:4:4: все коэффициенты равны
|
||||
|
||||
|
||||
def _huffman_codes_fit(counts: bytes) -> bool:
|
||||
"""Канонические коды Хаффмана помещаются в свои длины, и нет кода из одних единиц (рисунок C.2 T.81)."""
|
||||
code = 0
|
||||
for length, count in enumerate(counts, start=1):
|
||||
code += count
|
||||
if code >= 1 << length:
|
||||
return False
|
||||
code <<= 1
|
||||
return True
|
||||
|
||||
|
||||
@dataclass
|
||||
class _Component:
|
||||
ident: int
|
||||
h: int
|
||||
v: int
|
||||
quant: int
|
||||
quant_latched: bool = False # таблица квантования берётся при первом скане компонента
|
||||
scans: int = 0
|
||||
coef_bits: list | None = None # прогрессивный JPEG: последний Al каждого коэффициента, -1 — ещё не было
|
||||
|
||||
|
||||
class _JpegCheck:
|
||||
def __init__(self, data: bytes, width: int, height: int):
|
||||
self.data, self.n, self.width, self.height = data, len(data), width, height
|
||||
self.i = 2
|
||||
self.components: list[_Component] | None = None
|
||||
self.progressive = False
|
||||
self.hmax = self.vmax = 1
|
||||
self.quant: set[int] = set()
|
||||
self.huffman: dict[tuple[int, int], tuple[bytes, bytes]] = {} # (0 — DC / 1 — AC, номер) -> (счётчики, символы)
|
||||
self.restart_interval = 0
|
||||
self.jfif = False
|
||||
self.adobe_transform = None
|
||||
self.scans = 0
|
||||
self.full_scan = False # первый последовательный скан уже содержал все компоненты
|
||||
|
||||
def run(self) -> None:
|
||||
if not self.data.startswith(b"\xff\xd8"):
|
||||
raise Broken("нет маркера начала SOI")
|
||||
while True:
|
||||
marker = self._marker()
|
||||
if marker == 0xD9: # EOI: конец картинки
|
||||
break
|
||||
if marker in _SOF_OTHER:
|
||||
raise Broken("неподдерживаемый вид JPEG (lossless, arithmetic или hierarchical)")
|
||||
if marker == 0xD8:
|
||||
raise Broken("второй маркер SOI")
|
||||
if marker not in _SOF_SUPPORTED and marker != 0xDA and marker not in _SEGMENTS:
|
||||
raise Broken(f"недопустимый маркер 0x{marker:02X}")
|
||||
segment = self._segment()
|
||||
if marker in _SOF_SUPPORTED:
|
||||
self._frame(marker, segment)
|
||||
elif marker == 0xDA:
|
||||
self._scan(segment)
|
||||
elif marker == 0xC4:
|
||||
self._dht(segment)
|
||||
elif marker == 0xDB:
|
||||
self._dqt(segment)
|
||||
elif marker == 0xCC:
|
||||
self._dac(segment)
|
||||
elif marker == 0xDD:
|
||||
if len(segment) != 2:
|
||||
raise Broken("неверная длина DRI")
|
||||
self.restart_interval = (segment[0] << 8) | segment[1]
|
||||
elif marker == 0xE0 and len(segment) >= 14 and segment[:5] == b"JFIF\x00":
|
||||
if segment[5] != 1:
|
||||
raise Broken("неизвестная версия JFIF")
|
||||
self.jfif = self.jfif or self.scans == 0
|
||||
elif marker == 0xEE and len(segment) >= 12 and segment[:5] == b"Adobe" and self.scans == 0:
|
||||
self.adobe_transform = segment[11]
|
||||
if self.components is None or self.scans == 0:
|
||||
raise Broken("нет данных изображения")
|
||||
if not self.progressive and any(c.scans == 0 for c in self.components):
|
||||
raise Broken("не все компоненты цвета закодированы в сканах")
|
||||
# Данные ПОСЛЕ EOI допускаются: так устроены многие реальные фото (превью, «живые фото»).
|
||||
# Клиенту файл отдаётся с Content-Type image/jpeg и nosniff, а варианты делаются заново.
|
||||
|
||||
def _marker(self) -> int:
|
||||
data, n = self.data, self.n
|
||||
if self.i >= n or data[self.i] != 0xFF:
|
||||
raise Broken("лишние байты там, где должен быть маркер: файл испорчен или обрезан")
|
||||
while self.i < n and data[self.i] == 0xFF: # байты-заполнители перед маркером
|
||||
self.i += 1
|
||||
if self.i >= n:
|
||||
raise Broken("файл обрывается на маркере")
|
||||
self.i += 1
|
||||
return data[self.i - 1]
|
||||
|
||||
def _segment(self) -> bytes:
|
||||
i = self.i
|
||||
if i + 2 > self.n:
|
||||
raise Broken("файл обрывается в сегменте")
|
||||
length = (self.data[i] << 8) | self.data[i + 1]
|
||||
if length < 2 or i + length > self.n:
|
||||
raise Broken("неверная длина сегмента")
|
||||
self.i = i + length
|
||||
return self.data[i + 2:i + length]
|
||||
|
||||
def _frame(self, marker: int, segment: bytes) -> None:
|
||||
if self.components is not None:
|
||||
raise Broken("второй заголовок кадра SOF")
|
||||
if len(segment) < 6:
|
||||
raise Broken("неверный заголовок кадра SOF")
|
||||
precision, rows, cols, count = struct.unpack(">BHHB", segment[:6])
|
||||
if precision != 8:
|
||||
raise Broken("поддерживается только 8 бит на канал")
|
||||
if (cols, rows) != (self.width, self.height):
|
||||
raise Broken("неверный заголовок кадра SOF")
|
||||
if cols > _JPEG_MAX_DIMENSION or rows > _JPEG_MAX_DIMENSION:
|
||||
raise Broken(f"ширина или высота больше {_JPEG_MAX_DIMENSION}")
|
||||
if count not in (1, 3, 4) or len(segment) != 6 + 3 * count:
|
||||
raise Broken("неверное число компонентов цвета в SOF (допустимо 1, 3 или 4)")
|
||||
components = []
|
||||
for k in range(count):
|
||||
ident, factors, quant = segment[6 + 3 * k:9 + 3 * k]
|
||||
h, v = factors >> 4, factors & 15
|
||||
if not (1 <= h <= 4 and 1 <= v <= 4):
|
||||
raise Broken("недопустимые коэффициенты субдискретизации")
|
||||
if quant > 3:
|
||||
raise Broken("неверный номер таблицы квантования")
|
||||
if any(c.ident == ident for c in components):
|
||||
raise Broken("повторяется идентификатор компонента в SOF")
|
||||
components.append(_Component(ident, h, v, quant))
|
||||
self.components = components
|
||||
self.progressive = marker == 0xC2
|
||||
self.hmax = max(c.h for c in components)
|
||||
self.vmax = max(c.v for c in components)
|
||||
|
||||
def _dht(self, segment: bytes) -> None:
|
||||
rest = segment
|
||||
while rest:
|
||||
if len(rest) < 17:
|
||||
raise Broken("неверная таблица Хаффмана DHT")
|
||||
index, counts = rest[0], rest[1:17]
|
||||
total = sum(counts)
|
||||
if total > 256 or total > len(rest) - 17:
|
||||
raise Broken("неверная таблица Хаффмана DHT")
|
||||
kind, number = (1, index - 0x10) if index & 0x10 else (0, index)
|
||||
if not 0 <= number <= 3:
|
||||
raise Broken("неверный номер таблицы Хаффмана")
|
||||
self.huffman[(kind, number)] = (bytes(counts), bytes(rest[17:17 + total]))
|
||||
rest = rest[17 + total:]
|
||||
|
||||
def _dqt(self, segment: bytes) -> None:
|
||||
rest = segment
|
||||
while rest:
|
||||
precision, number = rest[0] >> 4, rest[0] & 15
|
||||
if precision > 1 or number > 3:
|
||||
raise Broken("неверная таблица квантования DQT")
|
||||
size = 1 + 64 * (precision + 1)
|
||||
if len(rest) < size:
|
||||
raise Broken("таблица квантования DQT обрезана")
|
||||
self.quant.add(number)
|
||||
rest = rest[size:]
|
||||
|
||||
def _dac(self, segment: bytes) -> None:
|
||||
if len(segment) % 2:
|
||||
raise Broken("неверная длина DAC")
|
||||
for k in range(0, len(segment), 2):
|
||||
index, value = segment[k], segment[k + 1]
|
||||
if index >= 32 or (index < 16 and (value & 15) > (value >> 4)):
|
||||
raise Broken("неверный сегмент DAC")
|
||||
|
||||
def _huffman_table(self, kind: int, number: int) -> None:
|
||||
"""Таблица, которую использует скан: определена и правильна (jpeg_make_d_derived_tbl)."""
|
||||
if number > 3:
|
||||
raise Broken("номер таблицы Хаффмана больше 3")
|
||||
table = self.huffman.get((kind, number))
|
||||
if table is None:
|
||||
if not self.progressive and number <= 1:
|
||||
return # последовательный декодер подставит стандартную таблицу (так пишет Motion JPEG)
|
||||
raise Broken("скан использует неопределённую таблицу Хаффмана")
|
||||
counts, symbols = table
|
||||
if not symbols or not _huffman_codes_fit(counts):
|
||||
raise Broken("неверная таблица Хаффмана: коды не помещаются в свою длину")
|
||||
if kind == 0 and max(symbols) > 15:
|
||||
raise Broken("неверная таблица Хаффмана DC")
|
||||
|
||||
def _first_scan(self) -> None:
|
||||
"""Перед первым сканом декодер выбирает цветовое пространство и схему субдискретизации."""
|
||||
count = len(self.components)
|
||||
if count == 3 and not self.jfif and self.adobe_transform not in (None, 0, 1):
|
||||
raise Broken("неизвестный код цветового преобразования Adobe")
|
||||
if count == 4 and self.adobe_transform not in (None, 0, 2):
|
||||
raise Broken("неизвестный код цветового преобразования Adobe")
|
||||
if not _subsampling_supported([(c.h, c.v) for c in self.components]):
|
||||
raise Broken("неподдерживаемая схема субдискретизации цвета")
|
||||
|
||||
def _scan(self, segment: bytes) -> None:
|
||||
if self.components is None:
|
||||
raise Broken("скан раньше заголовка кадра")
|
||||
if self.scans == 0:
|
||||
self._first_scan()
|
||||
count = segment[0] if segment else 0
|
||||
if not 1 <= count <= 4 or len(segment) != 4 + 2 * count:
|
||||
raise Broken("неверный заголовок скана SOS")
|
||||
members = []
|
||||
for k in range(count):
|
||||
ident, tables = segment[1 + 2 * k], segment[2 + 2 * k]
|
||||
component = next((c for c in self.components if c.ident == ident), None)
|
||||
if component is None:
|
||||
raise Broken("скан ссылается на компонент, которого нет в заголовке кадра SOF")
|
||||
if any(component is m[0] for m in members):
|
||||
raise Broken("компонент повторяется в одном скане")
|
||||
members.append((component, tables >> 4, tables & 15))
|
||||
if count > 1 and sum(c.h * c.v for c, _dc, _ac in members) > _MAX_BLOCKS_IN_MCU:
|
||||
raise Broken("слишком много блоков в MCU")
|
||||
ss, se, ah, al = segment[-3], segment[-2], segment[-1] >> 4, segment[-1] & 15
|
||||
if self.progressive:
|
||||
self._progressive(members, ss, se, ah, al)
|
||||
else:
|
||||
self._sequential(members, ss, se, ah, al)
|
||||
for component, _dc, _ac in members:
|
||||
if not component.quant_latched:
|
||||
if component.quant not in self.quant:
|
||||
raise Broken("компонент использует неопределённую таблицу квантования")
|
||||
component.quant_latched = True
|
||||
restarts = self._entropy_data()
|
||||
expected = (self._mcus(members) - 1) // self.restart_interval if self.restart_interval else 0
|
||||
if restarts != expected:
|
||||
raise Broken("маркеров RST не столько, сколько задаёт интервал DRI")
|
||||
self.scans += 1
|
||||
|
||||
def _sequential(self, members, ss, se, ah, al) -> None:
|
||||
if (ss, se, ah, al) != (0, 63, 0, 0):
|
||||
raise Broken("неверные параметры Ss/Se/Ah/Al для последовательного JPEG")
|
||||
if self.full_scan:
|
||||
raise Broken("лишний скан: первый скан уже содержал все компоненты")
|
||||
if self.scans == 0 and len(members) == len(self.components):
|
||||
self.full_scan = True
|
||||
for component, dc, ac in members:
|
||||
if component.scans:
|
||||
raise Broken("компонент закодирован в двух сканах")
|
||||
component.scans += 1
|
||||
self._huffman_table(0, dc)
|
||||
self._huffman_table(1, ac)
|
||||
|
||||
def _progressive(self, members, ss, se, ah, al) -> None:
|
||||
dc_band = ss == 0
|
||||
bad = se != 0 if dc_band else (ss > se or se > 63 or len(members) != 1)
|
||||
if bad or (ah and al != ah - 1) or al > 13:
|
||||
raise Broken("неверные параметры прогрессивного скана")
|
||||
for component, dc, ac in members:
|
||||
bits = component.coef_bits = component.coef_bits or [-1] * 64
|
||||
if not dc_band and bits[0] < 0:
|
||||
raise Broken("прогрессивный скан: коэффициенты AC раньше DC")
|
||||
for k in range(ss, se + 1):
|
||||
if ah != max(bits[k], 0):
|
||||
raise Broken("нарушена последовательность прогрессивных сканов")
|
||||
bits[k] = al
|
||||
component.scans += 1
|
||||
if dc_band:
|
||||
if ah == 0: # уточняющему DC-скану таблица не нужна
|
||||
self._huffman_table(0, dc)
|
||||
else:
|
||||
self._huffman_table(1, ac)
|
||||
|
||||
def _mcus(self, members) -> int:
|
||||
"""Сколько MCU в скане (per_scan_setup libjpeg): от этого зависит число маркеров RST."""
|
||||
if len(members) == 1:
|
||||
c = members[0][0]
|
||||
return (-(-self.width * c.h // (self.hmax * 8))) * (-(-self.height * c.v // (self.vmax * 8)))
|
||||
return (-(-self.width // (self.hmax * 8))) * (-(-self.height // (self.vmax * 8)))
|
||||
|
||||
def _entropy_data(self) -> int:
|
||||
"""Пройти сжатые данные скана до следующего маркера. Возвращает число маркеров RST."""
|
||||
data, n = self.data, self.n
|
||||
start = i = self.i
|
||||
restarts = 0
|
||||
while True:
|
||||
j = data.find(b"\xff", i)
|
||||
if j < 0 or j + 1 >= n:
|
||||
raise Broken("скан обрывается: нет маркера конца EOI (файл обрезан)")
|
||||
following = data[j + 1]
|
||||
if following == 0x00: # FF 00 — байт FF внутри данных
|
||||
i = j + 2
|
||||
elif following == 0xFF: # заполнитель перед маркером
|
||||
i = j + 1
|
||||
elif 0xD0 <= following <= 0xD7: # RSTn: номера идут по кругу 0..7, с 0 в каждом скане
|
||||
if following != 0xD0 + restarts % 8:
|
||||
raise Broken("маркеры RST идут не по порядку")
|
||||
restarts += 1
|
||||
i = j + 2
|
||||
else:
|
||||
break
|
||||
if j == start:
|
||||
raise Broken("пустой скан: нет сжатых данных изображения")
|
||||
self.i = j
|
||||
return restarts
|
||||
|
||||
|
||||
def check_jpeg(data: bytes, width: int, height: int) -> None:
|
||||
_JpegCheck(data, width, height).run()
|
||||
@@ -0,0 +1,272 @@
|
||||
"""Обработка картинки в worker (с lab5): полное декодирование и три варианта.
|
||||
|
||||
Модуль выполняется в ОТДЕЛЬНОМ дочернем процессе (sandbox.py), а не в самом worker:
|
||||
у дочернего процесса свой лимит памяти и общий лимит времени. Если картинка оказалась
|
||||
слишком «тяжёлой», убивается только дочерний процесс, worker продолжает работать.
|
||||
Модуль ничего не знает про S3, PostgreSQL и брокер: на входе путь к файлу-оригиналу,
|
||||
на выходе файлы вариантов в каталоге out_dir и их описание.
|
||||
|
||||
Варианты (contracts/README.md, «Фоновая обработка»):
|
||||
- thumbnail — JPEG, вписан в 256×256 с сохранением пропорций, маленькие НЕ увеличиваются;
|
||||
- crop — JPEG 128×128, центральный квадрат (маленькие увеличиваются, это разрешено контрактом);
|
||||
- optimized — WebP, вписан в 1280×1280, маленькие НЕ увеличиваются.
|
||||
Общие правила: размеры округляются вниз, минимум 1 px; ориентация из EXIF применяется;
|
||||
у JPEG прозрачность накладывается на белый фон (в JPEG нет альфа-канала), WebP прозрачность
|
||||
сохраняет. В варианты не попадают EXIF, XMP и ICC-профиль: метаданные (место съёмки, модель
|
||||
камеры) не утекают. Параметры качества — в config.py (JPEG_QUALITY, WEBP_QUALITY, WEBP_METHOD).
|
||||
|
||||
Повтор той же задачи даёт те же самые байты (тот же вход, те же параметры, та же версия Pillow),
|
||||
поэтому повторная запись варианта под тем же ключом S3 ничего не меняет (идемпотентность).
|
||||
"""
|
||||
import hashlib
|
||||
import math
|
||||
import os
|
||||
import warnings
|
||||
from dataclasses import dataclass
|
||||
|
||||
from PIL import Image
|
||||
|
||||
# simplejpeg — libjpeg-turbo в строгом режиме: любое предупреждение декодера (битые сжатые
|
||||
# данные, обрыв скана) — ошибка. Pillow такие предупреждения молча пропускает и дорисовывает
|
||||
# серым, поэтому JPEG сначала проверяется строго, а обрабатывается уже Pillow.
|
||||
import simplejpeg
|
||||
|
||||
EXIF_ORIENTATION = 0x0112
|
||||
# Как привести картинку к правильной ориентации (номер из EXIF -> операция Pillow).
|
||||
_TRANSPOSE = {
|
||||
2: Image.Transpose.FLIP_LEFT_RIGHT,
|
||||
3: Image.Transpose.ROTATE_180,
|
||||
4: Image.Transpose.FLIP_TOP_BOTTOM,
|
||||
5: Image.Transpose.TRANSPOSE,
|
||||
6: Image.Transpose.ROTATE_270,
|
||||
7: Image.Transpose.TRANSVERSE,
|
||||
8: Image.Transpose.ROTATE_90,
|
||||
}
|
||||
_SWAPS_AXES = {5, 6, 7, 8} # эти ориентации меняют местами ширину и высоту
|
||||
_FORMAT = {"image/png": "PNG", "image/jpeg": "JPEG"}
|
||||
|
||||
|
||||
class ImageError(Exception):
|
||||
"""Ошибка, которая зависит только от самого файла: повтор её не исправит (постоянная)."""
|
||||
code = "invalid_image"
|
||||
|
||||
|
||||
class InvalidImage(ImageError):
|
||||
code = "invalid_image"
|
||||
|
||||
|
||||
class ImageTooLarge(ImageError):
|
||||
code = "image_too_large"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Params:
|
||||
max_pixels: int = 40_000_000
|
||||
thumbnail: int = 256
|
||||
crop: int = 128
|
||||
optimized: int = 1280
|
||||
jpeg_quality: int = 85
|
||||
webp_quality: int = 80
|
||||
webp_method: int = 4
|
||||
|
||||
|
||||
def fit(width: int, height: int, box: int) -> tuple[int, int]:
|
||||
"""Вписать в квадрат box×box без увеличения. Округление вниз, минимум 1 px.
|
||||
|
||||
Целочисленная арифметика, без float: 320×200 в 256 даёт ровно 256×160.
|
||||
"""
|
||||
if width <= box and height <= box:
|
||||
return width, height
|
||||
if width >= height:
|
||||
return box, max(1, height * box // width)
|
||||
return max(1, width * box // height), box
|
||||
|
||||
|
||||
def _sha256(path: str) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with open(path, "rb") as f:
|
||||
for block in iter(lambda: f.read(1024 * 1024), b""):
|
||||
digest.update(block)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def _strict_jpeg_check(data: bytes) -> None:
|
||||
"""Строгая проверка всех сжатых данных JPEG. Декодирование в масштабе 1/8: памяти в 64 раза меньше."""
|
||||
try:
|
||||
_h, _w, colorspace, _sub = simplejpeg.decode_jpeg_header(data)
|
||||
target = "CMYK" if colorspace in ("CMYK", "YCCK") else ("GRAY" if colorspace == "Gray" else "RGB")
|
||||
simplejpeg.decode_jpeg(data, colorspace=target, strict=True, min_factor=8)
|
||||
except (ValueError, KeyError):
|
||||
# KeyError: simplejpeg не знает некоторых схем субдискретизации TurboJPEG 3 (например, 4:4:1).
|
||||
# API такие JPEG отклоняет сам (images._subsampling_supported), здесь — вторая линия защиты.
|
||||
raise InvalidImage("JPEG повреждён или не поддерживается: libjpeg-turbo в строгом режиме нашёл ошибку") from None
|
||||
|
||||
|
||||
def _orientation(img) -> int:
|
||||
try:
|
||||
value = int(img.getexif().get(EXIF_ORIENTATION, 1))
|
||||
except Exception: # битый EXIF не мешает обработке: считаем ориентацию обычной
|
||||
return 1
|
||||
return value if value in range(1, 9) else 1
|
||||
|
||||
|
||||
def _normalize(img):
|
||||
"""Режим, с которым умеют работать resize и кодировщики: RGB, RGBA или L (оттенки серого).
|
||||
|
||||
Если режим уже подходит, возвращается та же картинка, без копии: у 40 Мп RGBA копия — это
|
||||
ещё 160 МиБ.
|
||||
"""
|
||||
if img.mode in ("I;16", "I"):
|
||||
# 16 бит -> 8 бит: делим на 257 (65535 -> 255), иначе convert("L") обрезал бы яркость до 255.
|
||||
return img.point(lambda value: value * (1 / 257)).convert("L")
|
||||
if img.mode.startswith("I;16"): # редкий порядок байтов: через 32-битный режим
|
||||
return img.convert("I").point(lambda value: value * (1 / 257)).convert("L")
|
||||
if img.has_transparency_data:
|
||||
target = "RGBA"
|
||||
elif img.mode in ("1", "L"):
|
||||
target = "L"
|
||||
else:
|
||||
target = "RGB"
|
||||
return img if img.mode == target else img.convert(target)
|
||||
|
||||
|
||||
def _on_white(img):
|
||||
"""JPEG не хранит прозрачность: накладываем на белый фон, как требует контракт."""
|
||||
if img.mode != "RGBA":
|
||||
return img
|
||||
background = Image.new("RGB", img.size, (255, 255, 255))
|
||||
background.paste(img, mask=img.getchannel("A"))
|
||||
return background
|
||||
|
||||
|
||||
def _resize(img, size, box=None):
|
||||
if box is None and img.size == size:
|
||||
return img
|
||||
# reducing_gap: сначала быстрое уменьшение в целое число раз, потом точный LANCZOS.
|
||||
return img.resize(size, Image.Resampling.LANCZOS, box=box, reducing_gap=3.0)
|
||||
|
||||
|
||||
def _save(img, path: str, fmt: str, params: Params) -> None:
|
||||
img.info = {} # ни EXIF, ни XMP, ни ICC-профиля исходника в вариант не переносим
|
||||
if fmt == "JPEG":
|
||||
img.save(path, "JPEG", quality=params.jpeg_quality, optimize=True)
|
||||
else:
|
||||
img.save(path, "WEBP", quality=params.webp_quality, method=params.webp_method)
|
||||
|
||||
|
||||
def process(src_path: str, out_dir: str, content_type: str, params: Params = Params()) -> dict:
|
||||
"""Проверить и обработать оригинал. Возвращает описание исходника и трёх вариантов.
|
||||
|
||||
Ошибки: InvalidImage (нельзя декодировать), ImageTooLarge (лимит пикселей), MemoryError
|
||||
(не хватило лимита памяти процесса) — все постоянные. Остальное — неожиданная ошибка.
|
||||
"""
|
||||
fmt = _FORMAT.get(content_type)
|
||||
if fmt is None:
|
||||
raise InvalidImage("Неподдерживаемый тип")
|
||||
Image.MAX_IMAGE_PIXELS = params.max_pixels
|
||||
with warnings.catch_warnings():
|
||||
warnings.simplefilter("error", Image.DecompressionBombWarning)
|
||||
try:
|
||||
img = Image.open(src_path, formats=[fmt])
|
||||
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
|
||||
raise ImageTooLarge("Картинка больше лимита пикселей") from None
|
||||
except (OSError, SyntaxError, ValueError, EOFError):
|
||||
raise InvalidImage("Файл не открывается как " + fmt) from None
|
||||
with img:
|
||||
width, height = img.size
|
||||
if width < 1 or height < 1:
|
||||
raise InvalidImage("Нулевой размер")
|
||||
if width * height > params.max_pixels:
|
||||
raise ImageTooLarge("Картинка больше лимита пикселей")
|
||||
if fmt == "JPEG":
|
||||
with open(src_path, "rb") as f:
|
||||
_strict_jpeg_check(f.read())
|
||||
orientation = _orientation(img)
|
||||
# Размеры с учётом ориентации (как картинку увидит человек).
|
||||
ow, oh = (height, width) if orientation in _SWAPS_AXES else (width, height)
|
||||
thumb_o, opt_o = fit(ow, oh, params.thumbnail), fit(ow, oh, params.optimized)
|
||||
if fmt == "JPEG":
|
||||
# draft: libjpeg сразу декодирует в уменьшенном масштабе (1/2, 1/4, 1/8), если
|
||||
# этого хватает для самого большого варианта. Память и время — в разы меньше.
|
||||
need = min(1.0, max(opt_o[0] / ow, opt_o[1] / oh, params.crop / min(ow, oh)))
|
||||
img.draft(img.mode, (math.ceil(width * need), math.ceil(height * need)))
|
||||
try:
|
||||
img.load()
|
||||
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
|
||||
raise ImageTooLarge("Картинка больше лимита пикселей") from None
|
||||
except MemoryError:
|
||||
raise
|
||||
except (OSError, SyntaxError, ValueError, EOFError, IndexError, TypeError):
|
||||
raise InvalidImage("Файл повреждён: декодирование не удалось") from None
|
||||
base = _normalize(img)
|
||||
mode = base.mode
|
||||
if base is not img:
|
||||
img.close() # декодированный исходник больше не нужен: освобождаем память
|
||||
|
||||
transpose = _TRANSPOSE.get(orientation)
|
||||
|
||||
def stored(size): # размер с учётом ориентации -> размер в ориентации файла
|
||||
return (size[1], size[0]) if orientation in _SWAPS_AXES else size
|
||||
|
||||
def oriented(image):
|
||||
return image.transpose(transpose) if transpose is not None else image
|
||||
|
||||
# Память: полноразмерная картинка нужна только для ОДНОГО resize — в optimized (≤1280).
|
||||
# thumbnail и crop делаются уже из него, а оригинал сразу освобождается. Исключение —
|
||||
# очень вытянутые картинки, у которых короткая сторона optimized меньше 128 px:
|
||||
# для них crop берётся из полноразмерной картинки, чтобы не терять качество.
|
||||
optimized_stored = _resize(base, stored(opt_o))
|
||||
source_for_crop = optimized_stored if min(optimized_stored.size) >= params.crop else base
|
||||
if optimized_stored is not base and source_for_crop is not base:
|
||||
base.close() # полноразмерная картинка больше не нужна
|
||||
del base
|
||||
|
||||
os.makedirs(out_dir, exist_ok=True)
|
||||
variants = []
|
||||
|
||||
def emit(name, image, fmt_out, ext):
|
||||
path = os.path.join(out_dir, name + ext)
|
||||
_save(image, path, fmt_out, params)
|
||||
variants.append({"name": name, "path": path,
|
||||
"content_type": "image/jpeg" if fmt_out == "JPEG" else "image/webp",
|
||||
"width": image.size[0], "height": image.size[1],
|
||||
"size_bytes": os.path.getsize(path), "sha256": _sha256(path)})
|
||||
|
||||
thumb = oriented(_resize(optimized_stored, stored(thumb_o)))
|
||||
if thumb.size != thumb_o:
|
||||
raise RuntimeError("thumbnail: неожиданный размер")
|
||||
emit("thumbnail", _on_white(thumb), "JPEG", ".jpg")
|
||||
|
||||
cw, ch = source_for_crop.size # центральный квадрат; от поворота его положение не зависит
|
||||
side = min(cw, ch)
|
||||
left, top = (cw - side) // 2, (ch - side) // 2
|
||||
crop = oriented(_resize(source_for_crop, (params.crop, params.crop), box=(left, top, left + side, top + side)))
|
||||
emit("crop", _on_white(crop), "JPEG", ".jpg")
|
||||
del source_for_crop
|
||||
|
||||
optimized = oriented(optimized_stored)
|
||||
if optimized.size != opt_o:
|
||||
raise RuntimeError("optimized: неожиданный размер")
|
||||
if optimized.mode == "L":
|
||||
optimized = optimized.convert("RGB")
|
||||
emit("optimized", optimized, "WEBP", ".webp")
|
||||
|
||||
return {"source": {"width": width, "height": height, "orientation": orientation, "mode": mode},
|
||||
"variants": variants}
|
||||
|
||||
|
||||
def sniff_bytes(data: bytes) -> str | None:
|
||||
"""Тип по первым байтам (для самопроверки worker)."""
|
||||
if data.startswith(b"\x89PNG\r\n\x1a\n"):
|
||||
return "image/png"
|
||||
if data.startswith(b"\xff\xd8\xff"):
|
||||
return "image/jpeg"
|
||||
return None
|
||||
|
||||
|
||||
if __name__ == "__main__": # ручная проверка: python -m messenger.imaging файл.png каталог
|
||||
import json
|
||||
import sys
|
||||
with open(sys.argv[1], "rb") as f:
|
||||
kind = sniff_bytes(f.read(16))
|
||||
print(json.dumps(process(sys.argv[1], sys.argv[2], kind or ""), ensure_ascii=False, indent=1))
|
||||
@@ -0,0 +1,462 @@
|
||||
"""Задания обработки вложений в PostgreSQL (с lab5): состояния, lease, повторы, outbox, replay.
|
||||
|
||||
Источник истины о задании — строка attachment_jobs, а не сообщение в брокере. Брокер только
|
||||
доставляет «напоминание»: обработай задание job_id, попытку attempt. Поэтому дубль, устаревшее
|
||||
или потерянное сообщение ничего не ломают — решение принимается по строке задания:
|
||||
|
||||
сообщение (job_id, attempt) что делает worker
|
||||
задание ready / failed -> ack, ничего не делает (повтор не создаёт второй набор)
|
||||
attempt в сообщении устарел -> ack, ничего не делает (есть сообщение новее)
|
||||
processing, lease действует -> ack, ничего не делает (задание уже обрабатывается)
|
||||
processing, lease истёк -> попытка считается неудачной, назначается следующая
|
||||
queued, attempt совпадает -> взять под lease и обработать
|
||||
|
||||
Переходы (contracts/attachment-states.md):
|
||||
queued -> processing claim(): lease с жетоном (token) и сроком (lease_until);
|
||||
processing -> ready complete(): только с тем же жетоном (fencing);
|
||||
processing -> queued retry() при временной ошибке или reap() при истёкшем lease:
|
||||
attempt+1, пауза backoff с jitter, новая строка outbox;
|
||||
processing -> failed fail() при постоянной ошибке или когда попытки исчерпаны;
|
||||
failed -> queued replay(): явная команда оператора, с записью в журнал.
|
||||
Каждый переход — одна транзакция: строка задания, статус вложения, outbox и журнал
|
||||
меняются вместе или не меняются вовсе.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import logging
|
||||
import random
|
||||
import sys
|
||||
import uuid
|
||||
from contextlib import contextmanager
|
||||
from dataclasses import dataclass
|
||||
|
||||
import psycopg
|
||||
from psycopg.types.json import Jsonb
|
||||
from psycopg_pool import PoolTimeout
|
||||
|
||||
from . import broker, config
|
||||
from .errors import Unavailable
|
||||
|
||||
log = logging.getLogger("messenger.jobs")
|
||||
|
||||
|
||||
def backoff(attempt: int) -> float:
|
||||
"""Пауза перед попыткой attempt+1. «Равный jitter»: случайно в [d/2, d], d = min(MAX, BASE·2^(attempt-1)).
|
||||
|
||||
Удвоение даёт временному сбою время пройти. Случайная часть разводит по времени задания,
|
||||
упавшие одновременно (например, все при остановке S3): иначе они повторялись бы одной волной.
|
||||
"""
|
||||
limit = min(config.RETRY_MAX_SECONDS, config.RETRY_BASE_SECONDS * 2 ** (attempt - 1))
|
||||
return limit / 2 + random.uniform(0, limit / 2)
|
||||
|
||||
|
||||
def predecessor_of(owner: str | None, me: str) -> bool:
|
||||
"""owner — прошлая жизнь ЭТОГО ЖЕ контейнера (тот же hostname, другой запуск)?
|
||||
|
||||
В контейнере один процесс worker. Если lease держит прежний запуск того же контейнера,
|
||||
значит, тот процесс точно мёртв (контейнер перезапустился): ждать истечения lease не нужно.
|
||||
"""
|
||||
if not owner:
|
||||
return False
|
||||
return owner.partition("/")[0] == me.partition("/")[0] and owner != me
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Lease:
|
||||
job_id: str
|
||||
attachment_id: str
|
||||
pipeline_version: int
|
||||
attempt: int
|
||||
max_attempts: int
|
||||
token: str
|
||||
staging_key: str | None
|
||||
storage_key: str
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
sha256: str
|
||||
width: int
|
||||
height: int
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Decision:
|
||||
kind: str # claimed | ready | failed | stale | in_progress | rescheduled | unknown
|
||||
lease: Lease | None = None
|
||||
detail: str = ""
|
||||
|
||||
|
||||
def event(conn, job_id, attachment_id, attempt, name: str, actor: str, detail: str | None = None) -> None:
|
||||
conn.execute("""INSERT INTO job_events (job_id, attachment_id, attempt, event, actor, detail)
|
||||
VALUES (%s, %s, %s, %s, %s, %s)""",
|
||||
(job_id, attachment_id, attempt, name, actor[:120], detail[:300] if detail else None))
|
||||
|
||||
|
||||
def enqueue(conn, job_id, attachment_id, pipeline_version: int, attempt: int, delay_seconds: float = 0.0) -> None:
|
||||
"""Строка outbox в ТЕКУЩЕЙ транзакции: сообщение уйдёт в брокер не раньше чем через delay_seconds."""
|
||||
payload = broker.build_message(str(job_id), str(attachment_id), pipeline_version, attempt)
|
||||
conn.execute("""INSERT INTO outbox (job_id, attempt, payload, available_at)
|
||||
VALUES (%s, %s, %s, now() + make_interval(secs => %s))""",
|
||||
(job_id, attempt, Jsonb(payload), delay_seconds))
|
||||
|
||||
|
||||
def create(conn, attachment_id, actor: str) -> uuid.UUID:
|
||||
"""Новое задание для только что принятого вложения (в транзакции загрузки, см. store.py)."""
|
||||
job_id = uuid.uuid4()
|
||||
conn.execute("""INSERT INTO attachment_jobs (job_id, attachment_id, pipeline_version, status, attempt, max_attempts)
|
||||
VALUES (%s, %s, %s, 'queued', 1, %s)""",
|
||||
(job_id, attachment_id, config.PIPELINE_VERSION, config.JOB_MAX_ATTEMPTS))
|
||||
enqueue(conn, job_id, attachment_id, config.PIPELINE_VERSION, 1)
|
||||
event(conn, job_id, attachment_id, 1, "queued", actor, "загрузка принята, оригинал в staging")
|
||||
return job_id
|
||||
|
||||
|
||||
_CLEAR_LEASE = "lease_owner = NULL, lease_token = NULL, lease_until = NULL"
|
||||
|
||||
|
||||
class LockBusy(Exception):
|
||||
"""Строку задания дольше lock_timeout держит другая транзакция (уборщик, worker)."""
|
||||
|
||||
|
||||
class JobStore:
|
||||
def __init__(self, pool, actor: str):
|
||||
self.pool = pool
|
||||
self.actor = actor # кто выполняет переходы: worker-<id> или operator
|
||||
|
||||
@contextmanager
|
||||
def _tx(self):
|
||||
try:
|
||||
with self.pool.connection() as conn:
|
||||
with conn.transaction():
|
||||
yield conn
|
||||
except (psycopg.OperationalError, PoolTimeout) as exc:
|
||||
log.warning("PostgreSQL недоступен: %s", type(exc).__name__)
|
||||
raise Unavailable("PostgreSQL недоступен") from None
|
||||
|
||||
# ---------- переход «попытка закончилась неудачей» ----------
|
||||
|
||||
def _attempt_over(self, conn, job_id, attachment_id, version, attempt, max_attempts,
|
||||
code: str, message: str, permanent: bool) -> str:
|
||||
"""processing -> queued (следующая попытка через backoff) или -> failed. Возвращает retry|failed."""
|
||||
if permanent or attempt >= max_attempts:
|
||||
final = code if permanent else "retry_exhausted"
|
||||
conn.execute(f"""UPDATE attachment_jobs SET status = 'failed', {_CLEAR_LEASE},
|
||||
last_error_code = %s, last_error = %s, finished_at = now(), updated_at = now()
|
||||
WHERE job_id = %s""", (code, message[:300], job_id))
|
||||
conn.execute("""UPDATE attachments SET status = 'failed', error_code = %s, updated_at = now()
|
||||
WHERE id = %s AND status IN ('queued', 'processing')""", (final, attachment_id))
|
||||
event(conn, job_id, attachment_id, attempt, "failed", self.actor,
|
||||
f"{final}; последняя ошибка {code}: {message}")
|
||||
return "failed"
|
||||
delay = backoff(attempt)
|
||||
conn.execute(f"""UPDATE attachment_jobs SET status = 'queued', attempt = attempt + 1, {_CLEAR_LEASE},
|
||||
next_attempt_at = now() + make_interval(secs => %s),
|
||||
last_error_code = %s, last_error = %s, updated_at = now()
|
||||
WHERE job_id = %s""", (delay, code, message[:300], job_id))
|
||||
conn.execute("""UPDATE attachments SET status = 'queued', updated_at = now()
|
||||
WHERE id = %s AND status IN ('queued', 'processing')""", (attachment_id,))
|
||||
enqueue(conn, job_id, attachment_id, version, attempt + 1, delay)
|
||||
event(conn, job_id, attachment_id, attempt, "retry_scheduled", self.actor,
|
||||
f"{code}: {message}; попытка {attempt + 1} через {delay:.1f} с")
|
||||
return "retry"
|
||||
|
||||
# ---------- worker ----------
|
||||
|
||||
def claim(self, message: dict, worker_id: str) -> Decision:
|
||||
"""Решить, что делать с доставленным сообщением, и при необходимости взять задание под lease."""
|
||||
with self._tx() as conn:
|
||||
row = conn.execute(
|
||||
"""SELECT j.job_id, j.attachment_id, j.pipeline_version, j.status, j.attempt, j.max_attempts,
|
||||
j.lease_owner, j.lease_until < now(),
|
||||
a.staging_key, a.storage_key, a.content_type, a.size_bytes, a.sha256, a.width, a.height
|
||||
FROM attachment_jobs j JOIN attachments a ON a.id = j.attachment_id
|
||||
WHERE j.job_id = %s FOR UPDATE OF j""", (uuid.UUID(message["job_id"]),)).fetchone()
|
||||
if row is None:
|
||||
return Decision("unknown", detail="нет такого задания")
|
||||
(job_id, attachment_id, version, status, attempt, max_attempts, owner, expired,
|
||||
staging_key, storage_key, content_type, size_bytes, sha256, width, height) = row
|
||||
if str(attachment_id) != message["attachment_id"] or version != message["pipeline_version"]:
|
||||
return Decision("unknown", detail="сообщение не совпадает с заданием")
|
||||
if status in ("ready", "failed"):
|
||||
event(conn, job_id, attachment_id, message["attempt"], "duplicate_ignored", self.actor,
|
||||
f"задание уже {status}: повторная доставка, ack без обработки")
|
||||
return Decision(status)
|
||||
if message["attempt"] != attempt:
|
||||
event(conn, job_id, attachment_id, message["attempt"], "stale_ignored", self.actor,
|
||||
f"устаревшее сообщение: актуальная попытка {attempt}")
|
||||
return Decision("stale")
|
||||
if status == "processing":
|
||||
if owner == worker_id:
|
||||
return Decision("in_progress", detail="уже обрабатывается этим worker")
|
||||
dead = predecessor_of(owner, worker_id)
|
||||
if not expired and not dead:
|
||||
event(conn, job_id, attachment_id, attempt, "duplicate_in_progress", self.actor,
|
||||
"задание под действующим lease другого worker")
|
||||
return Decision("in_progress")
|
||||
reason = "прежний запуск этого контейнера упал" if dead else "lease истёк"
|
||||
event(conn, job_id, attachment_id, attempt, "lease_expired", self.actor, reason)
|
||||
outcome = self._attempt_over(conn, job_id, attachment_id, version, attempt, max_attempts,
|
||||
"worker_crashed", reason, permanent=False)
|
||||
return Decision("rescheduled", detail=outcome)
|
||||
token = uuid.uuid4()
|
||||
conn.execute("""UPDATE attachment_jobs SET status = 'processing', lease_owner = %s, lease_token = %s,
|
||||
lease_until = now() + make_interval(secs => %s), updated_at = now()
|
||||
WHERE job_id = %s""", (worker_id, token, config.JOB_LEASE_SECONDS, job_id))
|
||||
conn.execute("""UPDATE attachments SET status = 'processing', updated_at = now()
|
||||
WHERE id = %s AND status IN ('queued', 'processing')""", (attachment_id,))
|
||||
event(conn, job_id, attachment_id, attempt, "claimed", self.actor,
|
||||
f"lease на {config.JOB_LEASE_SECONDS} с")
|
||||
return Decision("claimed", Lease(str(job_id), str(attachment_id), version, attempt, max_attempts, str(token),
|
||||
staging_key, storage_key, content_type, int(size_bytes), sha256,
|
||||
int(width), int(height)))
|
||||
|
||||
def renew(self, tokens: list[str]) -> set[str]:
|
||||
"""Продлить lease заданий, которые этот worker ещё обрабатывает. Возвращает продлённые жетоны.
|
||||
|
||||
Жетона нет в ответе — lease уже забрали (истёк и задание переназначено): работу надо бросить.
|
||||
"""
|
||||
if not tokens:
|
||||
return set()
|
||||
with self._tx() as conn:
|
||||
rows = conn.execute("""UPDATE attachment_jobs
|
||||
SET lease_until = now() + make_interval(secs => %s), updated_at = now()
|
||||
WHERE status = 'processing' AND lease_token = ANY(%s::uuid[])
|
||||
RETURNING lease_token""",
|
||||
(config.JOB_LEASE_SECONDS, [uuid.UUID(t) for t in tokens])).fetchall()
|
||||
return {str(r[0]) for r in rows}
|
||||
|
||||
def _fenced(self, conn, lease: Lease):
|
||||
"""Строка задания, если lease всё ещё наш (тот же жетон). Иначе None: результат не принимается."""
|
||||
return conn.execute("""SELECT attempt, max_attempts FROM attachment_jobs
|
||||
WHERE job_id = %s AND lease_token = %s AND status = 'processing'
|
||||
FOR UPDATE""", (uuid.UUID(lease.job_id), uuid.UUID(lease.token))).fetchone()
|
||||
|
||||
def complete(self, lease: Lease, variants: list[dict]) -> bool:
|
||||
"""processing -> ready: варианты, статус вложения и задания — одной транзакцией."""
|
||||
with self._tx() as conn:
|
||||
if self._fenced(conn, lease) is None:
|
||||
return False
|
||||
attachment_id, job_id = uuid.UUID(lease.attachment_id), uuid.UUID(lease.job_id)
|
||||
for v in variants:
|
||||
# Первичный ключ (attachment_id, pipeline_version, name) — ключ эффекта: второй набор невозможен.
|
||||
conn.execute("""INSERT INTO attachment_variants (attachment_id, pipeline_version, name, storage_key,
|
||||
content_type, size_bytes, width, height, sha256, job_id)
|
||||
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
|
||||
ON CONFLICT (attachment_id, pipeline_version, name) DO UPDATE SET
|
||||
storage_key = EXCLUDED.storage_key, content_type = EXCLUDED.content_type,
|
||||
size_bytes = EXCLUDED.size_bytes, width = EXCLUDED.width,
|
||||
height = EXCLUDED.height, sha256 = EXCLUDED.sha256, job_id = EXCLUDED.job_id""",
|
||||
(attachment_id, lease.pipeline_version, v["name"], v["storage_key"], v["content_type"],
|
||||
v["size_bytes"], v["width"], v["height"], v["sha256"], job_id))
|
||||
conn.execute("""UPDATE attachments SET status = 'ready', error_code = NULL, updated_at = now()
|
||||
WHERE id = %s AND status IN ('queued', 'processing')""", (attachment_id,))
|
||||
conn.execute(f"""UPDATE attachment_jobs SET status = 'ready', {_CLEAR_LEASE},
|
||||
finished_at = now(), updated_at = now()
|
||||
WHERE job_id = %s""", (job_id,))
|
||||
event(conn, job_id, attachment_id, lease.attempt, "ready", self.actor,
|
||||
"оригинал опубликован, варианты: " + ", ".join(v["name"] for v in variants))
|
||||
return True
|
||||
|
||||
def fail(self, lease: Lease, code: str, message: str) -> bool:
|
||||
"""Постоянная ошибка: processing -> failed сразу, без повторов."""
|
||||
with self._tx() as conn:
|
||||
row = self._fenced(conn, lease)
|
||||
if row is None:
|
||||
return False
|
||||
self._attempt_over(conn, uuid.UUID(lease.job_id), uuid.UUID(lease.attachment_id), lease.pipeline_version,
|
||||
row[0], row[1], code, message, permanent=True)
|
||||
return True
|
||||
|
||||
def retry(self, lease: Lease, code: str, message: str) -> str:
|
||||
"""Временная ошибка: следующая попытка с backoff или failed. Возвращает retry | failed | lost."""
|
||||
with self._tx() as conn:
|
||||
row = self._fenced(conn, lease)
|
||||
if row is None:
|
||||
return "lost"
|
||||
return self._attempt_over(conn, uuid.UUID(lease.job_id), uuid.UUID(lease.attachment_id),
|
||||
lease.pipeline_version, row[0], row[1], code, message, permanent=False)
|
||||
|
||||
def reap(self, limit: int = 50) -> list[tuple[str, str]]:
|
||||
"""Задания с истёкшим lease (worker умер или завис и не продлевал аренду) -> следующая попытка."""
|
||||
done = []
|
||||
with self._tx() as conn:
|
||||
rows = conn.execute("""SELECT job_id, attachment_id, pipeline_version, attempt, max_attempts, lease_owner
|
||||
FROM attachment_jobs
|
||||
WHERE status = 'processing' AND lease_until < now()
|
||||
ORDER BY lease_until LIMIT %s
|
||||
FOR UPDATE SKIP LOCKED""", (limit,)).fetchall()
|
||||
for job_id, attachment_id, version, attempt, max_attempts, owner in rows:
|
||||
event(conn, job_id, attachment_id, attempt, "lease_expired", self.actor,
|
||||
f"lease {owner} истёк: worker не продлил аренду (упал или завис)")
|
||||
done.append((str(attachment_id), self._attempt_over(
|
||||
conn, job_id, attachment_id, version, attempt, max_attempts,
|
||||
"lease_expired", "worker не продлил lease", permanent=False)))
|
||||
return done
|
||||
|
||||
def republish_stale(self, age_seconds: int, limit: int = 50) -> int:
|
||||
"""Страховка: задание давно в queued, а свежей отправки нет — отправить сообщение ещё раз."""
|
||||
with self._tx() as conn:
|
||||
rows = conn.execute(
|
||||
"""SELECT j.job_id, j.attachment_id, j.pipeline_version, j.attempt FROM attachment_jobs j
|
||||
WHERE j.status = 'queued' AND j.next_attempt_at < now() - make_interval(secs => %s)
|
||||
AND NOT EXISTS (SELECT 1 FROM outbox o WHERE o.job_id = j.job_id AND o.attempt = j.attempt
|
||||
AND (o.published_at IS NULL
|
||||
OR o.published_at > now() - make_interval(secs => %s)))
|
||||
LIMIT %s FOR UPDATE OF j SKIP LOCKED""", (age_seconds, age_seconds, limit)).fetchall()
|
||||
for job_id, attachment_id, version, attempt in rows:
|
||||
enqueue(conn, job_id, attachment_id, version, attempt)
|
||||
event(conn, job_id, attachment_id, attempt, "republished", self.actor,
|
||||
f"нет обработки дольше {age_seconds} с: сообщение отправлено повторно")
|
||||
return len(rows)
|
||||
|
||||
# ---------- оператор ----------
|
||||
|
||||
def replay(self, attachment_id: str, staging_exists) -> dict:
|
||||
"""failed -> queued по команде оператора. Готовое или ещё идущее задание НЕ повторяется.
|
||||
|
||||
Всё в ОДНОЙ транзакции под блокировкой строк задания и вложения — тех же, что берёт уборщик
|
||||
(store.cleanup_attachment), в том же порядке. Поэтому уборщик не удалит staging между
|
||||
проверкой исходника и переводом в queued (замечание к MR):
|
||||
- уборщик успел раньше: он уже пометил staging удалённым (staging_key = NULL) и удалил его,
|
||||
replay ждал блокировку и теперь безопасно отказывает (source_missing), задание остаётся failed;
|
||||
- replay успел раньше: уборщик ждёт блокировку, потом видит queued — исходник нужен текущей
|
||||
работе, и он его не трогает.
|
||||
Наличие объекта в S3 (staging_exists) проверяется тоже под блокировкой.
|
||||
"""
|
||||
aid = uuid.UUID(attachment_id)
|
||||
try:
|
||||
return self._replay(aid, staging_exists)
|
||||
except LockBusy:
|
||||
return {"result": "busy", "detail": "вложение сейчас обрабатывает уборщик или worker, повторите позже"}
|
||||
|
||||
def _replay(self, aid: uuid.UUID, staging_exists) -> dict:
|
||||
with self._tx() as conn:
|
||||
# Команда оператора может подождать блокировку дольше обычного запроса (5 с).
|
||||
conn.execute("SET LOCAL lock_timeout = '20s'")
|
||||
conn.execute("SET LOCAL statement_timeout = '25s'")
|
||||
try:
|
||||
row = conn.execute("""SELECT job_id, status, attempt, last_error_code FROM attachment_jobs
|
||||
WHERE attachment_id = %s AND pipeline_version = %s FOR UPDATE""",
|
||||
(aid, config.PIPELINE_VERSION)).fetchone()
|
||||
if row is None:
|
||||
return {"result": "not_found"}
|
||||
staging_key, error_code = conn.execute(
|
||||
"SELECT staging_key, error_code FROM attachments WHERE id = %s FOR UPDATE", (aid,)).fetchone()
|
||||
except psycopg.errors.LockNotAvailable:
|
||||
raise LockBusy() from None
|
||||
job_id, status, attempt, last_code = row
|
||||
if status != "failed":
|
||||
event(conn, job_id, aid, attempt, "replay_refused", self.actor,
|
||||
f"задание в состоянии {status}: повторять нечего")
|
||||
return {"result": "noop", "reason": status}
|
||||
if not staging_key or not staging_exists(staging_key):
|
||||
detail = "оригинал в staging уже удалён (истёк STAGING_RETENTION_SECONDS)"
|
||||
event(conn, job_id, aid, attempt, "replay_refused", self.actor, "source_missing: " + detail)
|
||||
return {"result": "refused", "reason": "source_missing", "detail": detail}
|
||||
new_attempt = attempt + 1
|
||||
conn.execute(f"""UPDATE attachment_jobs SET status = 'queued', attempt = %s, max_attempts = %s,
|
||||
{_CLEAR_LEASE}, next_attempt_at = now(), finished_at = NULL, updated_at = now()
|
||||
WHERE job_id = %s""", (new_attempt, attempt + config.JOB_MAX_ATTEMPTS, job_id))
|
||||
conn.execute("""UPDATE attachments SET status = 'queued', error_code = NULL, updated_at = now()
|
||||
WHERE id = %s AND status = 'failed'""", (aid,))
|
||||
enqueue(conn, job_id, aid, config.PIPELINE_VERSION, new_attempt)
|
||||
event(conn, job_id, aid, new_attempt, "replay_requested", self.actor,
|
||||
f"replay оператора: было {error_code} (последняя ошибка {last_code}); "
|
||||
f"новая попытка {new_attempt}, ещё {config.JOB_MAX_ATTEMPTS} попыток")
|
||||
return {"result": "queued", "attempt": new_attempt, "previous_error": error_code}
|
||||
|
||||
def failed(self, limit: int = 50) -> list[dict]:
|
||||
"""Реестр failed для оператора: что упало, с каким кодом, сколько было попыток."""
|
||||
with self._tx() as conn:
|
||||
rows = conn.execute("""SELECT j.attachment_id, j.job_id, a.error_code, j.last_error_code, j.last_error,
|
||||
j.attempt, j.finished_at
|
||||
FROM attachment_jobs j JOIN attachments a ON a.id = j.attachment_id
|
||||
WHERE j.status = 'failed' ORDER BY j.finished_at DESC LIMIT %s""",
|
||||
(limit,)).fetchall()
|
||||
return [{"attachment_id": str(r[0]), "job_id": str(r[1]), "error_code": r[2], "last_error_code": r[3],
|
||||
"last_error": r[4], "attempts": r[5], "finished_at": r[6].isoformat() if r[6] else None}
|
||||
for r in rows]
|
||||
|
||||
def show(self, attachment_id: str) -> dict:
|
||||
"""Всё о задании вложения: состояние, журнал, строки outbox, варианты (без ключей доступа)."""
|
||||
with self._tx() as conn:
|
||||
job = conn.execute("""SELECT job_id, status, attempt, max_attempts, lease_owner, lease_until,
|
||||
next_attempt_at, last_error_code, last_error, created_at, finished_at
|
||||
FROM attachment_jobs WHERE attachment_id = %s""",
|
||||
(uuid.UUID(attachment_id),)).fetchone()
|
||||
if job is None:
|
||||
return {"result": "not_found"}
|
||||
events = conn.execute("""SELECT created_at, attempt, event, actor, detail FROM job_events
|
||||
WHERE job_id = %s ORDER BY id""", (job[0],)).fetchall()
|
||||
outbox = conn.execute("""SELECT id, attempt, available_at, published_at, published_by FROM outbox
|
||||
WHERE job_id = %s ORDER BY id""", (job[0],)).fetchall()
|
||||
variants = conn.execute("""SELECT name, storage_key, size_bytes, width, height, sha256
|
||||
FROM attachment_variants WHERE attachment_id = %s
|
||||
ORDER BY pipeline_version, name""", (uuid.UUID(attachment_id),)).fetchall()
|
||||
status = conn.execute("SELECT status, error_code FROM attachments WHERE id = %s",
|
||||
(uuid.UUID(attachment_id),)).fetchone()
|
||||
|
||||
def t(value):
|
||||
return value.isoformat() if value else None
|
||||
names = ("job_id", "status", "attempt", "max_attempts", "lease_owner", "lease_until", "next_attempt_at",
|
||||
"last_error_code", "last_error", "created_at", "finished_at")
|
||||
return {"attachment_status": status[0], "error_code": status[1],
|
||||
"job": {k: (t(v) if hasattr(v, "isoformat") else (str(v) if isinstance(v, uuid.UUID) else v))
|
||||
for k, v in zip(names, job)},
|
||||
"events": [{"at": t(e[0]), "attempt": e[1], "event": e[2], "actor": e[3], "detail": e[4]}
|
||||
for e in events],
|
||||
"outbox": [{"id": o[0], "attempt": o[1], "available_at": t(o[2]), "published_at": t(o[3]),
|
||||
"published_by": o[4]} for o in outbox],
|
||||
"variants": [{"name": v[0], "storage_key": v[1], "size_bytes": v[2], "width": v[3], "height": v[4],
|
||||
"sha256": v[5]} for v in variants]}
|
||||
|
||||
def stats(self) -> dict:
|
||||
with self._tx() as conn:
|
||||
by_status = dict(conn.execute("SELECT status, count(*) FROM attachment_jobs GROUP BY status").fetchall())
|
||||
unpublished = conn.execute("SELECT count(*) FROM outbox WHERE published_at IS NULL").fetchone()[0]
|
||||
processing = conn.execute("SELECT count(*) FROM attachment_jobs WHERE status = 'processing'").fetchone()[0]
|
||||
return {"jobs": by_status, "outbox_unpublished": unpublished, "processing_now": processing}
|
||||
|
||||
|
||||
def main(argv=None) -> int:
|
||||
"""Команды оператора (внутри контейнера worker):
|
||||
python -m messenger.jobs failed реестр failed
|
||||
python -m messenger.jobs show <attachment_id> состояние, журнал, outbox, варианты
|
||||
python -m messenger.jobs replay <attachment_id> [--actor имя] явный повтор failed
|
||||
python -m messenger.jobs stats сколько заданий в каждом состоянии
|
||||
"""
|
||||
parser = argparse.ArgumentParser(description="Задания обработки вложений")
|
||||
sub = parser.add_subparsers(dest="command", required=True)
|
||||
sub.add_parser("failed")
|
||||
sub.add_parser("stats")
|
||||
show = sub.add_parser("show")
|
||||
show.add_argument("attachment_id", type=uuid.UUID)
|
||||
replay = sub.add_parser("replay")
|
||||
replay.add_argument("attachment_id", type=uuid.UUID)
|
||||
replay.add_argument("--actor", default="operator")
|
||||
args = parser.parse_args(argv)
|
||||
logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(name)s: %(message)s")
|
||||
config.validate()
|
||||
from . import db
|
||||
pool = db.create_pool()
|
||||
pool.open()
|
||||
try:
|
||||
if args.command == "replay":
|
||||
config.validate_s3()
|
||||
from . import objects
|
||||
store = JobStore(pool, "operator:" + args.actor[:40])
|
||||
result = store.replay(str(args.attachment_id), objects.exists)
|
||||
else:
|
||||
store = JobStore(pool, "operator")
|
||||
result = {"failed": store.failed, "stats": store.stats}.get(args.command, None)
|
||||
result = result() if result else store.show(str(args.attachment_id))
|
||||
print(json.dumps(result, ensure_ascii=False, default=str))
|
||||
except Unavailable as exc:
|
||||
print(json.dumps({"error": exc.message}, ensure_ascii=False))
|
||||
return 1
|
||||
finally:
|
||||
pool.close()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,25 @@
|
||||
"""Миграции схемы БД отдельным процессом: `python -m messenger.migrate`.
|
||||
|
||||
Это команда одноразового сервиса migrate в compose.yaml. Он стартует после того,
|
||||
как PostgreSQL стал healthy, применяет новые migrations/*.sql и завершается с кодом 0.
|
||||
Реплики API запускаются только после успешного завершения migrate
|
||||
(depends_on: condition: service_completed_successfully) и сами схему не меняют.
|
||||
|
||||
Повторный запуск безопасен: применённые файлы отмечены в schema_migrations
|
||||
и второй раз не выполняются, а pg_advisory_lock не даёт двум запускам идти одновременно.
|
||||
"""
|
||||
import logging
|
||||
import sys
|
||||
|
||||
from . import config, db
|
||||
|
||||
|
||||
def main() -> int:
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
|
||||
config.validate()
|
||||
db.migrate_with_retry()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,297 @@
|
||||
"""Объектное хранилище S3 (SeaweedFS): байты вложений (с lab4).
|
||||
|
||||
Источник истины для СОДЕРЖИМОГО файла — приватный bucket, для МЕТАДАННЫХ — PostgreSQL.
|
||||
Ни одна реплика API не хранит оригинал у себя: любая реплика скачивает его из общего S3,
|
||||
поэтому файл доступен и после остановки реплики, которая его приняла.
|
||||
|
||||
Ключи объектов (с lab5) назначает сервер, имя файла от клиента в них не попадает:
|
||||
- staging/<attachment_id> — принятый оригинал до обработки (его пишет API перед ответом 202);
|
||||
- originals/<attachment_id> — опубликованный оригинал (его пишет worker перед статусом ready);
|
||||
- variants/<attachment_id>/v<версия>/<вариант>.<расширение> — thumbnail, crop, optimized.
|
||||
Ключ варианта однозначно задан ключом эффекта (attachment_id, pipeline_version, variant):
|
||||
повторная обработка пишет в тот же ключ те же байты и не создаёт второй набор.
|
||||
|
||||
API ходит в S3 под отдельным пользователем с минимальными правами (secrets/s3_config.json):
|
||||
читать, писать, удалять и перечислять объекты только своего bucket (действия Read/Write/List
|
||||
с именем bucket). Создавать и удалять bucket, менять его политику он не может.
|
||||
Ключ объекта назначает сервер (случайный UUID), имя файла от клиента в ключ не попадает.
|
||||
|
||||
Любая сетевая ошибка или таймаут S3 превращается в Unavailable (503), а не в 500.
|
||||
"""
|
||||
import concurrent.futures
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
|
||||
import boto3
|
||||
from botocore.config import Config
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
from . import config
|
||||
from .errors import Unavailable
|
||||
|
||||
log = logging.getLogger("messenger.objects")
|
||||
|
||||
PREFIX = "originals/" # опубликованные оригиналы (и оригиналы lab4)
|
||||
STAGING_PREFIX = "staging/" # принятые, но ещё не обработанные оригиналы (с lab5)
|
||||
VARIANTS_PREFIX = "variants/" # варианты (с lab5)
|
||||
CHUNK_BYTES = 64 * 1024 # скачивание отдаётся клиенту кусками, файл целиком в память не читается
|
||||
# Передача файла до 10 MiB внутри Docker-сети занимает доли секунды; запас на медленный диск.
|
||||
TRANSFER_TIMEOUT_SECONDS = 30
|
||||
|
||||
_client = None
|
||||
_client_lock = threading.Lock()
|
||||
|
||||
|
||||
# Каждая операция S3 выполняется в отдельном пуле потоков с общим пределом времени
|
||||
# S3_OPERATION_TIMEOUT_SECONDS. Таймауты boto3 (connect/read) не покрывают поиск имени в DNS:
|
||||
# когда контейнер s3 остановлен, разрешение имени "s3" внутри Docker может висеть 10+ с.
|
||||
# Предел гарантирует быстрый 503, даже если зависший поток ещё ждёт ответа DNS.
|
||||
_pool = concurrent.futures.ThreadPoolExecutor(max_workers=16, thread_name_prefix="s3")
|
||||
|
||||
|
||||
def _bounded(action: str, fn, timeout: float | None = None):
|
||||
future = _pool.submit(fn)
|
||||
try:
|
||||
return future.result(timeout=timeout or config.S3_OPERATION_TIMEOUT_SECONDS)
|
||||
except concurrent.futures.TimeoutError:
|
||||
log.warning("S3 %s: нет ответа за %s с", action, timeout or config.S3_OPERATION_TIMEOUT_SECONDS)
|
||||
raise Unavailable("Хранилище файлов временно недоступно") from None
|
||||
|
||||
|
||||
class MissingObject(Exception):
|
||||
"""Строка в БД есть, а объекта в S3 нет (нарушение согласованности, см. cleanup.py)."""
|
||||
|
||||
|
||||
def new_key() -> str:
|
||||
return PREFIX + uuid.uuid4().hex
|
||||
|
||||
|
||||
def staging_key(attachment_id: str) -> str:
|
||||
return STAGING_PREFIX + str(uuid.UUID(attachment_id))
|
||||
|
||||
|
||||
def original_key(attachment_id: str) -> str:
|
||||
return PREFIX + str(uuid.UUID(attachment_id))
|
||||
|
||||
|
||||
def variant_key(attachment_id: str, pipeline_version: int, name: str, extension: str) -> str:
|
||||
return f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/v{int(pipeline_version)}/{name}{extension}"
|
||||
|
||||
|
||||
def attachment_of(key: str) -> str | None:
|
||||
"""ID вложения, которому принадлежит ключ: staging/<id>, originals/<id>, variants/<id>/...
|
||||
Для ключа другого вида — None (уборщик решает по ключу, к какому вложению идти за блокировкой)."""
|
||||
for prefix in (STAGING_PREFIX, PREFIX, VARIANTS_PREFIX):
|
||||
if key.startswith(prefix):
|
||||
try:
|
||||
return str(uuid.UUID(key[len(prefix):].split("/", 1)[0]))
|
||||
except ValueError:
|
||||
return None
|
||||
return None
|
||||
|
||||
|
||||
def prefixes_of(attachment_id: str) -> list[str]:
|
||||
"""Префиксы всех объектов одного вложения (для уборки одного вложения: cleanup --attachment)."""
|
||||
return [staging_key(attachment_id), original_key(attachment_id), f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/"]
|
||||
|
||||
|
||||
def client():
|
||||
"""Один клиент на процесс (клиенты boto3 потокобезопасны), создаётся при первом обращении."""
|
||||
global _client
|
||||
with _client_lock:
|
||||
if _client is None:
|
||||
_client = boto3.session.Session().client(
|
||||
"s3",
|
||||
endpoint_url=config.S3_ENDPOINT,
|
||||
region_name=config.S3_REGION,
|
||||
aws_access_key_id=config.S3_ACCESS_KEY_ID,
|
||||
aws_secret_access_key=config.S3_SECRET_ACCESS_KEY,
|
||||
config=Config(
|
||||
signature_version="s3v4",
|
||||
s3={"addressing_style": "path"}, # http://s3:9000/<bucket>/<key>
|
||||
connect_timeout=config.S3_CONNECT_TIMEOUT_SECONDS,
|
||||
read_timeout=config.S3_READ_TIMEOUT_SECONDS,
|
||||
retries={"max_attempts": config.S3_MAX_ATTEMPTS, "mode": "standard"},
|
||||
max_pool_connections=20,
|
||||
# Без дополнительных CRC-заголовков новых версий boto3: целостность проверяем
|
||||
# своим SHA-256 (он же в метаданных объекта), а сервер S3 не обязан их понимать.
|
||||
request_checksum_calculation="when_required",
|
||||
response_checksum_validation="when_required",
|
||||
),
|
||||
)
|
||||
return _client
|
||||
|
||||
|
||||
def _unavailable(action: str, exc: Exception) -> Unavailable:
|
||||
# В лог — только тип ошибки и код S3: без ключей доступа и адресов с паролями.
|
||||
code = exc.response.get("Error", {}).get("Code", "") if isinstance(exc, ClientError) else ""
|
||||
log.warning("S3 %s не удалось: %s %s", action, type(exc).__name__, code)
|
||||
return Unavailable("Хранилище файлов временно недоступно")
|
||||
|
||||
|
||||
def _is_missing(exc: ClientError) -> bool:
|
||||
return exc.response.get("Error", {}).get("Code") in ("NoSuchKey", "404", "NotFound")
|
||||
|
||||
|
||||
# ---------- готовность S3 для /health/ready (с lab5) ----------
|
||||
# Отдельный поток раз в S3_HEALTH_INTERVAL_SECONDS делает HEAD bucket отдельным клиентом с короткими
|
||||
# таймаутами. Readiness только читает время последнего успеха, сам в S3 не ходит: healthcheck
|
||||
# отвечает мгновенно, а зависший запрос в S3 (например, поиск DNS-имени остановленного контейнера)
|
||||
# не копит потоки — проверка идёт строго одна за другой.
|
||||
_last_ok = 0.0
|
||||
|
||||
|
||||
def healthy() -> bool:
|
||||
return time.monotonic() - _last_ok < config.S3_HEALTH_MAX_AGE_SECONDS
|
||||
|
||||
|
||||
def start_monitor(stop: threading.Event) -> threading.Thread:
|
||||
probe = boto3.session.Session().client(
|
||||
"s3", endpoint_url=config.S3_ENDPOINT, region_name=config.S3_REGION,
|
||||
aws_access_key_id=config.S3_ACCESS_KEY_ID, aws_secret_access_key=config.S3_SECRET_ACCESS_KEY,
|
||||
config=Config(signature_version="s3v4", s3={"addressing_style": "path"}, connect_timeout=1,
|
||||
read_timeout=2, retries={"max_attempts": 1, "mode": "standard"},
|
||||
request_checksum_calculation="when_required",
|
||||
response_checksum_validation="when_required"))
|
||||
|
||||
def loop():
|
||||
global _last_ok
|
||||
was_ok = None
|
||||
while not stop.is_set():
|
||||
try:
|
||||
probe.head_bucket(Bucket=config.S3_BUCKET)
|
||||
_last_ok = time.monotonic()
|
||||
ok = True
|
||||
except (BotoCoreError, ClientError, OSError):
|
||||
ok = False
|
||||
if ok != was_ok:
|
||||
(log.info if ok else log.warning)("S3 %s", "доступен" if ok else "недоступен: /health/ready -> 503")
|
||||
was_ok = ok
|
||||
stop.wait(config.S3_HEALTH_INTERVAL_SECONDS)
|
||||
|
||||
thread = threading.Thread(target=loop, name="s3-monitor", daemon=True)
|
||||
thread.start()
|
||||
return thread
|
||||
|
||||
|
||||
def put(key: str, fileobj, size: int, content_type: str, sha256: str, timeout: float | None = None) -> None:
|
||||
"""Записать объект. Тело читается из файла кусками (boto3 не держит его целиком в памяти).
|
||||
|
||||
Возврат без ошибки = S3 ответил 200 на PUT: объект записан и виден всем репликам.
|
||||
"""
|
||||
fileobj.seek(0)
|
||||
_bounded("PUT", lambda: _put(key, fileobj, size, content_type, sha256), timeout)
|
||||
|
||||
|
||||
def put_file(key: str, path: str, content_type: str, sha256: str) -> None:
|
||||
"""Записать файл с диска (worker: оригинал и варианты)."""
|
||||
import os
|
||||
with open(path, "rb") as f:
|
||||
put(key, f, os.path.getsize(path), content_type, sha256, TRANSFER_TIMEOUT_SECONDS)
|
||||
|
||||
|
||||
def _put(key, fileobj, size, content_type, sha256):
|
||||
try:
|
||||
client().put_object(Bucket=config.S3_BUCKET, Key=key, Body=fileobj, ContentLength=size,
|
||||
ContentType=content_type, Metadata={"sha256": sha256})
|
||||
except (BotoCoreError, ClientError) as exc:
|
||||
raise _unavailable("PUT", exc) from None
|
||||
|
||||
|
||||
def open_stream(key: str):
|
||||
"""Открыть объект на чтение: StreamingBody, из которого читаем кусками по CHUNK_BYTES."""
|
||||
return _bounded("GET", lambda: _open_stream(key))
|
||||
|
||||
|
||||
def _open_stream(key: str):
|
||||
try:
|
||||
return client().get_object(Bucket=config.S3_BUCKET, Key=key)["Body"]
|
||||
except ClientError as exc:
|
||||
if _is_missing(exc):
|
||||
raise MissingObject(key) from None
|
||||
raise _unavailable("GET", exc) from None
|
||||
except BotoCoreError as exc:
|
||||
raise _unavailable("GET", exc) from None
|
||||
|
||||
|
||||
def download(key: str, path: str, max_bytes: int) -> int:
|
||||
"""Скачать объект в файл (worker). Больше max_bytes не читаем: это защита от подмены объекта."""
|
||||
return _bounded("GET", lambda: _download(key, path, max_bytes), TRANSFER_TIMEOUT_SECONDS)
|
||||
|
||||
|
||||
def _download(key: str, path: str, max_bytes: int) -> int:
|
||||
body = _open_stream(key)
|
||||
size = 0
|
||||
try:
|
||||
with open(path, "wb") as f:
|
||||
while True:
|
||||
chunk = body.read(CHUNK_BYTES)
|
||||
if not chunk:
|
||||
return size
|
||||
size += len(chunk)
|
||||
if size > max_bytes:
|
||||
raise Unavailable("Объект больше допустимого размера")
|
||||
f.write(chunk)
|
||||
except (BotoCoreError, OSError) as exc:
|
||||
raise _unavailable("GET", exc) from None
|
||||
finally:
|
||||
body.close()
|
||||
|
||||
|
||||
def exists(key: str) -> bool:
|
||||
"""Есть ли объект (HEAD). Нужно для replay: оригинал в staging ещё хранится?"""
|
||||
return _bounded("HEAD", lambda: _exists(key))
|
||||
|
||||
|
||||
def _exists(key: str) -> bool:
|
||||
try:
|
||||
client().head_object(Bucket=config.S3_BUCKET, Key=key)
|
||||
return True
|
||||
except ClientError as exc:
|
||||
if _is_missing(exc):
|
||||
return False
|
||||
raise _unavailable("HEAD", exc) from None
|
||||
except BotoCoreError as exc:
|
||||
raise _unavailable("HEAD", exc) from None
|
||||
|
||||
|
||||
def iter_chunks(body):
|
||||
"""Генератор для StreamingResponse: отдаёт файл кусками и закрывает соединение с S3."""
|
||||
try:
|
||||
while True:
|
||||
chunk = body.read(CHUNK_BYTES)
|
||||
if not chunk:
|
||||
return
|
||||
yield chunk
|
||||
finally:
|
||||
body.close()
|
||||
|
||||
|
||||
def delete(key: str) -> None:
|
||||
"""Удалить объект. Идемпотентно: удаление уже удалённого ключа — не ошибка."""
|
||||
_bounded("DELETE", lambda: _delete(key))
|
||||
|
||||
|
||||
def _delete(key: str) -> None:
|
||||
try:
|
||||
client().delete_object(Bucket=config.S3_BUCKET, Key=key)
|
||||
except (BotoCoreError, ClientError) as exc:
|
||||
raise _unavailable("DELETE", exc) from None
|
||||
|
||||
|
||||
def list_objects(prefix: str = ""):
|
||||
"""Все объекты под префиксом: [(ключ, время изменения)]. Нужен уборщику для сверки с БД."""
|
||||
return _bounded("LIST", lambda: _list_objects(prefix), timeout=config.S3_OPERATION_TIMEOUT_SECONDS * 10)
|
||||
|
||||
|
||||
def _list_objects(prefix: str):
|
||||
result: list[tuple[str, datetime]] = []
|
||||
try:
|
||||
for page in client().get_paginator("list_objects_v2").paginate(Bucket=config.S3_BUCKET, Prefix=prefix):
|
||||
result += [(item["Key"], item["LastModified"]) for item in page.get("Contents", [])]
|
||||
except (BotoCoreError, ClientError) as exc:
|
||||
raise _unavailable("LIST", exc) from None
|
||||
return result
|
||||
@@ -0,0 +1,140 @@
|
||||
"""Relay transactional outbox (с lab5): фоновый поток в каждой реплике API.
|
||||
|
||||
Задача — доставить в брокер каждую строку outbox хотя бы один раз:
|
||||
1. взять неотправленные строки, у которых подошло время (available_at), с блокировкой
|
||||
FOR UPDATE SKIP LOCKED — две реплики API не отправляют одну строку одновременно;
|
||||
2. отправить каждую в брокер и дождаться publisher confirm;
|
||||
3. отметить отправленные (published_at) и COMMIT.
|
||||
|
||||
Окна отказа и что происходит:
|
||||
- API упал после COMMIT загрузки, до отправки: строка осталась в outbox -> её отправит relay
|
||||
другой реплики (или этой после перезапуска). Новое задание вручную создавать не нужно;
|
||||
- relay упал после выборки, до отправки: транзакция откатывается вместе с соединением,
|
||||
блокировки снимаются, строки остаются неотправленными -> их отправят позже;
|
||||
- relay упал после подтверждения брокера, до отметки: строка отправится ещё раз (дубль).
|
||||
Это нормально для at-least-once: worker распознаёт дубль по состоянию задания;
|
||||
- брокер недоступен: строки копятся в outbox (в PostgreSQL), загрузки продолжают получать 202.
|
||||
Relay пробует снова с паузой 1, 2, 4… до 10 с.
|
||||
Relay будится сразу после загрузки в этом же процессе (nudge) и сам раз в RELAY_POLL_SECONDS:
|
||||
так он подхватывает строки других процессов — повторы с паузой и replay из worker.
|
||||
"""
|
||||
import logging
|
||||
import threading
|
||||
|
||||
import psycopg
|
||||
|
||||
from . import broker, config, db, faults
|
||||
|
||||
log = logging.getLogger("messenger.relay")
|
||||
|
||||
|
||||
class OutboxRelay:
|
||||
def __init__(self):
|
||||
self._wake = threading.Event()
|
||||
self._stop = threading.Event()
|
||||
self._thread = None
|
||||
self._conn = None
|
||||
self._publisher = broker.Publisher("relay")
|
||||
self._healthy = None # для логов: пишем только смену состояния
|
||||
self.published_total = 0
|
||||
|
||||
def start(self) -> None:
|
||||
self._thread = threading.Thread(target=self._loop, name="outbox-relay", daemon=True)
|
||||
self._thread.start()
|
||||
|
||||
def nudge(self) -> None:
|
||||
"""Есть новая строка outbox: отправить сейчас, не дожидаясь очередного опроса."""
|
||||
self._wake.set()
|
||||
|
||||
def stop(self) -> None:
|
||||
self._stop.set()
|
||||
self._wake.set()
|
||||
if self._thread is not None:
|
||||
self._thread.join(timeout=5)
|
||||
self._publisher.close()
|
||||
self._close_db()
|
||||
|
||||
def _db(self):
|
||||
if self._conn is None or self._conn.closed:
|
||||
kwargs = db.connection_kwargs()
|
||||
kwargs["application_name"] = "messenger-relay"
|
||||
self._conn = psycopg.connect(config.DATABASE_URL, autocommit=True, **kwargs)
|
||||
return self._conn
|
||||
|
||||
def _close_db(self) -> None:
|
||||
try:
|
||||
if self._conn is not None:
|
||||
self._conn.close()
|
||||
except psycopg.Error:
|
||||
pass
|
||||
self._conn = None
|
||||
|
||||
def _state(self, ok: bool, reason: str = "") -> None:
|
||||
if ok != self._healthy:
|
||||
if ok:
|
||||
log.info("relay: связь с брокером и PostgreSQL есть, outbox отправляется")
|
||||
else:
|
||||
log.warning("relay: не могу отправить outbox (%s), строки ждут в PostgreSQL", reason)
|
||||
self._healthy = ok
|
||||
|
||||
def _loop(self) -> None:
|
||||
pause = 1.0
|
||||
while not self._stop.is_set():
|
||||
self._wake.wait(config.RELAY_POLL_SECONDS)
|
||||
self._wake.clear()
|
||||
if self._stop.is_set():
|
||||
break
|
||||
try:
|
||||
while self.publish_batch() == config.RELAY_BATCH_SIZE: # пока есть полные пачки
|
||||
pass
|
||||
self._publisher.service()
|
||||
self._state(True)
|
||||
pause = 1.0
|
||||
except broker.BrokerError as exc:
|
||||
self._state(False, "брокер: " + type(exc).__name__)
|
||||
self._publisher.close()
|
||||
self._stop.wait(pause)
|
||||
pause = min(pause * 2, 10.0)
|
||||
except psycopg.Error as exc:
|
||||
self._state(False, "PostgreSQL: " + type(exc).__name__)
|
||||
self._close_db()
|
||||
self._stop.wait(pause)
|
||||
pause = min(pause * 2, 10.0)
|
||||
except Exception:
|
||||
log.exception("relay: неожиданная ошибка")
|
||||
self._publisher.close()
|
||||
self._close_db()
|
||||
self._stop.wait(pause)
|
||||
pause = min(pause * 2, 10.0)
|
||||
|
||||
def publish_batch(self) -> int:
|
||||
"""Одна пачка: выбрать -> отправить с подтверждением -> отметить. Возвращает число строк в пачке."""
|
||||
conn = self._db()
|
||||
error = None
|
||||
sent = []
|
||||
with conn.transaction():
|
||||
rows = conn.execute("""SELECT id, payload FROM outbox
|
||||
WHERE published_at IS NULL AND available_at <= now()
|
||||
ORDER BY available_at, id LIMIT %s
|
||||
FOR UPDATE SKIP LOCKED""", (config.RELAY_BATCH_SIZE,)).fetchall()
|
||||
if not rows:
|
||||
return 0
|
||||
faults.hit("relay_before_publish")
|
||||
for row_id, payload in rows:
|
||||
try:
|
||||
self._publisher.publish(payload)
|
||||
except broker.BrokerError as exc:
|
||||
error = exc # отправленное до ошибки всё равно отметим
|
||||
break
|
||||
sent.append(row_id)
|
||||
if sent:
|
||||
faults.hit("relay_after_publish")
|
||||
conn.execute("""UPDATE outbox SET published_at = now(), published_by = %s
|
||||
WHERE id = ANY(%s)""", ("relay-" + config.INSTANCE_ID, sent))
|
||||
if sent:
|
||||
self.published_total += len(sent)
|
||||
log.info("relay: отправлено в брокер %d (подтверждено), всего %d", len(sent), self.published_total)
|
||||
if error is not None:
|
||||
raise error
|
||||
return len(rows)
|
||||
|
||||
@@ -0,0 +1,74 @@
|
||||
"""Настройка S3 для стенда: сервис s3-init в compose.yaml (`python -m messenger.s3bootstrap`).
|
||||
|
||||
Идемпотентно, как migrate для БД: запускается при каждом `docker compose up`, повтор безопасен.
|
||||
1. ждёт, пока SeaweedFS начнёт отвечать (до 60 с);
|
||||
2. создаёт bucket, только если его ещё нет (HeadBucket -> CreateBucket); данные не трогает;
|
||||
3. проверяет, что bucket приватный: запрос списка объектов БЕЗ подписи должен получить 403.
|
||||
Пользователи и права задаются не здесь, а файлом-секретом s3_config.json (scripts/init-secrets.sh):
|
||||
у API действия Read/Write/List только для этого bucket, анонимного пользователя нет.
|
||||
|
||||
Ключи администратора S3 есть только у этого сервиса (и в конфиге SeaweedFS), у API — свои.
|
||||
Модуль намеренно не импортирует messenger.config: секретов БД у этого сервиса нет.
|
||||
Секреты в вывод не попадают.
|
||||
"""
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
import boto3
|
||||
from botocore.config import Config
|
||||
from botocore.exceptions import BotoCoreError, ClientError
|
||||
|
||||
|
||||
def secret(name: str) -> str:
|
||||
return Path(os.environ[name]).read_text(encoding="utf-8").strip()
|
||||
|
||||
|
||||
def main() -> int:
|
||||
endpoint = os.environ.get("S3_ENDPOINT", "http://s3:9000")
|
||||
bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
|
||||
s3 = boto3.session.Session().client(
|
||||
"s3", endpoint_url=endpoint, region_name=os.environ.get("S3_REGION", "us-east-1"),
|
||||
aws_access_key_id=secret("S3_ADMIN_ACCESS_KEY_ID_FILE"),
|
||||
aws_secret_access_key=secret("S3_ADMIN_SECRET_ACCESS_KEY_FILE"),
|
||||
config=Config(signature_version="s3v4", s3={"addressing_style": "path"}, connect_timeout=2,
|
||||
read_timeout=10, retries={"max_attempts": 2, "mode": "standard"},
|
||||
request_checksum_calculation="when_required", response_checksum_validation="when_required"))
|
||||
|
||||
deadline = time.monotonic() + 60
|
||||
while True:
|
||||
try:
|
||||
s3.head_bucket(Bucket=bucket)
|
||||
created = False
|
||||
break
|
||||
except ClientError as exc:
|
||||
if exc.response.get("Error", {}).get("Code") in ("404", "NoSuchBucket", "NotFound"):
|
||||
s3.create_bucket(Bucket=bucket)
|
||||
created = True
|
||||
break
|
||||
reason = exc.response.get("Error", {}).get("Code")
|
||||
except BotoCoreError as exc:
|
||||
reason = type(exc).__name__
|
||||
if time.monotonic() > deadline:
|
||||
print(f"s3-init: S3 is not ready ({reason})", file=sys.stderr)
|
||||
return 1
|
||||
time.sleep(1)
|
||||
|
||||
try:
|
||||
urllib.request.urlopen(f"{endpoint}/{bucket}?list-type=2", timeout=5)
|
||||
print("s3-init: bucket answers WITHOUT a signature — it is public, stop", file=sys.stderr)
|
||||
return 1
|
||||
except urllib.error.HTTPError as error:
|
||||
if error.code != 403:
|
||||
print(f"s3-init: unexpected anonymous status {error.code}", file=sys.stderr)
|
||||
return 1
|
||||
print(f"s3-init: bucket {bucket} {'created' if created else 'already exists'}; "
|
||||
f"anonymous access: 403 (private)")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,104 @@
|
||||
"""Запуск обработки картинки в дочернем процессе с лимитами памяти и времени (с lab5).
|
||||
|
||||
Зачем отдельный процесс. Декодирование и resize идут в C-коде Pillow: поток Python нельзя
|
||||
прервать посередине, а MemoryError в одном потоке может задеть весь процесс. Дочерний процесс
|
||||
можно просто убить, и у него свой лимит памяти:
|
||||
- время: если результата нет за JOB_TIMEOUT_SECONDS, процесс получает SIGKILL -> ProcessingTimeout;
|
||||
- память: RLIMIT_AS (адресное пространство) = WORKER_MEMORY_LIMIT_MB. Нехватка -> MemoryError
|
||||
внутри Pillow -> ImageTooLarge; если процесс всё же умер (например, OOM killer) -> ChildCrashed;
|
||||
- пиксели и байты проверяются ещё до декодирования (imaging.py и worker.py).
|
||||
|
||||
Процессы создаются через forkserver: сервер-родитель запускается один раз и заранее загружает
|
||||
Pillow и libjpeg-turbo (preload), а каждый дочерний процесс — быстрая копия этого сервера.
|
||||
fork прямо из worker был бы опасен: у worker есть потоки (брокер, продление lease),
|
||||
а копия процесса с чужими захваченными блокировками может зависнуть.
|
||||
"""
|
||||
import multiprocessing
|
||||
import os
|
||||
import resource
|
||||
import signal
|
||||
|
||||
from . import imaging
|
||||
|
||||
_ctx = multiprocessing.get_context("forkserver")
|
||||
_ctx.set_forkserver_preload(["messenger.imaging"])
|
||||
|
||||
|
||||
class ProcessingTimeout(Exception):
|
||||
"""Не уложились в лимит времени: процесс убит. Временная ошибка (может помочь повтор)."""
|
||||
code = "processing_timeout"
|
||||
|
||||
|
||||
class ChildCrashed(Exception):
|
||||
"""Дочерний процесс завершился, не прислав результата (убит сигналом). Временная ошибка."""
|
||||
code = "worker_crashed"
|
||||
|
||||
|
||||
def _child(conn, src_path, out_dir, content_type, params, memory_limit_bytes, slow_seconds):
|
||||
try:
|
||||
signal.signal(signal.SIGTERM, signal.SIG_DFL)
|
||||
if memory_limit_bytes:
|
||||
resource.setrlimit(resource.RLIMIT_AS, (memory_limit_bytes, memory_limit_bytes))
|
||||
resource.setrlimit(resource.RLIMIT_CORE, (0, 0)) # без core dump на диск контейнера
|
||||
if slow_seconds: # только для тестов «долгой задачи» (faults.py: worker_slow)
|
||||
import time
|
||||
time.sleep(slow_seconds)
|
||||
conn.send(("ok", imaging.process(src_path, out_dir, content_type, params)))
|
||||
except imaging.ImageError as exc:
|
||||
conn.send(("error", exc.code, str(exc)))
|
||||
except MemoryError:
|
||||
conn.send(("error", "image_too_large", "Не хватило лимита памяти на обработку картинки"))
|
||||
except Exception as exc: # неожиданная ошибка: тип без подробностей (там могут быть пути)
|
||||
conn.send(("unexpected", type(exc).__name__))
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
def run(src_path: str, out_dir: str, content_type: str, params: imaging.Params,
|
||||
timeout: float, memory_limit_mb: int, slow_seconds: float = 0, abort=None) -> dict:
|
||||
"""Результат imaging.process из дочернего процесса.
|
||||
|
||||
abort — threading.Event: если lease потерян (задачу забрал другой worker), процесс убивается
|
||||
сразу, не дожидаясь конца обработки.
|
||||
Исключения: imaging.InvalidImage / ImageTooLarge (постоянные), ProcessingTimeout,
|
||||
ChildCrashed, RuntimeError (временные).
|
||||
"""
|
||||
receiver, sender = _ctx.Pipe(duplex=False)
|
||||
proc = _ctx.Process(target=_child, daemon=True,
|
||||
args=(sender, src_path, out_dir, content_type, params,
|
||||
memory_limit_mb * 1024 * 1024, slow_seconds))
|
||||
proc.start()
|
||||
sender.close()
|
||||
try:
|
||||
waited, step = 0.0, 0.2
|
||||
while not receiver.poll(step):
|
||||
waited += step
|
||||
if abort is not None and abort.is_set():
|
||||
raise ChildCrashed("lease потерян, обработка прервана")
|
||||
if waited >= timeout:
|
||||
raise ProcessingTimeout(f"обработка дольше {timeout:g} с")
|
||||
if not proc.is_alive() and not receiver.poll(0):
|
||||
raise ChildCrashed(f"код завершения {proc.exitcode}")
|
||||
try:
|
||||
message = receiver.recv()
|
||||
except EOFError:
|
||||
proc.join(2)
|
||||
raise ChildCrashed(f"код завершения {proc.exitcode}") from None
|
||||
finally:
|
||||
receiver.close()
|
||||
if proc.is_alive():
|
||||
proc.kill()
|
||||
proc.join(5)
|
||||
if message[0] == "ok":
|
||||
return message[1]
|
||||
if message[0] == "error":
|
||||
error = imaging.ImageTooLarge if message[1] == "image_too_large" else imaging.InvalidImage
|
||||
raise error(message[2])
|
||||
raise RuntimeError("неожиданная ошибка обработки: " + message[1])
|
||||
|
||||
|
||||
def warm_up() -> None:
|
||||
"""Запустить forkserver заранее, при старте worker (первая задача не ждёт импорта Pillow)."""
|
||||
proc = _ctx.Process(target=os.getpid)
|
||||
proc.start()
|
||||
proc.join(30)
|
||||
@@ -0,0 +1,80 @@
|
||||
"""Пароли, токены и разбор заголовка Authorization.
|
||||
|
||||
Две разные задачи хеширования:
|
||||
- пароль хешируется МЕДЛЕННОЙ функцией Argon2id с солью: перебор паролей по украденной
|
||||
базе стоит дорого (каждая попытка — десятки миллисекунд и 19 МиБ памяти);
|
||||
- токен сессии хешируется БЫСТРЫМ SHA-256: токен — 256 случайных бит, перебирать
|
||||
его бессмысленно, а проверять его нужно на каждом запросе.
|
||||
"""
|
||||
import base64
|
||||
import binascii
|
||||
import hashlib
|
||||
import re
|
||||
import secrets
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import InvalidHashError, VerificationError
|
||||
|
||||
# Параметры Argon2id — минимальные из рекомендаций OWASP: m=19 МиБ, t=2, p=1.
|
||||
# Больше памяти — дороже перебор, но и каждый вход дороже для сервера.
|
||||
_hasher = PasswordHasher(time_cost=2, memory_cost=19 * 1024, parallelism=1)
|
||||
|
||||
# Hash заведомо неверного пароля. Если пользователя нет, всё равно выполняем проверку:
|
||||
# ответ занимает столько же времени, и по задержке нельзя узнать, существует ли username.
|
||||
_DUMMY_HASH = _hasher.hash("timing-equalizer-not-a-password")
|
||||
|
||||
TOKEN_BYTES = 32 # 32 байта = 256 бит энтропии (требование контракта)
|
||||
PASSWORD_MIN, PASSWORD_MAX = 12, 128
|
||||
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}") # то же правило, что при регистрации
|
||||
MAX_BASIC_HEADER = 1024 # длинный заголовок не проверяем: не тратим CPU на заведомый мусор
|
||||
|
||||
|
||||
def hash_password(password: str) -> str:
|
||||
return _hasher.hash(password) # строка вида $argon2id$v=19$m=19456,t=2,p=1$<соль>$<hash>
|
||||
|
||||
|
||||
def verify_password(password_hash: str | None, password: str) -> bool:
|
||||
try:
|
||||
return _hasher.verify(password_hash or _DUMMY_HASH, password) and password_hash is not None
|
||||
except (VerificationError, InvalidHashError):
|
||||
return False
|
||||
|
||||
|
||||
def new_token() -> str:
|
||||
"""Непрозрачный случайный токен: не username, не UUID и не JWT."""
|
||||
return secrets.token_urlsafe(TOKEN_BYTES)
|
||||
|
||||
|
||||
def token_hash(token: str) -> bytes:
|
||||
"""В БД и в кэше хранится только SHA-256 токена — сам токен знает лишь клиент."""
|
||||
return hashlib.sha256(token.encode("utf-8")).digest()
|
||||
|
||||
|
||||
def _split_scheme(header: str | None) -> tuple[str, str]:
|
||||
scheme, _, value = (header or "").strip().partition(" ")
|
||||
return scheme.lower(), value.strip()
|
||||
|
||||
|
||||
def parse_basic(header: str | None) -> tuple[str, str] | None:
|
||||
"""Authorization: Basic base64(username:password) -> (username, password) или None.
|
||||
|
||||
Пароль в UTF-8 и может содержать двоеточие: делим по ПЕРВОМУ двоеточию (RFC 7617).
|
||||
"""
|
||||
scheme, value = _split_scheme(header)
|
||||
if scheme != "basic" or not value or len(value) > MAX_BASIC_HEADER:
|
||||
return None
|
||||
try:
|
||||
decoded = base64.b64decode(value, validate=True).decode("utf-8")
|
||||
except (binascii.Error, ValueError):
|
||||
return None
|
||||
username, sep, password = decoded.partition(":")
|
||||
if not sep or not username.isascii():
|
||||
return None
|
||||
return username, password
|
||||
|
||||
|
||||
def parse_bearer(header: str | None) -> str | None:
|
||||
scheme, value = _split_scheme(header)
|
||||
if scheme != "bearer" or not value or len(value) > 512 or " " in value:
|
||||
return None
|
||||
return value
|
||||
@@ -0,0 +1,228 @@
|
||||
"""Сессии: вход (Basic -> токен), проверка Bearer-токена, выход.
|
||||
|
||||
Где что хранится:
|
||||
- ИСТОЧНИК ИСТИНЫ — таблица sessions в PostgreSQL. Она переживает рестарт и решает,
|
||||
действует ли сессия (не отозвана и не истекла).
|
||||
- Valkey — КЭШ «hash токена -> пользователь», ОДИН НА ВСЕ РЕПЛИКИ API. Он избавляет от
|
||||
SQL-запроса на каждом обращении с токеном. Запись, положенную одной репликой, используют
|
||||
все остальные. Кэш можно в любой момент очистить или потерять: при промахе данные
|
||||
берутся из PostgreSQL и снова кладутся в кэш.
|
||||
|
||||
Политика кэша:
|
||||
- запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии): кэш никогда
|
||||
не продлевает сессию, а истёкшая запись к тому же отбрасывается по expires_at;
|
||||
- logout: сначала отметка revoked_at в PostgreSQL, затем в кэш вместо записи о сессии
|
||||
кладётся отметка «отозвано» (tombstone). Новая запись о сессии кладётся только если ключа
|
||||
нет (SET NX), поэтому запрос, который прочитал сессию из базы до logout, не сможет
|
||||
«воскресить» её в кэше после logout;
|
||||
- ОБЩЕЕ поколение кэша (с lab3): в Valkey лежит ключ sess:gen, каждая запись о сессии помечена
|
||||
поколением, в котором её положили. Запись читается одним запросом MGET вместе с текущим
|
||||
поколением и считается доверенной, только если поколения совпадают. Каждая реплика раз
|
||||
в CACHE_CHECK_INTERVAL_SECONDS проверяет Valkey (фоновый поток). Реплика, заметившая сбой, перестаёт
|
||||
пользоваться кэшем, а когда Valkey вернулся, СНАЧАЛА записывает новое случайное поколение
|
||||
и только потом снова включает кэш. Зачем: пока Valkey был недоступен, logout не мог положить
|
||||
отметку «отозвано», и в кэше могла остаться старая запись «токен -> пользователь». После смены
|
||||
поколения её не доверяет ни одна реплика: проверка идёт в PostgreSQL, где сессия отозвана -> 401.
|
||||
Отметки «отозвано» действуют в любом поколении: они только запрещают, а не разрешают;
|
||||
- если Valkey недоступен, его обходят: всё работает напрямую через PostgreSQL.
|
||||
Ожидание подключения (в Docker это ещё и поиск DNS-имени остановленного контейнера,
|
||||
до нескольких секунд) достаётся фоновому потоку, а не запросам пользователей.
|
||||
"""
|
||||
import json
|
||||
import logging
|
||||
import secrets
|
||||
import threading
|
||||
import time
|
||||
from dataclasses import asdict, dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import valkey
|
||||
|
||||
from . import config, security
|
||||
from .store import PostgresStore, User, ts
|
||||
|
||||
log = logging.getLogger("messenger.sessions")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class AuthContext:
|
||||
"""Результат успешной проверки токена: кто пришёл и какой сессией (нужно для logout)."""
|
||||
user: User
|
||||
token_hash: bytes
|
||||
|
||||
|
||||
class SessionCache:
|
||||
PREFIX = "sess:" # пользователю Valkey разрешены только ключи sess:* (ACL: secrets/valkey_users.acl)
|
||||
GENERATION_KEY = PREFIX + "gen" # общее для всех реплик поколение кэша
|
||||
NO_GENERATION = "-" # sess:gen ещё не создан (свежий Valkey)
|
||||
|
||||
def __init__(self, url: str):
|
||||
self._client = None
|
||||
self._down = False # True = кэш считается недоступным, запросы его не трогают
|
||||
self._lock = threading.Lock()
|
||||
self._monitor = None
|
||||
if url:
|
||||
timeout = config.CACHE_TIMEOUT_MS / 1000
|
||||
pool = valkey.BlockingConnectionPool.from_url(
|
||||
url,
|
||||
max_connections=config.CACHE_POOL_MAX_SIZE, # ограниченный пул соединений
|
||||
timeout=timeout, # сколько ждать свободное соединение
|
||||
socket_timeout=timeout, # сколько ждать ответ
|
||||
socket_connect_timeout=timeout, # сколько ждать подключение
|
||||
lib_name=None, lib_version=None,
|
||||
)
|
||||
self._client = valkey.Valkey(connection_pool=pool)
|
||||
|
||||
@property
|
||||
def enabled(self) -> bool:
|
||||
return self._client is not None
|
||||
|
||||
def _available(self) -> bool:
|
||||
return self._client is not None and not self._down
|
||||
|
||||
def _failed(self, operation: str, exc: Exception) -> None:
|
||||
with self._lock:
|
||||
if self._down: # уже знаем о сбое
|
||||
return
|
||||
self._down = True
|
||||
log.warning("Valkey недоступен (%s при %s): работаем напрямую с PostgreSQL",
|
||||
type(exc).__name__, operation)
|
||||
|
||||
# --- фоновая проверка Valkey (один поток на процесс) ---
|
||||
|
||||
def start_monitor(self) -> None:
|
||||
if self._client is None or self._monitor is not None:
|
||||
return
|
||||
self._monitor = threading.Thread(target=self._watch, name="valkey-monitor", daemon=True)
|
||||
self._monitor.start()
|
||||
|
||||
def _watch(self) -> None:
|
||||
while True:
|
||||
if not self._down:
|
||||
try:
|
||||
# Проверка связи и заодно «создать поколение, если его ещё нет» (свежий Valkey).
|
||||
# NX: существующее поколение не трогаем.
|
||||
self._client.set(self.GENERATION_KEY, secrets.token_hex(8), nx=True)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("heartbeat", exc)
|
||||
else:
|
||||
try:
|
||||
# Valkey вернулся. Сначала НОВОЕ общее поколение: всё, что лежало в кэше до сбоя,
|
||||
# перестаёт быть доверенным для ВСЕХ реплик. Только потом снова пользуемся кэшем.
|
||||
self._client.set(self.GENERATION_KEY, secrets.token_hex(8))
|
||||
with self._lock:
|
||||
self._down = False
|
||||
log.info("Valkey снова доступен: новое поколение кэша, записи до сбоя не используются")
|
||||
except valkey.ValkeyError:
|
||||
pass
|
||||
time.sleep(config.CACHE_CHECK_INTERVAL_SECONDS)
|
||||
|
||||
# --- операции с кэшем; любая ошибка -> кэш выключается до возвращения Valkey ---
|
||||
|
||||
def lookup(self, key: bytes) -> tuple[dict | None, str] | None:
|
||||
"""(запись или None, текущее поколение) одним запросом MGET. None — кэш недоступен."""
|
||||
if not self._available():
|
||||
return None
|
||||
try:
|
||||
raw, generation = self._client.mget(self.PREFIX + key.hex(), self.GENERATION_KEY)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("mget", exc)
|
||||
return None
|
||||
entry = None if raw is None else json.loads(raw)
|
||||
return entry, (generation.decode() if generation else self.NO_GENERATION)
|
||||
|
||||
def generation(self) -> str | None:
|
||||
"""Текущее поколение (перед созданием сессии). None — кэш недоступен."""
|
||||
if not self._available():
|
||||
return None
|
||||
try:
|
||||
value = self._client.get(self.GENERATION_KEY)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("get", exc)
|
||||
return None
|
||||
return value.decode() if value else self.NO_GENERATION
|
||||
|
||||
def add(self, key: bytes, value: dict, ttl_ms: int) -> None:
|
||||
"""Положить запись, только если ключа ещё нет (SET NX): отметку «отозвано» не затираем."""
|
||||
if not self._available() or ttl_ms < 100:
|
||||
return
|
||||
try:
|
||||
self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms, nx=True)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("set", exc)
|
||||
|
||||
def mark_revoked(self, key: bytes) -> None:
|
||||
"""Заменить запись о сессии отметкой «отозвано» на SESSION_CACHE_TTL_SECONDS."""
|
||||
if not self._available():
|
||||
return # запись в кэше осталась, но после возвращения Valkey сменится поколение
|
||||
try:
|
||||
self._client.set(self.PREFIX + key.hex(), json.dumps({"revoked": True}),
|
||||
px=config.SESSION_CACHE_TTL_SECONDS * 1000)
|
||||
except valkey.ValkeyError as exc:
|
||||
self._failed("set", exc)
|
||||
|
||||
def ping(self) -> bool:
|
||||
try:
|
||||
return bool(self._client and self._client.ping())
|
||||
except valkey.ValkeyError:
|
||||
return False
|
||||
|
||||
|
||||
class Sessions:
|
||||
def __init__(self, store: PostgresStore, cache: SessionCache, ttl_seconds: int):
|
||||
self.store = store
|
||||
self.cache = cache
|
||||
self.ttl_seconds = ttl_seconds
|
||||
|
||||
def login(self, username: str, password: str) -> tuple[str, str, User] | None:
|
||||
"""Проверяет пароль и создаёт сессию. None — неверные credentials (без уточнений)."""
|
||||
if not security.PASSWORD_MIN <= len(password) <= security.PASSWORD_MAX:
|
||||
return None
|
||||
if not security.USERNAME_RE.fullmatch(username):
|
||||
return None # такого username не может существовать — в базу даже не ходим
|
||||
found = self.store.get_credentials(username)
|
||||
user, password_hash = found if found else (None, None)
|
||||
# Проверка выполняется и для несуществующего пользователя (с фиктивным hash):
|
||||
# одинаковое время ответа и одинаковый 401 не раскрывают, есть ли такой username.
|
||||
if not security.verify_password(password_hash, password) or user is None:
|
||||
return None
|
||||
token = security.new_token()
|
||||
key = security.token_hash(token)
|
||||
generation = self.cache.generation()
|
||||
expires_at = self.store.create_session(key, user.id, self.ttl_seconds)
|
||||
self._remember(key, user, expires_at, generation) # следующий запрос сразу попадёт в кэш
|
||||
return token, ts(expires_at), user
|
||||
|
||||
def authenticate(self, token: str) -> AuthContext | None:
|
||||
key = security.token_hash(token)
|
||||
# Поколение читаем ДО обращения к базе (вместе с записью, одним MGET): если во время
|
||||
# запроса случится сбой Valkey и поколение сменится, наша запись окажется недоверенной.
|
||||
looked = self.cache.lookup(key)
|
||||
generation = None
|
||||
if looked is not None:
|
||||
cached, generation = looked
|
||||
if cached is not None:
|
||||
if cached.get("revoked"):
|
||||
return None # logout уже был
|
||||
expires_at = datetime.fromisoformat(cached["expires_at"])
|
||||
if cached.get("gen") == generation and expires_at > datetime.now(timezone.utc):
|
||||
return AuthContext(User(**cached["user"]), key)
|
||||
# запись другого поколения или истёкшая -> проверяем по источнику истины
|
||||
found = self.store.get_session(key) # промах кэша, недоверенная запись или кэш недоступен
|
||||
if found is None:
|
||||
return None
|
||||
user, expires_at = found
|
||||
self._remember(key, user, expires_at, generation)
|
||||
return AuthContext(user, key)
|
||||
|
||||
def logout(self, auth: AuthContext) -> None:
|
||||
self.store.revoke_session(auth.token_hash) # сначала источник истины
|
||||
self.cache.mark_revoked(auth.token_hash) # затем инвалидация кэша
|
||||
|
||||
def _remember(self, key: bytes, user: User, expires_at: datetime, generation: str | None) -> None:
|
||||
if generation is None:
|
||||
return # кэш был недоступен, когда мы начинали: ничего не кладём
|
||||
left = expires_at - datetime.now(timezone.utc)
|
||||
ttl = min(timedelta(seconds=config.SESSION_CACHE_TTL_SECONDS), left)
|
||||
self.cache.add(key, {"user": asdict(user), "expires_at": expires_at.isoformat(), "gen": generation},
|
||||
int(ttl.total_seconds() * 1000))
|
||||
@@ -0,0 +1,613 @@
|
||||
"""Хранилище на PostgreSQL.
|
||||
|
||||
С lab2 источник истины — база данных, а не память процесса. Методы и их смысл
|
||||
те же, что у InMemoryStore из lab1, поэтому api.py почти не изменился.
|
||||
Модуль по-прежнему ничего не знает про HTTP: он хранит данные и соблюдает правила.
|
||||
С lab4 здесь же метаданные вложений (таблицы attachments и message_attachments):
|
||||
сами байты файлов лежат в S3 (objects.py), в базе только описание и ключ объекта.
|
||||
С lab5 загрузка в одной транзакции создаёт вложение (queued), задание и строку outbox
|
||||
(jobs.py), а варианты и состояния обработки пишет worker.
|
||||
|
||||
Все SQL-запросы параметризованные: значения передаются отдельно от текста запроса
|
||||
(%s), поэтому ввод пользователя никогда не становится частью SQL (нет SQL-инъекций).
|
||||
"""
|
||||
import logging
|
||||
import uuid
|
||||
from contextlib import contextmanager
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
|
||||
import psycopg
|
||||
from psycopg import errors as pg_errors
|
||||
from psycopg_pool import ConnectionPool, PoolTimeout
|
||||
|
||||
from . import config, faults, jobs
|
||||
from .errors import Conflict, InvalidRequest, NotFound, Unavailable
|
||||
|
||||
log = logging.getLogger("messenger.store")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class User:
|
||||
id: str
|
||||
username: str
|
||||
display_name: str
|
||||
created_at: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Chat:
|
||||
id: str
|
||||
title: str
|
||||
member_ids: tuple[str, ...]
|
||||
created_at: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Message:
|
||||
id: str
|
||||
chat_id: str
|
||||
sender_id: str
|
||||
text: str
|
||||
created_at: str
|
||||
attachment_ids: tuple[str, ...] = ()
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Attachment:
|
||||
"""Вложение в формате контракта. Ключи объектов в S3 сюда не входят: наружу они не отдаются.
|
||||
|
||||
size_bytes, sha256 и content_type всегда описывают ОРИГИНАЛ; у вариантов свои поля.
|
||||
variants заполнен только у ready, error_code — только у failed.
|
||||
"""
|
||||
id: str
|
||||
chat_id: str
|
||||
owner_id: str
|
||||
filename: str
|
||||
content_type: str
|
||||
size_bytes: int
|
||||
sha256: str
|
||||
status: str
|
||||
variants: list
|
||||
error_code: str | None
|
||||
created_at: str = ""
|
||||
updated_at: str = ""
|
||||
|
||||
|
||||
VARIANT_ORDER = ("thumbnail", "crop", "optimized")
|
||||
|
||||
|
||||
def sort_key(item) -> tuple[str, str]:
|
||||
"""Порядок по контракту: (created_at, id) по возрастанию. Из этой пары строится курсор."""
|
||||
return item.created_at, item.id
|
||||
|
||||
|
||||
def ts(value: datetime) -> str:
|
||||
"""Время из БД -> строка RFC 3339 в UTC с Z и микросекундами (как в lab1)."""
|
||||
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
||||
|
||||
|
||||
# Свободный текст (display_name, title, text) хранится в БД как байты UTF-8 (bytea), а не text:
|
||||
# тип text в PostgreSQL не может содержать символ U+0000, а контракт его не запрещает.
|
||||
# См. migrations/003_text_as_bytes.sql. Перед записью кодируем, после чтения декодируем.
|
||||
def to_db(value: str) -> bytes:
|
||||
return value.encode("utf-8")
|
||||
|
||||
|
||||
def from_db(value) -> str:
|
||||
return bytes(value).decode("utf-8")
|
||||
|
||||
|
||||
def _user(row) -> User:
|
||||
return User(str(row[0]), row[1], from_db(row[2]), ts(row[3]))
|
||||
|
||||
|
||||
def _chat(row) -> Chat:
|
||||
return Chat(str(row[0]), from_db(row[1]), tuple(str(m) for m in row[3]), ts(row[2]))
|
||||
|
||||
|
||||
def _message(row, attachment_ids=None) -> Message:
|
||||
ids = row[5] if attachment_ids is None and len(row) > 5 else (attachment_ids or ())
|
||||
return Message(str(row[0]), str(row[1]), str(row[2]), from_db(row[3]), ts(row[4]),
|
||||
tuple(str(a) for a in ids))
|
||||
|
||||
|
||||
# Вложения сообщения в порядке из запроса: подзапрос по первичному ключу (message_id, position).
|
||||
_MESSAGE_ATTACHMENTS = """ARRAY(SELECT ma.attachment_id FROM message_attachments ma
|
||||
WHERE ma.message_id = m.id ORDER BY ma.position)"""
|
||||
|
||||
# Варианты текущей версии pipeline, в порядке контракта; у не-ready вложения список пуст.
|
||||
# PIPELINE_VERSION — целая константа из кода (не ввод пользователя), поэтому подставлена в текст SQL.
|
||||
_VARIANTS = f"""CASE WHEN a.status = 'ready' THEN COALESCE((
|
||||
SELECT json_agg(json_build_object('name', v.name, 'content_type', v.content_type,
|
||||
'size_bytes', v.size_bytes, 'width', v.width,
|
||||
'height', v.height, 'sha256', v.sha256)
|
||||
ORDER BY array_position(ARRAY['thumbnail', 'crop', 'optimized'], v.name))
|
||||
FROM attachment_variants v
|
||||
WHERE v.attachment_id = a.id AND v.pipeline_version = {int(config.PIPELINE_VERSION)}), '[]'::json)
|
||||
ELSE '[]'::json END"""
|
||||
|
||||
_ATTACHMENT_COLUMNS = ("a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, "
|
||||
"a.status, a.created_at, a.updated_at, a.storage_key, a.error_code, " + _VARIANTS)
|
||||
|
||||
|
||||
# Advisory-блокировки PostgreSQL по ID вложения (замечание к MR про уборщика): пространство «l5»,
|
||||
# чтобы не пересечься с другими advisory-блокировками. Ключ — первые 32 бита UUID: совпадение у двух
|
||||
# вложений возможно, но безвредно (уборщик пропустит одно из них до следующего прохода).
|
||||
_LOCK_NAMESPACE = 0x6C35
|
||||
|
||||
|
||||
def attachment_lock(attachment_id: str) -> tuple[int, int]:
|
||||
return _LOCK_NAMESPACE, int.from_bytes(uuid.UUID(attachment_id).bytes[:4], "big", signed=True)
|
||||
|
||||
|
||||
def _cleanup_decision(row, variant_keys: set, key: str) -> tuple[str, str]:
|
||||
"""Можно ли удалить объект key вложения, если row — его ТЕКУЩЕЕ состояние (прочитано под блокировкой).
|
||||
|
||||
row = (status, staging_key, storage_key, failed и retention истёк) или None (строки нет).
|
||||
Возвращает ("delete" | "keep", причина). «delete» дан только там, где удаление безопасно
|
||||
навсегда: объект удаляется уже после COMMIT, без блокировок, и состояние к тому времени может
|
||||
поменяться только так, что этот объект всё равно никому не понадобится.
|
||||
"""
|
||||
if row is None:
|
||||
# Строки нет, а блокировку ID никто не держит: загрузка с этим ID закончилась без COMMIT
|
||||
# (новая загрузка всегда получает новый UUID), строка не появится уже никогда.
|
||||
return "delete", "orphan"
|
||||
status, staging_key, storage_key, expired = row
|
||||
if status in ("queued", "processing"):
|
||||
return "keep", "current_work" # worker может прямо сейчас читать staging и писать результат
|
||||
if status == "ready": # ready не меняется (replay готового — no-op)
|
||||
if key == storage_key or key in variant_keys:
|
||||
return "keep", "published"
|
||||
return ("delete", "staging_after_ready") if key == staging_key else ("delete", "orphan")
|
||||
# failed: пока не истёк retention и исходник на месте, возможен replay — он заново запишет оригинал
|
||||
# и варианты в те же ключи, поэтому ничего не трогаем. После retention staging помечается удалённым
|
||||
# (staging_key = NULL): replay уже невозможен, и все объекты вложения можно удалить.
|
||||
if not expired and staging_key is not None:
|
||||
return "keep", "staging_kept_for_replay" if key == staging_key else "failed_kept_for_replay"
|
||||
return "delete", "staging_failed_expired" if key.startswith("staging/") else "orphan"
|
||||
|
||||
|
||||
def _attachment(row) -> tuple[Attachment, str]:
|
||||
"""(вложение для ответа, ключ оригинала в S3 — только для сервера)."""
|
||||
return (Attachment(str(row[0]), str(row[1]), str(row[2]), row[3], row[4], int(row[5]), row[6], row[7],
|
||||
list(row[12] or []), row[11], ts(row[8]), ts(row[9])), row[10])
|
||||
|
||||
|
||||
# Участники чата всегда в одном порядке (по UUID), чтобы POST и GET отвечали одинаково.
|
||||
_CHAT_COLUMNS = """c.id, c.title, c.created_at,
|
||||
ARRAY(SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id)"""
|
||||
|
||||
|
||||
class PostgresStore:
|
||||
def __init__(self, pool: ConnectionPool):
|
||||
self.pool = pool
|
||||
|
||||
@contextmanager
|
||||
def _conn(self, timeout: float | None = None):
|
||||
"""Соединение из пула. В конце блока — COMMIT, при исключении — ROLLBACK.
|
||||
|
||||
Если база недоступна (нет соединения, истёк таймаут пула или запроса),
|
||||
клиент получает 503 без подробностей, а не 500 со stack trace.
|
||||
"""
|
||||
try:
|
||||
with self.pool.connection(timeout=timeout) as conn:
|
||||
yield conn
|
||||
except (psycopg.OperationalError, PoolTimeout) as exc:
|
||||
log.warning("PostgreSQL недоступен: %s", type(exc).__name__)
|
||||
raise Unavailable("Хранилище временно недоступно") from None
|
||||
except psycopg.DataError as exc:
|
||||
# База отвергла само значение (например, недопустимый символ): это ошибка входа -> 400,
|
||||
# а не внутренняя ошибка сервера (500).
|
||||
log.warning("PostgreSQL отверг значение: %s", type(exc).__name__)
|
||||
raise InvalidRequest("Недопустимое значение в запросе") from None
|
||||
|
||||
def ping(self, timeout: float = 1.0) -> None:
|
||||
"""Проверка готовности: короткий таймаут, чтобы healthcheck (3 с) успел получить 503."""
|
||||
with self._conn(timeout) as conn:
|
||||
conn.execute("SELECT 1")
|
||||
|
||||
# --- пользователи ---
|
||||
|
||||
def create_user(self, username: str, display_name: str, password_hash: str) -> User:
|
||||
try:
|
||||
with self._conn() as conn:
|
||||
row = conn.execute(
|
||||
"""INSERT INTO users (id, username, display_name, password_hash)
|
||||
VALUES (%s, %s, %s, %s)
|
||||
RETURNING id, username, display_name, created_at""",
|
||||
(uuid.uuid4(), username, to_db(display_name), password_hash)).fetchone()
|
||||
except pg_errors.UniqueViolation:
|
||||
# Не «проверить, потом вставить» (между этими шагами успеет вклиниться другой запрос),
|
||||
# а сразу вставить: уникальный индекс в БД пропустит ровно одну регистрацию.
|
||||
raise Conflict("Имя пользователя уже занято") from None
|
||||
return _user(row)
|
||||
|
||||
def get_credentials(self, username: str) -> tuple[User, str] | None:
|
||||
"""Пользователь и hash его пароля — только для проверки при входе."""
|
||||
with self._conn() as conn:
|
||||
row = conn.execute(
|
||||
"""SELECT id, username, display_name, created_at, password_hash
|
||||
FROM users WHERE username = %s""", (username,)).fetchone()
|
||||
return None if row is None else (_user(row), row[4])
|
||||
|
||||
# --- чаты ---
|
||||
|
||||
def create_chat(self, creator_id: str, title: str, member_ids: list[str]) -> Chat:
|
||||
if len(set(member_ids)) != len(member_ids):
|
||||
raise InvalidRequest("Участники чата повторяются")
|
||||
if creator_id not in member_ids:
|
||||
raise InvalidRequest("Создатель чата должен входить в member_ids")
|
||||
members = sorted(uuid.UUID(m) for m in member_ids)
|
||||
chat_id = uuid.uuid4()
|
||||
try:
|
||||
with self._conn() as conn:
|
||||
# Одна транзакция: чат и все участники записываются вместе или не записываются вовсе.
|
||||
with conn.transaction():
|
||||
self._check_members_exist(conn, members)
|
||||
created_at = conn.execute(
|
||||
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at",
|
||||
(chat_id, to_db(title))).fetchone()[0]
|
||||
with conn.cursor() as cur:
|
||||
cur.executemany("INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
|
||||
[(chat_id, m) for m in members])
|
||||
except pg_errors.ForeignKeyViolation:
|
||||
# Сюда попадаем, только если проверка выше пропустила несуществующего участника.
|
||||
# Транзакция уже откатилась: строки чата в базе не осталось.
|
||||
raise InvalidRequest("Среди участников есть несуществующий пользователь") from None
|
||||
return Chat(str(chat_id), title, tuple(str(m) for m in members), ts(created_at))
|
||||
|
||||
@staticmethod
|
||||
def _check_members_exist(conn, members: list[uuid.UUID]) -> None:
|
||||
found = conn.execute("SELECT count(*) FROM users WHERE id = ANY(%s)", (members,)).fetchone()[0]
|
||||
if found != len(members):
|
||||
raise InvalidRequest("Среди участников есть несуществующий пользователь")
|
||||
|
||||
def get_chat(self, user_id: str, chat_id: str) -> Chat:
|
||||
with self._conn() as conn:
|
||||
row = conn.execute(
|
||||
f"""SELECT {_CHAT_COLUMNS} FROM chats c
|
||||
WHERE c.id = %s AND EXISTS (
|
||||
SELECT 1 FROM chat_members cm WHERE cm.chat_id = c.id AND cm.user_id = %s)""",
|
||||
(uuid.UUID(chat_id), uuid.UUID(user_id))).fetchone()
|
||||
if row is None:
|
||||
# Один и тот же ответ для «чата нет» и «чат чужой»:
|
||||
# посторонний не должен узнать, что такой чат существует.
|
||||
raise NotFound("Чат не найден")
|
||||
return _chat(row)
|
||||
|
||||
def list_chats(self, user_id: str, after: tuple[datetime, uuid.UUID] | None, limit: int):
|
||||
query = f"""SELECT {_CHAT_COLUMNS}
|
||||
FROM chat_members me JOIN chats c ON c.id = me.chat_id
|
||||
WHERE me.user_id = %s {{after}}
|
||||
ORDER BY c.created_at, c.id
|
||||
LIMIT %s"""
|
||||
params: list = [uuid.UUID(user_id)]
|
||||
if after is None:
|
||||
query = query.format(after="")
|
||||
else:
|
||||
query = query.format(after="AND (c.created_at, c.id) > (%s, %s)")
|
||||
params += [after[0], after[1]]
|
||||
with self._conn() as conn:
|
||||
rows = conn.execute(query, (*params, limit + 1)).fetchall()
|
||||
return [_chat(r) for r in rows[:limit]], len(rows) > limit
|
||||
|
||||
# --- сообщения ---
|
||||
|
||||
def add_message(self, user_id: str, chat_id: str, text: str,
|
||||
idempotency_key: str, request_hash: bytes,
|
||||
attachment_ids: tuple[str, ...] = ()) -> tuple[Message, bool]:
|
||||
"""Сохраняет сообщение ровно один раз на ключ. Возвращает (сообщение, это_повтор).
|
||||
|
||||
Ключ и SHA-256 тела запроса лежат прямо в строке сообщения, а уникальное ограничение
|
||||
(chat_id, sender_id, idempotency_key) не даёт записать второе сообщение с тем же ключом.
|
||||
Поэтому само сообщение и «запомненный результат» — одна строка и один INSERT:
|
||||
они сохраняются атомарно, по отдельности их записать нельзя.
|
||||
|
||||
Два одновременных запроса с одним ключом (даже через разные реплики): PostgreSQL
|
||||
заставляет второй INSERT ждать, пока завершится транзакция первого. Первый закоммитил —
|
||||
у второго ON CONFLICT DO NOTHING ничего не вставляет, и он читает готовую строку.
|
||||
Первый откатился (ошибка, 5xx) — второй просто вставляет: неудача ключ не «занимает».
|
||||
|
||||
С lab4 в той же транзакции записываются ссылки на вложения. Каждое должно быть вложением
|
||||
ЭТОГО чата, иначе 404 и откат: сообщение без своих вложений не сохранится.
|
||||
С lab5 можно ссылаться на вложение, которое ещё обрабатывается (queued, processing);
|
||||
на failed — нельзя (409).
|
||||
"""
|
||||
chat, user = uuid.UUID(chat_id), uuid.UUID(user_id)
|
||||
with self._conn() as conn:
|
||||
# Один SQL-оператор: вставка произойдёт, только если отправитель — участник чата.
|
||||
# Отправитель берётся из сессии, а не из тела запроса.
|
||||
row = conn.execute(
|
||||
"""INSERT INTO messages (id, chat_id, sender_id, text, idempotency_key, request_hash)
|
||||
SELECT %s, cm.chat_id, cm.user_id, %s, %s, %s
|
||||
FROM chat_members cm WHERE cm.chat_id = %s AND cm.user_id = %s
|
||||
ON CONFLICT (chat_id, sender_id, idempotency_key) DO NOTHING
|
||||
RETURNING id, chat_id, sender_id, text, created_at""",
|
||||
(uuid.uuid4(), to_db(text), idempotency_key, request_hash, chat, user)).fetchone()
|
||||
if row is not None:
|
||||
if attachment_ids:
|
||||
self._link_attachments(conn, row[0], chat, attachment_ids)
|
||||
return _message(row, attachment_ids), False # новое сообщение
|
||||
# Ничего не вставилось: либо пользователь не участник чата, либо ключ уже использован.
|
||||
# Повтор тоже заново проверяет доступ (сессию уже проверил middleware).
|
||||
member = conn.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(chat, user)).fetchone()
|
||||
if member is None:
|
||||
raise NotFound("Чат не найден")
|
||||
saved = conn.execute(
|
||||
f"""SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, m.request_hash,
|
||||
{_MESSAGE_ATTACHMENTS}
|
||||
FROM messages m
|
||||
WHERE m.chat_id = %s AND m.sender_id = %s AND m.idempotency_key = %s""",
|
||||
(chat, user, idempotency_key)).fetchone()
|
||||
if saved is None:
|
||||
# Не должно случаться (строка с ключом есть, раз INSERT ничего не вставил).
|
||||
# Ответ 503 ничего не фиксирует: клиент повторит запрос с тем же ключом.
|
||||
raise Unavailable("Повторите запрос")
|
||||
if bytes(saved[5]) != request_hash:
|
||||
raise Conflict("Idempotency-Key уже использован с другим телом запроса")
|
||||
return _message(saved[:5], saved[6]), True # тот же ответ, что и в первый раз
|
||||
|
||||
@staticmethod
|
||||
def _link_attachments(conn, message_id, chat: uuid.UUID, attachment_ids) -> None:
|
||||
ids = [uuid.UUID(a) for a in attachment_ids]
|
||||
# FOR SHARE: пока транзакция не завершена, статус этих вложений не изменится
|
||||
# (worker, переводящий вложение в failed, подождёт COMMIT сообщения).
|
||||
statuses = [r[0] for r in conn.execute(
|
||||
"SELECT status FROM attachments WHERE id = ANY(%s) AND chat_id = %s FOR SHARE", (ids, chat))]
|
||||
if len(statuses) != len(ids):
|
||||
# Чужое или неизвестное вложение — один ответ, без подробностей.
|
||||
raise NotFound("Вложение не найдено в этом чате")
|
||||
if "failed" in statuses:
|
||||
raise Conflict("Вложение не удалось обработать (failed), его нельзя прикрепить")
|
||||
with conn.cursor() as cur:
|
||||
cur.executemany("""INSERT INTO message_attachments (message_id, attachment_id, position)
|
||||
VALUES (%s, %s, %s)""",
|
||||
[(message_id, a, i) for i, a in enumerate(ids)])
|
||||
|
||||
def list_messages(self, user_id: str, chat_id: str,
|
||||
after: tuple[datetime, uuid.UUID] | None, limit: int):
|
||||
chat, user = uuid.UUID(chat_id), uuid.UUID(user_id)
|
||||
# Keyset-пагинация: «следующие limit записей после ключа», а не OFFSET.
|
||||
# С индексом (chat_id, created_at, id) база сразу встаёт на нужное место индекса
|
||||
# и читает только limit+1 строк, сколько бы сообщений ни было в чате.
|
||||
if after is None:
|
||||
query = f"""SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, {_MESSAGE_ATTACHMENTS}
|
||||
FROM messages m WHERE m.chat_id = %s
|
||||
ORDER BY m.created_at, m.id LIMIT %s"""
|
||||
params = (chat, limit + 1)
|
||||
else:
|
||||
query = f"""SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, {_MESSAGE_ATTACHMENTS}
|
||||
FROM messages m WHERE m.chat_id = %s AND (m.created_at, m.id) > (%s, %s)
|
||||
ORDER BY m.created_at, m.id LIMIT %s"""
|
||||
params = (chat, after[0], after[1], limit + 1)
|
||||
with self._conn() as conn:
|
||||
member = conn.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
|
||||
(chat, user)).fetchone()
|
||||
if member is None:
|
||||
raise NotFound("Чат не найден")
|
||||
rows = conn.execute(query, params).fetchall()
|
||||
return [_message(r) for r in rows[:limit]], len(rows) > limit
|
||||
|
||||
# --- вложения: метаданные здесь, байты в S3 ---
|
||||
|
||||
@contextmanager
|
||||
def receiving(self, attachment_id: str):
|
||||
"""Транзакция приёма файла (замечание к MR про уборщика).
|
||||
|
||||
Блокировка ID вложения (advisory, attachment_lock) берётся ДО записи в staging и держится
|
||||
до COMMIT строки вложения. Уборщик (cleanup_attachment) берёт ту же блокировку без ожидания:
|
||||
пока загрузка идёт, её staging для него «занят», даже если строки в БД ещё нет. Упал API —
|
||||
PostgreSQL сам снимает блокировку вместе с сессией, и объект без строки уберётся как «сирота».
|
||||
Если процесс API завис посреди загрузки, сессию закроет idle_in_transaction_session_timeout
|
||||
(30 с: запись в staging ограничена 6 с, остальное — запас для медленного диска и точки-паузы теста).
|
||||
"""
|
||||
with self._conn() as conn, conn.transaction():
|
||||
conn.execute("SET LOCAL idle_in_transaction_session_timeout = '30s'")
|
||||
conn.execute("SELECT pg_advisory_xact_lock(%s, %s)", attachment_lock(attachment_id))
|
||||
yield conn
|
||||
|
||||
def create_queued_attachment(self, attachment_id: str, user_id: str, chat_id: str, filename: str,
|
||||
content_type: str, size_bytes: int, sha256: str, width: int, height: int,
|
||||
staging_key: str, storage_key: str, actor: str, conn=None) -> Attachment:
|
||||
"""Устойчивый приём (с lab5): оригинал уже в staging S3; теперь одной транзакцией —
|
||||
вложение (queued), задание и строка outbox для брокера. После COMMIT можно отвечать 202.
|
||||
|
||||
conn — транзакция receiving(), в которой оригинал записывался в staging (attachments.py).
|
||||
Вставка вложения идёт, только если пользователь — участник чата (иначе 404).
|
||||
"""
|
||||
if conn is None:
|
||||
with self.receiving(attachment_id) as conn:
|
||||
return self.create_queued_attachment(attachment_id, user_id, chat_id, filename, content_type,
|
||||
size_bytes, sha256, width, height, staging_key, storage_key,
|
||||
actor, conn)
|
||||
row = conn.execute(
|
||||
f"""INSERT INTO attachments AS a (id, chat_id, owner_id, filename, content_type, size_bytes,
|
||||
sha256, width, height, storage_key, staging_key, status)
|
||||
SELECT %s, cm.chat_id, cm.user_id, %s, %s, %s, %s, %s, %s, %s, %s, 'queued'
|
||||
FROM chat_members cm WHERE cm.chat_id = %s AND cm.user_id = %s
|
||||
RETURNING {_ATTACHMENT_COLUMNS}""",
|
||||
(uuid.UUID(attachment_id), filename, content_type, size_bytes, sha256, width, height,
|
||||
storage_key, staging_key, uuid.UUID(chat_id), uuid.UUID(user_id))).fetchone()
|
||||
if row is None:
|
||||
raise NotFound("Чат не найден")
|
||||
jobs.create(conn, row[0], actor)
|
||||
return _attachment(row)[0]
|
||||
|
||||
def get_attachment(self, user_id: str, attachment_id: str) -> tuple[Attachment, str]:
|
||||
"""Вложение в любом состоянии — только для участника чата. Иначе 404 без подробностей."""
|
||||
with self._conn() as conn:
|
||||
row = conn.execute(
|
||||
f"""SELECT {_ATTACHMENT_COLUMNS} FROM attachments a
|
||||
WHERE a.id = %s AND EXISTS (
|
||||
SELECT 1 FROM chat_members cm WHERE cm.chat_id = a.chat_id AND cm.user_id = %s)""",
|
||||
(uuid.UUID(attachment_id), uuid.UUID(user_id))).fetchone()
|
||||
if row is None:
|
||||
raise NotFound("Вложение не найдено")
|
||||
return _attachment(row)
|
||||
|
||||
def get_content(self, user_id: str, attachment_id: str, variant: str) -> tuple[str, str, int]:
|
||||
"""Что отдать на /content: (ключ объекта, Content-Type, размер).
|
||||
|
||||
Порядок проверок: участник чата (иначе 404) -> готово ли (queued/processing/failed -> 409)
|
||||
-> есть ли такой вариант у готового вложения (нет -> 404).
|
||||
"""
|
||||
attachment, key = self.get_attachment(user_id, attachment_id)
|
||||
if attachment.status != "ready":
|
||||
raise Conflict(f"Вложение ещё не готово (status={attachment.status})")
|
||||
if variant == "original":
|
||||
return key, attachment.content_type, attachment.size_bytes
|
||||
with self._conn() as conn:
|
||||
row = conn.execute("""SELECT storage_key, content_type, size_bytes FROM attachment_variants
|
||||
WHERE attachment_id = %s AND pipeline_version = %s AND name = %s""",
|
||||
(uuid.UUID(attachment_id), config.PIPELINE_VERSION, variant)).fetchone()
|
||||
if row is None:
|
||||
raise NotFound("Такого варианта у вложения нет")
|
||||
return row[0], row[1], int(row[2])
|
||||
|
||||
# --- для уборщика (cleanup.py) ---
|
||||
|
||||
def storage_references(self, retention_seconds: int) -> dict:
|
||||
"""Снимок ссылок для ПРЕДВАРИТЕЛЬНОГО отбора: ключ -> причина, почему объект нужен.
|
||||
|
||||
Нужны: оригиналы ready-вложений, их варианты, staging-оригиналы заданий в работе
|
||||
(queued, processing) и staging failed-вложений моложе retention (для replay).
|
||||
Снимок только отсекает заведомо нужное. Удалять по нему нельзя: пока уборщик идёт по
|
||||
списку, состояние меняется (замечание к MR). Окончательно решает cleanup_attachment
|
||||
под блокировками по текущему состоянию.
|
||||
"""
|
||||
with self._conn() as conn:
|
||||
rows = conn.execute(
|
||||
"""SELECT a.status, a.storage_key, a.staging_key,
|
||||
a.status = 'failed' AND a.updated_at < now() - make_interval(secs => %s)
|
||||
FROM attachments a""", (retention_seconds,)).fetchall()
|
||||
variant_keys = [r[0] for r in conn.execute("SELECT storage_key FROM attachment_variants")]
|
||||
needed, done = {}, {}
|
||||
for status, storage_key, staging_key, expired in rows:
|
||||
if status == "ready":
|
||||
needed[storage_key] = "original"
|
||||
if staging_key:
|
||||
done[staging_key] = "staging_after_ready"
|
||||
elif status in ("queued", "processing"):
|
||||
if staging_key:
|
||||
needed[staging_key] = "staging_in_work"
|
||||
elif staging_key: # failed
|
||||
if expired:
|
||||
done[staging_key] = "staging_failed_expired"
|
||||
else:
|
||||
needed[staging_key] = "staging_failed_kept"
|
||||
for key in variant_keys:
|
||||
needed[key] = "variant"
|
||||
ready_originals = {key for key, why in needed.items() if why == "original"}
|
||||
return {"needed": needed, "done": done, "ready_originals": ready_originals}
|
||||
|
||||
def cleanup_attachment(self, attachment_id: str, keys: list[str], retention_seconds: int,
|
||||
delete=None, actor: str = "cleanup") -> dict | None:
|
||||
"""Уборка объектов ОДНОГО вложения: решение принимается заново, под блокировками (замечание к MR).
|
||||
|
||||
Снимок ссылок (storage_references) мог устареть, пока уборщик шёл по списку: оператор сделал
|
||||
replay, загрузка закоммитила строку, worker записал объекты. Поэтому две фазы.
|
||||
Фаза 1 — короткая транзакция:
|
||||
1. advisory-блокировка ID вложения без ожидания — её держит идущая загрузка (receiving):
|
||||
занято -> None, объекты остаются до следующего прохода;
|
||||
2. блокировка строк задания и вложения (FOR NO KEY UPDATE; порядок тот же, что у claim,
|
||||
complete и replay: сначала задание, потом вложение) — переходы состояния ждут, а уборщик
|
||||
читает ТЕКУЩЕЕ состояние;
|
||||
3. решение (_cleanup_decision). Если удаляется staging истёкшего failed-вложения, он сначала
|
||||
помечается в БД удалённым (staging_key = NULL, запись staging_expired в журнале) — COMMIT.
|
||||
Replay, который ждал блокировку или придёт позже, видит, что исходника нет, и отказывает.
|
||||
Фаза 2 — удаление из S3 уже без блокировок. Удаляется только то, что после фазы 1 не может
|
||||
понадобиться никогда (см. _cleanup_decision), поэтому медленный S3 не держит блокировки,
|
||||
а оборванная сессия БД не открывает окно для гонки.
|
||||
delete=None — пробный прогон: решения те же, но ничего не меняется.
|
||||
Возвращает {"delete": [(ключ, причина)], "keep": [(ключ, почему)]} или None (занято).
|
||||
"""
|
||||
aid = uuid.UUID(attachment_id)
|
||||
with self._conn() as conn:
|
||||
try:
|
||||
with conn.transaction():
|
||||
if not conn.execute("SELECT pg_try_advisory_xact_lock(%s, %s)",
|
||||
attachment_lock(attachment_id)).fetchone()[0]:
|
||||
return None
|
||||
conn.execute("SET LOCAL lock_timeout = '3s'")
|
||||
# Транзакция короткая; запас — для медленной базы и точки-паузы теста (faults.py).
|
||||
conn.execute("SET LOCAL idle_in_transaction_session_timeout = '30s'")
|
||||
job_rows = conn.execute("""SELECT job_id, attempt FROM attachment_jobs WHERE attachment_id = %s
|
||||
FOR NO KEY UPDATE""", (aid,)).fetchall()
|
||||
row = conn.execute(
|
||||
"""SELECT status, staging_key, storage_key,
|
||||
status = 'failed' AND updated_at < now() - make_interval(secs => %s)
|
||||
FROM attachments WHERE id = %s FOR NO KEY UPDATE""", (retention_seconds, aid)).fetchone()
|
||||
variant_keys = {r[0] for r in conn.execute(
|
||||
"SELECT storage_key FROM attachment_variants WHERE attachment_id = %s", (aid,))}
|
||||
decisions = [(key, *_cleanup_decision(row, variant_keys, key)) for key in keys]
|
||||
orphans = [key for key, action, why in decisions if why == "orphan"]
|
||||
if orphans:
|
||||
# Страховка: ключ «чужого» вида (например, оригинал lab4 со случайным ключом)
|
||||
# может принадлежать другому вложению. На такой ключ ссылаются — не трогаем.
|
||||
referenced = {r[0] for r in conn.execute(
|
||||
"""SELECT t.k FROM unnest(%s::text[]) AS t(k)
|
||||
WHERE EXISTS (SELECT 1 FROM attachments a
|
||||
WHERE a.id <> %s AND (a.storage_key = t.k OR a.staging_key = t.k))
|
||||
OR EXISTS (SELECT 1 FROM attachment_variants v
|
||||
WHERE v.attachment_id <> %s AND v.storage_key = t.k)""",
|
||||
(orphans, aid, aid))}
|
||||
decisions = [(k, "keep", "referenced") if k in referenced else (k, a, w)
|
||||
for k, a, w in decisions]
|
||||
result = {"delete": [(k, w) for k, a, w in decisions if a == "delete"],
|
||||
"keep": [(k, w) for k, a, w in decisions if a == "keep"]}
|
||||
if delete is not None and result["delete"] and row is not None and row[0] == "failed" \
|
||||
and row[1] is not None:
|
||||
# У failed что-то удаляется, только когда retention истёк. Сначала — отметка
|
||||
# «исходника нет» (даже если сам staging попадёт в уборку в следующий раз):
|
||||
# после COMMIT replay невозможен, и объекты вложения больше никому не нужны.
|
||||
conn.execute("UPDATE attachments SET staging_key = NULL WHERE id = %s", (aid,))
|
||||
for job_id, attempt in job_rows:
|
||||
jobs.event(conn, job_id, aid, attempt, "staging_expired", actor,
|
||||
"retention истёк: исходник в staging удаляется уборщиком, replay невозможен")
|
||||
faults.pause("cleanup_pause_locked") # проверка: replay ждёт эту транзакцию
|
||||
except pg_errors.LockNotAvailable:
|
||||
return None # строку держит переход состояния: попробуем в следующий раз
|
||||
if delete is not None:
|
||||
for key, _why in result["delete"]:
|
||||
delete(key) # фаза 2: после COMMIT, без блокировок
|
||||
return result
|
||||
|
||||
def delete_old_outbox(self, retention_seconds: int) -> int:
|
||||
"""Отправленные строки outbox старше retention больше не нужны (журнал заданий остаётся)."""
|
||||
with self._conn() as conn:
|
||||
cur = conn.execute("""DELETE FROM outbox WHERE published_at IS NOT NULL
|
||||
AND published_at < now() - make_interval(secs => %s)""", (retention_seconds,))
|
||||
return cur.rowcount
|
||||
|
||||
# --- сессии (источник истины; Valkey — только кэш, см. sessions.py) ---
|
||||
|
||||
def create_session(self, token_hash: bytes, user_id: str, ttl_seconds: int) -> datetime:
|
||||
with self._conn() as conn, conn.transaction():
|
||||
# Заодно убираем у этого пользователя истёкшие и отозванные сессии: они уже не нужны.
|
||||
conn.execute("""DELETE FROM sessions
|
||||
WHERE user_id = %s AND (expires_at <= now() OR revoked_at IS NOT NULL)""",
|
||||
(uuid.UUID(user_id),))
|
||||
# Срок жизни считает часами PostgreSQL — теми же, по которым он потом проверяется.
|
||||
return conn.execute(
|
||||
"""INSERT INTO sessions (token_hash, user_id, expires_at)
|
||||
VALUES (%s, %s, now() + make_interval(secs => %s))
|
||||
RETURNING expires_at""",
|
||||
(token_hash, uuid.UUID(user_id), ttl_seconds)).fetchone()[0]
|
||||
|
||||
def get_session(self, token_hash: bytes) -> tuple[User, datetime] | None:
|
||||
"""Пользователь действующей сессии: не отозвана и не истекла. Иначе None."""
|
||||
with self._conn() as conn:
|
||||
row = conn.execute(
|
||||
"""SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
|
||||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()""",
|
||||
(token_hash,)).fetchone()
|
||||
return None if row is None else (_user(row), row[4])
|
||||
|
||||
def revoke_session(self, token_hash: bytes) -> bool:
|
||||
with self._conn() as conn:
|
||||
cur = conn.execute("UPDATE sessions SET revoked_at = now() "
|
||||
"WHERE token_hash = %s AND revoked_at IS NULL", (token_hash,))
|
||||
return cur.rowcount == 1
|
||||
@@ -0,0 +1,412 @@
|
||||
"""Worker (с lab5): отдельный процесс, который обрабатывает вложения из очереди брокера.
|
||||
|
||||
Запуск: `python -m messenger.worker` (сервис worker в compose.yaml). HTTP-порта нет: worker
|
||||
общается только с брокером (задания), PostgreSQL (состояние) и S3 (байты).
|
||||
|
||||
Обработка одного сообщения:
|
||||
1. проверить формат по contracts/jobs.schema.json; неверное сообщение -> reject -> DLQ;
|
||||
2. claim (jobs.py): по строке задания решить — обработать или это дубль/устаревшее
|
||||
сообщение (тогда ack без работы);
|
||||
3. скачать оригинал из staging и сверить размер и SHA-256 с метаданными в БД: доверяем
|
||||
только БД, а не сообщению;
|
||||
4. обработать в дочернем процессе с лимитами времени и памяти (sandbox.py, imaging.py);
|
||||
5. записать оригинал в originals/<id> и варианты в variants/<id>/v1/... Ключи однозначно
|
||||
заданы ключом эффекта, поэтому повтор пишет те же байты в те же ключи;
|
||||
6. COMMIT результата с проверкой жетона lease (jobs.complete) — и только потом ack;
|
||||
7. удалить staging: результат уже зафиксирован (не вышло — удалит уборщик).
|
||||
|
||||
Ошибки:
|
||||
- постоянная (картинка не декодируется, слишком большая, исходник пропал) -> failed сразу,
|
||||
reject -> сообщение в DLQ;
|
||||
- временная (S3 недоступен, не уложились во время, дочерний процесс упал) -> следующая попытка
|
||||
через backoff с jitter (новое сообщение из outbox), текущее — ack; попытки кончились -> failed;
|
||||
- PostgreSQL недоступен -> результат не записать: сообщение возвращается в очередь после паузы.
|
||||
|
||||
Параллельность ограничена: WORKER_CONCURRENCY заданий одновременно, и prefetch брокера такой
|
||||
же. Неподтверждённых сообщений у worker не больше, чем он может обрабатывать; остальные ждут
|
||||
в очереди и достанутся другому worker, если его запустить.
|
||||
|
||||
Lease: пока задание обрабатывается, отдельный поток каждые JOB_HEARTBEAT_SECONDS продлевает
|
||||
аренду. Если продлить не удалось (аренду уже забрали), обработка прерывается и результат
|
||||
не записывается. Другой поток ищет задания, чью аренду никто не продлевает (worker упал или
|
||||
завис), и возвращает их в очередь.
|
||||
"""
|
||||
import concurrent.futures
|
||||
import hashlib
|
||||
import logging
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from dataclasses import dataclass
|
||||
from functools import partial
|
||||
|
||||
from . import broker, cleanup, config, db, faults, imaging, jobs, objects, sandbox
|
||||
from .errors import AppError, Unavailable
|
||||
from .store import PostgresStore
|
||||
|
||||
log = logging.getLogger("messenger.worker")
|
||||
|
||||
ALIVE_FILE = "/tmp/worker.alive" # healthcheck контейнера: файл обновляется, пока жив главный цикл
|
||||
SHUTDOWN_SECONDS = 20 # по SIGTERM столько ждём начатые задания (stop_grace_period 30 с)
|
||||
DB_WAIT_SECONDS = 20 # столько ждём PostgreSQL перед возвратом сообщения в очередь
|
||||
|
||||
|
||||
class Permanent(Exception):
|
||||
"""Повтор не поможет: задание сразу получает failed."""
|
||||
|
||||
def __init__(self, code: str, message: str):
|
||||
super().__init__(message)
|
||||
self.code = code
|
||||
|
||||
|
||||
class Transient(Exception):
|
||||
"""Может пройти при повторе: следующая попытка через backoff."""
|
||||
|
||||
def __init__(self, code: str, message: str):
|
||||
super().__init__(message)
|
||||
self.code = code
|
||||
|
||||
|
||||
class LeaseLost(Exception):
|
||||
"""Аренду забрал другой worker: работу бросаем, результат не записываем."""
|
||||
|
||||
|
||||
@dataclass
|
||||
class InFlight:
|
||||
lease: jobs.Lease
|
||||
abort: threading.Event
|
||||
started: float
|
||||
|
||||
|
||||
def _sha256(path: str) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with open(path, "rb") as f:
|
||||
for block in iter(lambda: f.read(1024 * 1024), b""):
|
||||
digest.update(block)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
class Worker:
|
||||
def __init__(self):
|
||||
# Уникален для каждого запуска процесса: hostname контейнера + случайный суффикс.
|
||||
self.id = f"{config.INSTANCE_ID}/{uuid.uuid4().hex[:8]}"
|
||||
self.pool = db.create_pool(application_name="messenger-worker",
|
||||
max_size=config.WORKER_CONCURRENCY + 3)
|
||||
self.jobs = jobs.JobStore(self.pool, "worker-" + self.id)
|
||||
self.store = PostgresStore(self.pool)
|
||||
self.stop = threading.Event() # SIGTERM: больше не берём новые сообщения
|
||||
self.threads_stop = threading.Event() # после завершения начатых заданий: стоп фоновых потоков
|
||||
self.executor = concurrent.futures.ThreadPoolExecutor(config.WORKER_CONCURRENCY, thread_name_prefix="job")
|
||||
self.inflight: dict[str, InFlight] = {}
|
||||
self.lock = threading.Lock()
|
||||
self.busy = 0 # сколько доставок ещё не подтверждено (ack/nack)
|
||||
self.params = imaging.Params(max_pixels=config.MAX_IMAGE_PIXELS, jpeg_quality=config.JPEG_QUALITY,
|
||||
webp_quality=config.WEBP_QUALITY, webp_method=config.WEBP_METHOD)
|
||||
|
||||
# ---------- запуск и остановка ----------
|
||||
|
||||
def run(self) -> None:
|
||||
signal.signal(signal.SIGTERM, self._on_signal)
|
||||
signal.signal(signal.SIGINT, self._on_signal)
|
||||
config.validate()
|
||||
config.validate_s3()
|
||||
config.validate_broker()
|
||||
db.wait_for_schema()
|
||||
self.pool.open()
|
||||
sandbox.warm_up()
|
||||
for target, name in ((self._keeper, "lease-keeper"), (self._reaper, "lease-reaper")):
|
||||
threading.Thread(target=target, name=name, daemon=True).start()
|
||||
log.info("Worker %s запущен: версия %s, параллельно %d, попыток %d, lease %d с (продление каждые %g с), "
|
||||
"лимит попытки %d с и %d МиБ", self.id, config.APP_VERSION, config.WORKER_CONCURRENCY,
|
||||
config.JOB_MAX_ATTEMPTS, config.JOB_LEASE_SECONDS, config.JOB_HEARTBEAT_SECONDS,
|
||||
config.JOB_TIMEOUT_SECONDS, config.WORKER_MEMORY_LIMIT_MB)
|
||||
try:
|
||||
self._consume_loop()
|
||||
finally:
|
||||
self.threads_stop.set()
|
||||
self.executor.shutdown(wait=False, cancel_futures=True)
|
||||
self.pool.close()
|
||||
log.info("Worker %s остановлен", self.id)
|
||||
|
||||
def _on_signal(self, signum, _frame):
|
||||
if self.stop.is_set():
|
||||
os._exit(1) # второй сигнал: выйти сразу
|
||||
log.info("Сигнал %s: новые задания не беру, дожидаюсь начатых (до %d с)", signum, SHUTDOWN_SECONDS)
|
||||
self.stop.set()
|
||||
|
||||
def _touch(self) -> None:
|
||||
try:
|
||||
with open(ALIVE_FILE, "a", encoding="ascii"):
|
||||
pass
|
||||
os.utime(ALIVE_FILE, None)
|
||||
except OSError:
|
||||
pass
|
||||
|
||||
def _busy(self) -> int:
|
||||
with self.lock:
|
||||
return self.busy
|
||||
|
||||
def _consume_loop(self) -> None:
|
||||
pause = 1.0
|
||||
while not self.stop.is_set():
|
||||
self._touch()
|
||||
connection = None
|
||||
try:
|
||||
connection = broker.connect("worker")
|
||||
channel = connection.channel()
|
||||
broker.declare(channel)
|
||||
# prefetch = сколько неподтверждённых сообщений брокер выдаёт этому worker.
|
||||
channel.basic_qos(prefetch_count=config.WORKER_CONCURRENCY)
|
||||
tag = channel.basic_consume(broker.QUEUE, partial(self._on_message, connection), auto_ack=False)
|
||||
log.info("Подписан на очередь %s, prefetch=%d", broker.QUEUE, config.WORKER_CONCURRENCY)
|
||||
pause = 1.0
|
||||
while not self.stop.is_set():
|
||||
connection.process_data_events(time_limit=1)
|
||||
self._touch()
|
||||
channel.basic_cancel(tag) # новые доставки прекращаются
|
||||
deadline = time.monotonic() + SHUTDOWN_SECONDS
|
||||
while self._busy() and time.monotonic() < deadline:
|
||||
connection.process_data_events(time_limit=0.5) # тут уходят ack начатых заданий
|
||||
connection.process_data_events(time_limit=0) # ack, поставленные последними
|
||||
connection.close()
|
||||
except broker.BrokerError as exc:
|
||||
log.warning("Брокер недоступен (%s), повтор через %g с", type(exc).__name__, pause)
|
||||
try:
|
||||
if connection is not None and connection.is_open:
|
||||
connection.close()
|
||||
except broker.BrokerError:
|
||||
pass
|
||||
self._touch()
|
||||
self.stop.wait(pause)
|
||||
pause = min(pause * 2, 10.0)
|
||||
|
||||
# ---------- доставка сообщения ----------
|
||||
|
||||
def _on_message(self, connection, channel, method, _properties, body) -> None:
|
||||
with self.lock:
|
||||
self.busy += 1
|
||||
self.executor.submit(self._handle, connection, channel, method.delivery_tag, body)
|
||||
|
||||
def _settle(self, connection, channel, tag, action: str) -> None:
|
||||
"""ack / reject / requeue выполняются в потоке соединения (так требует pika)."""
|
||||
def callback():
|
||||
if not channel.is_open: # канал закрылся: брокер сам вернёт сообщение в очередь
|
||||
return
|
||||
if action == "ack":
|
||||
channel.basic_ack(tag)
|
||||
elif action == "reject":
|
||||
channel.basic_reject(tag, requeue=False) # -> DLQ
|
||||
else:
|
||||
channel.basic_nack(tag, requeue=True)
|
||||
try:
|
||||
connection.add_callback_threadsafe(callback)
|
||||
except Exception: # соединение уже закрыто — та же логика, что выше
|
||||
pass
|
||||
finally:
|
||||
with self.lock:
|
||||
self.busy -= 1
|
||||
|
||||
def _handle(self, connection, channel, tag, body) -> None:
|
||||
action = "requeue"
|
||||
try:
|
||||
action = self._process(body)
|
||||
except Exception:
|
||||
log.exception("Неожиданная ошибка обработки сообщения: вернётся в очередь")
|
||||
time.sleep(2)
|
||||
finally:
|
||||
self._settle(connection, channel, tag, action)
|
||||
|
||||
def _claim(self, message: dict):
|
||||
deadline = time.monotonic() + DB_WAIT_SECONDS
|
||||
while True:
|
||||
try:
|
||||
return self.jobs.claim(message, self.id)
|
||||
except Unavailable:
|
||||
if time.monotonic() > deadline or self.stop.is_set():
|
||||
return None
|
||||
time.sleep(2)
|
||||
|
||||
def _process(self, body: bytes) -> str:
|
||||
try:
|
||||
message = broker.parse(body)
|
||||
except broker.InvalidMessage as exc:
|
||||
log.error("Сообщение не по схеме jobs.schema.json (%s): reject -> DLQ", exc)
|
||||
return "reject"
|
||||
decision = self._claim(message)
|
||||
if decision is None:
|
||||
log.warning("PostgreSQL недоступен: задание %s вернётся в очередь", message["job_id"])
|
||||
return "requeue"
|
||||
if decision.kind != "claimed":
|
||||
log.info("Задание %s попытка %d: %s %s — ack без обработки", message["job_id"], message["attempt"],
|
||||
decision.kind, decision.detail)
|
||||
return "ack"
|
||||
lease = decision.lease
|
||||
item = InFlight(lease, threading.Event(), time.monotonic())
|
||||
with self.lock:
|
||||
self.inflight[lease.token] = item
|
||||
try:
|
||||
return self._run_job(item)
|
||||
finally:
|
||||
with self.lock:
|
||||
self.inflight.pop(lease.token, None)
|
||||
|
||||
def _run_job(self, item: InFlight) -> str:
|
||||
lease = item.lease
|
||||
try:
|
||||
try:
|
||||
variants = self._produce(lease, item.abort)
|
||||
faults.pause("worker_pause_after_objects") # проверка уборщика: объекты есть, COMMIT ещё нет
|
||||
faults.hit("worker_after_objects") # объекты в S3 есть, COMMIT и ack — нет
|
||||
if not self.jobs.complete(lease, variants):
|
||||
log.warning("Задание %s: lease потерян до COMMIT — результат не записан", lease.job_id)
|
||||
return "ack"
|
||||
faults.hit("worker_after_commit") # результат закоммичен, ack — нет
|
||||
self._drop_staging(lease)
|
||||
log.info("Вложение %s готово: попытка %d за %.2f с", lease.attachment_id, lease.attempt,
|
||||
time.monotonic() - item.started)
|
||||
return "ack"
|
||||
except Permanent as exc:
|
||||
log.warning("Вложение %s: постоянная ошибка %s (%s) -> failed", lease.attachment_id, exc.code, exc)
|
||||
return "reject" if self.jobs.fail(lease, exc.code, str(exc)) else "ack"
|
||||
except Transient as exc:
|
||||
outcome = self.jobs.retry(lease, exc.code, str(exc))
|
||||
log.warning("Вложение %s: временная ошибка %s (%s), попытка %d -> %s", lease.attachment_id,
|
||||
exc.code, exc, lease.attempt, outcome)
|
||||
return "reject" if outcome == "failed" else "ack"
|
||||
except LeaseLost:
|
||||
log.warning("Задание %s: lease забрал другой worker — работа брошена", lease.job_id)
|
||||
return "ack"
|
||||
except Unavailable:
|
||||
# PostgreSQL недоступен: исход не записан. Сообщение вернётся; lease истечёт сам.
|
||||
time.sleep(2)
|
||||
return "requeue"
|
||||
|
||||
# ---------- сама работа ----------
|
||||
|
||||
def _fetch_source(self, lease: jobs.Lease, path: str) -> None:
|
||||
for key in (lease.staging_key, lease.storage_key):
|
||||
if not key:
|
||||
continue
|
||||
try:
|
||||
objects.download(key, path, config.MAX_UPLOAD_BYTES)
|
||||
return
|
||||
except objects.MissingObject:
|
||||
continue
|
||||
except Unavailable:
|
||||
raise Transient("storage_unavailable", "S3 недоступен при чтении оригинала") from None
|
||||
raise Permanent("source_missing", "оригинала нет ни в staging, ни в originals")
|
||||
|
||||
def _produce(self, lease: jobs.Lease, abort: threading.Event) -> list[dict]:
|
||||
with tempfile.TemporaryDirectory(prefix="job-") as tmp:
|
||||
source = os.path.join(tmp, "source")
|
||||
self._fetch_source(lease, source)
|
||||
# Метаданные в БД — доверенный источник: объект должен совпасть с ними байт в байт.
|
||||
if os.path.getsize(source) != lease.size_bytes or _sha256(source) != lease.sha256:
|
||||
raise Permanent("source_corrupted", "оригинал в S3 не совпадает с размером или SHA-256 из БД")
|
||||
if lease.width * lease.height > config.MAX_IMAGE_PIXELS:
|
||||
raise Permanent("image_too_large", "больше лимита пикселей")
|
||||
with open(source, "rb") as f:
|
||||
if imaging.sniff_bytes(f.read(16)) != lease.content_type:
|
||||
raise Permanent("invalid_image", "тип содержимого не совпадает с метаданными")
|
||||
if faults.consume("worker_transient"):
|
||||
raise Transient("storage_unavailable", "внедрённый временный сбой (faults: worker_transient)")
|
||||
try:
|
||||
result = sandbox.run(source, os.path.join(tmp, "out"), lease.content_type, self.params,
|
||||
timeout=config.JOB_TIMEOUT_SECONDS,
|
||||
memory_limit_mb=config.WORKER_MEMORY_LIMIT_MB,
|
||||
slow_seconds=faults.number("worker_slow"), abort=abort)
|
||||
except imaging.ImageError as exc:
|
||||
raise Permanent(exc.code, str(exc)) from None
|
||||
except (sandbox.ProcessingTimeout, sandbox.ChildCrashed) as exc:
|
||||
if abort.is_set():
|
||||
raise LeaseLost() from None
|
||||
raise Transient(exc.code, str(exc)) from None
|
||||
except RuntimeError as exc:
|
||||
raise Transient("processing_failed", str(exc)) from None
|
||||
if abort.is_set():
|
||||
raise LeaseLost()
|
||||
try:
|
||||
objects.put_file(lease.storage_key, source, lease.content_type, lease.sha256)
|
||||
variants = []
|
||||
for v in result["variants"]:
|
||||
extension = ".jpg" if v["content_type"] == "image/jpeg" else ".webp"
|
||||
key = objects.variant_key(lease.attachment_id, lease.pipeline_version, v["name"], extension)
|
||||
objects.put_file(key, v["path"], v["content_type"], v["sha256"])
|
||||
variants.append({k: v[k] for k in ("name", "content_type", "size_bytes", "width", "height",
|
||||
"sha256")} | {"storage_key": key})
|
||||
except Unavailable:
|
||||
raise Transient("storage_unavailable", "S3 недоступен при записи результата") from None
|
||||
return variants
|
||||
|
||||
def _drop_staging(self, lease: jobs.Lease) -> None:
|
||||
if not lease.staging_key:
|
||||
return
|
||||
try:
|
||||
objects.delete(lease.staging_key)
|
||||
except Unavailable:
|
||||
log.warning("Staging %s не удалён сейчас — его удалит уборщик", lease.attachment_id)
|
||||
|
||||
# ---------- фоновые потоки ----------
|
||||
|
||||
def _keeper(self) -> None:
|
||||
"""Продление lease начатых заданий. Не продлили — задание у нас забрали: прерываем работу."""
|
||||
while not self.threads_stop.wait(config.JOB_HEARTBEAT_SECONDS):
|
||||
with self.lock:
|
||||
items = list(self.inflight.values())
|
||||
if not items:
|
||||
continue
|
||||
# Задание дольше лимита попытки уже не продлеваем: его дочерний процесс должен был быть убит.
|
||||
alive = [it for it in items if time.monotonic() - it.started < config.JOB_TIMEOUT_SECONDS + 30]
|
||||
try:
|
||||
renewed = self.jobs.renew([it.lease.token for it in alive])
|
||||
except Unavailable:
|
||||
continue
|
||||
for it in items:
|
||||
if it.lease.token not in renewed and not it.abort.is_set():
|
||||
log.warning("Lease задания %s не продлён (его забрали): прерываю обработку", it.lease.job_id)
|
||||
it.abort.set()
|
||||
|
||||
def _reaper(self) -> None:
|
||||
"""Истёкшие lease -> следующая попытка; страховка от потерянных сообщений; уборка S3."""
|
||||
last_cleanup = time.monotonic()
|
||||
problem = None
|
||||
while not self.threads_stop.wait(config.REAPER_INTERVAL_SECONDS):
|
||||
try:
|
||||
for attachment_id, outcome in self.jobs.reap():
|
||||
log.warning("Вложение %s: lease истёк -> %s", attachment_id, outcome)
|
||||
republished = self.jobs.republish_stale(config.QUEUED_REPUBLISH_SECONDS)
|
||||
if republished:
|
||||
log.warning("Повторно отправлено заданий без движения: %d", republished)
|
||||
problem = None
|
||||
except AppError as exc:
|
||||
if problem != exc.message:
|
||||
log.warning("Проверка lease пропущена: %s", exc.message)
|
||||
problem = exc.message
|
||||
except Exception:
|
||||
log.exception("Проверка lease: неожиданная ошибка")
|
||||
if time.monotonic() - last_cleanup >= config.CLEANUP_INTERVAL_SECONDS:
|
||||
last_cleanup = time.monotonic()
|
||||
try:
|
||||
summary = cleanup.run_once(self.store, config.ATTACHMENT_GRACE_SECONDS,
|
||||
config.STAGING_RETENTION_SECONDS)
|
||||
if summary["deleted"]:
|
||||
log.info("Уборка S3: %s", summary)
|
||||
except AppError as exc:
|
||||
log.warning("Уборка S3 пропущена: %s", exc.message)
|
||||
except Exception:
|
||||
log.exception("Уборка S3: неожиданная ошибка")
|
||||
|
||||
|
||||
def main() -> int:
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
|
||||
logging.getLogger("pika").setLevel(logging.WARNING)
|
||||
Worker().run()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
@@ -0,0 +1,53 @@
|
||||
"""lab4–lab5, уровень 3: upload -> СРАЗУ остановка обслужившей реплики -> ready и download через другую.
|
||||
|
||||
make attachment-failover (= python student-tests/attachment_failover.py)
|
||||
|
||||
С lab5 реплика останавливается сразу после ответа 202, ещё до обработки. Это доказывает две вещи:
|
||||
- остановка API после ответа не теряет работу: оригинал уже в staging S3, задание — в PostgreSQL,
|
||||
worker доводит вложение до ready без этой реплики;
|
||||
- оригинал не лежит на диске реплики: другая реплика отдаёт тот же файл байт в байт (SHA-256).
|
||||
В конце остановленная реплика запускается обратно (`docker start`).
|
||||
"""
|
||||
import hashlib
|
||||
|
||||
from filegen import upload_when_ready, wait_status, wait_until
|
||||
from helpers import Client, check, run
|
||||
from stand import docker, lb_summary, lb_up_count, ps_table, wait_balanced
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
replicas = wait_balanced(2)
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
reply = upload_when_ready(api, alice, chat, name="failover.png")
|
||||
attachment, served = reply["json"], reply["headers"]["X-Instance-Id"]
|
||||
target = [c for c in replicas if c.startswith(served)]
|
||||
check(len(target) == 1, f"X-Instance-Id {served} does not match a running api container")
|
||||
print(f"uploaded {attachment['size_bytes']} bytes -> 202 {attachment['status']}, "
|
||||
f"sha256 {attachment['sha256'][:16]}..., served by api replica {served}")
|
||||
print(ps_table())
|
||||
docker("stop", target[0])
|
||||
try:
|
||||
wait_until(lambda: lb_up_count() == len(replicas) - 1, 30, "HAProxy did not remove the stopped replica")
|
||||
print(f"stopped {served} (docker stop) right after 202; HAProxy: {lb_summary()}")
|
||||
ready = wait_status(api, bob, attachment["id"], seconds=90)
|
||||
print(f"the worker finished the job without that replica: status {ready['status']}, "
|
||||
f"variants {[v['name'] for v in ready['variants']]}")
|
||||
seen = set()
|
||||
for _ in range(4):
|
||||
got = api.call("GET", f"/api/v1/attachments/{attachment['id']}/content", actor=bob)
|
||||
check(hashlib.sha256(got["bytes"]).hexdigest() == attachment["sha256"], "downloaded file differs")
|
||||
seen.add(got["headers"]["X-Instance-Id"])
|
||||
check(served not in seen, "the stopped replica still answered")
|
||||
print(f"downloaded 4 times through {sorted(seen)}: same SHA-256 as uploaded")
|
||||
finally:
|
||||
docker("start", target[0])
|
||||
wait_balanced(len(replicas))
|
||||
print(f"restored {served}; HAProxy: {lb_summary()}")
|
||||
print(ps_table())
|
||||
print("PASS: the replica that accepted the upload was stopped right after 202; the job still became ready and "
|
||||
"another replica returned the same bytes (the original lives in S3, not on the replica)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Отозванный токен не «воскресает» из кэша после возвращения Valkey (замечание к MR).
|
||||
|
||||
Запуск: make failure-valkey-pause
|
||||
|
||||
Сценарий преподавателя: Valkey ставится на паузу (docker compose pause) — процесс жив,
|
||||
данные в его памяти сохраняются, но он не отвечает. В это время делается logout: PostgreSQL
|
||||
отзывает сессию, а убрать запись из кэша нельзя. После unpause в кэше всё ещё лежит старая
|
||||
запись «токен -> пользователь». Она не должна снова пропускать этот токен.
|
||||
"""
|
||||
import time
|
||||
|
||||
from helpers import Client, compose, run, wait_ready
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
dave = api.user("dave")
|
||||
for _ in range(2): # запись о сессии dave точно лежит в кэше
|
||||
api.call("GET", "/api/v1/users/me", actor=dave, schema="User")
|
||||
|
||||
print("pausing valkey (docker compose pause valkey): данные в кэше сохраняются")
|
||||
compose("pause", "valkey")
|
||||
try:
|
||||
api.call("GET", "/api/v1/users/me", actor=dave, schema="User") # этот запрос обнаруживает сбой кэша
|
||||
api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=dave)
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=dave)
|
||||
print("во время паузы: logout -> 204, тот же токен -> 401")
|
||||
finally:
|
||||
print("unpausing valkey")
|
||||
compose("unpause", "valkey")
|
||||
|
||||
wait_ready(api)
|
||||
# Фоновая проверка возвращает кэш в работу в течение 5 с. Смотрим 12 с — дольше, чем она.
|
||||
deadline = time.monotonic() + 12
|
||||
checks = 0
|
||||
while time.monotonic() < deadline:
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=dave)
|
||||
api.call("POST", "/api/v1/chats", 401, actor=dave, body={"title": "x", "member_ids": [dave["id"]]})
|
||||
checks += 1
|
||||
time.sleep(0.5)
|
||||
print(f"после unpause: {checks} проверок за 12 с, отозванный токен всегда 401 (и GET, и POST)")
|
||||
|
||||
api.call("GET", "/api/v1/users/me", actor=alice, schema="User")
|
||||
api.message(bob, chat, "после возвращения Valkey")
|
||||
print("действующие токены других пользователей работают")
|
||||
print("PASS: revoked session stays revoked after Valkey comes back with stale data")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,130 @@
|
||||
"""lab3–lab5, уровень 4: проверка устройства стенда по реальным контейнерам и docker compose config.
|
||||
|
||||
make check-stack (= python student-tests/check_stack.py)
|
||||
|
||||
- не меньше 2 работающих реплик api, у них нет опубликованных портов (обойти балансировщик нельзя);
|
||||
- в балансировщике каждая реплика под проверкой готовности, резервных серверов без проверки нет
|
||||
(неготовая реплика не получает запросы ни при каких условиях);
|
||||
- ни у одного сервиса нет container_name (иначе нельзя запустить несколько реплик одного сервиса);
|
||||
- наружу опубликован только балансировщик и только на 127.0.0.1;
|
||||
- у каждого работающего контейнера есть лимиты CPU и RAM;
|
||||
- сети: postgres, valkey, s3, broker и worker только во внутренней сети backend, lb только в edge, api в обеих;
|
||||
- (lab5) брокер — отдельный сервис с volume и постоянным hostname, без портов и без веб-консоли;
|
||||
worker — отдельный сервис без портов;
|
||||
- секреты получает только тот, кому они нужны;
|
||||
- версии Docker, Compose и образов (для отчёта).
|
||||
"""
|
||||
import json
|
||||
|
||||
from helpers import check, run
|
||||
from stand import api_containers, compose_config, compose_output, docker, inspect, lb_rows
|
||||
|
||||
|
||||
def main():
|
||||
config = compose_config()
|
||||
services = config["services"]
|
||||
networks = config.get("networks", {})
|
||||
|
||||
print("docker: " + docker("version", "--format", "{{.Server.Version}}"))
|
||||
print("compose: " + compose_output("version", "--short").strip())
|
||||
|
||||
check(not [name for name, svc in services.items() if "container_name" in svc], "container_name is set")
|
||||
print("container_name: not set for any service (replicas of one service are possible)")
|
||||
|
||||
replicas = api_containers()
|
||||
check(len(replicas) >= 2, f"need >= 2 running api replicas, got {len(replicas)}")
|
||||
print(f"api replicas running: {len(replicas)} -> {[c[:12] for c in replicas]} "
|
||||
f"(deploy.replicas = {services['api'].get('deploy', {}).get('replicas')})")
|
||||
|
||||
print()
|
||||
print(f"{'service':<14} {'container':<13} {'cpus':>5} {'memory':>8} {'published ports':<34} networks")
|
||||
published = {}
|
||||
for container in sorted(compose_output("ps", "-q").split()):
|
||||
service = inspect(container, '{{index .Config.Labels "com.docker.compose.service"}}')
|
||||
nano_cpus = int(inspect(container, "{{.HostConfig.NanoCpus}}") or 0)
|
||||
memory = int(inspect(container, "{{.HostConfig.Memory}}") or 0)
|
||||
ports = json.loads(inspect(container, "{{json .NetworkSettings.Ports}}") or "{}") or {}
|
||||
bindings = [f"{b['HostIp']}:{b['HostPort']}->{port}" for port, items in ports.items() for b in (items or [])]
|
||||
nets = sorted(json.loads(inspect(container, "{{json .NetworkSettings.Networks}}") or "{}"))
|
||||
nets = [name.split("_", 1)[-1] for name in nets]
|
||||
published[service] = published.get(service, []) + bindings
|
||||
print(f"{service:<14} {container[:12]:<13} {nano_cpus / 1e9:>5.2f} {memory // 2**20:>6}Mi "
|
||||
f"{', '.join(bindings) or '-':<34} {', '.join(nets)}")
|
||||
check(nano_cpus > 0 and memory > 0, f"{service} {container[:12]} has no CPU/RAM limit")
|
||||
print()
|
||||
|
||||
check(not published.get("api"), "api publishes ports and can be reached bypassing the balancer")
|
||||
others = {service: ports for service, ports in published.items() if ports and service != "lb"}
|
||||
check(not others, f"only the balancer may publish ports, got {others}")
|
||||
check(published.get("lb") and all(b.startswith("127.0.0.1:") for b in published["lb"]),
|
||||
"the balancer must be published on 127.0.0.1 only")
|
||||
print("published: only lb, only on 127.0.0.1 (api replicas have no ports)")
|
||||
|
||||
servers = lb_rows("api")
|
||||
backups = [row["svname"] for row in servers if row.get("bck") == "1"]
|
||||
unchecked = [row["svname"] for row in servers
|
||||
if not row.get("status", "").startswith("MAINT") and not row.get("check_status")]
|
||||
check(not backups, f"backup servers in the balancer: {backups}")
|
||||
check(not unchecked, f"servers without a readiness check in the balancer: {unchecked}")
|
||||
in_use = [f"{row['svname']} {row['status']} ({row['check_status']})" for row in servers
|
||||
if not row.get("status", "").startswith("MAINT")]
|
||||
print(f"balancer: every api server is under the /health/ready check, no backup servers -> {', '.join(in_use)}")
|
||||
print("limits: every running container has CPU and RAM limits")
|
||||
|
||||
def nets_of(name):
|
||||
return sorted(services[name].get("networks", {}))
|
||||
|
||||
check(all(nets_of(name) == ["backend"] for name in ("postgres", "valkey", "s3", "s3-init", "broker", "worker")),
|
||||
"stores, broker and worker must be on backend only")
|
||||
check(nets_of("lb") == ["edge"], "lb must be on edge only")
|
||||
check(nets_of("api") == ["backend", "edge"], "api must be on edge and backend")
|
||||
check(networks.get("backend", {}).get("internal") is True, "backend network must be internal")
|
||||
print("networks: lb -> edge; api -> edge + backend; postgres, valkey, s3, broker, worker -> backend "
|
||||
"(internal: no way out)")
|
||||
|
||||
# lab5: брокер и worker — отдельные сервисы общего стенда.
|
||||
broker, worker = services["broker"], services["worker"]
|
||||
check(not broker.get("ports") and not worker.get("ports"), "broker and worker must not publish ports")
|
||||
check(":" in broker["image"] and not broker["image"].endswith(":latest") and "management" not in broker["image"],
|
||||
"broker image must be pinned and without the management console")
|
||||
check(any(v.get("source") == "rabbitmqdata" for v in broker.get("volumes", [])), "broker needs a volume")
|
||||
check(broker.get("hostname") == "broker", "broker needs a fixed hostname (node name = data directory)")
|
||||
check(worker.get("command", [])[-1:] == ["messenger.worker"], "worker must be a separate process")
|
||||
workers = sorted(compose_output("ps", "-q", "worker").split())
|
||||
check(len(workers) >= 1, "worker is not running")
|
||||
print(f"broker: {broker['image']}, volume rabbitmqdata, hostname broker, no ports, no web console; "
|
||||
f"worker: separate service ({len(workers)} running), no ports")
|
||||
|
||||
# lab4: S3 без портов наружу и без веб-консоли; версии образов закреплены.
|
||||
s3 = services["s3"]
|
||||
check(not s3.get("ports"), "s3 must not publish ports")
|
||||
command = s3.get("command", [])
|
||||
check("-ip.bind=127.0.0.1" in command and "-s3.iam=false" in command,
|
||||
"SeaweedFS master/filer UIs must listen on 127.0.0.1 only and IAM API must be off")
|
||||
check(not s3["image"].endswith(":latest") and ":" in s3["image"], "s3 image must be pinned")
|
||||
check(any(v.get("source") == "s3data" for v in s3.get("volumes", [])), "s3 must use the persistent volume s3data")
|
||||
print("s3: no published ports; master/filer web UIs only on 127.0.0.1 inside the container; IAM API off; "
|
||||
"pinned image; volume s3data")
|
||||
|
||||
def secrets_of(name):
|
||||
return sorted(item["source"] for item in services[name].get("secrets", []))
|
||||
|
||||
expected = {"api": ["broker_url", "cache_url", "database_url", "s3_access_key_id", "s3_secret_access_key"],
|
||||
"worker": ["broker_url", "database_url", "s3_access_key_id", "s3_secret_access_key"],
|
||||
"broker": ["broker_credentials"],
|
||||
"migrate": ["database_url"], "lb": [],
|
||||
"postgres": ["postgres_password"], "valkey": ["valkey_acl"],
|
||||
"s3": ["s3_config"],
|
||||
"s3-init": ["s3_root_password", "s3_root_user"]}
|
||||
for name, wanted in expected.items():
|
||||
check(secrets_of(name) == wanted, f"{name} secrets {secrets_of(name)} != {wanted}")
|
||||
print("secrets: " + "; ".join(f"{name} -> {', '.join(wanted) or 'none'}" for name, wanted in expected.items()))
|
||||
print("images: " + "; ".join(f"{name} {services[name]['image']}"
|
||||
for name in ("lb", "api", "worker", "postgres", "valkey", "s3", "broker")))
|
||||
print("PASS: one entry point (lb on 127.0.0.1), >= 2 api replicas without ports and container_name, "
|
||||
"only ready replicas get traffic, CPU/RAM limits everywhere, stores (incl. S3) only on the internal network, "
|
||||
"S3 admin credentials only in s3-init; broker and worker are separate services")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,200 @@
|
||||
"""Замечание к MR: уборщик S3 не удаляет текущую работу — воспроизведение на стенде с «барьерами».
|
||||
|
||||
make cleanup-race (= python student-tests/cleanup_race.py)
|
||||
|
||||
Порядок событий закрепляют точки-паузы (src/messenger/faults.py): процесс один раз ждёт
|
||||
несколько секунд в опасном месте, а тест в это время делает следующий шаг. Grace period = 0,
|
||||
чтобы уборщик рассматривал даже свежие объекты (так же, как в воспроизведении из замечания).
|
||||
Настоящие PostgreSQL, S3, CLI уборщика, replay, API и worker.
|
||||
|
||||
A. Как в замечании. failed-вложение с истёкшим retention (состояние и возраст заданы через
|
||||
updated_at, как в замечании). Уборщик прочитал ссылки и остановился (cleanup_pause) ->
|
||||
оператор делает replay (queued) -> уборщик продолжает. Было: staging удалён, worker ->
|
||||
failed / source_missing. Стало: уборщик перепроверяет состояние под блокировкой и staging
|
||||
не трогает; после запуска worker вложение становится ready.
|
||||
B. Обратный порядок. Уборщик под блокировкой уже решил удалить staging истёкшего failed и пометил
|
||||
его удалённым, COMMIT ещё нет (cleanup_pause_locked) -> replay ждёт блокировку и безопасно
|
||||
отказывает (source_missing), задание остаётся failed, в журнале — запись уборщика и отказ
|
||||
replay; сам объект уборщик удаляет после COMMIT.
|
||||
C. Загрузка между PUT в staging и COMMIT строки вложения (api_pause_after_staging): уборщик
|
||||
пропускает это вложение (занято), загрузка заканчивается 202 -> ready.
|
||||
D. Worker записал оригинал и варианты в S3, COMMIT ещё нет (worker_pause_after_objects):
|
||||
уборщик ничего не удаляет (задание в processing), worker коммитит -> ready, файлы на месте.
|
||||
"""
|
||||
import hashlib
|
||||
import threading
|
||||
import time
|
||||
|
||||
import ops
|
||||
from filegen import SAMPLE_PNG, png, wait_status
|
||||
from helpers import Client, check, run
|
||||
|
||||
# Секунд в точке-паузе: столько длится «окно» гонки. С запасом: на Windows каждый docker exec — около секунды.
|
||||
PAUSE = {"cleanup_pause": "10", "cleanup_pause_locked": "8", "api_pause_after_staging": "10",
|
||||
"worker_pause_after_objects": "12"}
|
||||
|
||||
|
||||
def background(fn, *args):
|
||||
result = {}
|
||||
|
||||
def target():
|
||||
try:
|
||||
result["value"] = fn(*args)
|
||||
except BaseException as exc: # noqa: BLE001 — передаём в основной поток
|
||||
result["error"] = exc
|
||||
thread = threading.Thread(target=target, daemon=True)
|
||||
thread.start()
|
||||
return thread, result
|
||||
|
||||
|
||||
def finish(step, seconds=60):
|
||||
thread, result = step
|
||||
thread.join(seconds)
|
||||
check(not thread.is_alive(), "a background step did not finish")
|
||||
if "error" in result:
|
||||
raise result["error"]
|
||||
return result["value"]
|
||||
|
||||
|
||||
def wait_paused(container, point, seconds=40):
|
||||
"""Точка-пауза сработала (процесс удалил её файл и ждёт) — можно делать следующий шаг."""
|
||||
deadline = time.monotonic() + seconds
|
||||
while ops.armed(container, point):
|
||||
check(time.monotonic() < deadline, f"{point} did not fire")
|
||||
time.sleep(0.2)
|
||||
|
||||
|
||||
def janitor(container, attachment_id):
|
||||
return ops.cli_in(container, "messenger.cleanup", "--grace-seconds", "0", "--attachment", attachment_id)
|
||||
|
||||
|
||||
def mark_failed_long_ago(attachment_id):
|
||||
ops.psql(f"""UPDATE attachment_jobs SET status = 'failed', finished_at = now(),
|
||||
last_error_code = 'storage_unavailable', last_error = 'cleanup-race'
|
||||
WHERE attachment_id = '{attachment_id}';
|
||||
UPDATE attachments SET status = 'failed', error_code = 'retry_exhausted',
|
||||
updated_at = now() - interval '2 days'
|
||||
WHERE id = '{attachment_id}'""")
|
||||
|
||||
|
||||
def staging_exists(attachment_id):
|
||||
return ops.objects(f"staging/{attachment_id}") == [f"staging/{attachment_id}"]
|
||||
|
||||
|
||||
def upload(api, actor, chat, data, name):
|
||||
return api.call("POST", f"/api/v1/chats/{chat['id']}/attachments?filename={name}", 202, actor=actor,
|
||||
raw=data, headers={"Content-Type": "image/png"}, schema="Attachment")["json"]
|
||||
|
||||
|
||||
def main():
|
||||
api = Client(timeout=30)
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
container = ops.containers("api")[0] # здесь запускается уборщик и включаются его паузы
|
||||
|
||||
# ---------- A и B: подготовка двух failed-вложений с истёкшим retention ----------
|
||||
ops.stop("worker")
|
||||
try:
|
||||
a = upload(api, alice, chat, SAMPLE_PNG, "race-a.png")
|
||||
b = upload(api, alice, chat, png(40, 30), "race-b.png")
|
||||
for att in (a, b):
|
||||
mark_failed_long_ago(att["id"])
|
||||
|
||||
# ---------- A ----------
|
||||
ops.arm("api", "cleanup_pause", PAUSE["cleanup_pause"], container=container)
|
||||
cleanup = background(janitor, container, a["id"])
|
||||
wait_paused(container, "cleanup_pause")
|
||||
print(f"A. failed {a['id']} (retention expired); the janitor read the references and stopped")
|
||||
replayed = ops.replay(a["id"])
|
||||
check(replayed.get("result") == "queued", f"replay: {replayed}")
|
||||
print(f" operator replay while the janitor waits -> {replayed}")
|
||||
out = finish(cleanup)
|
||||
check(out["deleted"] == 0 and out["kept_after_recheck"] == {"current_work": 1}, f"janitor: {out}")
|
||||
check(staging_exists(a["id"]), "the staging of the replayed job was deleted")
|
||||
print(f" janitor continued: deleted {out['deleted']}, re-checked under the lock -> kept "
|
||||
f"{out['kept_after_recheck']}; staging/{a['id'][:8]}... is still in S3")
|
||||
|
||||
# ---------- B ----------
|
||||
ops.arm("api", "cleanup_pause_locked", PAUSE["cleanup_pause_locked"], container=container)
|
||||
cleanup = background(janitor, container, b["id"])
|
||||
wait_paused(container, "cleanup_pause_locked")
|
||||
print(f"B. failed {b['id']} (retention expired); the janitor holds the lock: staging marked deleted, "
|
||||
f"no COMMIT yet")
|
||||
started = time.monotonic()
|
||||
refused = ops.replay(b["id"])
|
||||
waited = time.monotonic() - started
|
||||
out = finish(cleanup)
|
||||
check(refused.get("result") == "refused" and refused.get("reason") == "source_missing", f"replay: {refused}")
|
||||
check(out["deleted"] == 1 and out["to_delete"]["staging_failed_expired"] == 1, f"janitor: {out}")
|
||||
job = ops.job(b["id"])
|
||||
events = [e["event"] for e in job["events"] if e["event"] in ("staging_expired", "replay_refused")]
|
||||
check(job["job"]["status"] == "failed" and events == ["staging_expired", "replay_refused"], f"{job}")
|
||||
check(not staging_exists(b["id"]), "the expired staging must be deleted")
|
||||
print(f" replay waited {waited:.1f} s for the lock -> {refused['result']} ({refused['reason']}); "
|
||||
f"job stays failed; journal: {' -> '.join(events)}")
|
||||
finally:
|
||||
ops.start("worker")
|
||||
ops.wait_healthy("worker", 1)
|
||||
ready = wait_status(api, bob, a["id"], ("ready", "failed"), seconds=90)
|
||||
check(ready["status"] == "ready", f"A must become ready, got {ready['status']} / {ready['error_code']}")
|
||||
print(f" A: worker started -> ready with {[v['name'] for v in ready['variants']]} (before the fix: "
|
||||
f"failed / source_missing)")
|
||||
|
||||
# ---------- C ----------
|
||||
before = set(ops.objects("staging/"))
|
||||
ops.arm("api", "api_pause_after_staging", PAUSE["api_pause_after_staging"])
|
||||
try:
|
||||
sending = background(upload, api, alice, chat, png(48, 36), "race-c.png")
|
||||
deadline = time.monotonic() + 30
|
||||
while True:
|
||||
new = sorted(set(ops.objects("staging/")) - before)
|
||||
if new:
|
||||
break
|
||||
check(time.monotonic() < deadline, "the upload did not reach staging")
|
||||
time.sleep(0.2)
|
||||
c_id = new[0].split("/", 1)[1]
|
||||
rows = ops.psql(f"SELECT count(*) FROM attachments WHERE id = '{c_id}'")
|
||||
check(rows == "0", "the row must not be committed yet")
|
||||
print(f"C. upload {c_id}: staging written, no row in the database yet (API paused before COMMIT)")
|
||||
out = janitor(container, c_id)
|
||||
check(out["deleted"] == 0 and out["skipped_busy"] == 1, f"janitor: {out}")
|
||||
print(f" janitor (grace 0): skipped_busy {out['skipped_busy']}, deleted {out['deleted']} — "
|
||||
f"the upload holds the attachment lock")
|
||||
att = finish(sending)
|
||||
check(att["id"] == c_id, "unexpected attachment id")
|
||||
finally:
|
||||
ops.disarm("api", "api_pause_after_staging")
|
||||
meta = wait_status(api, bob, c_id, seconds=60)
|
||||
print(f" upload -> 202, then {meta['status']} with {len(meta['variants'])} variants")
|
||||
|
||||
# ---------- D ----------
|
||||
ops.arm("worker", "worker_pause_after_objects", PAUSE["worker_pause_after_objects"])
|
||||
try:
|
||||
d = upload(api, alice, chat, SAMPLE_PNG, "race-d.png")
|
||||
deadline = time.monotonic() + 60
|
||||
while len(ops.objects(f"variants/{d['id']}/")) < 3 or not ops.objects(f"originals/{d['id']}"):
|
||||
check(time.monotonic() < deadline, "the worker did not write the objects")
|
||||
time.sleep(0.2)
|
||||
status = ops.job(d["id"])["attachment_status"]
|
||||
check(status == "processing", f"expected processing, got {status}")
|
||||
print(f"D. {d['id']}: worker wrote the original and 3 variants, COMMIT not yet (status {status})")
|
||||
out = janitor(container, d["id"])
|
||||
# По снимку ссылок оригинал и 3 варианта — ничьи (на них ещё нет COMMIT), staging — нужен.
|
||||
check(out["deleted"] == 0 and out["kept_after_recheck"].get("current_work", 0) == 4, f"janitor: {out}")
|
||||
print(f" janitor (grace 0): the snapshot marked the original and 3 variants as unreferenced; re-checked "
|
||||
f"under the lock -> kept {out['kept_after_recheck']}, deleted {out['deleted']}")
|
||||
finally:
|
||||
ops.disarm("worker", "worker_pause_after_objects")
|
||||
meta = wait_status(api, bob, d["id"], seconds=60)
|
||||
body = api.call("GET", f"/api/v1/attachments/{d['id']}/content", 200, actor=bob)["bytes"]
|
||||
check(hashlib.sha256(body).hexdigest() == d["sha256"], "the original changed")
|
||||
for variant in meta["variants"]:
|
||||
got = api.call("GET", f"/api/v1/attachments/{d['id']}/content?variant={variant['name']}", 200, actor=bob)
|
||||
check(hashlib.sha256(got["bytes"]).hexdigest() == variant["sha256"], "variant bytes differ")
|
||||
print(f" worker committed -> {meta['status']}; the original and all variants download with the same SHA-256")
|
||||
print("PASS: the janitor re-checks the state under the attachment lock before deleting: a replay accepted "
|
||||
"after its snapshot keeps the staging (A), a replay after the janitor's decision is refused safely (B), "
|
||||
"an upload in progress (C) and objects of a job in processing (D) are not deleted")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,64 @@
|
||||
"""lab5, уровень 4: ограниченная конкуренция worker и prefetch брокера.
|
||||
|
||||
make concurrency (= python student-tests/concurrency.py)
|
||||
|
||||
Точка worker_slow=6: каждая обработка «работает» 6 с. В очередь сразу попадают 6 заданий.
|
||||
Раз в 0,5 с смотрим:
|
||||
- сколько заданий в processing (PostgreSQL) — не больше WORKER_CONCURRENCY (2);
|
||||
- сколько сообщений выдано worker и не подтверждено (RabbitMQ messages_unacknowledged) — не больше
|
||||
prefetch (2), остальные лежат в очереди (messages_ready) и ждут: worker не набирает работу впрок,
|
||||
и при втором worker они достались бы ему.
|
||||
Все 6 вложений в итоге ready.
|
||||
"""
|
||||
import time
|
||||
|
||||
import ops
|
||||
from filegen import upload_when_ready, wait_status
|
||||
from helpers import Client, check, run
|
||||
|
||||
COUNT = 6
|
||||
LIMIT = 2
|
||||
|
||||
|
||||
def main():
|
||||
api = Client(timeout=15)
|
||||
ops.scale("worker", 1)
|
||||
worker = ops.wait_healthy("worker", 1)[0]
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
try:
|
||||
ops.arm("worker", "worker_slow", "6", container=worker)
|
||||
ids = [upload_when_ready(api, alice, chat, name=f"conc-{i}.png")["json"]["id"] for i in range(COUNT)]
|
||||
quoted = ", ".join(f"'{i}'" for i in ids)
|
||||
samples = []
|
||||
started = time.monotonic()
|
||||
while time.monotonic() - started < 60:
|
||||
rows = ops.psql(f"SELECT status, count(*) FROM attachment_jobs WHERE attachment_id IN ({quoted}) "
|
||||
"GROUP BY status").splitlines()
|
||||
by_status = {status: int(n) for status, n in (row.split("|") for row in rows if row)}
|
||||
ready_q, unacked = ops.queues().get("attachments.process", (0, 0))
|
||||
samples.append((round(time.monotonic() - started, 1), by_status.get("processing", 0), unacked, ready_q))
|
||||
if by_status.get("ready", 0) == COUNT:
|
||||
break
|
||||
time.sleep(0.5)
|
||||
finally:
|
||||
ops.disarm("worker", "worker_slow")
|
||||
for attachment_id in ids:
|
||||
wait_status(api, bob, attachment_id, seconds=60)
|
||||
peak_processing = max(s[1] for s in samples)
|
||||
peak_unacked = max(s[2] for s in samples)
|
||||
waited = max(s[3] for s in samples)
|
||||
print("time s | processing (DB) | unacked (broker) | waiting in queue")
|
||||
for sample in samples[:: max(1, len(samples) // 12)]:
|
||||
print(f"{sample[0]:>6} | {sample[1]:>15} | {sample[2]:>16} | {sample[3]:>16}")
|
||||
check(peak_processing <= LIMIT, f"more than {LIMIT} jobs were processed at once: {peak_processing}")
|
||||
check(peak_unacked <= LIMIT, f"the worker took more than prefetch={LIMIT} messages: {peak_unacked}")
|
||||
check(peak_processing == LIMIT, "the worker did not use its parallelism")
|
||||
check(waited >= 1, "the other jobs should wait in the broker, not in the worker")
|
||||
print(f"peak: {peak_processing} jobs in processing, {peak_unacked} unacknowledged messages, up to {waited} "
|
||||
f"waiting in the queue; all {COUNT} ready after {samples[-1][0]} s")
|
||||
print(f"PASS: at most WORKER_CONCURRENCY={LIMIT} jobs run at once and the broker gives the worker at most "
|
||||
f"prefetch={LIMIT} messages; the rest wait in the durable queue")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,249 @@
|
||||
"""Замечание к MR: уборщик S3 не удаляет текущую работу — решение под блокировками в настоящей PostgreSQL.
|
||||
|
||||
Выполняется ВНУТРИ контейнера приложения вместе с остальными тестами БД:
|
||||
make db-test == docker compose --profile tools run --rm db-test
|
||||
|
||||
Уборщик проверяется без S3: вместо удаления объекта ему передаётся функция-«барьер», которая
|
||||
запоминает ключ и, если нужно, ждёт сигнала теста. Так порядок событий задаётся точно, как
|
||||
в воспроизведении из замечания (барьер в тестовом драйвере), а не надеждой на тайминги:
|
||||
1. снимок ссылок -> replay коммитит queued -> уборщик продолжает: staging НЕ удаляется
|
||||
(решение перепроверяется по текущему состоянию под блокировкой);
|
||||
2. уборщик под блокировкой уже пометил staging истёкшего failed-вложения удалённым, COMMIT ещё
|
||||
нет -> replay ждёт и безопасно отказывает source_missing, задание остаётся failed, в журнале
|
||||
обе записи; сам объект удаляется после COMMIT;
|
||||
3. replay держит блокировку (проверяет исходник) -> уборщик ждёт и видит queued: не удаляет;
|
||||
4. загрузка записала staging, COMMIT строки ещё не было -> уборщик вложение пропускает;
|
||||
5. задание в processing (worker пишет оригинал и варианты) -> ничего не удаляется;
|
||||
6. обычная уборка не сломана: «сирота» без строки, staging готового и объекты failed-вложения
|
||||
после retention удаляются; опубликованное и всё failed-вложения до конца retention — нет.
|
||||
"""
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
from messenger import config, db, faults, jobs
|
||||
from messenger.store import PostgresStore
|
||||
|
||||
RETENTION = 3600
|
||||
|
||||
|
||||
class Barrier:
|
||||
"""«Удаление объекта» для уборщика: запоминает ключи; может остановиться и ждать сигнала."""
|
||||
|
||||
def __init__(self, hold: bool = False):
|
||||
self.deleted, self.entered, self.release = [], threading.Event(), threading.Event()
|
||||
if not hold:
|
||||
self.release.set()
|
||||
|
||||
def __call__(self, key):
|
||||
self.deleted.append(key)
|
||||
self.entered.set()
|
||||
assert self.release.wait(20), "the test never released the barrier"
|
||||
|
||||
|
||||
class CleanupRaceTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
config.validate()
|
||||
db.migrate()
|
||||
cls.pool = db.create_pool(max_size=6)
|
||||
cls.pool.open(wait=True)
|
||||
cls.store = PostgresStore(cls.pool)
|
||||
cls.jobs = jobs.JobStore(cls.pool, "operator:db-test")
|
||||
cls.worker = jobs.JobStore(cls.pool, "worker-db-test")
|
||||
cls.user = cls.store.create_user("cl_" + uuid.uuid4().hex[:12], "Cleanup test", "not-a-real-hash")
|
||||
cls.chat = cls.store.create_chat(cls.user.id, "cleanup", [cls.user.id])
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.pool.close()
|
||||
|
||||
def scalar(self, sql, *params):
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute(sql, params).fetchone()[0]
|
||||
|
||||
def execute(self, sql, *params):
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute(sql, params)
|
||||
|
||||
def queued(self):
|
||||
attachment_id = str(uuid.uuid4())
|
||||
self.store.create_queued_attachment(
|
||||
attachment_id, self.user.id, self.chat.id, "c.png", "image/png", 10, "0" * 64, 2, 2,
|
||||
staging_key="staging/" + attachment_id, storage_key="originals/" + attachment_id, actor="db-test")
|
||||
return attachment_id
|
||||
|
||||
def failed(self, expired: bool):
|
||||
"""failed-вложение; expired — retention истёк (как в замечании: возраст через updated_at)."""
|
||||
attachment_id = self.queued()
|
||||
job_id = str(self.scalar("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", uuid.UUID(attachment_id)))
|
||||
message = {"job_id": job_id, "attachment_id": attachment_id, "pipeline_version": 1, "attempt": 1}
|
||||
lease = self.worker.claim(message, "host/1").lease
|
||||
self.worker.fail(lease, "invalid_image", "test")
|
||||
if expired:
|
||||
self.execute("UPDATE attachments SET updated_at = now() - interval '2 days' WHERE id = %s",
|
||||
uuid.UUID(attachment_id))
|
||||
return attachment_id, job_id
|
||||
|
||||
def state(self, attachment_id):
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute("""SELECT a.status, a.staging_key IS NOT NULL, j.status FROM attachments a
|
||||
JOIN attachment_jobs j ON j.attachment_id = a.id WHERE a.id = %s""",
|
||||
(uuid.UUID(attachment_id),)).fetchone()
|
||||
|
||||
def events(self, job_id):
|
||||
with self.pool.connection() as conn:
|
||||
return [r[0] for r in conn.execute("SELECT event FROM job_events WHERE job_id = %s ORDER BY id",
|
||||
(uuid.UUID(job_id),))]
|
||||
|
||||
def test_1_replay_after_snapshot_keeps_staging(self):
|
||||
attachment_id, job_id = self.failed(expired=True)
|
||||
staging = "staging/" + attachment_id
|
||||
refs = self.store.storage_references(RETENTION) # уборщик прочитал ссылки...
|
||||
self.assertNotIn(staging, refs["needed"]) # ...по снимку staging лишний
|
||||
self.assertEqual(self.jobs.replay(attachment_id, lambda key: True)["result"], "queued") # барьер: replay
|
||||
barrier = Barrier()
|
||||
outcome = self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier) # уборщик продолжает
|
||||
self.assertEqual((outcome["delete"], outcome["keep"]), ([], [(staging, "current_work")]))
|
||||
self.assertEqual(barrier.deleted, [])
|
||||
self.assertEqual(self.state(attachment_id), ("queued", True, "queued"))
|
||||
print(f"\n snapshot -> replay (queued) -> cleanup: kept {outcome['keep']}, nothing deleted")
|
||||
|
||||
def test_2_cleanup_first_then_replay_waits_and_refuses(self):
|
||||
attachment_id, job_id = self.failed(expired=True)
|
||||
staging = "staging/" + attachment_id
|
||||
locked, release = threading.Event(), threading.Event()
|
||||
real_pause = faults.pause
|
||||
|
||||
def pause(name): # барьер внутри транзакции уборщика (точка cleanup_pause_locked)
|
||||
if name == "cleanup_pause_locked":
|
||||
locked.set()
|
||||
release.wait(20)
|
||||
faults.pause = pause
|
||||
try:
|
||||
barrier, cleanup = Barrier(), {}
|
||||
janitor = threading.Thread(target=lambda: cleanup.update(
|
||||
self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier)))
|
||||
janitor.start()
|
||||
self.assertTrue(locked.wait(10), "cleanup did not reach its decision") # держит блокировки
|
||||
replay = {}
|
||||
operator = threading.Thread(target=lambda: replay.update(self.jobs.replay(attachment_id, lambda key: True)))
|
||||
operator.start()
|
||||
time.sleep(1.0)
|
||||
self.assertTrue(operator.is_alive(), "replay must wait for the cleanup's lock")
|
||||
self.assertEqual(barrier.deleted, []) # до COMMIT в S3 ничего не удаляется
|
||||
release.set()
|
||||
janitor.join(10)
|
||||
operator.join(10)
|
||||
finally:
|
||||
faults.pause = real_pause
|
||||
self.assertEqual(cleanup["delete"], [(staging, "staging_failed_expired")])
|
||||
self.assertEqual(barrier.deleted, [staging]) # удалён после COMMIT
|
||||
self.assertEqual((replay["result"], replay["reason"]), ("refused", "source_missing"))
|
||||
self.assertEqual(self.state(attachment_id), ("failed", False, "failed"))
|
||||
# Порядок в журнале: сначала уборщик, потом отказ replay (записи worker стенда, если он
|
||||
# успел увидеть тестовое задание, сюда не относятся).
|
||||
ours = [e for e in self.events(job_id) if e in ("staging_expired", "replay_refused", "replay_requested")]
|
||||
self.assertEqual(ours, ["staging_expired", "replay_refused"])
|
||||
print(f"\n cleanup marked the staging deleted, holds the lock -> replay waited 1 s+ -> {replay['result']} "
|
||||
f"({replay['reason']}); job stays failed; journal: staging_expired, replay_refused")
|
||||
|
||||
def test_3_replay_first_then_cleanup_waits_and_keeps(self):
|
||||
attachment_id, job_id = self.failed(expired=True)
|
||||
staging = "staging/" + attachment_id
|
||||
checking, release = threading.Event(), threading.Event()
|
||||
|
||||
def slow_head(key): # replay проверяет исходник в S3, держа блокировки
|
||||
checking.set()
|
||||
return release.wait(20)
|
||||
replay = {}
|
||||
operator = threading.Thread(target=lambda: replay.update(self.jobs.replay(attachment_id, slow_head)))
|
||||
operator.start()
|
||||
self.assertTrue(checking.wait(10))
|
||||
cleanup, barrier = {}, Barrier()
|
||||
janitor = threading.Thread(target=lambda: cleanup.update(
|
||||
self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier) or {"busy": True}))
|
||||
janitor.start()
|
||||
time.sleep(1.0)
|
||||
self.assertTrue(janitor.is_alive(), "cleanup must wait for the replay's lock")
|
||||
release.set()
|
||||
operator.join(10)
|
||||
janitor.join(10)
|
||||
self.assertEqual(replay["result"], "queued")
|
||||
self.assertEqual(cleanup.get("keep"), [(staging, "current_work")])
|
||||
self.assertEqual(barrier.deleted, [])
|
||||
print(f"\n replay holds the lock -> cleanup waited -> kept {cleanup['keep']}")
|
||||
|
||||
def test_4_upload_in_progress_is_skipped(self):
|
||||
attachment_id = str(uuid.uuid4())
|
||||
staging = "staging/" + attachment_id
|
||||
inside, finish = threading.Event(), threading.Event()
|
||||
|
||||
def upload(): # как attachments.accept: PUT в staging, потом строка, COMMIT
|
||||
with self.store.receiving(attachment_id) as conn:
|
||||
inside.set() # «PUT в staging прошёл»
|
||||
finish.wait(20)
|
||||
self.store.create_queued_attachment(
|
||||
attachment_id, self.user.id, self.chat.id, "u.png", "image/png", 10, "0" * 64, 2, 2,
|
||||
staging_key=staging, storage_key="originals/" + attachment_id, actor="db-test", conn=conn)
|
||||
api = threading.Thread(target=upload)
|
||||
api.start()
|
||||
self.assertTrue(inside.wait(10))
|
||||
barrier = Barrier()
|
||||
self.assertIsNone(self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier)) # занято
|
||||
finish.set()
|
||||
api.join(10)
|
||||
after = self.store.cleanup_attachment(attachment_id, [staging], RETENTION, barrier)
|
||||
self.assertEqual((after["keep"], barrier.deleted), ([(staging, "current_work")], []))
|
||||
self.assertEqual(self.state(attachment_id), ("queued", True, "queued"))
|
||||
print("\n upload between PUT and COMMIT -> cleanup skipped it (busy); after COMMIT -> current work, kept")
|
||||
|
||||
def test_5_objects_of_processing_job_are_kept(self):
|
||||
attachment_id = self.queued()
|
||||
job_id = str(self.scalar("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", uuid.UUID(attachment_id)))
|
||||
self.worker.claim({"job_id": job_id, "attachment_id": attachment_id, "pipeline_version": 1, "attempt": 1},
|
||||
"host/1")
|
||||
keys = [f"originals/{attachment_id}", f"variants/{attachment_id}/v1/thumbnail.jpg", f"staging/{attachment_id}"]
|
||||
barrier = Barrier()
|
||||
outcome = self.store.cleanup_attachment(attachment_id, keys, RETENTION, barrier)
|
||||
self.assertEqual((outcome["delete"], barrier.deleted), ([], []))
|
||||
self.assertEqual({why for _key, why in outcome["keep"]}, {"current_work"})
|
||||
print("\n processing job (worker writes the original and variants before COMMIT) -> all 3 objects kept")
|
||||
|
||||
def test_6_regular_cleanup_still_works(self):
|
||||
barrier = Barrier()
|
||||
orphan = str(uuid.uuid4()) # строки нет, загрузка не идёт
|
||||
out = self.store.cleanup_attachment(orphan, [f"staging/{orphan}"], RETENTION, barrier)
|
||||
self.assertEqual(out["delete"], [(f"staging/{orphan}", "orphan")])
|
||||
kept_id, _job = self.failed(expired=False) # retention не истёк: нужен для replay
|
||||
out = self.store.cleanup_attachment(kept_id, [f"staging/{kept_id}", f"originals/{kept_id}"], RETENTION, barrier)
|
||||
self.assertEqual(out["keep"], [(f"staging/{kept_id}", "staging_kept_for_replay"),
|
||||
(f"originals/{kept_id}", "failed_kept_for_replay")]) # replay перезапишет
|
||||
dead_id, dead_job = self.failed(expired=True) # retention истёк: удаляется всё
|
||||
out = self.store.cleanup_attachment(dead_id, [f"originals/{dead_id}"], RETENTION, barrier)
|
||||
self.assertEqual(out["delete"], [(f"originals/{dead_id}", "orphan")])
|
||||
self.assertEqual(self.state(dead_id)[1], False) # staging помечен удалённым до удаления
|
||||
self.assertEqual(self.jobs.replay(dead_id, lambda key: True)["reason"], "source_missing")
|
||||
ready = self.queued()
|
||||
job_id = str(self.scalar("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", uuid.UUID(ready)))
|
||||
lease = self.worker.claim({"job_id": job_id, "attachment_id": ready, "pipeline_version": 1, "attempt": 1},
|
||||
"host/1").lease
|
||||
variants = [{"name": n, "storage_key": f"variants/{ready}/v1/{n}.jpg", "content_type": "image/jpeg",
|
||||
"size_bytes": 5, "width": 1, "height": 1, "sha256": "a" * 64} for n in ("thumbnail", "crop")]
|
||||
self.assertTrue(self.worker.complete(lease, variants))
|
||||
keys = [f"staging/{ready}", f"originals/{ready}", f"variants/{ready}/v1/thumbnail.jpg",
|
||||
f"variants/{ready}/v1/stale.jpg"]
|
||||
out = self.store.cleanup_attachment(ready, keys, RETENTION, barrier)
|
||||
self.assertEqual(sorted(out["delete"]), sorted([(f"staging/{ready}", "staging_after_ready"),
|
||||
(f"variants/{ready}/v1/stale.jpg", "orphan")]))
|
||||
self.assertEqual({why for _key, why in out["keep"]}, {"published"})
|
||||
dry = self.store.cleanup_attachment(orphan, [f"staging/{orphan}"], RETENTION, None) # пробный прогон
|
||||
self.assertEqual(dry["delete"], [(f"staging/{orphan}", "orphan")])
|
||||
self.assertEqual(len(barrier.deleted), 4) # dry-run ничего не удалил
|
||||
print("\n orphan, staging after ready, objects of a failed attachment after retention -> deleted; "
|
||||
"published original and variants, a failed attachment within retention -> kept; dry-run deletes nothing")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(verbosity=2)
|
||||
@@ -0,0 +1,194 @@
|
||||
"""lab5: состояние заданий в настоящей PostgreSQL — claim, lease, fencing, повторы, replay, outbox.
|
||||
|
||||
Выполняются ВНУТРИ контейнера приложения вместе с test_store.py:
|
||||
make db-test == docker compose --profile tools run --rm db-test
|
||||
|
||||
Здесь проверяется сама логика jobs.py без брокера и S3 — точно и без ожидания таймеров:
|
||||
- claim берёт задание один раз; конкурентные claim (10 потоков) — ровно один успех;
|
||||
- дубль ready-задания и устаревшее сообщение (старая попытка) не обрабатываются;
|
||||
- результат с чужим жетоном lease не принимается (fencing), повторный complete — тоже;
|
||||
- временная ошибка -> следующая попытка через backoff с jitter в [d/2, d] и новая строка outbox;
|
||||
после JOB_MAX_ATTEMPTS -> failed / retry_exhausted; постоянная ошибка -> failed сразу;
|
||||
- истёкший lease забирает reap(); lease прежнего запуска того же контейнера — сразу;
|
||||
- продление lease: свой жетон продлевается, забранный — нет;
|
||||
- replay: failed -> queued с записью в журнале; ready/queued — no-op; нет staging — отказ;
|
||||
- две транзакции relay с FOR UPDATE SKIP LOCKED берут разные строки outbox.
|
||||
"""
|
||||
import threading
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
import psycopg
|
||||
|
||||
from messenger import broker, config, db, jobs
|
||||
from messenger.store import PostgresStore
|
||||
|
||||
|
||||
class JobsIntegrationTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
config.validate()
|
||||
db.migrate()
|
||||
cls.pool = db.create_pool()
|
||||
cls.pool.open(wait=True)
|
||||
cls.store = PostgresStore(cls.pool)
|
||||
cls.jobs = jobs.JobStore(cls.pool, "db-test")
|
||||
cls.user = cls.store.create_user("jb_" + uuid.uuid4().hex[:12], "Jobs test", "not-a-real-hash")
|
||||
cls.chat = cls.store.create_chat(cls.user.id, "jobs", [cls.user.id])
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.pool.close()
|
||||
|
||||
def scalar(self, sql, *params):
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute(sql, params).fetchone()[0]
|
||||
|
||||
def execute(self, sql, *params):
|
||||
with self.pool.connection() as conn:
|
||||
conn.execute(sql, params)
|
||||
|
||||
def new_job(self):
|
||||
attachment_id = str(uuid.uuid4())
|
||||
self.store.create_queued_attachment(
|
||||
attachment_id, self.user.id, self.chat.id, "t.png", "image/png", 10, "0" * 64, 2, 2,
|
||||
staging_key="staging/" + attachment_id, storage_key="originals/" + attachment_id, actor="db-test")
|
||||
job_id = str(self.scalar("SELECT job_id FROM attachment_jobs WHERE attachment_id = %s", uuid.UUID(attachment_id)))
|
||||
return attachment_id, job_id
|
||||
|
||||
def message(self, attachment_id, job_id, attempt=1):
|
||||
return broker.parse(broker.encode(broker.build_message(job_id, attachment_id, 1, attempt)))
|
||||
|
||||
def status(self, attachment_id):
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute("""SELECT a.status, a.error_code, j.status, j.attempt FROM attachments a
|
||||
JOIN attachment_jobs j ON j.attachment_id = a.id WHERE a.id = %s""",
|
||||
(uuid.UUID(attachment_id),)).fetchone()
|
||||
|
||||
def variants(self):
|
||||
return [{"name": n, "storage_key": f"variants/{uuid.uuid4()}/{n}", "content_type": "image/jpeg",
|
||||
"size_bytes": 5, "width": 1, "height": 1, "sha256": "a" * 64} for n in ("thumbnail", "crop", "optimized")]
|
||||
|
||||
def test_upload_creates_job_and_outbox_in_one_transaction(self):
|
||||
attachment_id, job_id = self.new_job()
|
||||
self.assertEqual(self.status(attachment_id), ("queued", None, "queued", 1))
|
||||
payload = self.scalar("SELECT payload FROM outbox WHERE job_id = %s", uuid.UUID(job_id))
|
||||
self.assertEqual(broker.parse(broker.encode(payload))["attachment_id"], attachment_id)
|
||||
self.assertEqual(set(payload), {"schema_version", "job_id", "type", "attachment_id", "pipeline_version",
|
||||
"attempt", "created_at"}) # только ID и служебные поля
|
||||
|
||||
def test_claim_once_and_concurrent_claims(self):
|
||||
attachment_id, job_id = self.new_job()
|
||||
results = []
|
||||
barrier = threading.Barrier(10)
|
||||
|
||||
def claim(n):
|
||||
barrier.wait()
|
||||
results.append(self.jobs.claim(self.message(attachment_id, job_id), f"host{n}/w").kind)
|
||||
|
||||
threads = [threading.Thread(target=claim, args=(n,)) for n in range(10)]
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
self.assertEqual(results.count("claimed"), 1, results)
|
||||
self.assertEqual(results.count("in_progress"), 9, results)
|
||||
self.assertEqual(self.status(attachment_id)[0], "processing")
|
||||
print(f"\n 10 concurrent claims of one job: {results.count('claimed')} claimed, "
|
||||
f"{results.count('in_progress')} in_progress")
|
||||
|
||||
def test_fencing_and_duplicates(self):
|
||||
attachment_id, job_id = self.new_job()
|
||||
lease = self.jobs.claim(self.message(attachment_id, job_id), "hostA/1").lease
|
||||
stolen = jobs.Lease(**{**lease.__dict__, "token": str(uuid.uuid4())})
|
||||
self.assertFalse(self.jobs.complete(stolen, self.variants())) # чужой жетон: не принимается
|
||||
self.assertTrue(self.jobs.complete(lease, self.variants()))
|
||||
self.assertFalse(self.jobs.complete(lease, self.variants())) # второй раз: lease уже снят
|
||||
self.assertEqual(self.status(attachment_id), ("ready", None, "ready", 1))
|
||||
self.assertEqual(self.jobs.claim(self.message(attachment_id, job_id), "hostB/1").kind, "ready")
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM attachment_variants WHERE attachment_id = %s",
|
||||
uuid.UUID(attachment_id)), 3)
|
||||
|
||||
def test_retry_backoff_then_exhausted(self):
|
||||
attachment_id, job_id = self.new_job()
|
||||
for attempt in range(1, config.JOB_MAX_ATTEMPTS + 1):
|
||||
lease = self.jobs.claim(self.message(attachment_id, job_id, attempt), "hostA/1").lease
|
||||
self.assertIsNotNone(lease, attempt)
|
||||
outcome = self.jobs.retry(lease, "storage_unavailable", "S3 недоступен")
|
||||
if attempt < config.JOB_MAX_ATTEMPTS:
|
||||
self.assertEqual(outcome, "retry")
|
||||
delay = self.scalar("""SELECT extract(epoch FROM available_at - created_at) FROM outbox
|
||||
WHERE job_id = %s AND attempt = %s""", uuid.UUID(job_id), attempt + 1)
|
||||
limit = min(config.RETRY_MAX_SECONDS, config.RETRY_BASE_SECONDS * 2 ** (attempt - 1))
|
||||
self.assertTrue(limit / 2 - 0.01 <= float(delay) <= limit + 0.01, (attempt, delay))
|
||||
# Сообщение прошлой попытки теперь устаревшее.
|
||||
self.assertEqual(self.jobs.claim(self.message(attachment_id, job_id, attempt), "hostB/1").kind, "stale")
|
||||
else:
|
||||
self.assertEqual(outcome, "failed")
|
||||
self.assertEqual(self.status(attachment_id), ("failed", "retry_exhausted", "failed", config.JOB_MAX_ATTEMPTS))
|
||||
|
||||
def test_permanent_error_fails_at_once(self):
|
||||
attachment_id, job_id = self.new_job()
|
||||
lease = self.jobs.claim(self.message(attachment_id, job_id), "hostA/1").lease
|
||||
self.assertTrue(self.jobs.fail(lease, "invalid_image", "не декодируется"))
|
||||
self.assertEqual(self.status(attachment_id), ("failed", "invalid_image", "failed", 1))
|
||||
self.assertEqual(self.jobs.claim(self.message(attachment_id, job_id), "hostA/2").kind, "failed")
|
||||
|
||||
def test_expired_lease_and_dead_predecessor(self):
|
||||
attachment_id, job_id = self.new_job()
|
||||
lease = self.jobs.claim(self.message(attachment_id, job_id), "hostA/1").lease
|
||||
self.assertEqual(self.jobs.claim(self.message(attachment_id, job_id), "hostB/1").kind, "in_progress")
|
||||
self.assertEqual(self.jobs.renew([lease.token]), {lease.token}) # живой worker продлевает
|
||||
self.execute("UPDATE attachment_jobs SET lease_until = now() - interval '1 second' WHERE job_id = %s",
|
||||
uuid.UUID(job_id))
|
||||
reaped = [r for r in self.jobs.reap() if r[0] == attachment_id]
|
||||
self.assertEqual(reaped, [(attachment_id, "retry")])
|
||||
self.assertEqual(self.status(attachment_id)[2:], ("queued", 2))
|
||||
self.assertEqual(self.jobs.renew([lease.token]), set()) # забранный lease не продлевается
|
||||
self.assertFalse(self.jobs.complete(lease, self.variants())) # и результат не принимается
|
||||
# Прежний запуск того же контейнера держит lease -> следующая попытка сразу, без ожидания срока.
|
||||
lease2 = self.jobs.claim(self.message(attachment_id, job_id, 2), "hostC/old").lease
|
||||
decision = self.jobs.claim(self.message(attachment_id, job_id, 2), "hostC/new")
|
||||
self.assertEqual((decision.kind, decision.detail), ("rescheduled", "retry"))
|
||||
self.assertEqual(self.status(attachment_id)[2:], ("queued", 3))
|
||||
self.assertIsNotNone(lease2)
|
||||
|
||||
def test_replay_rules(self):
|
||||
attachment_id, job_id = self.new_job()
|
||||
self.assertEqual(self.jobs.replay(attachment_id, lambda key: True), {"result": "noop", "reason": "queued"})
|
||||
lease = self.jobs.claim(self.message(attachment_id, job_id), "hostA/1").lease
|
||||
self.jobs.fail(lease, "invalid_image", "битый файл")
|
||||
self.assertEqual(self.jobs.replay(attachment_id, lambda key: False)["reason"], "source_missing")
|
||||
result = self.jobs.replay(attachment_id, lambda key: True)
|
||||
self.assertEqual(result["result"], "queued")
|
||||
self.assertEqual(self.status(attachment_id), ("queued", None, "queued", 2))
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM job_events WHERE job_id = %s AND event = 'replay_requested'",
|
||||
uuid.UUID(job_id)), 1)
|
||||
lease = self.jobs.claim(self.message(attachment_id, job_id, 2), "hostA/1").lease
|
||||
self.jobs.complete(lease, self.variants())
|
||||
before = self.scalar("SELECT count(*) FROM outbox WHERE job_id = %s", uuid.UUID(job_id))
|
||||
self.assertEqual(self.jobs.replay(attachment_id, lambda key: True), {"result": "noop", "reason": "ready"})
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM outbox WHERE job_id = %s", uuid.UUID(job_id)), before)
|
||||
|
||||
def test_outbox_rows_are_taken_by_one_relay(self):
|
||||
for _ in range(4):
|
||||
self.new_job()
|
||||
sql = """SELECT id FROM outbox WHERE published_at IS NULL ORDER BY available_at, id LIMIT 2
|
||||
FOR UPDATE SKIP LOCKED"""
|
||||
with psycopg.connect(config.DATABASE_URL, autocommit=True) as one, \
|
||||
psycopg.connect(config.DATABASE_URL, autocommit=True) as two:
|
||||
with one.transaction(), two.transaction(): # как две реплики relay одновременно
|
||||
a = {r[0] for r in one.execute(sql)}
|
||||
b = {r[0] for r in two.execute(sql)}
|
||||
self.assertTrue(a and b and not (a & b), (a, b))
|
||||
|
||||
def test_backoff_bounds(self):
|
||||
for attempt in range(1, 8):
|
||||
limit = min(config.RETRY_MAX_SECONDS, config.RETRY_BASE_SECONDS * 2 ** (attempt - 1))
|
||||
samples = [jobs.backoff(attempt) for _ in range(200)]
|
||||
self.assertTrue(all(limit / 2 <= s <= limit for s in samples), attempt)
|
||||
self.assertGreater(max(samples) - min(samples), limit * 0.2) # действительно случайно
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(verbosity=2)
|
||||
@@ -0,0 +1,150 @@
|
||||
"""Интеграционные тесты хранилища на настоящей PostgreSQL (уровень 4).
|
||||
|
||||
Выполняются ВНУТРИ контейнера приложения (там есть psycopg и доступ к БД по сети стенда):
|
||||
make db-test == docker compose --profile tools run --rm db-test
|
||||
|
||||
Что проверяется:
|
||||
- повторный запуск миграций ничего не меняет;
|
||||
- составная операция «создать чат» откатывается целиком, если упала на середине;
|
||||
- одновременная регистрация одного username даёт ровно одного пользователя;
|
||||
- сама база не даёт записать сообщение от не-участника (внешний ключ);
|
||||
- (lab3) 20 одновременных add_message с одним Idempotency-Key создают одну строку;
|
||||
- (lab3) тот же ключ с другим телом — Conflict (409), строка одна;
|
||||
- (lab3) миграция 004 совместима со старой версией: INSERT сообщения без ключа, как делает
|
||||
код lab2, по-прежнему работает (поэтому миграцию можно применить до замены реплик).
|
||||
"""
|
||||
import hashlib
|
||||
import threading
|
||||
import unittest
|
||||
import uuid
|
||||
from unittest import mock
|
||||
|
||||
import psycopg
|
||||
from psycopg import errors as pg_errors
|
||||
|
||||
from messenger import config, db
|
||||
from messenger.errors import Conflict, InvalidRequest
|
||||
from messenger.store import PostgresStore
|
||||
|
||||
|
||||
class StoreIntegrationTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
config.validate()
|
||||
db.migrate()
|
||||
cls.pool = db.create_pool()
|
||||
cls.pool.open(wait=True)
|
||||
cls.store = PostgresStore(cls.pool)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.pool.close()
|
||||
|
||||
def scalar(self, sql, *params):
|
||||
with self.pool.connection() as conn:
|
||||
return conn.execute(sql, params).fetchone()[0]
|
||||
|
||||
def new_user(self):
|
||||
return self.store.create_user("db_" + uuid.uuid4().hex[:12], "DB test", "not-a-real-hash")
|
||||
|
||||
def test_migrations_rerun_is_noop(self):
|
||||
versions = self.scalar("SELECT array_agg(version ORDER BY version) FROM schema_migrations")
|
||||
users = self.scalar("SELECT count(*) FROM users")
|
||||
self.assertEqual(db.migrate(), []) # второй прогон: применять нечего
|
||||
self.assertEqual(self.scalar("SELECT array_agg(version ORDER BY version) FROM schema_migrations"), versions)
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM users"), users)
|
||||
print(f"\n schema_migrations: {versions}; повторный migrate() ничего не применил")
|
||||
|
||||
def test_create_chat_rolls_back_when_failing_midway(self):
|
||||
alice = self.new_user()
|
||||
ghost = str(uuid.uuid4()) # такого пользователя нет
|
||||
title = "rollback-" + uuid.uuid4().hex[:8]
|
||||
# Отключаем предварительную проверку участников, чтобы ошибка случилась ВНУТРИ транзакции:
|
||||
# строка чата уже вставлена, а вставка участника-призрака нарушает внешний ключ.
|
||||
with mock.patch.object(PostgresStore, "_check_members_exist", staticmethod(lambda conn, members: None)):
|
||||
with self.assertRaises(InvalidRequest):
|
||||
self.store.create_chat(alice.id, title, [alice.id, ghost])
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM chats WHERE title = %s", title), 0)
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM chat_members WHERE user_id = %s", uuid.UUID(alice.id)), 0)
|
||||
print("\n чат с несуществующим участником: транзакция откатилась, строк chats/chat_members не осталось")
|
||||
|
||||
def test_concurrent_registration_has_one_winner(self):
|
||||
username = "dbrace_" + uuid.uuid4().hex[:10]
|
||||
threads, barrier, results = 20, threading.Barrier(20), []
|
||||
|
||||
def register():
|
||||
barrier.wait()
|
||||
try:
|
||||
self.store.create_user(username, "Race", "not-a-real-hash")
|
||||
results.append("created")
|
||||
except Conflict:
|
||||
results.append("conflict")
|
||||
|
||||
workers = [threading.Thread(target=register) for _ in range(threads)]
|
||||
for w in workers:
|
||||
w.start()
|
||||
for w in workers:
|
||||
w.join()
|
||||
self.assertEqual(results.count("created"), 1)
|
||||
self.assertEqual(results.count("conflict"), threads - 1)
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM users WHERE username = %s", username), 1)
|
||||
print(f"\n {threads} параллельных create_user: 1 создан, {threads - 1} получили Conflict (409)")
|
||||
|
||||
def test_concurrent_same_idempotency_key_creates_one_row(self):
|
||||
alice = self.new_user()
|
||||
chat = self.store.create_chat(alice.id, "idem", [alice.id])
|
||||
key, digest = "db-" + uuid.uuid4().hex, hashlib.sha256(b"same body").digest()
|
||||
threads, barrier, results, errors = 20, threading.Barrier(20), [], []
|
||||
|
||||
def send():
|
||||
barrier.wait()
|
||||
try:
|
||||
results.append(self.store.add_message(alice.id, chat.id, "один раз", key, digest))
|
||||
except Exception as exc: # noqa: BLE001 — любая ошибка = провал теста
|
||||
errors.append(exc)
|
||||
|
||||
workers = [threading.Thread(target=send) for _ in range(threads)]
|
||||
for w in workers:
|
||||
w.start()
|
||||
for w in workers:
|
||||
w.join()
|
||||
self.assertEqual(errors, [])
|
||||
self.assertEqual(len({message.id for message, _ in results}), 1)
|
||||
self.assertEqual(sum(1 for _, replayed in results if not replayed), 1)
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM messages WHERE chat_id = %s", uuid.UUID(chat.id)), 1)
|
||||
print(f"\n {threads} одновременных add_message с одним ключом: 1 строка, 1 новое + "
|
||||
f"{threads - 1} повторов с тем же сообщением")
|
||||
|
||||
def test_same_key_other_body_is_conflict(self):
|
||||
alice = self.new_user()
|
||||
chat = self.store.create_chat(alice.id, "idem409", [alice.id])
|
||||
key = "db-" + uuid.uuid4().hex
|
||||
self.store.add_message(alice.id, chat.id, "первый", key, hashlib.sha256(b"first").digest())
|
||||
with self.assertRaises(Conflict):
|
||||
self.store.add_message(alice.id, chat.id, "другой", key, hashlib.sha256(b"other").digest())
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM messages WHERE chat_id = %s", uuid.UUID(chat.id)), 1)
|
||||
print("\n тот же ключ с другим телом: Conflict (409), в базе по-прежнему одна строка")
|
||||
|
||||
def test_old_version_insert_without_key_still_works(self):
|
||||
alice = self.new_user()
|
||||
chat = self.store.create_chat(alice.id, "compat", [alice.id])
|
||||
with psycopg.connect(config.DATABASE_URL) as conn:
|
||||
for _ in range(2): # две строки без ключа: NULL не нарушает уникальность
|
||||
conn.execute("INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s)",
|
||||
(uuid.uuid4(), uuid.UUID(chat.id), uuid.UUID(alice.id), b"lab2 style"))
|
||||
self.assertEqual(self.scalar("SELECT count(*) FROM messages WHERE chat_id = %s AND idempotency_key IS NULL",
|
||||
uuid.UUID(chat.id)), 2)
|
||||
print("\n INSERT как в lab2 (без ключа) после миграции 004 работает: старая версия совместима со схемой")
|
||||
|
||||
def test_database_rejects_message_from_non_member(self):
|
||||
alice, mallory = self.new_user(), self.new_user()
|
||||
chat = self.store.create_chat(alice.id, "fk", [alice.id])
|
||||
with self.assertRaises(pg_errors.ForeignKeyViolation):
|
||||
with psycopg.connect(config.DATABASE_URL) as conn:
|
||||
conn.execute("INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, 'x')",
|
||||
(uuid.uuid4(), uuid.UUID(chat.id), uuid.UUID(mallory.id)))
|
||||
print("\n INSERT сообщения от не-участника напрямую в БД: ForeignKeyViolation")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,44 @@
|
||||
"""Демонстрация для защиты: пользователи, вход, чат, сообщения, logout — через балансировщик.
|
||||
|
||||
Запуск: make demo (печатает шаги; пароли и токены не выводятся)
|
||||
У каждого шага в скобках — какая реплика API ответила (X-Instance-Id = ID контейнера в `make ps`).
|
||||
"""
|
||||
import uuid
|
||||
|
||||
from helpers import Client, read_history, run
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
|
||||
def who(reply):
|
||||
return reply["headers"]["X-Instance-Id"]
|
||||
|
||||
ready = api.call("GET", "/health/ready", schema="Health")
|
||||
print(f"1. /health/ready -> 200 ({who(ready)}): API запущен, PostgreSQL доступна, схема актуальна")
|
||||
alice, bob, eve, chat = api.bootstrap() # регистрация с паролем + вход через Basic у каждого
|
||||
for name, actor in (("alice", alice), ("bob", bob), ("eve", eve)):
|
||||
print(f"2. зарегистрирован {name}: {actor['user']['username']}, вход через Basic -> Bearer-токен")
|
||||
print(f"3. alice создала чат {chat['id']} с bob (eve не участник)")
|
||||
served = [who(api.call("GET", "/api/v1/users/me", actor=alice, schema="User")) for _ in range(4)]
|
||||
print(f"4. один и тот же токен alice, 4 запроса -> реплики {served}: повторный вход не нужен")
|
||||
key = uuid.uuid4().hex
|
||||
first = api.message(alice, chat, "Привет, Боб! Это сообщение лежит в PostgreSQL", key=key)
|
||||
again = api.message(alice, chat, "Привет, Боб! Это сообщение лежит в PostgreSQL", key=key)
|
||||
print(f"5. alice отправила сообщение ({who(first)}) и повторила его с тем же Idempotency-Key "
|
||||
f"({who(again)}): тот же id {again['json']['id'] == first['json']['id']}")
|
||||
api.message(bob, chat, "Привет, Алиса! Переживёт перезапуск и отказ реплики")
|
||||
history, pages = read_history(api, bob, chat["id"], limit=1)
|
||||
print(f"6. история чата (по 1 сообщению на страницу, страниц: {pages}) — дубля нет:")
|
||||
names = {alice["id"]: "alice", bob["id"]: "bob"}
|
||||
for m in history:
|
||||
print(f" {m['created_at']} {names[m['sender_id']]}: {m['text']}")
|
||||
api.call("GET", f"/api/v1/chats/{chat['id']}/messages", 404, actor=eve)
|
||||
print("7. eve читает чужой чат -> 404 (существование чата не раскрывается)")
|
||||
api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=alice)
|
||||
after = [who(api.call("GET", "/api/v1/users/me", 401, actor=alice)) for _ in range(2)]
|
||||
print(f"8. alice logout -> 204, тот же токен -> 401 на репликах {after}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,137 @@
|
||||
"""Отказ зависимости (уровень 4). Запуск: make failure-valkey или make failure-postgres
|
||||
|
||||
Тест сам останавливает указанный контейнер (docker compose stop), проверяет поведение API
|
||||
и запускает контейнер обратно (docker compose start). Volumes не трогаются.
|
||||
|
||||
valkey — кэш недоступен: API обходит его и работает через PostgreSQL; logout действует сразу.
|
||||
postgres — источник истины недоступен: обе реплики не готовы (/health/ready = 503), и балансировщик
|
||||
исключает их из маршрутизации. Даже запрос с действующим токеном, который реплика могла бы
|
||||
подтвердить из кэша Valkey, через балансировщик получает 503 и до реплики не доходит
|
||||
(замечание к MR: раньше резервные слоты без проверки пропускали его, и он получал 200).
|
||||
Сами реплики при этом живы (/health/live = 200 изнутри контейнера).
|
||||
Запись во время отказа не сохраняется. После запуска БД прежний токен и данные доступны.
|
||||
"""
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from helpers import Client, check, compose, idempotency, read_history, run, wait_ready
|
||||
from stand import api_containers, lb_summary, lb_up_count, replica_status, try_call
|
||||
|
||||
LB_EXCLUDE_TIMEOUT_SECONDS = 15
|
||||
LOST_TEXT = "во время отказа PostgreSQL, не должно сохраниться " + uuid.uuid4().hex
|
||||
|
||||
|
||||
def timed(fn):
|
||||
started = time.monotonic()
|
||||
result = fn()
|
||||
return result, (time.monotonic() - started) * 1000
|
||||
|
||||
|
||||
def valkey_down(api, alice, bob, chat):
|
||||
ready, ms = timed(lambda: api.call("GET", "/health/ready", schema="Health"))
|
||||
print(f"/health/ready -> 200 ({ms:.0f} ms): Valkey не критичен, API готов")
|
||||
_, ms = timed(lambda: api.call("GET", "/api/v1/users/me", actor=alice, schema="User"))
|
||||
print(f"existing token: GET /users/me -> 200 ({ms:.0f} ms), сессия проверена по PostgreSQL (этот запрос и обнаружил сбой кэша)")
|
||||
sent = api.message(bob, chat, "во время отказа Valkey")["json"]
|
||||
history, _ = read_history(api, alice, chat["id"])
|
||||
check(sent["id"] in [m["id"] for m in history], "message written during Valkey outage is missing")
|
||||
print("POST message -> 201, история читается")
|
||||
carol = api.user("carol") # регистрация и вход тоже работают без кэша
|
||||
print("register + login new user -> 201")
|
||||
api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=carol)
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=carol)
|
||||
print("logout -> 204, затем тот же токен -> 401 (отзыв записан в PostgreSQL)")
|
||||
latencies = [timed(lambda: api.call("GET", "/api/v1/users/me", actor=alice))[1] for _ in range(10)]
|
||||
print(f"10 x GET /users/me без кэша: max {max(latencies):.0f} ms (кэш не ждём на каждом запросе)")
|
||||
check(max(latencies) < 1000, "requests must not wait for the dead cache on every call")
|
||||
# Фоновая проверка Valkey идёт раз в 5 с. Ждём дольше и убеждаемся, что запросы её не ждут.
|
||||
time.sleep(6)
|
||||
latencies = [timed(lambda: api.call("GET", "/api/v1/users/me", actor=alice))[1] for _ in range(10)]
|
||||
print(f"через 6 с, ещё 10 x GET /users/me: max {max(latencies):.0f} ms (повторные попытки — в фоне)")
|
||||
check(max(latencies) < 1000, "periodic reconnect attempts must not block user requests")
|
||||
return carol
|
||||
|
||||
|
||||
def refused_by_lb(method, path, token=None, body=None, headers=None):
|
||||
"""Запрос через балансировщик: ждём 503 от САМОГО балансировщика в формате ошибки контракта.
|
||||
|
||||
Признак того, что запрос не дошёл до реплики API: в ответе нет X-Instance-Id
|
||||
(его ставит каждая реплика), а X-Request-Id и request_id в теле — от балансировщика.
|
||||
"""
|
||||
reply = try_call(method, path, token=token, body=body, headers=headers, timeout=5)
|
||||
check(reply is not None, f"{method} {path}: no response from the balancer")
|
||||
check(reply.status == 503, f"{method} {path}: expected 503 from the balancer, got {reply.status}")
|
||||
check(not reply.instance, f"{method} {path}: answered by a NOT READY API replica {reply.instance}")
|
||||
error = (reply.json or {}).get("error") or {}
|
||||
check(error.get("code") == "unavailable", f"{method} {path}: wrong error format {reply.json}")
|
||||
check(error.get("request_id") and error["request_id"] == reply.headers.get("x-request-id"),
|
||||
f"{method} {path}: request_id differs from X-Request-Id")
|
||||
|
||||
|
||||
def postgres_down(api, alice, chat):
|
||||
started = time.monotonic()
|
||||
while lb_up_count() > 0:
|
||||
check(time.monotonic() - started < LB_EXCLUDE_TIMEOUT_SECONDS,
|
||||
f"HAProxy still routes to a replica {LB_EXCLUDE_TIMEOUT_SECONDS} s after the failure")
|
||||
time.sleep(0.2)
|
||||
print(f"HAProxy вывел все реплики из балансировки через {time.monotonic() - started:.1f} с "
|
||||
f"после остановки PostgreSQL ({lb_summary()})")
|
||||
for container in api_containers():
|
||||
live, ready = replica_status(container, "/health/live"), replica_status(container, "/health/ready")
|
||||
check(live == 200 and ready == 503, f"replica {container[:12]}: live {live}, ready {ready}")
|
||||
print(f"реплика {container[:12]} изнутри контейнера: /health/live -> {live}, /health/ready -> {ready} "
|
||||
f"(жива, но не готова)")
|
||||
# Главное (замечание к MR): токен alice лежит в кэше Valkey, и реплика могла бы ответить 200 без базы.
|
||||
refused_by_lb("GET", "/api/v1/users/me", token=alice["token"])
|
||||
print("GET /users/me с действующим токеном (он есть в кэше) -> 503 от балансировщика, без X-Instance-Id: "
|
||||
"до неготовой реплики запрос не дошёл")
|
||||
refused_by_lb("GET", "/api/v1/chats", token=alice["token"])
|
||||
refused_by_lb("GET", f"/api/v1/chats/{chat['id']}/messages", token=alice["token"])
|
||||
refused_by_lb("POST", f"/api/v1/chats/{chat['id']}/messages", token=alice["token"],
|
||||
body={"text": LOST_TEXT}, headers=idempotency())
|
||||
print("бизнес-запросы (список чатов, история, отправка сообщения) -> 503 от балансировщика")
|
||||
refused_by_lb("GET", "/api/v1/users/me")
|
||||
refused_by_lb("POST", "/api/v1/users", body={"username": "pg_" + uuid.uuid4().hex[:10],
|
||||
"display_name": "x", "password": "Pg-down-password"})
|
||||
refused_by_lb("GET", "/health/ready")
|
||||
print("без токена, регистрация и /health/ready через балансировщик -> 503: успешного ответа нет ни у кого")
|
||||
|
||||
|
||||
def main():
|
||||
target = sys.argv[1] if len(sys.argv) > 1 else ""
|
||||
check(target in ("valkey", "postgres"), "usage: dependency_failure.py valkey|postgres")
|
||||
api = Client()
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
before = api.message(alice, chat, "до отказа " + target)["json"]
|
||||
for _ in range(4): # запись о сессии alice точно лежит в общем кэше Valkey
|
||||
api.call("GET", "/api/v1/users/me", actor=alice, schema="User")
|
||||
|
||||
print(f"stopping {target} (docker compose stop {target})")
|
||||
compose("stop", target)
|
||||
try:
|
||||
if target == "valkey":
|
||||
carol = valkey_down(api, alice, bob, chat)
|
||||
else:
|
||||
postgres_down(api, alice, chat)
|
||||
finally:
|
||||
print(f"starting {target} again")
|
||||
compose("start", target)
|
||||
|
||||
wait_ready(api)
|
||||
history, _ = read_history(api, alice, chat["id"])
|
||||
check(before in history, "message confirmed before the outage is lost or changed")
|
||||
check(all(m["text"] != LOST_TEXT for m in history), "a write refused during the outage was stored")
|
||||
api.call("GET", "/api/v1/users/me", actor=alice, schema="User")
|
||||
if target == "valkey":
|
||||
api.call("GET", "/api/v1/users/me", 401, actor=carol) # отозванный токен не «воскрес» из кэша
|
||||
print("after recovery: прежний токен работает, подтверждённые сообщения на месте")
|
||||
if target == "postgres":
|
||||
print("PASS: postgres outage: not ready replicas were excluded by the balancer, no request reached them, "
|
||||
"nothing was stored; data and the existing token survived")
|
||||
else:
|
||||
print("PASS: valkey outage handled without the cache; revoked tokens stay revoked")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,46 @@
|
||||
"""Проверка истечения сессии при коротком TTL (уровень 4). Запуск: make expiry
|
||||
|
||||
Нужен второй экземпляр API с SESSION_TTL_SECONDS=2 (сервис api-short-ttl, make expiry
|
||||
поднимает его сам). С lab3 он, как и основные реплики, доступен только через балансировщик:
|
||||
127.0.0.1:8081. База и кэш общие с основным API.
|
||||
|
||||
Сценарий: вход -> токен работает (и попадает в кэш Valkey) -> ждём истечения ->
|
||||
токен отклоняется с 401 и на коротком, и на основном API. Значит, срок жизни — свойство
|
||||
сессии в PostgreSQL, а кэш не продлевает её.
|
||||
"""
|
||||
import datetime as dt
|
||||
import os
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from helpers import Client, check, login, run, wait_ready
|
||||
|
||||
|
||||
def main():
|
||||
short = Client(os.environ.get("BASE_URL_TTL", "http://127.0.0.1:8081"))
|
||||
main_api = Client()
|
||||
# Контейнер уже healthy, но балансировщику нужно ещё пару секунд: найти его по DNS
|
||||
# и пройти 2 проверки готовности. Ждём готовности именно через балансировщик (:8081).
|
||||
wait_ready(short, seconds=60)
|
||||
body = {"username": "ttl_" + uuid.uuid4().hex[:12], "display_name": "TTL", "password": "Ttl-password-123"}
|
||||
short.call("POST", "/api/v1/users", 201, body=body, schema="User")
|
||||
session = login(short, body["username"], body["password"])
|
||||
auth = {"Authorization": "Bearer " + session["token"]}
|
||||
expires_at = dt.datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
|
||||
ttl = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()
|
||||
print(f"session issued by short-TTL API, expires in {ttl:.2f}s")
|
||||
check(0 < ttl <= 3, "short-TTL instance must issue ~2 second sessions")
|
||||
|
||||
for api in (short, short, main_api): # два раза подряд: второй ответ уже из кэша
|
||||
api.call("GET", "/api/v1/users/me", 200, headers=auth, schema="User")
|
||||
print("before expiry: GET /users/me -> 200 (short API twice, main API once)")
|
||||
|
||||
time.sleep(max(0.0, (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds()) + 1.0)
|
||||
for api in (short, main_api):
|
||||
api.call("GET", "/api/v1/users/me", 401, headers=auth) # клиент проверяет WWW-Authenticate: Bearer
|
||||
print("after expiry: GET /users/me -> 401 on both instances")
|
||||
print("PASS: session expired after SESSION_TTL_SECONDS; cache did not extend it")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,148 @@
|
||||
"""lab3, уровень 4: по очереди останавливаем КАЖДУЮ реплику API под нагрузкой и меряем.
|
||||
|
||||
make failover-metrics (= python student-tests/failover_metrics.py: stop и kill)
|
||||
python student-tests/failover_metrics.py stop (только плановая остановка)
|
||||
|
||||
Режимы:
|
||||
stop — docker stop (SIGTERM): плановая остановка. Реплика сначала отвечает 503 на /health/ready,
|
||||
HAProxy выводит её из балансировки, и только потом она закрывает приём (__main__.py).
|
||||
kill — docker kill (SIGKILL): авария. Процесс умирает сразу, начатые на нём запросы обрываются,
|
||||
клиент повторяет их с тем же Idempotency-Key.
|
||||
Нагрузка (loadgen.py): 4 потока пишут сообщения без пауз, 1 поток читает историю, timeout клиента 2 с.
|
||||
Меряем: успешные записи в секунду до и после отказа, ошибки и их коды, через сколько HAProxy вывел
|
||||
реплику (по его статистике, опрос раз в 0,1 с), через сколько прекратились ошибки, отвечала ли
|
||||
остановленная реплика после остановки, нет ли потерь и дублей. Затем реплика запускается снова
|
||||
(docker start) и ждём, пока HAProxy вернёт её, — только потом следующий прогон.
|
||||
Итог: таблица в консоли и evidence/failover-metrics.json (без токенов).
|
||||
"""
|
||||
import json
|
||||
import platform
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
from helpers import ROOT, check, run
|
||||
from loadgen import CLIENT_TIMEOUT_SECONDS, WRITERS, Load, summary
|
||||
from stand import api_containers, docker, lb_up_count, wait_balanced
|
||||
|
||||
WARMUP_SECONDS = 3
|
||||
AFTER_SECONDS = 10
|
||||
OUTPUT = ROOT / "evidence" / "failover-metrics.json"
|
||||
|
||||
|
||||
class LbWatch:
|
||||
"""Раз в 0,1 с спрашивает у HAProxy, сколько реплик в балансировке (UP)."""
|
||||
|
||||
def __init__(self):
|
||||
self.points, self.stopping = [], threading.Event()
|
||||
self.thread = threading.Thread(target=self._run, daemon=True)
|
||||
|
||||
def _run(self):
|
||||
while not self.stopping.is_set():
|
||||
try:
|
||||
self.points.append((time.monotonic(), lb_up_count()))
|
||||
except OSError:
|
||||
pass
|
||||
time.sleep(0.1)
|
||||
|
||||
def start(self):
|
||||
self.thread.start()
|
||||
|
||||
def stop(self):
|
||||
self.stopping.set()
|
||||
self.thread.join(timeout=3)
|
||||
|
||||
def first_drop(self, after, replicas):
|
||||
return next((t for t, up in self.points if t >= after and up < replicas), None)
|
||||
|
||||
|
||||
def measure(container, mode, replicas):
|
||||
wait_balanced(replicas)
|
||||
load, watch = Load(), LbWatch()
|
||||
watch.start()
|
||||
load.start()
|
||||
time.sleep(WARMUP_SECONDS)
|
||||
t0 = time.monotonic()
|
||||
if mode == "stop":
|
||||
docker("stop", "--time", "8", container)
|
||||
else:
|
||||
docker("kill", container)
|
||||
command_seconds = time.monotonic() - t0
|
||||
time.sleep(max(0.0, AFTER_SECONDS - command_seconds))
|
||||
end = t0 + AFTER_SECONDS
|
||||
load.stop()
|
||||
watch.stop()
|
||||
|
||||
errors = [e for e in load.window(t0 - WARMUP_SECONDS, end) if not e[2]]
|
||||
errors_end = max((e[0] + e[5] for e in errors), default=None)
|
||||
drop = watch.first_drop(t0, replicas)
|
||||
served_after = [e[4] for e in load.window(t0 + command_seconds, end) if e[2]]
|
||||
target_hits = sum(1 for instance in served_after if instance and container.startswith(instance))
|
||||
integrity = load.verify()
|
||||
|
||||
started = time.monotonic()
|
||||
docker("start", container)
|
||||
wait_balanced(replicas)
|
||||
rejoin_seconds = time.monotonic() - started
|
||||
|
||||
return {
|
||||
"replica": container[:12],
|
||||
"mode": mode,
|
||||
"command_seconds": round(command_seconds, 2),
|
||||
"lb_excluded_after_seconds": round(drop - t0, 2) if drop else None,
|
||||
"errors": len(errors),
|
||||
"error_codes": summary(load, t0 - WARMUP_SECONDS, end)["error_codes"],
|
||||
"errors_stopped_after_seconds": round(errors_end - t0, 2) if errors_end else 0.0,
|
||||
"before": summary(load, t0 - WARMUP_SECONDS, t0),
|
||||
"after": summary(load, t0, end),
|
||||
"stopped_replica_answers_after_stop": target_hits,
|
||||
"integrity": integrity,
|
||||
"rejoin_seconds": round(rejoin_seconds, 2),
|
||||
}
|
||||
|
||||
|
||||
def main():
|
||||
modes = sys.argv[1:] or ["stop", "kill"]
|
||||
check(set(modes) <= {"stop", "kill"}, "usage: python student-tests/failover_metrics.py [stop] [kill]")
|
||||
containers = api_containers()
|
||||
replicas = len(containers)
|
||||
check(replicas >= 2, "need at least 2 running api replicas")
|
||||
print(f"api replicas: {[c[:12] for c in containers]}; load: {WRITERS} writers without pauses + 1 reader, "
|
||||
f"client timeout {CLIENT_TIMEOUT_SECONDS} s, retry with the same Idempotency-Key; "
|
||||
f"{WARMUP_SECONDS} s before and {AFTER_SECONDS} s after the failure")
|
||||
runs = []
|
||||
for container in containers:
|
||||
for mode in modes:
|
||||
print(f"--- {mode} {container[:12]} ...")
|
||||
run = measure(container, mode, replicas)
|
||||
runs.append(run)
|
||||
print(f" docker {mode}: {run['command_seconds']} s; HAProxy excluded it after "
|
||||
f"{run['lb_excluded_after_seconds']} s; errors: {run['errors']} {run['error_codes']}, "
|
||||
f"last error ended {run['errors_stopped_after_seconds']} s after the failure")
|
||||
print(f" write RPS before {run['before']['write_rps']} -> after {run['after']['write_rps']}; "
|
||||
f"p95 after {run['after']['write_p95_ms']} ms, max {run['after']['write_max_ms']} ms; "
|
||||
f"answers from the stopped replica after stop: {run['stopped_replica_answers_after_stop']}")
|
||||
print(f" confirmed {run['integrity']['confirmed_writes']}, in history "
|
||||
f"{run['integrity']['messages_in_history']}, lost 0, duplicates 0; "
|
||||
f"back in the balancer {run['rejoin_seconds']} s after docker start")
|
||||
check(run["stopped_replica_answers_after_stop"] == 0, "the stopped replica still answered")
|
||||
check(run["after"]["write_rps"] > 0, "no successful writes after the failure")
|
||||
print()
|
||||
print("replica mode cmd,s lb_out,s errors errors_end,s rps_before rps_after p95_after,ms rejoin,s")
|
||||
for r in runs:
|
||||
print(f"{r['replica']} {r['mode']:<4} {r['command_seconds']:>5} {str(r['lb_excluded_after_seconds']):>8} "
|
||||
f"{r['errors']:>6} {r['errors_stopped_after_seconds']:>12} {r['before']['write_rps']:>10} "
|
||||
f"{r['after']['write_rps']:>9} {str(r['after']['write_p95_ms']):>12} {r['rejoin_seconds']:>8}")
|
||||
OUTPUT.parent.mkdir(exist_ok=True)
|
||||
OUTPUT.write_text(json.dumps({
|
||||
"profile": {"writers": WRITERS, "readers": 1, "client_timeout_seconds": CLIENT_TIMEOUT_SECONDS,
|
||||
"warmup_seconds": WARMUP_SECONDS, "after_seconds": AFTER_SECONDS, "replicas": replicas,
|
||||
"client_python": platform.python_version()},
|
||||
"runs": runs,
|
||||
}, indent=2) + "\n", encoding="utf-8")
|
||||
print(f"PASS: every replica was stopped ({', '.join(modes)}) and restored; no lost or duplicated messages; "
|
||||
f"saved {OUTPUT.relative_to(ROOT).as_posix()}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,77 @@
|
||||
"""lab4–lab5, уровень 3: недоступность S3.
|
||||
|
||||
make failure-s3 (= python student-tests/failure_s3.py)
|
||||
|
||||
С lab5 S3 входит в /health/ready: без него нельзя принять файл в staging, а это обязательный путь
|
||||
(без staging нельзя честно ответить 202). Поэтому при остановке контейнера s3 (SeaweedFS):
|
||||
- каждая реплика: /health/live = 200 (процесс жив), /health/ready = 503 (не может обслужить путь);
|
||||
- HAProxy выводит обе реплики из балансировки и сам отвечает 503 в формате ошибки контракта —
|
||||
быстро, без зависаний и без 500;
|
||||
после запуска S3 реплики возвращаются, файл, загруженный до сбоя, скачивается без изменений,
|
||||
новая загрузка снова 202 -> ready.
|
||||
"""
|
||||
import hashlib
|
||||
import time
|
||||
|
||||
from filegen import SAMPLE_PNG, upload_when_ready, wait_status, wait_until
|
||||
from helpers import Client, Failure, check, run
|
||||
from stand import api_containers, compose_quiet, lb_summary, lb_up_count, ps_table, replica_status, try_call
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
replicas = api_containers()
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
att = upload_when_ready(api, alice, chat, name="before.png")["json"]
|
||||
wait_status(api, bob, att["id"])
|
||||
content = f"/api/v1/attachments/{att['id']}/content"
|
||||
compose_quiet("stop", "s3")
|
||||
stopped = time.monotonic()
|
||||
try:
|
||||
print("=== s3 stopped")
|
||||
print(ps_table())
|
||||
wait_until(lambda: lb_up_count() == 0, 30, "HAProxy kept a replica that cannot reach S3")
|
||||
took = time.monotonic() - stopped
|
||||
print(f"both api replicas are out of the balancer after {took:.1f} s: {lb_summary()}")
|
||||
for container in replicas:
|
||||
live, ready = replica_status(container, "/health/live"), replica_status(container, "/health/ready")
|
||||
print(f"replica {container[:12]}: /health/live {live}, /health/ready {ready}")
|
||||
check(live == 200 and ready == 503, "expected live 200 and ready 503")
|
||||
for method, path, body, ctype in (("GET", "/health/ready", None, None),
|
||||
("POST", f"/api/v1/chats/{chat['id']}/attachments?filename=x.png",
|
||||
SAMPLE_PNG, "image/png"),
|
||||
("GET", content, None, None),
|
||||
("GET", f"/api/v1/chats/{chat['id']}/messages", None, None)):
|
||||
started = time.monotonic()
|
||||
reply = try_call(method, path, raw=body, token=alice["token"],
|
||||
headers={"Content-Type": ctype} if ctype else None, timeout=15)
|
||||
check(reply is not None and reply.status == 503, f"{method} {path}: expected 503")
|
||||
check(reply.json["error"]["code"] == "unavailable" and reply.headers.get("x-request-id"),
|
||||
"the balancer must answer in the contract error format")
|
||||
print(f"{method} {path.split('?')[0]} -> {reply.status} {reply.json['error']['code']} "
|
||||
f"in {time.monotonic() - started:.2f} s (answered by the balancer)")
|
||||
finally:
|
||||
compose_quiet("start", "s3")
|
||||
print("=== s3 started")
|
||||
started = time.monotonic()
|
||||
wait_until(lambda: lb_up_count() == len(replicas), 120, "replicas did not come back")
|
||||
print(f"replicas are back in the balancer after {time.monotonic() - started:.1f} s: {lb_summary()}")
|
||||
|
||||
def downloaded():
|
||||
try:
|
||||
return api.call("GET", content, actor=bob)["bytes"] == SAMPLE_PNG
|
||||
except Failure:
|
||||
return False
|
||||
|
||||
wait_until(downloaded, 60, "the old file is not downloadable after S3 restart")
|
||||
print(f"the file uploaded before the outage is intact (sha256 {hashlib.sha256(SAMPLE_PNG).hexdigest()[:16]}...)")
|
||||
new = upload_when_ready(api, alice, chat, name="after.png")["json"]
|
||||
wait_status(api, bob, new["id"])
|
||||
print(f"new upload -> 202 -> ready ({new['id']})")
|
||||
print(ps_table())
|
||||
print("PASS: S3 down -> replicas not ready (live 200, ready 503), the balancer answers 503 in the contract "
|
||||
"format, no 500 and no hanging; after S3 is back the original is intact and uploads work again")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,434 @@
|
||||
"""lab4–lab5: тестовые картинки и низкоуровневая загрузка — только стандартная библиотека Python.
|
||||
|
||||
- png(): настоящий PNG любого размера (шум не сжимается — так получаются файлы на 9 МБ);
|
||||
- bomb_png(): «бомба» — файл ~150 КБ, внутри 42 млн пикселей (больше лимита 40 млн);
|
||||
- SAMPLE_JPEG: синтетический JPEG 48×32 (781 байт), создан для курса программно;
|
||||
- garbage_scan_jpeg(): JPEG с правильной структурой, но мусором вместо сжатых данных (lab5:
|
||||
API его принимает — структура цела, а worker при строгом декодировании даёт invalid_image);
|
||||
- bad_filter_png(): PNG с недопустимым типом фильтра строки (lab5: 415 уже в API);
|
||||
- raw_upload(): POST через сокет. Нужен там, где urllib не справится: сервер отвечает 413
|
||||
и закрывает соединение, пока клиент ещё отправляет тело, или клиент сам обрывает передачу;
|
||||
- in_api() / psql(): выполнить код внутри контейнера API или SQL в PostgreSQL (для проверок
|
||||
S3 и уборщика). Секреты не печатаются: код внутри контейнера сам читает их из /run/secrets.
|
||||
"""
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import select
|
||||
import socket
|
||||
import struct
|
||||
import subprocess
|
||||
import time
|
||||
import zlib
|
||||
from urllib.parse import urlsplit
|
||||
|
||||
from helpers import ROOT, Failure, check
|
||||
|
||||
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
|
||||
|
||||
SAMPLE_PNG = (ROOT / "tests" / "fixtures" / "sample.png").read_bytes()
|
||||
SAMPLE_JPEG = base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYn"
|
||||
"KSopGR8tMC0oMCUoKSj/2wBDAQcHBwoIChMKChMoGhYaKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgoKCgo"
|
||||
"KCgoKCgoKCj/wAARCAAgADADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUF"
|
||||
"BAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVW"
|
||||
"V1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi"
|
||||
"4+Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAEC"
|
||||
"AxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVm"
|
||||
"Z2hpanN0dXZ3eHl6goOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq"
|
||||
"8vP09fb3+Pn6/9oADAMBAAIRAxEAPwDwGCw9q0ILD2rcgsPatCCw9q+pqYw4MFj9tTDgsPatCCw9q24LD2rQgsPauCpjD67BY/bU"
|
||||
"xILD2q/BYe1bkFh7VoQWHtXBUxh9dgsftqc3BYe1aEFh7VuQWHtWhBYe1cdTGH824LH7amHBYe1aEFh7VuQWHtWhBYe1cFTGH12C"
|
||||
"x+2phwWHtWhBYe1bkFh7VoQWHtXn1MYfXYLH7an/2Q==")
|
||||
# Ещё два синтетических JPEG 40×24 (созданы для курса Pillow): progressive и с маркерами RST (DRI = 1 MCU).
|
||||
PROGRESSIVE_JPEG = base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
|
||||
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
|
||||
"T0//wgARCAAYACgDASIAAhEBAxEB/8QAFwABAQEBAAAAAAAAAAAAAAAAAAMEBf/EABgBAAMBAQAAAAAAAAAAAAAAAAIDBAEG/9oADAMB"
|
||||
"AAIQAxAAAAHg11WxeWuqzbMreOuNSLlrVG22B1f/xAAWEAADAAAAAAAAAAAAAAAAAAAAAQL/2gAIAQEAAQUCUCgUCgUCgUCgUCgUCgUC"
|
||||
"gUH/xAAXEQADAQAAAAAAAAAAAAAAAAAAAQID/9oACAEDAQE/AY2I2FsRTIpipn//xAAXEQEBAQEAAAAAAAAAAAAAAAABABAR/9oACAEC"
|
||||
"AQE/ARhuxGf/xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAY/An//xAAUEAEAAAAAAAAAAAAAAAAAAAAw/9oACAEBAAE/IXAAAAA/"
|
||||
"/9oADAMBAAIAAwAAABBpk59wP//EABcRAQADAAAAAAAAAAAAAAAAABAAESH/2gAIAQMBAT8QKydq0//EABYRAQEBAAAAAAAAAAAAAAAA"
|
||||
"AAEAEP/aAAgBAgEBPxDPK2bC3//EABUQAQEAAAAAAAAAAAAAAAAAAABh/9oACAEBAAE/EJJJJJJJJJJJJJJJP//Z")
|
||||
RESTART_JPEG = base64.b64decode(
|
||||
"/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAA0JCgsKCA0LCgsODg0PEyAVExISEyccHhcgLikxMC4pLSwzOko+MzZGNywtQFdBRkxOUlNS"
|
||||
"Mj5aYVpQYEpRUk//2wBDAQ4ODhMREyYVFSZPNS01T09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09P"
|
||||
"T0//wAARCAAYACgDASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAAAgEDAwIEAwUFBAQAAAF9AQID"
|
||||
"AAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlq"
|
||||
"c3R1dnd4eXqDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl5ufo6erx8vP09fb3"
|
||||
"+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEI"
|
||||
"FEKRobHBCSMzUvAVYnLRChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOEhYaHiImK"
|
||||
"kpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk5ebn6Onq8vP09fb3+Pn6/90ABAAB/9oADAMBAAIR"
|
||||
"AxEAPwDg4rP2q3FZ+1akVn7Vbis/alCZz0MYf//Q5mKz9qtxWftWpFZ+1W4rP2rohM9GhjD/0c+Kz9qK34rP2orvUz6aGM0P/9J0Vn7V"
|
||||
"bis/aiiuSDZ8pQqyP//T2IrP2q3FZ+1FFTBs82hVkf/U66Kz9qKKK1TZcKsrH//Z")
|
||||
|
||||
|
||||
def _chunk(kind: bytes, data: bytes) -> bytes:
|
||||
return struct.pack(">I", len(data)) + kind + data + struct.pack(">I", zlib.crc32(kind + data) & 0xFFFFFFFF)
|
||||
|
||||
|
||||
def png(width: int, height: int, noise: bool = False) -> bytes:
|
||||
"""RGB PNG. noise=True — случайные пиксели (файл почти не сжимается), иначе однотонный."""
|
||||
compressor = zlib.compressobj(1)
|
||||
parts = []
|
||||
row = b"\x00" + b"\x40\x80\xc0" * width
|
||||
for _ in range(height):
|
||||
parts.append(compressor.compress(b"\x00" + os.urandom(width * 3) if noise else row))
|
||||
parts.append(compressor.flush())
|
||||
ihdr = struct.pack(">IIBBBBB", width, height, 8, 2, 0, 0, 0)
|
||||
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", b"".join(parts)) + _chunk(b"IEND", b"")
|
||||
|
||||
|
||||
def bomb_png() -> bytes:
|
||||
"""7000×6000 = 42 млн пикселей нулей: файл маленький, распакованный — 126 МБ."""
|
||||
return png(7000, 6000)
|
||||
|
||||
|
||||
def png_exact_size(total: int) -> bytes:
|
||||
"""Корректный PNG ровно total байт: маленькая картинка + служебный блок-заполнитель (tEXt)."""
|
||||
base = png(64, 64, noise=True)
|
||||
head, iend = base[:-12], base[-12:]
|
||||
filler = total - len(base) - 12 # 12 байт — длина, тип и CRC блока-заполнителя
|
||||
check(filler >= 6, "total is too small")
|
||||
return head + _chunk(b"tEXt", b"pad\x00" + b"x" * (filler - 4)) + iend
|
||||
|
||||
|
||||
def gray_png(width: int, height: int) -> bytes:
|
||||
"""Оттенки серого, нули: 40 млн пикселей сжимаются в ~40 КБ."""
|
||||
compressor = zlib.compressobj(9)
|
||||
row = b"\x00" + bytes(width)
|
||||
data = b"".join(compressor.compress(row) for _ in range(height)) + compressor.flush()
|
||||
ihdr = struct.pack(">IIBBBBB", width, height, 8, 0, 0, 0, 0)
|
||||
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", data) + _chunk(b"IEND", b"")
|
||||
|
||||
|
||||
def bad_filter_png() -> bytes:
|
||||
"""PNG 40×30, у 11-й строки тип фильтра 7 (допустимы 0–4)."""
|
||||
raw = b"".join(bytes([7 if y == 10 else 0]) + bytes(40 * 3) for y in range(30))
|
||||
ihdr = struct.pack(">IIBBBBB", 40, 30, 8, 2, 0, 0, 0)
|
||||
return b"\x89PNG\r\n\x1a\n" + _chunk(b"IHDR", ihdr) + _chunk(b"IDAT", zlib.compress(raw)) + _chunk(b"IEND", b"")
|
||||
|
||||
|
||||
# ---------- JPEG по сегментам: чтобы портить структуру точечно ----------
|
||||
|
||||
def jpeg_parts(data: bytes) -> list:
|
||||
"""JPEG -> [("seg", маркер, данные) | ("scan", заголовок SOS, сжатые данные) | ("eoi", хвост)]."""
|
||||
i, parts = 2, []
|
||||
while True:
|
||||
marker = data[i + 1]
|
||||
i += 2
|
||||
if marker == 0xD9:
|
||||
parts.append(("eoi", data[i:]))
|
||||
return parts
|
||||
length = int.from_bytes(data[i:i + 2], "big")
|
||||
payload, i = data[i + 2:i + length], i + length
|
||||
if marker != 0xDA:
|
||||
parts.append(("seg", marker, payload))
|
||||
continue
|
||||
j = i
|
||||
while data[j] != 0xFF or data[j + 1] == 0x00 or 0xD0 <= data[j + 1] <= 0xD7:
|
||||
j += 1
|
||||
parts.append(("scan", payload, data[i:j]))
|
||||
i = j
|
||||
|
||||
|
||||
def jpeg_join(parts: list) -> bytes:
|
||||
out = bytearray(b"\xff\xd8")
|
||||
for part in parts:
|
||||
if part[0] == "seg":
|
||||
out += bytes([0xFF, part[1]]) + struct.pack(">H", len(part[2]) + 2) + part[2]
|
||||
elif part[0] == "scan":
|
||||
out += b"\xff\xda" + struct.pack(">H", len(part[1]) + 2) + part[1] + part[2]
|
||||
else:
|
||||
out += b"\xff\xd9" + part[1]
|
||||
return bytes(out)
|
||||
|
||||
|
||||
def _edit(data: bytes, kind, fn, index: int = 0) -> bytes:
|
||||
"""Поменять index-й сегмент вида kind (маркер или "scan"): fn(bytearray) -> bytes."""
|
||||
parts, seen = jpeg_parts(data), 0
|
||||
for k, part in enumerate(parts):
|
||||
hit = part[0] == "scan" if kind == "scan" else part[0] == "seg" and part[1] == kind
|
||||
if hit:
|
||||
if seen == index:
|
||||
if kind == "scan":
|
||||
parts[k] = ("scan", fn(bytearray(part[1])), part[2])
|
||||
else:
|
||||
parts[k] = ("seg", kind, fn(bytearray(part[2])))
|
||||
return jpeg_join(parts)
|
||||
seen += 1
|
||||
raise AssertionError(f"segment {kind} #{index} not found")
|
||||
|
||||
|
||||
def _set(position: int, value: int):
|
||||
def change(payload: bytearray) -> bytes:
|
||||
payload[position] = value
|
||||
return bytes(payload)
|
||||
return change
|
||||
|
||||
|
||||
def teacher_bad_sos_jpeg() -> bytes:
|
||||
"""Воспроизведение из замечания: в первом SOS (FF DA по смещению i) байт i+5 — первый
|
||||
идентификатор компонента — заменить на 250, которого нет в SOF."""
|
||||
data = bytearray(SAMPLE_JPEG)
|
||||
i = data.index(b"\xff\xda")
|
||||
data[i + 5] = 250
|
||||
return bytes(data)
|
||||
|
||||
|
||||
def broken_structure_jpegs() -> list[tuple[str, bytes]]:
|
||||
"""JPEG, которые строгий декодер worker отвергает по маркерам и заголовкам (API: 415)."""
|
||||
def drop(data, test):
|
||||
return jpeg_join([p for p in jpeg_parts(data) if not test(p)])
|
||||
|
||||
def scans(data):
|
||||
return [p for p in jpeg_parts(data) if p[0] == "scan"]
|
||||
|
||||
def swap_rst(entropy: bytes) -> bytes:
|
||||
e = bytearray(entropy)
|
||||
positions = [k for k in range(len(e) - 1) if e[k] == 0xFF and 0xD0 <= e[k + 1] <= 0xD7]
|
||||
e[positions[0] + 1], e[positions[1] + 1] = e[positions[1] + 1], e[positions[0] + 1]
|
||||
return bytes(e)
|
||||
|
||||
seq_scan = scans(SAMPLE_JPEG)[0]
|
||||
first_progressive = scans(PROGRESSIVE_JPEG)[0]
|
||||
no_jfif = drop(SAMPLE_JPEG, lambda p: p[0] == "seg" and p[1] == 0xE0)
|
||||
restart_parts = jpeg_parts(RESTART_JPEG)
|
||||
return [
|
||||
("SOS: компонент 250, которого нет в SOF (замечание к MR)", teacher_bad_sos_jpeg()),
|
||||
("SOS: один компонент дважды в скане", _edit(SAMPLE_JPEG, "scan", _set(3, 1))),
|
||||
("SOS: таблица Хаффмана DC 2 не определена", _edit(SAMPLE_JPEG, "scan", _set(2, 0x20))),
|
||||
("SOS: номер таблицы Хаффмана AC 5", _edit(SAMPLE_JPEG, "scan", _set(4, 0x05))),
|
||||
("SOS: Se=62 в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-2, 62))),
|
||||
("SOS: Ah/Al не нули в последовательном JPEG", _edit(SAMPLE_JPEG, "scan", _set(-1, 0x10))),
|
||||
("SOS: 5 компонентов в скане", _edit(SAMPLE_JPEG, "scan", _set(0, 5))),
|
||||
("SOF: таблица квантования 3 не определена", _edit(SAMPLE_JPEG, 0xC0, _set(8, 3))),
|
||||
("SOF: повторяется идентификатор компонента", _edit(SAMPLE_JPEG, 0xC0, _set(9, 1))),
|
||||
("SOF: субдискретизация 1×4 (не понимает декодер)", _edit(SAMPLE_JPEG, 0xC0, _set(7, 0x14))),
|
||||
("SOF: коэффициент субдискретизации 0", _edit(SAMPLE_JPEG, 0xC0, _set(10, 0x01))),
|
||||
("SOF: 12 бит на канал", _edit(SAMPLE_JPEG, 0xC0, _set(0, 12))),
|
||||
("SOF: 2 компонента", _edit(SAMPLE_JPEG, 0xC0, lambda p: bytes(p[:5]) + b"\x02" + bytes(p[6:12]))),
|
||||
("DHT: коды не помещаются в длину (3 кода по 1 биту)",
|
||||
_edit(SAMPLE_JPEG, 0xC4, lambda p: b"\x00" + bytes([3] + [0] * 15) + b"\x00\x01\x02")),
|
||||
("DHT: символ 16 в таблице DC", _edit(SAMPLE_JPEG, 0xC4, lambda p: bytes(p[:-1]) + b"\x10")),
|
||||
("DHT: номер таблицы 4", _edit(SAMPLE_JPEG, 0xC4, _set(0, 0x04))),
|
||||
("DQT: таблица обрезана", _edit(SAMPLE_JPEG, 0xDB, lambda p: bytes(p[:-1]))),
|
||||
("сегмент с зарезервированным маркером 0xF0",
|
||||
jpeg_join([("seg", 0xF0, b"\x00\x00")] + jpeg_parts(SAMPLE_JPEG))),
|
||||
("мусорные байты между сегментами", SAMPLE_JPEG.replace(b"\xff\xdb", b"\x00\x00\xff\xdb", 1)),
|
||||
("APP0: JFIF версии 3", _edit(SAMPLE_JPEG, 0xE0, _set(5, 3))),
|
||||
("APP14: неизвестное преобразование Adobe 7",
|
||||
jpeg_join([("seg", 0xEE, b"Adobe\x00\x64\x00\x00\x00\x00\x07")] + jpeg_parts(no_jfif))),
|
||||
("второй скан после полного скана",
|
||||
jpeg_join(jpeg_parts(SAMPLE_JPEG)[:-1] + [seq_scan, ("eoi", b"")])),
|
||||
("progressive: AC-скан раньше DC-скана", drop(PROGRESSIVE_JPEG, lambda p: p is not None and p == first_progressive)),
|
||||
("progressive: Al=14", _edit(PROGRESSIVE_JPEG, "scan", _set(-1, 14))),
|
||||
("RST: маркеры RST0 и RST1 поменяны местами",
|
||||
jpeg_join([("scan", p[1], swap_rst(p[2])) if p[0] == "scan" else p for p in restart_parts])),
|
||||
("RST: маркеры есть, а интервала DRI нет", drop(RESTART_JPEG, lambda p: p[0] == "seg" and p[1] == 0xDD)),
|
||||
("RST: интервал DRI 2 вместо 1", _edit(RESTART_JPEG, 0xDD, lambda p: b"\x00\x02")),
|
||||
]
|
||||
|
||||
|
||||
def garbage_scan_jpeg() -> bytes:
|
||||
"""SAMPLE_JPEG с мусором вместо сжатых данных скана: маркеры и длины целы, данные — нет."""
|
||||
sos = SAMPLE_JPEG.index(b"\xff\xda")
|
||||
length = int.from_bytes(SAMPLE_JPEG[sos + 2:sos + 4], "big")
|
||||
noise = bytes((i * 37 + 11) % 255 for i in range(400)) # без 0xFF: маркеры не появятся
|
||||
return SAMPLE_JPEG[:sos + 2 + length] + noise + b"\xff\xd9"
|
||||
|
||||
|
||||
def corrupt_crc(data: bytes) -> bytes:
|
||||
"""Испортить один байт внутри данных IDAT: контрольная сумма блока перестаёт сходиться."""
|
||||
position = data.index(b"IDAT") + 8
|
||||
return data[:position] + bytes([data[position] ^ 0xFF]) + data[position + 1:]
|
||||
|
||||
|
||||
def truncated(data: bytes) -> bytes:
|
||||
return data[: len(data) // 2]
|
||||
|
||||
|
||||
# ---------- загрузка через сокет ----------
|
||||
|
||||
def raw_upload(path: str, token: str, body: bytes = b"", content_type: str = "image/png",
|
||||
content_length: int | None = None, abort_after: int | None = None, timeout: float = 30):
|
||||
"""POST path через балансировщик. Возвращает (status, headers, json) или None, если ответа нет.
|
||||
|
||||
content_length — что заявить в заголовке (по умолчанию len(body));
|
||||
abort_after — отправить столько байт тела и оборвать соединение (имитация обрыва загрузки).
|
||||
Тело шлётся кусками; если сервер уже ответил (413) и закрыл соединение — перестаём слать
|
||||
и читаем ответ.
|
||||
"""
|
||||
url = urlsplit(BASE_URL)
|
||||
sock = socket.create_connection((url.hostname, url.port or 80), timeout=timeout)
|
||||
length = len(body) if content_length is None else content_length
|
||||
# content_length=-1: Transfer-Encoding: chunked, размер заранее неизвестен серверу.
|
||||
framing = "Transfer-Encoding: chunked" if length == -1 else f"Content-Length: {length}"
|
||||
head = (f"POST {path} HTTP/1.1\r\nHost: {url.hostname}\r\nAuthorization: Bearer {token}\r\n"
|
||||
f"Content-Type: {content_type}\r\n{framing}\r\nConnection: close\r\n\r\n")
|
||||
to_send = body if abort_after is None else body[:abort_after]
|
||||
if length == -1:
|
||||
step = 64 * 1024
|
||||
to_send = b"".join(b"%x\r\n%s\r\n" % (len(to_send[i:i + step]), to_send[i:i + step])
|
||||
for i in range(0, len(to_send), step)) + b"0\r\n\r\n"
|
||||
try:
|
||||
sock.sendall(head.encode("ascii"))
|
||||
for start in range(0, len(to_send), 64 * 1024):
|
||||
# Сервер уже ответил (например, 413 до конца тела)? Тогда перестаём слать и читаем ответ:
|
||||
# продолжение отправки в закрытое соединение может стереть ответ (RST).
|
||||
if select.select([sock], [], [], 0)[0]:
|
||||
break
|
||||
sock.sendall(to_send[start:start + 64 * 1024])
|
||||
except OSError:
|
||||
pass # сервер закрыл соединение раньше — читаем то, что он успел ответить
|
||||
if abort_after is not None:
|
||||
sock.close()
|
||||
return None
|
||||
data = b""
|
||||
try:
|
||||
while True:
|
||||
part = sock.recv(65536)
|
||||
if not part:
|
||||
break
|
||||
data += part
|
||||
if _complete(data): # ответ получен целиком: не ждём, пока балансировщик закроет соединение
|
||||
break
|
||||
except OSError:
|
||||
pass
|
||||
finally:
|
||||
sock.close()
|
||||
if not data.startswith(b"HTTP/1."):
|
||||
return None
|
||||
header_blob, _, payload = data.partition(b"\r\n\r\n")
|
||||
lines = header_blob.decode("latin-1").split("\r\n")
|
||||
status = int(lines[0].split()[1])
|
||||
headers = {k.strip().lower(): v.strip() for k, v in (line.split(":", 1) for line in lines[1:] if ":" in line)}
|
||||
try:
|
||||
payload_json = json.loads(payload.decode("utf-8")) if payload else None
|
||||
except ValueError:
|
||||
payload_json = None
|
||||
return status, headers, payload_json
|
||||
|
||||
|
||||
def _complete(data: bytes) -> bool:
|
||||
head, sep, body = data.partition(b"\r\n\r\n")
|
||||
if not sep:
|
||||
return False
|
||||
for line in head.decode("latin-1").split("\r\n")[1:]:
|
||||
name, _, value = line.partition(":")
|
||||
if name.strip().lower() == "content-length":
|
||||
return len(body) >= int(value.strip())
|
||||
return False
|
||||
|
||||
|
||||
def upload_when_ready(api, actor, chat, data=None, name="ready.png", seconds=60, ctype="image/png"):
|
||||
"""Загрузить файл; пока стенд только запускается (503) — повторять до seconds. Возвращает ответ 202."""
|
||||
path = f"/api/v1/chats/{chat['id']}/attachments?filename={name}"
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
try:
|
||||
reply = api.call("POST", path, [202, 503], actor=actor, raw=data or SAMPLE_PNG,
|
||||
headers={"Content-Type": ctype}, schema="Attachment")
|
||||
except Failure: # балансировщик без готовых реплик или обрыв соединения
|
||||
reply = {"status": 0}
|
||||
if reply["status"] == 202:
|
||||
check(reply["json"]["status"] == "queued", "upload must return a queued snapshot")
|
||||
return reply
|
||||
check(time.monotonic() < deadline, f"stand is not ready for uploads after {seconds} s")
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def wait_status(api, actor, attachment_id, statuses=("ready",), seconds=60, step=0.3):
|
||||
"""Опрашивать GET вложения, пока статус не станет одним из statuses. Возвращает Attachment."""
|
||||
deadline = time.monotonic() + seconds
|
||||
last = None
|
||||
while True:
|
||||
try:
|
||||
last = api.call("GET", f"/api/v1/attachments/{attachment_id}", actor=actor, schema="Attachment")["json"]
|
||||
if last["status"] in statuses:
|
||||
return last
|
||||
check(last["status"] != "failed" or "failed" in statuses,
|
||||
f"attachment failed with {last['error_code']}")
|
||||
except Failure as exc:
|
||||
if "attachment failed" in str(exc):
|
||||
raise
|
||||
check(time.monotonic() < deadline,
|
||||
f"attachment is {last and last['status']} after {seconds} s, expected {statuses}")
|
||||
time.sleep(step)
|
||||
|
||||
|
||||
def webp_size(data: bytes) -> tuple[int, int]:
|
||||
"""Ширина и высота WebP по заголовку RIFF (VP8, VP8L или VP8X) — без библиотек."""
|
||||
check(data[:4] == b"RIFF" and data[8:12] == b"WEBP", "not a WebP file")
|
||||
kind = data[12:16]
|
||||
if kind == b"VP8 ":
|
||||
return int.from_bytes(data[26:28], "little") & 0x3FFF, int.from_bytes(data[28:30], "little") & 0x3FFF
|
||||
if kind == b"VP8L":
|
||||
bits = int.from_bytes(data[21:25], "little")
|
||||
return (bits & 0x3FFF) + 1, ((bits >> 14) & 0x3FFF) + 1
|
||||
check(kind == b"VP8X", "unknown WebP chunk")
|
||||
return int.from_bytes(data[24:27], "little") + 1, int.from_bytes(data[27:30], "little") + 1
|
||||
|
||||
|
||||
def webp_chunks(data: bytes) -> list[bytes]:
|
||||
"""Типы блоков RIFF внутри WebP (EXIF, XMP , ICCP — метаданные)."""
|
||||
kinds, i = [], 12
|
||||
while i + 8 <= len(data):
|
||||
kinds.append(data[i:i + 4])
|
||||
i += 8 + ((int.from_bytes(data[i + 4:i + 8], "little") + 1) & ~1)
|
||||
return kinds
|
||||
|
||||
|
||||
def jpeg_markers(data: bytes) -> list[int]:
|
||||
"""Маркеры JPEG до начала скана: по ним видно, есть ли EXIF (APP1) или ICC (APP2)."""
|
||||
found, i = [], 2
|
||||
while i + 4 <= len(data) and data[i] == 0xFF:
|
||||
marker = data[i + 1]
|
||||
found.append(marker)
|
||||
if marker == 0xDA:
|
||||
break
|
||||
i += 2 + int.from_bytes(data[i + 2:i + 4], "big")
|
||||
return found
|
||||
|
||||
|
||||
# ---------- внутри стенда ----------
|
||||
|
||||
def in_api(code: str) -> str:
|
||||
"""Выполнить Python-код в контейнере API (сеть backend, модули messenger). Возвращает stdout."""
|
||||
result = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-"], cwd=ROOT,
|
||||
input=code.encode("utf-8"), capture_output=True)
|
||||
last_error = (result.stderr.decode("utf-8", "replace").strip().splitlines() or [""])[-1]
|
||||
check(result.returncode == 0, "code inside the api container failed: " + last_error)
|
||||
return result.stdout.decode("utf-8", "replace").strip()
|
||||
|
||||
|
||||
def exec_python(container: str, code: str) -> str:
|
||||
"""Python-код в конкретном контейнере через stdin (переводы строк одинаково работают и на Windows)."""
|
||||
result = subprocess.run(["docker", "exec", "-i", container, "python", "-"], cwd=ROOT,
|
||||
input=code.encode("utf-8"), capture_output=True)
|
||||
check(result.returncode == 0, f"code inside {container[:12]} failed")
|
||||
return result.stdout.decode("utf-8", "replace").strip()
|
||||
|
||||
|
||||
def psql(sql: str) -> str:
|
||||
"""SQL в PostgreSQL стенда (только для проверок; значения в SQL — проверенные UUID и числа)."""
|
||||
result = subprocess.run(["docker", "compose", "exec", "-T", "postgres", "psql", "-X", "-q", "-t", "-A",
|
||||
"-U", "messenger", "-d", "messenger", "-v", "ON_ERROR_STOP=1", "-c", sql],
|
||||
cwd=ROOT, capture_output=True)
|
||||
check(result.returncode == 0, "psql failed: " + result.stderr.decode("utf-8", "replace").strip())
|
||||
return result.stdout.decode("utf-8", "replace").strip()
|
||||
|
||||
|
||||
def cleanup_cli(*args: str) -> dict:
|
||||
"""python -m messenger.cleanup внутри контейнера API -> словарь счётчиков."""
|
||||
result = subprocess.run(["docker", "compose", "exec", "-T", "api", "python", "-m", "messenger.cleanup", *args],
|
||||
cwd=ROOT, capture_output=True)
|
||||
output = result.stdout.decode("utf-8", "replace").strip().splitlines()
|
||||
check(result.returncode == 0 and output, "cleanup failed: " + result.stderr.decode("utf-8", "replace")[-300:])
|
||||
return json.loads(output[-1])
|
||||
|
||||
|
||||
def wait_until(condition, seconds: float, message: str, step: float = 0.5):
|
||||
deadline = time.monotonic() + seconds
|
||||
while not condition():
|
||||
check(time.monotonic() < deadline, message)
|
||||
time.sleep(step)
|
||||
@@ -0,0 +1,71 @@
|
||||
"""Общие помощники для собственных тестов.
|
||||
|
||||
Переиспользуем публичный HTTP-клиент курса (tests/client.py), а не пишем свой:
|
||||
он уже проверяет X-Request-Id, X-Instance-Id (с lab3), формат ошибок, WWW-Authenticate
|
||||
и схемы ответов из контракта.
|
||||
С lab2 клиент сам регистрирует пользователя с паролем, входит через Basic
|
||||
и подставляет Bearer-токен (токен живёт только в памяти теста и не печатается).
|
||||
"""
|
||||
import base64
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
from urllib.parse import quote
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "tests"))
|
||||
|
||||
from client import Client, Failure, check, run # noqa: E402 (импорт после правки sys.path)
|
||||
|
||||
__all__ = ["Client", "Failure", "check", "run", "read_history", "basic", "login", "compose", "wait_ready",
|
||||
"idempotency", "ROOT"]
|
||||
|
||||
|
||||
def idempotency(key=None):
|
||||
"""Заголовок Idempotency-Key (обязателен для POST сообщения с lab3). Без аргумента — новый ключ."""
|
||||
return {"Idempotency-Key": key or uuid.uuid4().hex}
|
||||
|
||||
|
||||
def read_history(api, actor, chat_id, limit=100):
|
||||
"""Читает всю историю чата по страницам. Возвращает (сообщения, число_страниц)."""
|
||||
items, pages, cursor = [], 0, None
|
||||
while True:
|
||||
query = f"?limit={limit}" + (f"&cursor={quote(cursor, safe='')}" if cursor else "")
|
||||
page = api.call("GET", f"/api/v1/chats/{chat_id}/messages{query}",
|
||||
actor=actor, schema="MessagePage")["json"]
|
||||
items += page["items"]
|
||||
pages += 1
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
return items, pages
|
||||
|
||||
|
||||
def basic(username, password):
|
||||
"""Значение заголовка Authorization: Basic base64(username:password), пароль в UTF-8."""
|
||||
return "Basic " + base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("ascii")
|
||||
|
||||
|
||||
def login(api, username, password, expected=201):
|
||||
"""POST /auth/sessions; при успехе возвращает тело Session (токен — только в памяти)."""
|
||||
schema = "Session" if expected == 201 else None
|
||||
return api.call("POST", "/api/v1/auth/sessions", expected,
|
||||
headers={"Authorization": basic(username, password)}, schema=schema)["json"]
|
||||
|
||||
|
||||
def compose(*args):
|
||||
"""docker compose <args> из корня репозитория; вывод скрыт (там могут быть имена/секреты)."""
|
||||
subprocess.run(["docker", "compose", *args], cwd=ROOT, check=True,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def wait_ready(api, seconds=90):
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
try:
|
||||
api.call("GET", "/health/ready", schema="Health")
|
||||
return
|
||||
except Failure:
|
||||
check(time.monotonic() < deadline, f"API не стал готов за {seconds} с")
|
||||
time.sleep(0.5)
|
||||
@@ -0,0 +1,96 @@
|
||||
"""lab5, уровень 4: lease для зависшего processing — как отличить зависший worker от долго работающего.
|
||||
|
||||
make lease (= python student-tests/lease_takeover.py)
|
||||
|
||||
1. Долгая задача: точка worker_slow=35 — обработка «идёт» 35 с. Пока worker жив, он продлевает
|
||||
lease каждые JOB_HEARTBEAT_SECONDS (10 с): lease_until в БД сдвигается вперёд. Задание никто
|
||||
не забирает, хотя оно дольше JOB_LEASE_SECONDS (30 с).
|
||||
2. Зависание: запускается второй worker B (docker compose up --scale worker=2), затем контейнер
|
||||
worker A замораживается (docker pause) — процесс есть, но ничего не делает, как при зависании.
|
||||
Продлений нет, lease истекает. Проверка lease в B видит истёкшую аренду, засчитывает попытку
|
||||
как неудачную и назначает следующую. B обрабатывает задание -> ready (попытка 2).
|
||||
3. «Оживший» A: после docker unpause он пытается продлить lease, но жетон уже не его —
|
||||
обработка прерывается, результат не записывается (fencing). В БД ровно один ready и один
|
||||
набор вариантов, автор результата — B.
|
||||
Неконтролируемых дублей нет: одновременно задание держит только владелец действующего lease,
|
||||
а записать результат может только владелец текущего жетона.
|
||||
"""
|
||||
import time
|
||||
|
||||
import ops
|
||||
from filegen import upload_when_ready, wait_status
|
||||
from helpers import Client, check, run
|
||||
|
||||
|
||||
def main():
|
||||
api = Client(timeout=15)
|
||||
ops.scale("worker", 1)
|
||||
worker_a = ops.wait_healthy("worker", 1)[0]
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
paused = False
|
||||
try:
|
||||
ops.arm("worker", "worker_slow", "35", container=worker_a)
|
||||
att = upload_when_ready(api, alice, chat, name="lease.png")["json"]
|
||||
wait_status(api, bob, att["id"], ("processing",), seconds=30, step=0.2)
|
||||
leases = []
|
||||
deadline = time.monotonic() + 30
|
||||
while time.monotonic() < deadline:
|
||||
value = ops.job(att["id"])["job"]["lease_until"]
|
||||
if value and value not in leases:
|
||||
leases.append(value)
|
||||
if len(leases) >= 3:
|
||||
break
|
||||
time.sleep(1)
|
||||
check(len(leases) >= 3, f"the lease was not renewed while the job was running: {leases}")
|
||||
owner = ops.job(att["id"])["job"]["lease_owner"]
|
||||
print(f"1. long job (35 s > lease 30 s) on {owner}: lease_until moved forward "
|
||||
f"{len(leases) - 1} times: {' -> '.join(v[11:19] for v in leases)}")
|
||||
|
||||
ops.scale("worker", 2)
|
||||
ops.wait_healthy("worker", 2)
|
||||
worker_b = [c for c in ops.containers("worker") if c != worker_a][0]
|
||||
print(f"2. worker B {worker_b[:12]} started (the job is still held by A's lease)")
|
||||
ops.pause(worker_a)
|
||||
paused = True
|
||||
frozen_at = time.monotonic()
|
||||
print(f" worker A {worker_a[:12]} frozen (docker pause): no more renewals")
|
||||
ready = wait_status(api, bob, att["id"], seconds=120)
|
||||
job = ops.job(att["id"])
|
||||
took = time.monotonic() - frozen_at
|
||||
winner = [e for e in job["events"] if e["event"] == "ready"]
|
||||
check(job["job"]["attempt"] == 2 and len(winner) == 1, "expected exactly one result at attempt 2")
|
||||
check(not winner[0]["actor"].endswith(owner), "the frozen worker must not be the one who committed")
|
||||
print(f" lease expired -> attempt 2 -> ready {took:.0f} s after the freeze; result committed by "
|
||||
f"{winner[0]['actor']}")
|
||||
print(" events: " + " -> ".join(f"{e['event']}({e['attempt']})" for e in job["events"]))
|
||||
|
||||
ops.unpause(worker_a)
|
||||
paused = False
|
||||
deadline = time.monotonic() + 40
|
||||
lost = []
|
||||
while not lost:
|
||||
lines = [line for line in ops.logs("worker", "5m").splitlines() if job["job"]["job_id"] in line]
|
||||
lost = [line for line in lines if "не продлён" in line or "брошена" in line]
|
||||
if not lost:
|
||||
check(time.monotonic() < deadline, "the woken worker A did not notice that its lease was lost")
|
||||
time.sleep(2)
|
||||
after = ops.job(att["id"])
|
||||
check(after["attachment_status"] == "ready" and after["job"]["attempt"] == 2, "state changed after unpause")
|
||||
check(sum(e["event"] == "ready" for e in after["events"]) == 1 and len(after["variants"]) == 3,
|
||||
"the stale worker wrote a second result")
|
||||
meta = api.call("GET", f"/api/v1/attachments/{att['id']}", actor=bob, schema="Attachment")["json"]
|
||||
check(meta == ready, "metadata changed after the stale worker woke up")
|
||||
print("3. worker A unpaused: " + lost[-1].split(": ", 1)[-1])
|
||||
print(" still exactly one result: status ready, attempt 2, 3 variant rows, metadata unchanged")
|
||||
finally:
|
||||
if paused:
|
||||
ops.unpause(worker_a)
|
||||
ops.disarm("worker", "worker_slow")
|
||||
ops.scale("worker", 1)
|
||||
ops.wait_healthy("worker", 1)
|
||||
print("PASS: a running worker keeps its lease by renewing it; a frozen one loses it, the job moves to another "
|
||||
"worker, and the stale worker cannot overwrite the result (fencing token)")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,78 @@
|
||||
"""Профиль нагрузки для отчёта: публичный tests/load.py + CPU/RAM контейнеров во время нагрузки.
|
||||
|
||||
python student-tests/load_profile.py (30 с, 4 потока — как в tests/README.md)
|
||||
|
||||
Запускает tests/load.py (closed loop: каждый поток шлёт следующий POST сразу после ответа)
|
||||
и параллельно раз в ~2 с снимает `docker stats --no-stream` по контейнерам стенда.
|
||||
Сохраняет evidence/load.json (вывод load.py: успешные RPS, ошибки, p50/p95/p99)
|
||||
и evidence/load-stats.json (максимум CPU % и RAM по каждому сервису за время нагрузки).
|
||||
Числа зависят от машины и Docker Desktop; это замер этого стенда, а не предел пропускной способности.
|
||||
"""
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
|
||||
from helpers import ROOT, check, run
|
||||
from stand import BASE_URL, compose_output, inspect
|
||||
|
||||
DURATION, CONCURRENCY = 30, 4
|
||||
LOAD_JSON = ROOT / "evidence" / "load.json"
|
||||
STATS_JSON = ROOT / "evidence" / "load-stats.json"
|
||||
|
||||
|
||||
def mib(text):
|
||||
"""'123.4MiB' / '1.2GiB' / '512kB' -> MiB."""
|
||||
text = text.strip()
|
||||
units = {"KiB": 1 / 1024, "kB": 1 / 1024, "MiB": 1, "MB": 1, "GiB": 1024, "GB": 1024, "B": 1 / 2**20}
|
||||
for unit in sorted(units, key=len, reverse=True):
|
||||
if text.endswith(unit):
|
||||
return float(text[: -len(unit)]) * units[unit]
|
||||
return 0.0
|
||||
|
||||
|
||||
def main():
|
||||
# Только основной путь запроса: балансировщик, реплики API, PostgreSQL, Valkey.
|
||||
names = {c[:12]: inspect(c, '{{index .Config.Labels "com.docker.compose.service"}}')
|
||||
for c in compose_output("ps", "-q").split()}
|
||||
names = {cid: service for cid, service in names.items() if service in ("lb", "api", "postgres", "valkey")}
|
||||
containers = list(names)
|
||||
peaks, stopping = {}, threading.Event()
|
||||
|
||||
def sample():
|
||||
while not stopping.is_set():
|
||||
result = subprocess.run(["docker", "stats", "--no-stream", "--format", "{{json .}}", *containers],
|
||||
capture_output=True, text=True)
|
||||
for line in result.stdout.splitlines():
|
||||
item = json.loads(line)
|
||||
key = item["ID"][:12]
|
||||
cpu = float(item["CPUPerc"].rstrip("%") or 0)
|
||||
used, _, limit = item["MemUsage"].partition("/")
|
||||
peak = peaks.setdefault(key, {"service": names.get(key, "?"), "cpu_percent_max": 0.0,
|
||||
"mem_mib_max": 0.0, "mem_limit_mib": round(mib(limit))})
|
||||
peak["cpu_percent_max"] = max(peak["cpu_percent_max"], cpu)
|
||||
peak["mem_mib_max"] = round(max(peak["mem_mib_max"], mib(used)), 1)
|
||||
time.sleep(1)
|
||||
|
||||
sampler = threading.Thread(target=sample, daemon=True)
|
||||
sampler.start()
|
||||
result = subprocess.run([sys.executable, "tests/load.py", "--base-url", BASE_URL, "--duration", str(DURATION),
|
||||
"--concurrency", str(CONCURRENCY), "--output", str(LOAD_JSON)],
|
||||
cwd=ROOT, capture_output=True)
|
||||
stopping.set()
|
||||
sampler.join(timeout=10)
|
||||
print(result.stdout.decode("utf-8", "replace").strip())
|
||||
check(result.returncode == 0, "tests/load.py failed: " + result.stderr.decode("utf-8", "replace")[-300:])
|
||||
rows = sorted(peaks.values(), key=lambda row: row["service"])
|
||||
STATS_JSON.write_text(json.dumps({"duration_seconds": DURATION, "concurrency": CONCURRENCY,
|
||||
"containers": rows}, indent=2) + "\n", encoding="utf-8")
|
||||
print("\nservice cpu % max RAM max / limit, MiB")
|
||||
for row in rows:
|
||||
print(f"{row['service']:<14} {row['cpu_percent_max']:>9.1f} {row['mem_mib_max']:>7.1f} / {row['mem_limit_mib']}")
|
||||
print(f"PASS: load profile saved to {LOAD_JSON.relative_to(ROOT).as_posix()} and "
|
||||
f"{STATS_JSON.relative_to(ROOT).as_posix()}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,120 @@
|
||||
"""Фоновая нагрузка для замеров во время отказа и rolling update
|
||||
(используют failover_metrics.py и rolling_update.py). Только стандартная библиотека.
|
||||
|
||||
WRITERS потоков без пауз пишут сообщения в один чат (closed loop: следующий запрос — сразу после
|
||||
ответа на предыдущий). Если запрос не подтверждён (обрыв, timeout, 5xx), поток повторяет ТОТ ЖЕ
|
||||
запрос с ТЕМ ЖЕ Idempotency-Key — так по контракту делает клиент. Один поток параллельно читает
|
||||
историю. Каждая попытка записывается: время, успех, код, реплика, задержка.
|
||||
В конце verify() читает всю историю и проверяет, что все подтверждённые сообщения на месте
|
||||
и дублей нет (тексты уникальны, поэтому дубль сразу виден).
|
||||
"""
|
||||
import math
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
|
||||
from helpers import Client, check, read_history
|
||||
from stand import try_call
|
||||
|
||||
WRITERS = 4
|
||||
CLIENT_TIMEOUT_SECONDS = 2
|
||||
|
||||
|
||||
class Load:
|
||||
def __init__(self, writers=WRITERS, timeout=CLIENT_TIMEOUT_SECONDS):
|
||||
self.api = Client()
|
||||
self.alice, self.bob = self.api.user("load_a"), self.api.user("load_b")
|
||||
self.chat = self.api.call("POST", "/api/v1/chats", 201, actor=self.alice, schema="Chat",
|
||||
body={"title": "load", "member_ids": [self.alice["id"], self.bob["id"]]})["json"]
|
||||
self.writers, self.timeout = writers, timeout
|
||||
self.events = [] # (время старта, "write"/"read", ok, код или "conn", реплика, задержка в с)
|
||||
self.confirmed = [] # сообщения, на которые пришёл 201
|
||||
self.lock = threading.Lock()
|
||||
self.stopping = threading.Event()
|
||||
self.threads = []
|
||||
|
||||
def _record(self, kind, started, reply, ok):
|
||||
code = reply.status if reply is not None else "conn"
|
||||
instance = reply.instance if reply is not None else None
|
||||
with self.lock:
|
||||
self.events.append((started, kind, ok, code, instance, time.monotonic() - started))
|
||||
|
||||
def _writer(self, number):
|
||||
path = f"/api/v1/chats/{self.chat['id']}/messages"
|
||||
sent = 0
|
||||
key, text = uuid.uuid4().hex, f"load-{number}-{sent}"
|
||||
while not self.stopping.is_set():
|
||||
started = time.monotonic()
|
||||
reply = try_call("POST", path, body={"text": text}, token=self.alice["token"],
|
||||
headers={"Idempotency-Key": key}, timeout=self.timeout)
|
||||
ok = reply is not None and reply.status == 201
|
||||
self._record("write", started, reply, ok)
|
||||
if ok:
|
||||
with self.lock:
|
||||
self.confirmed.append(reply.json)
|
||||
sent += 1
|
||||
key, text = uuid.uuid4().hex, f"load-{number}-{sent}"
|
||||
else:
|
||||
time.sleep(0.05) # и повторить тот же text с тем же ключом
|
||||
|
||||
def _reader(self):
|
||||
path = f"/api/v1/chats/{self.chat['id']}/messages?limit=20"
|
||||
while not self.stopping.is_set():
|
||||
started = time.monotonic()
|
||||
reply = try_call("GET", path, token=self.bob["token"], timeout=self.timeout)
|
||||
self._record("read", started, reply, reply is not None and reply.status == 200)
|
||||
time.sleep(0.05)
|
||||
|
||||
def start(self):
|
||||
self.threads = [threading.Thread(target=self._writer, args=(n,), daemon=True) for n in range(self.writers)]
|
||||
self.threads.append(threading.Thread(target=self._reader, daemon=True))
|
||||
for thread in self.threads:
|
||||
thread.start()
|
||||
|
||||
def stop(self):
|
||||
self.stopping.set()
|
||||
for thread in self.threads:
|
||||
thread.join(timeout=self.timeout + 5)
|
||||
|
||||
def window(self, start, end, kind=None):
|
||||
with self.lock:
|
||||
return [e for e in self.events if start <= e[0] < end and (kind is None or e[1] == kind)]
|
||||
|
||||
def verify(self):
|
||||
"""Все подтверждённые сообщения есть в истории, id и тексты не повторяются."""
|
||||
history, _ = read_history(self.api, self.bob, self.chat["id"])
|
||||
ids = [message["id"] for message in history]
|
||||
texts = [message["text"] for message in history]
|
||||
by_id = {message["id"]: message for message in history}
|
||||
check(len(ids) == len(set(ids)), "duplicated message ids in history")
|
||||
check(len(texts) == len(set(texts)), "a retried request created a duplicate message")
|
||||
lost = [m for m in self.confirmed if by_id.get(m["id"]) != m]
|
||||
check(not lost, f"{len(lost)} confirmed messages are lost or changed")
|
||||
return {"confirmed_writes": len(self.confirmed), "messages_in_history": len(history),
|
||||
"duplicates": 0, "lost": 0}
|
||||
|
||||
|
||||
def summary(load, start, end):
|
||||
"""Успешные записи в секунду, ошибки по кодам и задержки успешных записей на отрезке [start, end)."""
|
||||
events = load.window(start, end)
|
||||
writes = [e for e in events if e[1] == "write"]
|
||||
ok_writes = sorted(e[5] for e in writes if e[2])
|
||||
errors = [e for e in events if not e[2]]
|
||||
seconds = max(end - start, 1e-6)
|
||||
|
||||
def percentile(p):
|
||||
return round(1000 * ok_writes[max(0, math.ceil(p * len(ok_writes)) - 1)], 1) if ok_writes else None
|
||||
|
||||
codes = {}
|
||||
for e in errors:
|
||||
codes[str(e[3])] = codes.get(str(e[3]), 0) + 1
|
||||
return {
|
||||
"seconds": round(seconds, 2),
|
||||
"write_rps": round(len(ok_writes) / seconds, 1),
|
||||
"reads": len([e for e in events if e[1] == "read"]),
|
||||
"errors": len(errors),
|
||||
"error_codes": codes,
|
||||
"write_p50_ms": percentile(0.50),
|
||||
"write_p95_ms": percentile(0.95),
|
||||
"write_max_ms": round(1000 * ok_writes[-1], 1) if ok_writes else None,
|
||||
}
|
||||
@@ -0,0 +1,196 @@
|
||||
"""lab5: управление стендом для собственных проверок — всё, что делается через Docker.
|
||||
|
||||
Тесты останавливают и запускают сервисы, ставят worker на паузу, включают точки отказа
|
||||
(src/messenger/faults.py) и смотрят в PostgreSQL и RabbitMQ только через этот модуль.
|
||||
Так в самих тестах видно, ЧТО делается со стендом, а не КАК вызвать docker.
|
||||
|
||||
Точка отказа включается файлом /tmp/faults/<имя> внутри контейнера (docker exec). Процесс
|
||||
сам удаляет файл, когда точка сработала, поэтому после перезапуска он работает нормально.
|
||||
Секреты не печатаются: код внутри контейнеров сам читает их из /run/secrets.
|
||||
"""
|
||||
import json
|
||||
import re
|
||||
import subprocess
|
||||
import time
|
||||
|
||||
from helpers import ROOT, check
|
||||
|
||||
_NAME = re.compile(r"^[a-z_]{1,40}$")
|
||||
_VALUE = re.compile(r"^[0-9.]{1,10}$")
|
||||
|
||||
|
||||
def _run(args, stdin: bytes | None = None, check_exit: bool = True) -> str:
|
||||
result = subprocess.run(args, cwd=ROOT, input=stdin, capture_output=True)
|
||||
if check_exit and result.returncode != 0:
|
||||
last = (result.stderr.decode("utf-8", "replace").strip().splitlines() or [""])[-1]
|
||||
check(False, f"`{' '.join(args[:4])} ...` failed: {last[:300]}")
|
||||
return result.stdout.decode("utf-8", "replace").strip()
|
||||
|
||||
|
||||
def compose(*args, stdin: bytes | None = None, check_exit: bool = True) -> str:
|
||||
return _run(["docker", "compose", *args], stdin, check_exit)
|
||||
|
||||
|
||||
def docker(*args, check_exit: bool = True) -> str:
|
||||
return _run(["docker", *args], None, check_exit)
|
||||
|
||||
|
||||
# ---------- сервисы и контейнеры ----------
|
||||
|
||||
def containers(service: str, include_stopped: bool = False) -> list[str]:
|
||||
"""Полные ID контейнеров сервиса (по умолчанию только запущенные)."""
|
||||
args = ["ps", "-q", "-a", service] if include_stopped else ["ps", "-q", service]
|
||||
return sorted(compose(*args).split())
|
||||
|
||||
|
||||
def stop(*services: str) -> None:
|
||||
compose("stop", *services)
|
||||
|
||||
|
||||
def start(*services: str) -> None:
|
||||
compose("start", *services)
|
||||
|
||||
|
||||
def restart(*services: str) -> None:
|
||||
compose("restart", *services)
|
||||
|
||||
|
||||
def pause(container: str) -> None:
|
||||
docker("pause", container)
|
||||
|
||||
|
||||
def unpause(container: str) -> None:
|
||||
docker("unpause", container)
|
||||
|
||||
|
||||
def scale(service: str, replicas: int) -> None:
|
||||
"""Число контейнеров сервиса; существующие не пересоздаются."""
|
||||
compose("up", "-d", "--no-recreate", "--scale", f"{service}={replicas}", service)
|
||||
|
||||
|
||||
def restarts(container: str) -> int:
|
||||
"""Сколько раз Docker перезапускал контейнер (restart: unless-stopped после падения)."""
|
||||
return int(docker("inspect", "-f", "{{.RestartCount}}", container) or 0)
|
||||
|
||||
|
||||
def health(container: str) -> str:
|
||||
return docker("inspect", "-f", "{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}",
|
||||
container, check_exit=False)
|
||||
|
||||
|
||||
def wait_healthy(service: str, count: int, seconds: float = 120) -> list[str]:
|
||||
"""Дождаться count запущенных и healthy контейнеров сервиса."""
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
running = containers(service)
|
||||
ready = [c for c in running if health(c) == "healthy"]
|
||||
if len(ready) >= count:
|
||||
return ready
|
||||
check(time.monotonic() < deadline, f"{service}: {len(ready)} healthy of {count} after {seconds} s")
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def logs(service: str, since: str = "10m") -> str:
|
||||
return compose("logs", "--no-color", "--since", since, service, check_exit=False)
|
||||
|
||||
|
||||
# ---------- точки отказа ----------
|
||||
|
||||
def arm(service: str, point: str, value: str = "1", container: str | None = None) -> list[str]:
|
||||
"""Включить точку отказа во всех контейнерах сервиса (или в одном). Возвращает ID контейнеров."""
|
||||
check(bool(_NAME.match(point)) and bool(_VALUE.match(value)), "bad fault point")
|
||||
targets = [container] if container else containers(service)
|
||||
for target in targets:
|
||||
docker("exec", target, "sh", "-c", f"mkdir -p /tmp/faults && printf '%s' {value} > /tmp/faults/{point}")
|
||||
return targets
|
||||
|
||||
|
||||
def disarm(service: str, point: str) -> None:
|
||||
check(bool(_NAME.match(point)), "bad fault point")
|
||||
for target in containers(service):
|
||||
docker("exec", target, "rm", "-f", f"/tmp/faults/{point}", check_exit=False)
|
||||
|
||||
|
||||
def armed(container: str, point: str) -> bool:
|
||||
check(bool(_NAME.match(point)), "bad fault point")
|
||||
return docker("exec", container, "sh", "-c", f"test -e /tmp/faults/{point} && echo yes || echo no",
|
||||
check_exit=False) == "yes"
|
||||
|
||||
|
||||
# ---------- код и данные внутри стенда ----------
|
||||
|
||||
def python(service: str, code: str, container: str | None = None) -> str:
|
||||
"""Python-код внутри контейнера (модули messenger и секреты есть только там). Возвращает stdout."""
|
||||
target = container or containers(service)[0]
|
||||
return _run(["docker", "exec", "-i", target, "python", "-"], code.encode("utf-8"))
|
||||
|
||||
|
||||
def cli(service: str, *args: str) -> dict:
|
||||
"""python -m <модуль> ... внутри контейнера, последний вывод — одна строка JSON."""
|
||||
out = _run(["docker", "compose", "exec", "-T", service, "python", "-m", *args])
|
||||
lines = [line for line in out.splitlines() if line.startswith("{") or line.startswith("[")]
|
||||
check(bool(lines), f"no JSON from {' '.join(args)}")
|
||||
return json.loads(lines[-1])
|
||||
|
||||
|
||||
def cli_in(container: str, *args: str) -> dict:
|
||||
"""То же, что cli(), но в конкретном контейнере (там, где включена точка-пауза)."""
|
||||
out = _run(["docker", "exec", "-i", container, "python", "-m", *args])
|
||||
lines = [line for line in out.splitlines() if line.startswith("{") or line.startswith("[")]
|
||||
check(bool(lines), f"no JSON from {' '.join(args)}")
|
||||
return json.loads(lines[-1])
|
||||
|
||||
|
||||
def job(attachment_id: str, service: str = "api") -> dict:
|
||||
"""Состояние задания, журнал, строки outbox и варианты (python -m messenger.jobs show)."""
|
||||
return cli(service, "messenger.jobs", "show", attachment_id)
|
||||
|
||||
|
||||
def replay(attachment_id: str) -> dict:
|
||||
return cli("api", "messenger.jobs", "replay", attachment_id, "--actor", "student-test")
|
||||
|
||||
|
||||
def psql(sql: str) -> str:
|
||||
"""SQL в PostgreSQL стенда (значения в SQL — проверенные UUID и числа)."""
|
||||
return compose("exec", "-T", "postgres", "psql", "-X", "-q", "-t", "-A", "-U", "messenger", "-d", "messenger",
|
||||
"-v", "ON_ERROR_STOP=1", "-c", sql)
|
||||
|
||||
|
||||
def queues(seconds: float = 30) -> dict:
|
||||
"""{очередь: (готовых к выдаче, выдано и не подтверждено)} — rabbitmqctl внутри контейнера брокера.
|
||||
|
||||
Сразу после перезапуска брокер уже отвечает на ping, но quorum-очереди ещё восстанавливаются
|
||||
с диска, и list_queues может один раз не ответить: тогда повторяем до seconds секунд.
|
||||
"""
|
||||
args = ("exec", "-T", "broker", "rabbitmqctl", "-q", "list_queues", "-p", "messenger",
|
||||
"name", "messages_ready", "messages_unacknowledged", "--formatter", "json")
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
out = compose(*args, check_exit=False) # при ошибке rabbitmqctl печатает справку, не JSON
|
||||
try:
|
||||
rows = json.loads(out or "[]")
|
||||
return {q["name"]: (int(q["messages_ready"]), int(q["messages_unacknowledged"])) for q in rows}
|
||||
except (ValueError, KeyError, TypeError):
|
||||
pass
|
||||
check(time.monotonic() < deadline, "rabbitmqctl list_queues: the broker does not answer")
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def objects(prefix: str) -> list[str]:
|
||||
"""Ключи объектов S3 под префиксом (список из контейнера API его ключами)."""
|
||||
out = python("api", "import json\nfrom messenger import objects\n"
|
||||
f"print(json.dumps([k for k, _ in objects.list_objects({prefix!r})]))")
|
||||
return json.loads(out.splitlines()[-1])
|
||||
|
||||
|
||||
def publish(message: dict) -> None:
|
||||
"""Отправить сообщение в очередь заданий напрямую (имитация повторной доставки)."""
|
||||
python("api", "import json\nfrom messenger import broker\n"
|
||||
f"p = broker.Publisher('student-test')\np.publish(json.loads({json.dumps(message)!r}))\np.close()")
|
||||
|
||||
|
||||
def publish_raw(body: bytes) -> None:
|
||||
"""Отправить в очередь произвольное тело (проверка, что worker отвергает чужой формат)."""
|
||||
python("api", "import pika\nfrom messenger import broker\n"
|
||||
"c = broker.connect('student-test'); ch = c.channel(); ch.confirm_delivery()\n"
|
||||
f"ch.basic_publish(broker.EXCHANGE, broker.ROUTING_KEY, {body!r}, mandatory=True)\nc.close()")
|
||||
@@ -0,0 +1,150 @@
|
||||
"""lab5, уровень 4: разрыв между PostgreSQL и брокером закрыт transactional outbox.
|
||||
|
||||
make outbox-crash (= python student-tests/outbox_crash.py)
|
||||
|
||||
Три окна отказа из contracts/attachment-states.md, в каждом процесс API падает по-настоящему
|
||||
(os._exit, как SIGKILL: без ответа, без finally) в точке отказа (src/messenger/faults.py):
|
||||
|
||||
A. api_after_commit — вложение, задание и строка outbox закоммичены, ответ 202 ещё не отправлен.
|
||||
Клиент получает ошибку балансировщика (502), но работа принята: relay другой реплики (или этой
|
||||
после перезапуска) отправляет задание, worker его выполняет. Новое задание вручную не создаётся.
|
||||
B. relay_before_publish — relay взял строки outbox, но в брокер ничего не отправил. Транзакция
|
||||
откатывается вместе с упавшим процессом, строки остаются неотправленными, их отправляют позже.
|
||||
C. relay_after_publish — брокер подтвердил приём, но строка не отмечена отправленной. После
|
||||
перезапуска её отправляют ещё раз: worker получает дубль и подтверждает его без обработки.
|
||||
D. Брокер остановлен целиком: загрузка всё равно получает 202 (брокер не входит в readiness),
|
||||
строка outbox ждёт в PostgreSQL неотправленной; после запуска брокера relay её отправляет.
|
||||
Точка включается во всех репликах API: какая бы реплика ни взялась за строку, она упадёт.
|
||||
Docker сам перезапускает упавшие контейнеры (restart: unless-stopped); файл точки удаляется до
|
||||
падения, поэтому после перезапуска реплика работает нормально.
|
||||
В каждом сценарии проверяется: вложение стало ready, у задания одна попытка и один набор вариантов.
|
||||
"""
|
||||
import time
|
||||
import uuid
|
||||
|
||||
import ops
|
||||
from filegen import SAMPLE_PNG, upload_when_ready, wait_status
|
||||
from helpers import Client, check, run
|
||||
from stand import lb_up_count, try_call
|
||||
|
||||
|
||||
def stand_ready(seconds=120):
|
||||
ops.wait_healthy("api", 2, seconds)
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
try:
|
||||
if lb_up_count() >= 2:
|
||||
return
|
||||
except OSError:
|
||||
pass
|
||||
check(time.monotonic() < deadline, "HAProxy does not see 2 ready api replicas")
|
||||
time.sleep(0.5)
|
||||
|
||||
|
||||
def restart_counts():
|
||||
return {c[:12]: ops.restarts(c) for c in ops.containers("api")}
|
||||
|
||||
|
||||
def finished(api, bob, attachment_id):
|
||||
meta = wait_status(api, bob, attachment_id, ("ready",), seconds=120)
|
||||
job = ops.job(attachment_id)
|
||||
check(job["job"]["attempt"] == 1, "the job must finish in its first attempt")
|
||||
check(len(job["variants"]) == 3, "exactly one set of variants expected")
|
||||
check(sum(e["event"] == "ready" for e in job["events"]) == 1, "the result must be committed once")
|
||||
return meta, job
|
||||
|
||||
|
||||
def show(job):
|
||||
outbox = "; ".join(f"row {o['id']} published {o['published_at']} by {o['published_by']}" for o in job["outbox"])
|
||||
events = " -> ".join(f"{e['event']}" for e in job["events"])
|
||||
return f"outbox: {outbox}\n events: {events}"
|
||||
|
||||
|
||||
def main():
|
||||
api = Client(timeout=15)
|
||||
ops.wait_healthy("worker", 1)
|
||||
stand_ready()
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
|
||||
# ---------- A ----------
|
||||
before = restart_counts()
|
||||
ops.arm("api", "api_after_commit")
|
||||
name = f"outbox-a-{uuid.uuid4().hex[:8]}.png"
|
||||
reply = try_call("POST", f"/api/v1/chats/{chat['id']}/attachments?filename={name}", raw=SAMPLE_PNG,
|
||||
token=alice["token"], headers={"Content-Type": "image/png"}, timeout=30)
|
||||
status = reply.status if reply else "no response"
|
||||
check(reply is None or reply.status >= 500, "the client must NOT get 202 when the API crashed after COMMIT")
|
||||
ops.disarm("api", "api_after_commit") # реплика, которая не упала, ещё «заряжена»
|
||||
attachment_id = ops.psql(f"SELECT id FROM attachments WHERE filename = '{name}'")
|
||||
check(bool(attachment_id), "the committed attachment row must exist")
|
||||
print(f"A. api_after_commit: the client got {status} instead of 202, but the attachment {attachment_id} "
|
||||
f"and its outbox row were committed before the crash")
|
||||
_meta, job = finished(api, bob, attachment_id)
|
||||
stand_ready()
|
||||
after = restart_counts()
|
||||
crashed = [c for c in after if after[c] > before.get(c, after[c])]
|
||||
print(f" ready without creating a new job by hand; api restarted by Docker: {crashed or 'see logs'}")
|
||||
print(" " + show(job))
|
||||
|
||||
# ---------- B ----------
|
||||
before = restart_counts()
|
||||
ops.arm("api", "relay_before_publish")
|
||||
att = upload_when_ready(api, alice, chat, name="outbox-b.png")["json"]
|
||||
print(f"B. relay_before_publish: upload -> 202 ({att['id']}); every relay that takes the row crashes "
|
||||
f"before publishing")
|
||||
_meta, job = finished(api, bob, att["id"])
|
||||
stand_ready()
|
||||
after = restart_counts()
|
||||
crashed = [c for c in after if after[c] > before.get(c, after[c])]
|
||||
check(crashed, "at least one relay must have crashed")
|
||||
check(not any(e["event"].startswith("duplicate") for e in job["events"]), "nothing was published twice here")
|
||||
print(f" crashed and restarted: {crashed}; after restart the row was published once -> ready")
|
||||
print(" " + show(job))
|
||||
|
||||
# ---------- C ----------
|
||||
before = restart_counts()
|
||||
ops.arm("api", "relay_after_publish")
|
||||
att = upload_when_ready(api, alice, chat, name="outbox-c.png")["json"]
|
||||
print(f"C. relay_after_publish: upload -> 202 ({att['id']}); the broker confirms, the relay crashes before "
|
||||
f"marking the row")
|
||||
_meta, job = finished(api, bob, att["id"])
|
||||
deadline = time.monotonic() + 60
|
||||
while not any(e["event"].startswith("duplicate") for e in job["events"]):
|
||||
check(time.monotonic() < deadline, "the duplicate delivery was not observed")
|
||||
time.sleep(1)
|
||||
job = ops.job(att["id"])
|
||||
stand_ready()
|
||||
after = restart_counts()
|
||||
crashed = [c for c in after if after[c] > before.get(c, after[c])]
|
||||
duplicates = [e for e in job["events"] if e["event"].startswith("duplicate")]
|
||||
print(f" crashed and restarted: {crashed}; the same message was delivered again "
|
||||
f"{len(duplicates)} time(s): " + ", ".join(e["event"] for e in duplicates))
|
||||
print(" " + show(job))
|
||||
keys = ops.objects(f"variants/{att['id']}/")
|
||||
check(len(keys) == 3, "duplicates must not create more objects")
|
||||
print(f" still one set of variants: {len(job['variants'])} rows, {len(keys)} objects")
|
||||
# ---------- D ----------
|
||||
ops.stop("broker")
|
||||
try:
|
||||
att = upload_when_ready(api, alice, chat, name="outbox-d.png")["json"]
|
||||
time.sleep(5)
|
||||
job = ops.job(att["id"])
|
||||
check(job["outbox"] and not job["outbox"][0]["published_at"], "the row must wait while the broker is down")
|
||||
meta = api.call("GET", f"/api/v1/attachments/{att['id']}", actor=bob, schema="Attachment")["json"]
|
||||
print(f"D. broker stopped: upload -> 202 ({att['id']}), after 5 s status {meta['status']}, outbox row "
|
||||
f"{job['outbox'][0]['id']} not published yet (it waits in PostgreSQL)")
|
||||
finally:
|
||||
ops.start("broker")
|
||||
ops.wait_healthy("broker", 1, 180)
|
||||
started = time.monotonic()
|
||||
_meta, job = finished(api, bob, att["id"])
|
||||
print(f" broker started: the relay published the row, ready {time.monotonic() - started:.1f} s later")
|
||||
print(" " + show(job))
|
||||
print("PASS: a crash between COMMIT and publish (A, B) loses nothing — the outbox row is published later and "
|
||||
"the job becomes ready without manual action; a crash after publish (C) only causes a duplicate "
|
||||
"delivery, which the worker acknowledges without a second set of variants; while the broker is down (D) "
|
||||
"uploads are still accepted and the jobs wait in the outbox")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,75 @@
|
||||
"""Проверка гонок (уровень 4). Запуск: make race
|
||||
|
||||
1. 10 клиентов одновременно отправляют по 10 сообщений в один чат:
|
||||
в истории ровно 100 сообщений, все id уникальны, ни один текст не потерян.
|
||||
2. 20 клиентов одновременно регистрируют ОДИН И ТОТ ЖЕ username:
|
||||
ровно один получает 201, остальные 409; в базе один такой пользователь.
|
||||
Защита — уникальный индекс users.username в PostgreSQL, а не проверка в коде.
|
||||
"""
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
from helpers import Client, check, idempotency, read_history, run
|
||||
|
||||
CLIENTS = 10
|
||||
PER_CLIENT = 10
|
||||
REGISTRATIONS = 20
|
||||
|
||||
|
||||
def concurrent_messages(api):
|
||||
users = [api.user(f"race{i}") for i in range(CLIENTS)]
|
||||
chat = api.call("POST", "/api/v1/chats", 201, actor=users[0], schema="Chat",
|
||||
body={"title": "race", "member_ids": [u["id"] for u in users]})["json"]
|
||||
path = f"/api/v1/chats/{chat['id']}/messages"
|
||||
start_together = threading.Barrier(CLIENTS) # все потоки стартуют одновременно
|
||||
|
||||
def send_all(index):
|
||||
client = Client() # у каждого «клиента» свои HTTP-соединения
|
||||
start_together.wait()
|
||||
for n in range(PER_CLIENT):
|
||||
client.call("POST", path, 201, actor=users[index], body={"text": f"client-{index}-msg-{n}"},
|
||||
headers=idempotency())
|
||||
|
||||
started = time.monotonic()
|
||||
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
|
||||
list(pool.map(send_all, range(CLIENTS))) # list() пробрасывает ошибки из потоков
|
||||
elapsed = time.monotonic() - started
|
||||
|
||||
history, pages = read_history(api, users[0], chat["id"], limit=25)
|
||||
expected = {f"client-{i}-msg-{n}" for i in range(CLIENTS) for n in range(PER_CLIENT)}
|
||||
print(f"messages: sent {CLIENTS * PER_CLIENT} from {CLIENTS} parallel clients in {elapsed:.2f}s")
|
||||
print(f"messages: read {len(history)} in {pages} pages, unique ids: {len({m['id'] for m in history})}")
|
||||
check(len(history) == CLIENTS * PER_CLIENT, "wrong number of messages")
|
||||
check(len({m["id"] for m in history}) == len(history), "duplicate message ids")
|
||||
check({m["text"] for m in history} == expected, "lost or corrupted message texts")
|
||||
print("PASS: 100 concurrent messages stored without loss or duplicates")
|
||||
|
||||
|
||||
def concurrent_registration():
|
||||
username = "race_" + uuid.uuid4().hex[:12]
|
||||
start_together = threading.Barrier(REGISTRATIONS)
|
||||
|
||||
def register(index):
|
||||
client = Client()
|
||||
body = {"username": username, "display_name": f"Участник {index}", "password": f"Race-password-{index:03d}"}
|
||||
start_together.wait()
|
||||
return client.call("POST", "/api/v1/users", [201, 409], body=body)["status"]
|
||||
|
||||
with ThreadPoolExecutor(max_workers=REGISTRATIONS) as pool:
|
||||
statuses = list(pool.map(register, range(REGISTRATIONS)))
|
||||
created, conflicts = statuses.count(201), statuses.count(409)
|
||||
print(f"registration: {REGISTRATIONS} parallel requests for one username -> 201 x{created}, 409 x{conflicts}")
|
||||
check(created == 1 and conflicts == REGISTRATIONS - 1, "exactly one registration must win")
|
||||
print("PASS: concurrent registration of the same username created exactly one user")
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
concurrent_messages(api)
|
||||
concurrent_registration()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,80 @@
|
||||
"""lab5, уровень 3: повторная доставка — нормальная ситуация, она не создаёт второй набор вариантов.
|
||||
|
||||
make redelivery (= python student-tests/redelivery.py)
|
||||
|
||||
1. upload -> ready: запоминаем варианты (SHA-256), объекты под variants/<id>/ и строки в БД;
|
||||
2. в очередь ещё дважды отправляется ТО ЖЕ сообщение (тот же job_id и attempt) — так выглядит
|
||||
повторная доставка (например, relay упал после подтверждения брокера, но до отметки в outbox);
|
||||
3. worker получает оба дубля и подтверждает их без обработки: в журнале задания duplicate_ignored,
|
||||
вариантов по-прежнему 3, объектов 3, SHA-256 те же, статус ready, попытка 1;
|
||||
4. сообщение не по схеме jobs.schema.json (лишнее поле с URL; число вместо UUID; не JSON) worker
|
||||
не обрабатывает и не падает: reject -> DLQ (attachments.dead), обычная работа продолжается.
|
||||
"""
|
||||
import json
|
||||
import time
|
||||
|
||||
import ops
|
||||
from filegen import upload_when_ready, wait_status
|
||||
from helpers import Client, check, run
|
||||
|
||||
|
||||
def wait_events(attachment_id, name, count, seconds=30):
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
job = ops.job(attachment_id)
|
||||
found = [e for e in job["events"] if e["event"] == name]
|
||||
if len(found) >= count:
|
||||
return job
|
||||
check(time.monotonic() < deadline, f"expected {count} {name} events, got {len(found)}")
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
def main():
|
||||
api = Client(timeout=15)
|
||||
ops.wait_healthy("worker", 1)
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
att = upload_when_ready(api, alice, chat, name="redelivery.png")["json"]
|
||||
ready = wait_status(api, bob, att["id"])
|
||||
before = ops.job(att["id"])
|
||||
keys = ops.objects(f"variants/{att['id']}/")
|
||||
check(len(before["variants"]) == 3 and len(keys) == 3, "one set of variants expected")
|
||||
print(f"1. attachment {att['id']} ready: 3 variant rows, objects {keys}")
|
||||
|
||||
message = {"schema_version": 1, "job_id": before["job"]["job_id"], "type": "attachment.process.v1",
|
||||
"attachment_id": att["id"], "pipeline_version": 1, "attempt": 1,
|
||||
"created_at": "2026-10-25T12:00:00Z"}
|
||||
for _ in range(2):
|
||||
ops.publish(message)
|
||||
print("2. the same message (same job_id and attempt) published twice more")
|
||||
after = wait_events(att["id"], "duplicate_ignored", 2)
|
||||
keys_after = ops.objects(f"variants/{att['id']}/")
|
||||
check(after["variants"] == before["variants"], "variants changed after a duplicate")
|
||||
check(sorted(keys_after) == sorted(keys), "a second set of objects appeared")
|
||||
check(after["job"]["attempt"] == 1 and after["attachment_status"] == "ready", "duplicate changed the job")
|
||||
meta = api.call("GET", f"/api/v1/attachments/{att['id']}", actor=bob, schema="Attachment")["json"]
|
||||
check(meta == ready, "metadata changed after a duplicate")
|
||||
print("3. both duplicates acknowledged without processing: " +
|
||||
", ".join(f"{e['event']}({e['detail']})" for e in after["events"] if e["event"] == "duplicate_ignored"))
|
||||
print(f" variants: {[(v['name'], v['sha256'][:12]) for v in after['variants']]} — same rows, same objects, "
|
||||
f"status ready, attempt 1")
|
||||
|
||||
dead_before = ops.queues().get("attachments.dead", (0, 0))[0]
|
||||
bad = [dict(message, url="http://example.invalid/steal"), dict(message, job_id=42), None]
|
||||
for body in bad:
|
||||
ops.publish_raw(b"not json at all" if body is None else json.dumps(body).encode())
|
||||
deadline = time.monotonic() + 30
|
||||
while ops.queues().get("attachments.dead", (0, 0))[0] < dead_before + len(bad):
|
||||
check(time.monotonic() < deadline, "invalid messages did not reach the DLQ")
|
||||
time.sleep(1)
|
||||
dead_after = ops.queues().get("attachments.dead", (0, 0))[0]
|
||||
print(f"4. 3 messages that do not match jobs.schema.json -> reject -> DLQ attachments.dead: "
|
||||
f"{dead_before} -> {dead_after}")
|
||||
second = upload_when_ready(api, alice, chat, name="after-bad.png")["json"]
|
||||
wait_status(api, bob, second["id"])
|
||||
print(" the worker keeps working: a new upload became ready")
|
||||
print("PASS: redelivery of a finished job is a no-op with ack (no second set of variants); "
|
||||
"malformed messages go to the DLQ without crashing the worker")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,142 @@
|
||||
"""Таблицы замеров для REPORT.md из evidence/*.json (без ручного переписывания чисел).
|
||||
|
||||
make report-tables (= python student-tests/report_tables.py)
|
||||
|
||||
Берёт evidence/failover-metrics.json, rolling-update.json, load.json, load-stats.json
|
||||
и время из evidence/persistence.txt, собирает markdown-таблицы и вставляет их в REPORT.md
|
||||
между метками <!-- measurements:begin --> и <!-- measurements:end -->. Запускать после
|
||||
make failover-metrics, make rolling-update, make load-profile и make persistence.
|
||||
"""
|
||||
import json
|
||||
import re
|
||||
|
||||
from helpers import ROOT, check, run
|
||||
|
||||
EVIDENCE = ROOT / "evidence"
|
||||
REPORT = ROOT / "REPORT.md"
|
||||
BEGIN, END = "<!-- measurements:begin -->", "<!-- measurements:end -->"
|
||||
|
||||
|
||||
def load(name):
|
||||
path = EVIDENCE / name
|
||||
return json.loads(path.read_text(encoding="utf-8")) if path.exists() else None
|
||||
|
||||
|
||||
def codes(mapping):
|
||||
return ", ".join(f"{code}: {count}" for code, count in mapping.items()) or "-"
|
||||
|
||||
|
||||
def failover_table(data):
|
||||
lines = [
|
||||
f"Остановка каждой реплики под нагрузкой (`make failover-metrics`, evidence/failover-metrics.json): "
|
||||
f"{data['profile']['writers']} потока пишут сообщения без пауз, 1 читает историю, timeout клиента "
|
||||
f"{data['profile']['client_timeout_seconds']} с, неподтверждённая запись повторяется с тем же ключом; "
|
||||
f"{data['profile']['warmup_seconds']} с до отказа и {data['profile']['after_seconds']} с после. "
|
||||
"stop = `docker stop` (SIGTERM, плановая остановка), kill = `docker kill` (SIGKILL, авария).",
|
||||
"",
|
||||
"| Реплика | Отказ | Вывод из LB, с | Ошибок (коды) | Ошибки закончились через, с | Записей/с до → после | "
|
||||
"p95 записи после, мс | Возврат в LB после `docker start`, с | Потери / дубли |",
|
||||
"| --- | --- | --- | --- | --- | --- | --- | --- | --- |",
|
||||
]
|
||||
for r in data["runs"]:
|
||||
lines.append(f"| {r['replica']} | {r['mode']} | {r['lb_excluded_after_seconds']} | {r['errors']} "
|
||||
f"({codes(r['error_codes'])}) | {r['errors_stopped_after_seconds']} | "
|
||||
f"{r['before']['write_rps']} → {r['after']['write_rps']} | {r['after']['write_p95_ms']} | "
|
||||
f"{r['rejoin_seconds']} | 0 / 0 (подтверждено {r['integrity']['confirmed_writes']}) |")
|
||||
return lines
|
||||
|
||||
|
||||
def rolling_lines(data):
|
||||
during = data["during"]
|
||||
steps = "; ".join(f"{s['old']} → {s['new']}: новая готова через {s['new_ready_seconds']} с, шаг {s['step_seconds']} с"
|
||||
for s in data["steps"])
|
||||
return [f"Rolling update под той же нагрузкой (`make rolling-update`, evidence/rolling-update.json): версия "
|
||||
f"{data['from_version']} → {data['to_version']}, {data['replicas']} реплики заменены по одной за "
|
||||
f"{data['update_seconds']} с ({steps}). Записей/с до: {data['before']['write_rps']}, во время замены: "
|
||||
f"{during['write_rps']}; ошибок: {during['errors']} ({codes(during['error_codes'])}); p95 "
|
||||
f"{during['write_p95_ms']} мс, максимум {during['write_max_ms']} мс; подтверждено "
|
||||
f"{data['integrity']['confirmed_writes']} сообщений, потерь и дублей нет."]
|
||||
|
||||
|
||||
def load_lines(data, stats):
|
||||
latency = data["successful_latency_ms"]
|
||||
lines = [f"Публичный генератор нагрузки (`make load-profile` = `tests/load.py`, closed loop, {data['concurrency']} "
|
||||
f"потока, {data['requested_duration_seconds']:.0f} с, 2 реплики): {data['successful_rps']} успешных "
|
||||
f"POST/с, ошибок {data['failed_requests']} (доля {data['error_ratio']}), задержка успешных: p50 "
|
||||
f"{latency['p50']} мс, p95 {latency['p95']} мс, p99 {latency['p99']} мс."]
|
||||
if stats:
|
||||
lines += ["", "| Сервис | CPU, % макс. (100 % = 1 ядро) | RAM макс. / лимит, МиБ |", "| --- | --- | --- |"]
|
||||
lines += [f"| {row['service']} | {row['cpu_percent_max']:.1f} | {row['mem_mib_max']:.0f} / {row['mem_limit_mib']} |"
|
||||
for row in stats["containers"]]
|
||||
return lines
|
||||
|
||||
|
||||
def impacts(failover, rolling):
|
||||
rows = ["| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |",
|
||||
"| --- | --- | --- | --- |"]
|
||||
if failover:
|
||||
for mode, title, expect in (
|
||||
("stop", "`docker stop` одной реплики (по очереди каждой)",
|
||||
"реплика сама уходит из балансировки до выхода; ошибок нет"),
|
||||
("kill", "`docker kill` одной реплики (по очереди каждой)",
|
||||
"несколько 502 у запросов, начатых на ней; клиент повторяет с тем же ключом")):
|
||||
runs = [r for r in failover["runs"] if r["mode"] == mode]
|
||||
if not runs:
|
||||
continue
|
||||
errors = sum(r["errors"] for r in runs)
|
||||
out = max(r["lb_excluded_after_seconds"] or 0 for r in runs)
|
||||
end = max(r["errors_stopped_after_seconds"] for r in runs)
|
||||
recovery = f"ошибки закончились не позже {end} с после отказа" if errors else "ошибок не было"
|
||||
rows.append(f"| {title} | {expect} | ошибок всего {errors} за {len(runs)} прогона; HAProxy вывел реплику "
|
||||
f"не позже {out} с; остановленная реплика после остановки не отвечала | {recovery}; "
|
||||
f"потерь и дублей 0 |")
|
||||
if rolling:
|
||||
rows.append(f"| Rolling update 2 реплик под нагрузкой | замена по одной без простоя | ошибок "
|
||||
f"{rolling['during']['errors']}, записей/с {rolling['during']['write_rps']} | "
|
||||
f"{rolling['update_seconds']} с на замену; потерь и дублей 0 |")
|
||||
persistence = EVIDENCE / "persistence.txt"
|
||||
if persistence.exists():
|
||||
found = re.search(r"test took ([\d.]+) s", persistence.read_text(encoding="utf-8"))
|
||||
if found:
|
||||
rows.append(f"| Перезапуск всего стенда (`make persistence`, hook restart) | данные и действующий токен "
|
||||
f"сохраняются | PASS: те же контейнеры с новым временем старта, прежний токен работает | "
|
||||
f"{found.group(1)} с на весь тест (hook + готовность); потерь нет |")
|
||||
# Отказы зависимостей (проверки lab2, теперь через балансировщик): строка — если тест прошёл.
|
||||
for name, title, expect, seen, recovery in (
|
||||
("failure-valkey.txt", "`docker compose stop valkey`", "API работает без кэша",
|
||||
"ready 200; вход, сообщения и logout работают через PostgreSQL",
|
||||
"кэш снова включается за 1–2 с после start; потерь нет"),
|
||||
("failure-postgres.txt", "`docker compose stop postgres`",
|
||||
"неготовые реплики исключены из маршрутизации, клиенту 503",
|
||||
"HAProxy вывел обе реплики (ready 503, live 200); запрос с действующим токеном из кэша -> 503 "
|
||||
"от балансировщика, до реплики не дошёл; запись не сохранилась",
|
||||
"после start прежний токен и данные на месте; запросы во время отказа не сохранены (503)"),
|
||||
("failure-valkey-pause.txt", "`docker compose pause valkey`, logout, `unpause`",
|
||||
"отозванный токен не оживает ни на одной реплике", "после unpause отозванный токен всегда 401",
|
||||
"поколение кэша сменилось после возвращения Valkey; отзыв не потерян")):
|
||||
path = EVIDENCE / name
|
||||
if path.exists() and "PASS" in path.read_text(encoding="utf-8"):
|
||||
rows.append(f"| {title} | {expect} | {seen} | {recovery} |")
|
||||
return rows if len(rows) > 2 else []
|
||||
|
||||
|
||||
def main():
|
||||
failover, rolling = load("failover-metrics.json"), load("rolling-update.json")
|
||||
load_result, stats = load("load.json"), load("load-stats.json")
|
||||
parts = []
|
||||
for block in (failover and failover_table(failover), rolling and rolling_lines(rolling),
|
||||
load_result and load_lines(load_result, stats), impacts(failover, rolling)):
|
||||
if block:
|
||||
parts += block + [""]
|
||||
check(parts, "no evidence/*.json yet: run make failover-metrics, rolling-update, load-profile first")
|
||||
text = REPORT.read_text(encoding="utf-8")
|
||||
check(BEGIN in text and END in text, "REPORT.md has no measurements markers")
|
||||
head, rest = text.split(BEGIN, 1)
|
||||
_, tail = rest.split(END, 1)
|
||||
REPORT.write_text(head + BEGIN + "\n" + "\n".join(parts).strip() + "\n" + END + tail, encoding="utf-8")
|
||||
print("\n".join(parts).strip())
|
||||
print("\nPASS: tables inserted into REPORT.md between the measurements markers")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,122 @@
|
||||
"""lab5, уровень 4: ограниченные повторы с backoff и jitter, постоянные и временные ошибки, DLQ и replay.
|
||||
|
||||
make retry-replay (= python student-tests/retry_replay.py)
|
||||
|
||||
A. Временная ошибка, потом успех: точка worker_transient=2 — две попытки подряд «падают», как при
|
||||
недоступном S3. Каждая назначает следующую с паузой backoff + jitter (случайно в [d/2, d],
|
||||
d = 2, 4, 8… с). Третья попытка успешна -> ready. Паузы берутся из outbox (available_at).
|
||||
B. Попытки исчерпаны: worker_transient=99 -> 5 попыток (JOB_MAX_ATTEMPTS) -> failed с
|
||||
error_code=retry_exhausted; сообщение уходит в DLQ (attachments.dead), задание — в реестр failed
|
||||
(python -m messenger.jobs failed); /content -> 409, прикрепить к сообщению -> 409.
|
||||
C. Постоянная ошибка: JPEG с испорченными сжатыми данными -> invalid_image сразу, без повторов (попытка 1).
|
||||
D. Replay оператора (python -m messenger.jobs replay): failed из B -> queued -> ready (новая попытка,
|
||||
запись в журнале с автором). Replay готового вложения — no-op: дубль успешной работы не запускается.
|
||||
Replay постоянной ошибки из C снова даёт invalid_image: replay не обходит проверку файла.
|
||||
"""
|
||||
import time
|
||||
from datetime import datetime
|
||||
|
||||
import ops
|
||||
from filegen import garbage_scan_jpeg, upload_when_ready, wait_status
|
||||
from helpers import Client, check, idempotency, run
|
||||
|
||||
|
||||
def parse(value):
|
||||
return datetime.fromisoformat(value)
|
||||
|
||||
|
||||
def delays(job):
|
||||
"""Пауза перед каждой следующей попыткой: available_at - created_at строки outbox этой попытки."""
|
||||
created = {e["attempt"]: e["at"] for e in job["events"] if e["event"] == "retry_scheduled"}
|
||||
rows = {o["attempt"]: o for o in job["outbox"]}
|
||||
out = []
|
||||
for attempt in sorted(created):
|
||||
row = rows.get(attempt + 1)
|
||||
if row:
|
||||
out.append((attempt + 1, (parse(row["available_at"]) - parse(created[attempt])).total_seconds()))
|
||||
return out
|
||||
|
||||
|
||||
def main():
|
||||
api = Client(timeout=15)
|
||||
worker = ops.wait_healthy("worker", 1)[0]
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
try:
|
||||
# ---------- A ----------
|
||||
ops.arm("worker", "worker_transient", "2", container=worker)
|
||||
att_a = upload_when_ready(api, alice, chat, name="retry-a.png")["json"]
|
||||
wait_status(api, bob, att_a["id"], seconds=90)
|
||||
job = ops.job(att_a["id"])
|
||||
check(job["job"]["attempt"] == 3, "expected success at attempt 3")
|
||||
pauses = delays(job)
|
||||
for attempt, pause in pauses:
|
||||
limit = min(60, 2 * 2 ** (attempt - 2))
|
||||
check(limit / 2 - 0.05 <= pause <= limit + 0.05, f"pause {pause:.2f} s before attempt {attempt} "
|
||||
f"is outside [{limit / 2}, {limit}]")
|
||||
print(f"A. transient errors twice, then success: ready at attempt {job['job']['attempt']}")
|
||||
print(" pauses before attempts: " + ", ".join(f"#{a}: {p:.2f} s" for a, p in pauses) +
|
||||
" (backoff 2^n with random jitter in [d/2, d])")
|
||||
print(" events: " + " -> ".join(f"{e['event']}({e['attempt']})" for e in job["events"]))
|
||||
|
||||
# ---------- B ----------
|
||||
dead_before = ops.queues().get("attachments.dead", (0, 0))[0]
|
||||
ops.arm("worker", "worker_transient", "99", container=worker)
|
||||
att_b = upload_when_ready(api, alice, chat, name="retry-b.png")["json"]
|
||||
failed = wait_status(api, bob, att_b["id"], ("failed",), seconds=180)
|
||||
ops.disarm("worker", "worker_transient")
|
||||
job = ops.job(att_b["id"])
|
||||
check(failed["error_code"] == "retry_exhausted" and job["job"]["attempt"] == 5, "expected 5 attempts")
|
||||
api.call("GET", f"/api/v1/attachments/{att_b['id']}/content", 409, actor=bob)
|
||||
api.call("POST", f"/api/v1/chats/{chat['id']}/messages", 409, actor=alice, headers=idempotency(),
|
||||
body={"text": "", "attachment_ids": [att_b["id"]]})
|
||||
deadline = time.monotonic() + 30
|
||||
while ops.queues().get("attachments.dead", (0, 0))[0] <= dead_before:
|
||||
check(time.monotonic() < deadline, "the final failure did not reach the DLQ")
|
||||
time.sleep(1)
|
||||
registry = ops.cli("api", "messenger.jobs", "failed")
|
||||
check(isinstance(registry, list) and any(r["attachment_id"] == att_b["id"] for r in registry),
|
||||
"the failed job is missing from the registry")
|
||||
entry = [r for r in registry if r["attachment_id"] == att_b["id"]][0]
|
||||
print(f"B. transient error every time: {job['job']['attempt']} attempts -> failed, "
|
||||
f"error_code={failed['error_code']} (last error {entry['last_error_code']})")
|
||||
print(" pauses: " + ", ".join(f"#{a}: {p:.2f} s" for a, p in delays(job)))
|
||||
print(f" DLQ attachments.dead: {dead_before} -> {ops.queues()['attachments.dead'][0]}; "
|
||||
f"registry: python -m messenger.jobs failed lists it; content -> 409, attach -> 409")
|
||||
|
||||
# ---------- C ----------
|
||||
att_c = upload_when_ready(api, alice, chat, data=garbage_scan_jpeg(), name="broken.jpg",
|
||||
ctype="image/jpeg")["json"]
|
||||
failed_c = wait_status(api, bob, att_c["id"], ("failed",), seconds=60)
|
||||
job_c = ops.job(att_c["id"])
|
||||
check(failed_c["error_code"] == "invalid_image" and job_c["job"]["attempt"] == 1, "no retries for a bad file")
|
||||
print(f"C. permanent error: broken JPEG scan -> failed at attempt 1, error_code={failed_c['error_code']} "
|
||||
f"(no retries)")
|
||||
finally:
|
||||
ops.disarm("worker", "worker_transient")
|
||||
|
||||
# ---------- D ----------
|
||||
result = ops.replay(att_b["id"])
|
||||
check(result.get("result") == "queued", f"replay of a failed job must queue it: {result}")
|
||||
ready = wait_status(api, bob, att_b["id"], seconds=90)
|
||||
job = ops.job(att_b["id"])
|
||||
audit = [e for e in job["events"] if e["event"] == "replay_requested"]
|
||||
check(audit and audit[-1]["actor"].startswith("operator:"), "replay must be audited")
|
||||
print(f"D. replay of the failed job: {result} -> ready at attempt {job['job']['attempt']}; "
|
||||
f"audit: {audit[-1]['actor']}: {audit[-1]['detail']}")
|
||||
outbox_rows, variants = len(job["outbox"]), job["variants"]
|
||||
noop = ops.replay(att_b["id"])
|
||||
after = ops.job(att_b["id"])
|
||||
check(noop == {"result": "noop", "reason": "ready"}, f"replay of a ready job must be a no-op: {noop}")
|
||||
check(len(after["outbox"]) == outbox_rows and after["variants"] == variants, "replay of ready changed something")
|
||||
print(f" replay of the now ready job: {noop} — no new message, variants unchanged "
|
||||
f"({len(variants)} rows), status {ready['status']}")
|
||||
again = ops.replay(att_c["id"])
|
||||
failed_again = wait_status(api, bob, att_c["id"], ("failed",), seconds=60)
|
||||
check(again.get("result") == "queued" and failed_again["error_code"] == "invalid_image", "bad file must fail again")
|
||||
print(f" replay of the permanent failure: {again} -> failed again with {failed_again['error_code']}")
|
||||
print("PASS: bounded retries with backoff and jitter; permanent errors fail at once; final failures go to the "
|
||||
"DLQ and the failed registry; replay re-runs only failed jobs and is audited")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,108 @@
|
||||
"""lab3, уровень 4: rolling update под нагрузкой — реплики по одной заменяются новой версией.
|
||||
|
||||
make rolling-update (= python student-tests/rolling_update.py)
|
||||
|
||||
1. Собирается новый образ с APP_VERSION=rolling-<время> (docker compose build api migrate).
|
||||
2. Миграции новой версии применяются ОДИН раз отдельным запуском: docker compose run --rm migrate.
|
||||
Миграции только добавляют (как 004: новые столбцы, которые могут быть NULL), поэтому старые
|
||||
реплики продолжают работать с новой схемой, пока их не заменят.
|
||||
3. Для каждой старой реплики: запустить ещё одну, новую (docker compose up --scale api=N+1
|
||||
--no-recreate), дождаться healthy и UP в HAProxy, затем остановить старую (docker stop:
|
||||
сначала readiness 503 и выход из балансировки) и удалить её. Реплик всё время не меньше N.
|
||||
4. Всё это время идёт нагрузка (loadgen.py): ошибки, RPS, задержки; в конце — проверка,
|
||||
что подтверждённые сообщения на месте и дублей нет.
|
||||
Итог: таблица в консоли и evidence/rolling-update.json. После скрипта стенд работает на новой
|
||||
версии. Обычный `docker compose up -d --build` потом вернёт версию dev, пересоздав реплики разом
|
||||
(это уже не rolling update).
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
|
||||
from helpers import ROOT, check, run
|
||||
from loadgen import CLIENT_TIMEOUT_SECONDS, WRITERS, Load, summary
|
||||
from stand import api_containers, compose_output, compose_quiet, docker, health, lb_summary, lb_up_count, wait_balanced
|
||||
|
||||
OUTPUT = ROOT / "evidence" / "rolling-update.json"
|
||||
|
||||
|
||||
def version_of(container):
|
||||
lines = docker("inspect", "-f", "{{range .Config.Env}}{{println .}}{{end}}", container).splitlines()
|
||||
env = dict(line.split("=", 1) for line in lines if "=" in line)
|
||||
return env.get("APP_VERSION")
|
||||
|
||||
|
||||
def wait_new_replica(container, up_needed, seconds=90):
|
||||
deadline = time.monotonic() + seconds
|
||||
while health(container) != "healthy" or lb_up_count() < up_needed:
|
||||
check(time.monotonic() < deadline, f"new replica {container[:12]} is not in the balancer after {seconds} s")
|
||||
time.sleep(0.2)
|
||||
|
||||
|
||||
def main():
|
||||
old = api_containers()
|
||||
replicas = len(old)
|
||||
check(replicas >= 2, "need at least 2 running api replicas")
|
||||
wait_balanced(replicas)
|
||||
old_version = version_of(old[0])
|
||||
version = time.strftime("rolling-%Y%m%d-%H%M%S")
|
||||
env = dict(os.environ, APP_VERSION=version)
|
||||
|
||||
print(f"old replicas {[c[:12] for c in old]}, version {old_version}; building version {version}")
|
||||
started = time.monotonic()
|
||||
compose_quiet("build", "api", "migrate", env=env)
|
||||
print(f"image built in {time.monotonic() - started:.1f} s")
|
||||
migrate_log = compose_output("run", "--rm", "--no-deps", "-T", "migrate", env=env)
|
||||
lines = [line for line in migrate_log.splitlines() if "Миграции" in line]
|
||||
print("migrations (one run, before replacing replicas): " + (lines[-1].split("messenger.db: ")[-1] if lines else "?"))
|
||||
|
||||
load = Load()
|
||||
load.start()
|
||||
time.sleep(3)
|
||||
t0 = time.monotonic()
|
||||
steps = []
|
||||
for container in old:
|
||||
step_start = time.monotonic()
|
||||
before = set(api_containers())
|
||||
compose_quiet("up", "-d", "--no-deps", "--no-recreate", "--scale", f"api={len(before) + 1}", "api", env=env)
|
||||
new = sorted(set(api_containers()) - before)
|
||||
check(len(new) == 1, f"expected one new container, got {len(new)}")
|
||||
wait_new_replica(new[0], replicas + 1)
|
||||
ready = time.monotonic() - step_start
|
||||
docker("stop", "--time", "15", container)
|
||||
docker("rm", container)
|
||||
steps.append({"old": container[:12], "new": new[0][:12], "new_ready_seconds": round(ready, 2),
|
||||
"step_seconds": round(time.monotonic() - step_start, 2)})
|
||||
print(f"replaced {container[:12]} -> {new[0][:12]}: new replica healthy and UP in HAProxy after "
|
||||
f"{ready:.1f} s, then the old one drained and stopped; step {steps[-1]['step_seconds']} s "
|
||||
f"(HAProxy: {lb_summary()})")
|
||||
t1 = time.monotonic()
|
||||
time.sleep(3)
|
||||
load.stop()
|
||||
|
||||
final = api_containers()
|
||||
versions = sorted({version_of(c) for c in final})
|
||||
integrity = load.verify()
|
||||
during = summary(load, t0, t1)
|
||||
before_stats = summary(load, t0 - 3, t0)
|
||||
print(f"now: replicas {[c[:12] for c in final]}, versions {versions}")
|
||||
print(f"under load: write RPS before {before_stats['write_rps']}, during the update {during['write_rps']}; "
|
||||
f"errors {during['errors']} {during['error_codes']}; p95 {during['write_p95_ms']} ms, "
|
||||
f"max {during['write_max_ms']} ms; update took {t1 - t0:.1f} s")
|
||||
print(f"confirmed {integrity['confirmed_writes']}, in history {integrity['messages_in_history']}, "
|
||||
f"lost 0, duplicates 0")
|
||||
check(len(final) == replicas and not set(final) & set(old), "old replicas are still running")
|
||||
check(versions == [version], "not every replica runs the new version")
|
||||
OUTPUT.parent.mkdir(exist_ok=True)
|
||||
OUTPUT.write_text(json.dumps({
|
||||
"from_version": old_version, "to_version": version, "replicas": replicas,
|
||||
"profile": {"writers": WRITERS, "readers": 1, "client_timeout_seconds": CLIENT_TIMEOUT_SECONDS},
|
||||
"steps": steps, "update_seconds": round(t1 - t0, 2),
|
||||
"before": before_stats, "during": during, "integrity": integrity,
|
||||
}, indent=2) + "\n", encoding="utf-8")
|
||||
print(f"PASS: all {replicas} replicas replaced one by one under load, "
|
||||
f"{during['errors']} errors, no lost or duplicated messages; saved {OUTPUT.relative_to(ROOT).as_posix()}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,69 @@
|
||||
"""Публичный тест отказа (tests/resilience.py --mode failover) для КАЖДОЙ реплики по очереди.
|
||||
|
||||
make failover (= python student-tests/run_failover.py)
|
||||
|
||||
Публичный тест сам выбирает реплику — ту, что ответила на его первое сообщение, — и вызывает
|
||||
hook scripts/stop-one.cmd (Windows) или scripts/stop-one.sh, который останавливает именно её.
|
||||
Этот скрипт печатает контейнеры до и после теста (видно, какой контейнер реально остановлен
|
||||
и что postgres, valkey и lb не тронуты), запускает реплику обратно (docker start), ждёт,
|
||||
пока HAProxy вернёт её в балансировку, и повторяет тест, пока каждая реплика не будет
|
||||
остановлена хотя бы раз (не больше 6 прогонов).
|
||||
|
||||
Как попасть в нужную реплику: при 2 репликах HAProxy отвечает строго по очереди, а до первого
|
||||
сообщения тест делает 9 запросов. Значит, его сообщение (10-й запрос) уйдёт на ту же реплику,
|
||||
что ответила на наш последний запрос. Поэтому перед прогоном один-два запроса /health/live
|
||||
«сдвигают» очередь так, чтобы последней ответила ещё не проверенная реплика.
|
||||
"""
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
from helpers import ROOT, Client, check, run
|
||||
from stand import BASE_URL, api_containers, docker, lb_summary, ps_table, wait_balanced
|
||||
|
||||
HOOK = ROOT / "scripts" / ("stop-one.cmd" if os.name == "nt" else "stop-one.sh")
|
||||
|
||||
|
||||
def aim(api, wanted):
|
||||
"""Для 2 реплик: последним перед тестом должна ответить реплика из wanted."""
|
||||
probe = api.call("GET", "/health/live", schema="Health")["headers"]["X-Instance-Id"]
|
||||
if not any(container.startswith(probe) for container in wanted):
|
||||
api.call("GET", "/health/live", schema="Health") # теперь последней ответила другая реплика
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
containers = api_containers()
|
||||
check(len(containers) >= 2, "need at least 2 running api replicas")
|
||||
print(f"hook: {HOOK.relative_to(ROOT).as_posix()}; api replicas: {[c[:12] for c in containers]}")
|
||||
stopped_once = set()
|
||||
for attempt in range(1, 7):
|
||||
wait_balanced(len(containers))
|
||||
if len(containers) == 2:
|
||||
aim(api, set(containers) - stopped_once)
|
||||
print(f"\n=== run {attempt}: containers before (HAProxy: {lb_summary()})")
|
||||
print(ps_table())
|
||||
env = dict(os.environ, PYTHONUTF8="1", PYTHONIOENCODING="utf-8")
|
||||
result = subprocess.run([sys.executable, "tests/resilience.py", "--mode", "failover",
|
||||
"--action-script", str(HOOK), "--base-url", BASE_URL],
|
||||
cwd=ROOT, capture_output=True, env=env)
|
||||
print((result.stdout + result.stderr).decode("utf-8", "replace").strip())
|
||||
check(result.returncode == 0, "public failover test failed")
|
||||
print(f"containers after (HAProxy: {lb_summary()})")
|
||||
print(ps_table())
|
||||
stopped = [container for container in containers if container not in api_containers()]
|
||||
check(len(stopped) == 1, f"expected exactly one stopped api container, got {len(stopped)}")
|
||||
print(f"the hook stopped {stopped[0][:12]} (X-Instance-Id of that replica = container ID); "
|
||||
f"other api containers, postgres, valkey, s3 and lb kept running")
|
||||
stopped_once.add(stopped[0])
|
||||
docker("start", stopped[0])
|
||||
wait_balanced(len(containers))
|
||||
print(f"restored: docker start {stopped[0][:12]} -> healthy and back in HAProxy ({lb_summary()})")
|
||||
if stopped_once == set(containers):
|
||||
break
|
||||
check(stopped_once == set(containers), "not every replica was stopped by the public test")
|
||||
print(f"\nPASS: public failover test passed {attempt} times; every api replica was stopped once and restored")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,60 @@
|
||||
"""Публичный тест сохранности (tests/resilience.py --mode persistence) и доказательство,
|
||||
что hook scripts/restart.cmd (Windows) или scripts/restart.sh действительно перезапустил процессы.
|
||||
|
||||
make persistence (= python student-tests/run_persistence.py)
|
||||
|
||||
До и после теста печатаются все контейнеры стенда с временем старта (StartedAt). После теста
|
||||
у postgres, valkey, s3, broker (с lab5), worker, обеих реплик api и lb должен быть ТОТ ЖЕ ID контейнера
|
||||
(контейнеры и volumes те же, ничего не пересоздано) и НОВОЕ время старта (процесс перезапущен).
|
||||
Сам тест проверяет, что данные, прежний токен и файл (с lab5 — после ready) на месте. Сервис migrate при `docker compose start api` запускается
|
||||
снова как зависимость: он видит, что новых миграций нет, и сразу завершается.
|
||||
"""
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
|
||||
from helpers import ROOT, check, run
|
||||
from stand import BASE_URL, compose_output, inspect, ps_table
|
||||
|
||||
HOOK = ROOT / "scripts" / ("restart.cmd" if os.name == "nt" else "restart.sh")
|
||||
MUST_RESTART = ("api", "worker", "postgres", "valkey", "s3", "broker", "lb")
|
||||
|
||||
|
||||
def started_at():
|
||||
"""{ID контейнера: (сервис, время старта)} для работающих сервисов стенда."""
|
||||
result = {}
|
||||
for container in compose_output("ps", "-q").split():
|
||||
service = inspect(container, '{{index .Config.Labels "com.docker.compose.service"}}')
|
||||
result[container] = (service, inspect(container, "{{.State.StartedAt}}"))
|
||||
return result
|
||||
|
||||
|
||||
def main():
|
||||
print(f"hook: {HOOK.relative_to(ROOT).as_posix()}")
|
||||
print("=== containers before")
|
||||
print(ps_table())
|
||||
before = started_at()
|
||||
env = dict(os.environ, PYTHONUTF8="1", PYTHONIOENCODING="utf-8")
|
||||
t0 = time.monotonic()
|
||||
result = subprocess.run([sys.executable, "tests/resilience.py", "--mode", "persistence",
|
||||
"--action-script", str(HOOK), "--base-url", BASE_URL],
|
||||
cwd=ROOT, capture_output=True, env=env)
|
||||
took = time.monotonic() - t0
|
||||
print((result.stdout + result.stderr).decode("utf-8", "replace").strip())
|
||||
check(result.returncode == 0, "public persistence test failed")
|
||||
print(f"=== containers after (test took {took:.1f} s: hook + waiting for readiness + data checks)")
|
||||
print(ps_table())
|
||||
after = started_at()
|
||||
for container, (service, start) in sorted(before.items(), key=lambda item: item[1]):
|
||||
if service not in MUST_RESTART:
|
||||
continue
|
||||
check(container in after, f"{service} {container[:12]} was recreated or is not running")
|
||||
check(after[container][1] != start, f"{service} {container[:12]} was not restarted")
|
||||
print(f"{service:<9} {container[:12]}: same container, start time {start[11:19]} -> {after[container][1][11:19]}")
|
||||
print("PASS: api replicas, worker, postgres, valkey, s3, broker and lb were restarted (same containers and "
|
||||
"volumes, new start time); data, the attachment bytes and the existing token survived")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,160 @@
|
||||
"""lab4–lab5, уровень 4: S3 приватный, у API минимальные права, консоль закрыта, bootstrap идемпотентен.
|
||||
|
||||
make s3-checks (= python student-tests/s3_checks.py)
|
||||
|
||||
Все проверки идут ВНЕ API (напрямую в S3, в PostgreSQL и в файловую систему контейнеров):
|
||||
1. анонимный GET объекта, список объектов bucket и список bucket'ов -> 403 (bucket приватный);
|
||||
2. с ключами API объект читается (байты действительно в S3), но создать bucket, сделать bucket
|
||||
публичным, удалить bucket или получить список всех bucket'ов нельзя -> AccessDenied;
|
||||
3. веб-интерфейсы SeaweedFS (master :9333, filer :8888, volume :8080) не слушают в сети,
|
||||
порт S3 не опубликован на хосте;
|
||||
4. в таблице attachments нет столбца с байтами (bytea), а на дисках реплик API и worker нет файла
|
||||
оригинала (у worker есть только временная копия на время обработки, она удаляется);
|
||||
5. s3-init запускается ещё два раза: оба раза код 0, объекты на месте, файл скачивается;
|
||||
6. (lab5) сообщение для брокера (строка outbox) содержит только поля contracts/jobs.schema.json:
|
||||
ID и служебные данные, без байтов, ключей S3, URL и паролей.
|
||||
"""
|
||||
import hashlib
|
||||
import json
|
||||
import socket
|
||||
import subprocess
|
||||
import uuid
|
||||
|
||||
from filegen import SAMPLE_PNG, cleanup_cli, exec_python, in_api, psql, upload_when_ready, wait_status
|
||||
from helpers import ROOT, Client, check, run
|
||||
from stand import api_containers, compose_output
|
||||
|
||||
DIRECT = """
|
||||
import hashlib, json, socket, urllib.error, urllib.request
|
||||
from botocore.exceptions import ClientError
|
||||
from messenger import config, objects
|
||||
base, bucket, key = config.S3_ENDPOINT, config.S3_BUCKET, "{key}"
|
||||
def anonymous(url):
|
||||
try:
|
||||
return urllib.request.urlopen(url, timeout=5).status
|
||||
except urllib.error.HTTPError as error:
|
||||
return error.code
|
||||
out = {{"anonymous_get_object": anonymous(f"{{base}}/{{bucket}}/{{key}}"),
|
||||
"anonymous_list_bucket": anonymous(f"{{base}}/{{bucket}}?list-type=2"),
|
||||
"anonymous_list_buckets": anonymous(f"{{base}}/")}}
|
||||
s3 = objects.client()
|
||||
out["api_key_get_object_sha256"] = hashlib.sha256(s3.get_object(Bucket=bucket, Key=key)["Body"].read()).hexdigest()
|
||||
public = json.dumps({{"Version": "2012-10-17", "Statement": [{{"Effect": "Allow", "Principal": {{"AWS": ["*"]}},
|
||||
"Action": ["s3:GetObject"], "Resource": [f"arn:aws:s3:::{{bucket}}/*"]}}]}})
|
||||
try:
|
||||
out["api_key_list_buckets"] = sorted(b["Name"] for b in s3.list_buckets().get("Buckets", []))
|
||||
except ClientError as exc:
|
||||
out["api_key_list_buckets"] = exc.response["Error"]["Code"]
|
||||
for name, call in (("create_bucket", lambda: s3.create_bucket(Bucket="lab4-forbidden-bucket")),
|
||||
("make_bucket_public", lambda: s3.put_bucket_policy(Bucket=bucket, Policy=public)),
|
||||
("delete_bucket", lambda: s3.delete_bucket(Bucket=bucket))):
|
||||
try:
|
||||
call()
|
||||
out["api_key_" + name] = "ALLOWED"
|
||||
except ClientError as exc:
|
||||
out["api_key_" + name] = exc.response["Error"]["Code"]
|
||||
for port in (9333, 8888, 8080):
|
||||
try:
|
||||
socket.create_connection(("s3", port), timeout=2).close()
|
||||
out[f"admin_port_{{port}}"] = "open"
|
||||
except OSError:
|
||||
out[f"admin_port_{{port}}"] = "closed"
|
||||
out["bucket"] = bucket
|
||||
print(json.dumps(out))
|
||||
"""
|
||||
|
||||
FIND_LOCAL_COPY = """
|
||||
import hashlib, os
|
||||
size, wanted, found = {size}, "{sha}", []
|
||||
for root, dirs, files in os.walk("/"):
|
||||
dirs[:] = [d for d in dirs if os.path.join(root, d) not in ("/proc", "/sys", "/dev")]
|
||||
for name in files:
|
||||
path = os.path.join(root, name)
|
||||
try:
|
||||
if os.path.isfile(path) and os.path.getsize(path) == size:
|
||||
with open(path, "rb") as f:
|
||||
if hashlib.sha256(f.read()).hexdigest() == wanted:
|
||||
found.append(path)
|
||||
except OSError:
|
||||
pass
|
||||
print(len(found))
|
||||
"""
|
||||
|
||||
|
||||
def host_port_closed(port):
|
||||
try:
|
||||
socket.create_connection(("127.0.0.1", port), timeout=1).close()
|
||||
return False
|
||||
except OSError:
|
||||
return True
|
||||
|
||||
|
||||
def main():
|
||||
api = Client()
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
att = upload_when_ready(api, alice, chat, name="private.png")["json"]
|
||||
wait_status(api, bob, att["id"])
|
||||
key = psql(f"SELECT storage_key FROM attachments WHERE id = '{uuid.UUID(att['id'])}'")
|
||||
check(key == f"originals/{att['id']}" and "private" not in key, "object key must be server-generated")
|
||||
print("object keys are server-generated: staging/<attachment uuid> -> originals/<attachment uuid>, "
|
||||
"variants/<attachment uuid>/v1/<variant> (filename is not used in keys)")
|
||||
|
||||
out = json.loads(in_api(DIRECT.format(key=key)))
|
||||
for name in ("anonymous_get_object", "anonymous_list_bucket", "anonymous_list_buckets"):
|
||||
print(f"{name}: HTTP {out[name]}")
|
||||
check(out[name] == 403, f"{name} must be 403")
|
||||
check(out["api_key_get_object_sha256"] == att["sha256"], "object in S3 differs from the upload")
|
||||
print("API key GetObject: same SHA-256 as uploaded (the bytes are in the bucket)")
|
||||
# SeaweedFS на ListBuckets показывает только bucket'ы, на которые у пользователя есть право List,
|
||||
# к которым у пользователя есть доступ: чужих bucket'ов API в любом случае не видит.
|
||||
listed = out["api_key_list_buckets"]
|
||||
print(f"API key list_buckets: {listed}")
|
||||
check(listed == "AccessDenied" or set(listed) <= {"messenger-attachments", out["bucket"]},
|
||||
"API key sees other buckets")
|
||||
for name in ("create_bucket", "make_bucket_public", "delete_bucket"):
|
||||
print(f"API key {name}: {out['api_key_' + name]}")
|
||||
check(out["api_key_" + name] != "ALLOWED", f"API key must not be allowed to {name}")
|
||||
for port in (9333, 8888, 8080):
|
||||
print(f"SeaweedFS admin/UI port {port} inside the network: {out[f'admin_port_{port}']}")
|
||||
check(out[f"admin_port_{port}"] == "closed", f"SeaweedFS port {port} must not be reachable")
|
||||
check(host_port_closed(9000) and host_port_closed(9333) and host_port_closed(8888),
|
||||
"S3 ports must not be published on the host")
|
||||
print("host 127.0.0.1:9000, :9333, :8888: closed (S3 is not published)")
|
||||
|
||||
columns = psql("SELECT string_agg(column_name || ':' || data_type, ', ' ORDER BY ordinal_position) "
|
||||
"FROM information_schema.columns WHERE table_name = 'attachments'")
|
||||
print(f"attachments columns: {columns}")
|
||||
check("bytea" not in columns, "attachment bytes must not be stored in PostgreSQL")
|
||||
workers = sorted(compose_output("ps", "-q", "worker").split())
|
||||
for role, container in [("api", c) for c in api_containers()] + [("worker", c) for c in workers]:
|
||||
code = FIND_LOCAL_COPY.format(size=len(SAMPLE_PNG), sha=att["sha256"])
|
||||
found = exec_python(container, code)
|
||||
print(f"{role} {container[:12]}: files with the same SHA-256 on disk: {found}")
|
||||
check(found == "0", f"{role} keeps a local copy of the original")
|
||||
|
||||
payload = json.loads(psql(f"""SELECT o.payload::text FROM outbox o JOIN attachment_jobs j ON j.job_id = o.job_id
|
||||
WHERE j.attachment_id = '{uuid.UUID(att['id'])}' ORDER BY o.id LIMIT 1"""))
|
||||
allowed = {"schema_version", "job_id", "type", "attachment_id", "pipeline_version", "attempt", "created_at",
|
||||
"traceparent", "tracestate"}
|
||||
text = json.dumps(payload)
|
||||
check(set(payload) <= allowed, f"unexpected fields in the broker message: {set(payload) - allowed}")
|
||||
check(not any(word in text for word in ("staging/", "originals/", "http", "secret", "password")),
|
||||
"the broker message must not contain keys, URLs or credentials")
|
||||
print(f"broker message ({len(text)} bytes): {sorted(payload)} — only IDs and service fields")
|
||||
|
||||
before = cleanup_cli("--dry-run")["objects_in_bucket"]
|
||||
for attempt in (1, 2):
|
||||
result = subprocess.run(["docker", "compose", "run", "--rm", "s3-init"], cwd=ROOT, capture_output=True)
|
||||
last = (result.stdout.decode("utf-8", "replace").strip().splitlines() or [""])[-1]
|
||||
print(f"s3-init run {attempt}: exit {result.returncode}: {last}")
|
||||
check(result.returncode == 0, "s3-init is not idempotent")
|
||||
after = cleanup_cli("--dry-run")["objects_in_bucket"]
|
||||
got = api.call("GET", f"/api/v1/attachments/{att['id']}/content", actor=bob)["bytes"]
|
||||
check(before == after and hashlib.sha256(got).hexdigest() == att["sha256"], "bootstrap changed the data")
|
||||
print(f"objects in bucket before/after bootstrap: {before}/{after}; the file still downloads")
|
||||
print("PASS: bucket is private outside the API, the API S3 user has least privilege, the console is "
|
||||
"closed, bytes are only in S3, bucket bootstrap is idempotent")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,112 @@
|
||||
"""lab5, уровень 4: очистка staging после безопасной фиксации и уборка объектов без ссылок из БД.
|
||||
|
||||
make staging-cleanup (= python student-tests/staging_cleanup.py)
|
||||
|
||||
1. Обычный путь: после COMMIT результата worker сам удаляет staging/<id>; остаются originals/<id>
|
||||
и три варианта.
|
||||
2. Состояния, которые оставляют сбои (создаются напрямую в S3 и через API):
|
||||
- staging готового вложения (worker упал между COMMIT и удалением staging);
|
||||
- staging без строки в БД (API упал между PUT в staging и COMMIT);
|
||||
- вариант без строки в БД (worker записал объекты, а задание потом ушло в failed);
|
||||
- staging failed-вложения (битый JPEG) — хранится STAGING_RETENTION_SECONDS для replay;
|
||||
- staging задания в очереди (worker остановлен) — нужен, его трогать нельзя.
|
||||
3. python -m messenger.cleanup:
|
||||
--dry-run все найдены, ничего не удалено;
|
||||
обычный запуск (grace 900 с) ничего не удалено: объекты моложе grace (это может быть
|
||||
идущая прямо сейчас работа);
|
||||
--grace-seconds 2 (только тест) удалены «сироты» и staging готового; staging задания в очереди,
|
||||
staging failed (в пределах retention), оригиналы и варианты на месте;
|
||||
--retention-seconds 0 удалён staging failed; replay такого вложения отказывается
|
||||
(source_missing) вместо падения worker;
|
||||
повторный запуск удалять нечего.
|
||||
4. worker запущен: задание из очереди стало ready, его staging удалён.
|
||||
"""
|
||||
import json
|
||||
import time
|
||||
import uuid
|
||||
|
||||
import ops
|
||||
from filegen import garbage_scan_jpeg, upload_when_ready, wait_status
|
||||
from helpers import Client, check, run
|
||||
|
||||
PUT = """
|
||||
import io
|
||||
from messenger import objects
|
||||
for key in %s:
|
||||
objects.put(key, io.BytesIO(b"left-behind"), 11, "image/png", "0" * 64)
|
||||
print("ok")
|
||||
"""
|
||||
|
||||
|
||||
def exists(keys):
|
||||
present = set(ops.objects("staging/")) | set(ops.objects("originals/")) | set(ops.objects("variants/"))
|
||||
return {name: key in present for name, key in keys.items()}
|
||||
|
||||
|
||||
def cleanup(*args):
|
||||
return ops.cli("api", "messenger.cleanup", *args)
|
||||
|
||||
|
||||
def main():
|
||||
api = Client(timeout=15)
|
||||
ops.wait_healthy("worker", 1)
|
||||
alice, bob, _eve, chat = api.bootstrap()
|
||||
|
||||
ready = upload_when_ready(api, alice, chat, name="keep.png")["json"]
|
||||
wait_status(api, bob, ready["id"])
|
||||
rid = ready["id"]
|
||||
state = exists({"staging": f"staging/{rid}", "original": f"originals/{rid}",
|
||||
"thumbnail": f"variants/{rid}/v1/thumbnail.jpg"})
|
||||
check(state == {"staging": False, "original": True, "thumbnail": True}, f"unexpected objects: {state}")
|
||||
print(f"1. ready {rid}: staging removed by the worker right after COMMIT; original and variants kept")
|
||||
|
||||
failed = upload_when_ready(api, alice, chat, data=garbage_scan_jpeg(), name="bad.jpg", ctype="image/jpeg")["json"]
|
||||
wait_status(api, bob, failed["id"], ("failed",))
|
||||
try:
|
||||
ops.stop("worker")
|
||||
queued = upload_when_ready(api, alice, chat, name="queued.png")["json"]
|
||||
keys = {"ready_original": f"originals/{rid}", "ready_variant": f"variants/{rid}/v1/crop.jpg",
|
||||
"ready_staging_leftover": f"staging/{rid}", "orphan_staging": f"staging/{uuid.uuid4()}",
|
||||
"orphan_variant": f"variants/{uuid.uuid4()}/v1/thumbnail.jpg",
|
||||
"failed_staging": f"staging/{failed['id']}", "queued_staging": f"staging/{queued['id']}"}
|
||||
ops.python("api", PUT % json.dumps([keys["ready_staging_leftover"], keys["orphan_staging"],
|
||||
keys["orphan_variant"]]))
|
||||
check(all(exists(keys).values()), "setup failed")
|
||||
print("2. prepared: staging leftover of a ready attachment, orphan staging, orphan variant, "
|
||||
"staging of a failed attachment, staging of a queued job (worker stopped)")
|
||||
|
||||
dry = cleanup("--dry-run", "--grace-seconds", "0")
|
||||
check(dry["deleted"] == 0 and all(exists(keys).values()), "dry-run deleted something")
|
||||
print(f"3. dry-run: {json.dumps(dry['to_delete'])} found, deleted {dry['deleted']}")
|
||||
normal = cleanup()
|
||||
check(all(exists(keys).values()), "grace 900 s must protect young objects")
|
||||
print(f" grace 900 s: deleted {normal['deleted']} — everything is younger than the grace period")
|
||||
time.sleep(3)
|
||||
short = cleanup("--grace-seconds", "2")
|
||||
state = exists(keys)
|
||||
check(not state["ready_staging_leftover"] and not state["orphan_staging"] and not state["orphan_variant"],
|
||||
f"leftovers must be deleted: {state}")
|
||||
check(state["ready_original"] and state["ready_variant"] and state["failed_staging"] and state["queued_staging"],
|
||||
f"needed objects were deleted: {state}")
|
||||
print(f" grace 2 s: {json.dumps(short['to_delete'])}, deleted {short['deleted']}; kept: ready original "
|
||||
f"and variants, staging of the queued job, staging of the failed attachment (retention)")
|
||||
expired = cleanup("--grace-seconds", "2", "--retention-seconds", "0")
|
||||
check(not exists(keys)["failed_staging"], "failed staging past retention must be deleted")
|
||||
refused = ops.replay(failed["id"])
|
||||
check(refused.get("result") == "refused" and refused.get("reason") == "source_missing", f"{refused}")
|
||||
print(f" retention 0 s: failed staging deleted ({json.dumps(expired['to_delete'])}); replay now: {refused}")
|
||||
again = cleanup("--grace-seconds", "2", "--retention-seconds", "0")
|
||||
check(again["deleted"] == 0, "repeated run is not a no-op")
|
||||
print(f" repeated run: deleted {again['deleted']}")
|
||||
finally:
|
||||
ops.start("worker")
|
||||
wait_status(api, bob, queued["id"], seconds=90)
|
||||
check(not exists({"q": f"staging/{queued['id']}"})["q"], "staging of the processed job must be removed")
|
||||
print(f"4. worker started: {queued['id']} ready, its staging removed")
|
||||
print("PASS: staging is removed after the result is committed; objects without a reference in the database are "
|
||||
"removed only after the grace period; the staging of failed uploads is kept for replay until retention "
|
||||
"ends; dry-run and repeated runs are safe")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
run(main)
|
||||
@@ -0,0 +1,193 @@
|
||||
"""Помощники lab3 для собственных проверок: реплики, балансировщик, Docker.
|
||||
|
||||
Только стандартная библиотека Python. Docker вызывается прямо из Python (`docker compose ...`),
|
||||
поэтому всё работает одинаково в Git Bash, PowerShell и cmd на Windows.
|
||||
Вывод проверок — латиницей и кириллицей в UTF-8 (в Git Bash задан PYTHONUTF8=1).
|
||||
"""
|
||||
import csv
|
||||
import http.client
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
from helpers import ROOT, check
|
||||
|
||||
BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/")
|
||||
LB_STATS_URL = os.environ.get("LB_STATS_URL", "http://127.0.0.1:8404/stats;csv")
|
||||
|
||||
|
||||
class Reply:
|
||||
"""Ответ без проверок: для нагрузки во время отказа, где ошибки — ожидаемая часть замера."""
|
||||
|
||||
def __init__(self, status, headers, data):
|
||||
self.status = status
|
||||
self.headers = {name.lower(): value for name, value in headers.items()}
|
||||
try:
|
||||
self.json = json.loads(data.decode("utf-8")) if data else None
|
||||
except ValueError:
|
||||
self.json = None
|
||||
|
||||
@property
|
||||
def instance(self):
|
||||
return self.headers.get("x-instance-id")
|
||||
|
||||
|
||||
def try_call(method, path, *, body=None, raw=None, token=None, headers=None, timeout=2.0):
|
||||
"""HTTP-запрос через балансировщик. Reply или None, если соединение оборвалось / вышел timeout.
|
||||
|
||||
Обрыв возможен и посреди ответа (реплику убили, когда заголовки уже ушли): http.client.HTTPException.
|
||||
"""
|
||||
all_headers = dict(headers or {})
|
||||
data = raw
|
||||
if body is not None:
|
||||
data = json.dumps(body, ensure_ascii=False).encode("utf-8")
|
||||
if data is not None:
|
||||
all_headers.setdefault("Content-Type", "application/json")
|
||||
if token is not None:
|
||||
all_headers["Authorization"] = "Bearer " + token
|
||||
request = urllib.request.Request(BASE_URL + path, data=data, method=method, headers=all_headers)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=timeout) as reply:
|
||||
return Reply(reply.status, reply.headers, reply.read())
|
||||
except urllib.error.HTTPError as error:
|
||||
try:
|
||||
return Reply(error.code, error.headers, error.read())
|
||||
except (OSError, http.client.HTTPException):
|
||||
return None
|
||||
except (urllib.error.URLError, OSError, http.client.HTTPException):
|
||||
return None
|
||||
|
||||
|
||||
# ---------- Docker ----------
|
||||
|
||||
def docker(*args, check_exit=True):
|
||||
"""docker <args>; возвращает stdout."""
|
||||
result = subprocess.run(["docker", *args], cwd=ROOT, capture_output=True, check=check_exit)
|
||||
return result.stdout.decode("utf-8", "replace").strip()
|
||||
|
||||
|
||||
def compose_output(*args, env=None):
|
||||
"""docker compose <args> и его вывод (stdout + stderr). Секретов в нём нет: ps, logs, build."""
|
||||
result = subprocess.run(["docker", "compose", *args], cwd=ROOT, capture_output=True, check=True, env=env)
|
||||
return result.stdout.decode("utf-8", "replace") + result.stderr.decode("utf-8", "replace")
|
||||
|
||||
|
||||
def compose_config():
|
||||
"""Итоговая конфигурация стенда (docker compose config) как словарь: только stdout, без предупреждений."""
|
||||
result = subprocess.run(["docker", "compose", "config", "--format", "json"], cwd=ROOT,
|
||||
capture_output=True, check=True)
|
||||
return json.loads(result.stdout.decode("utf-8"))
|
||||
|
||||
|
||||
def compose_quiet(*args, env=None):
|
||||
subprocess.run(["docker", "compose", *args], cwd=ROOT, check=True, env=env,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
|
||||
|
||||
def api_containers(include_stopped=False):
|
||||
"""Полные ID контейнеров сервиса api (по умолчанию только запущенные), по порядку."""
|
||||
args = ["ps", "-q", "-a", "api"] if include_stopped else ["ps", "-q", "api"]
|
||||
return sorted(compose_output(*args).split())
|
||||
|
||||
|
||||
def inspect(container, template):
|
||||
return docker("inspect", "-f", template, container, check_exit=False)
|
||||
|
||||
|
||||
def health(container):
|
||||
"""Статус Docker healthcheck: starting / healthy / unhealthy / ''."""
|
||||
return inspect(container, "{{if .State.Health}}{{.State.Health.Status}}{{end}}")
|
||||
|
||||
|
||||
def ps_table():
|
||||
"""Все контейнеры стенда: сервис, короткий ID (= X-Instance-Id у api), состояние, время старта."""
|
||||
lines = []
|
||||
for container in sorted(compose_output("ps", "-a", "-q").split()):
|
||||
info = inspect(container, '{{index .Config.Labels "com.docker.compose.service"}}|{{.State.Status}}|'
|
||||
'{{.State.StartedAt}}|{{if .State.Health}}{{.State.Health.Status}}{{end}}')
|
||||
service, status, started, healthy = (info.split("|") + ["", "", "", ""])[:4]
|
||||
shown = f"{status} ({healthy})" if healthy and status == "running" else status
|
||||
lines.append((service, container[:12], shown, started[:23]))
|
||||
lines.sort()
|
||||
width = max((len(service) for service, *_ in lines), default=7)
|
||||
text = [f"{'SERVICE':<{width}} CONTAINER STATE STARTED AT (UTC)"]
|
||||
text += [f"{service:<{width}} {cid} {state:<19} {started}" for service, cid, state, started in lines]
|
||||
return "\n".join(text)
|
||||
|
||||
|
||||
# ---------- балансировщик ----------
|
||||
|
||||
def lb_rows(backend="api"):
|
||||
"""Строки статистики HAProxy (CSV) по серверам backend: имя, статус, backup-флаг, результат проверки."""
|
||||
with urllib.request.urlopen(LB_STATS_URL, timeout=2) as reply:
|
||||
rows = list(csv.reader(io.StringIO(reply.read().decode("utf-8", "replace"))))
|
||||
header = [name.lstrip("# ") for name in rows[0]]
|
||||
items = [dict(zip(header, row)) for row in rows[1:]]
|
||||
return [item for item in items
|
||||
if item.get("pxname") == backend and item.get("svname") not in ("FRONTEND", "BACKEND")]
|
||||
|
||||
|
||||
def lb_servers(backend="api"):
|
||||
"""Слоты backend в HAProxy: {имя: статус}, например {'api1': 'UP'}."""
|
||||
return {item["svname"]: item.get("status", "") for item in lb_rows(backend)}
|
||||
|
||||
|
||||
def lb_up_count():
|
||||
"""Сколько реплик (слоты api1..api6) HAProxy держит в балансировке (UP)."""
|
||||
return sum(1 for name, status in lb_servers().items() if name.startswith("api") and status.startswith("UP"))
|
||||
|
||||
|
||||
def lb_summary():
|
||||
"""Короткая строка состояния основных слотов: 'api1 UP, api2 DOWN' (пустые слоты MAINT не показываем)."""
|
||||
servers = lb_servers()
|
||||
shown = [f"{name} {status}" for name, status in sorted(servers.items())
|
||||
if name.startswith("api") and not status.startswith("MAINT")]
|
||||
return ", ".join(shown) or "no api servers"
|
||||
|
||||
|
||||
def wait_balanced(replicas, seconds=90):
|
||||
"""Ждёт, пока replicas контейнеров api healthy и HAProxy держит их в балансировке (UP)."""
|
||||
deadline = time.monotonic() + seconds
|
||||
while True:
|
||||
running = api_containers()
|
||||
healthy = [container for container in running if health(container) == "healthy"]
|
||||
try:
|
||||
up = lb_up_count()
|
||||
except OSError:
|
||||
up = 0
|
||||
if len(healthy) >= replicas and up >= replicas:
|
||||
return running
|
||||
check(time.monotonic() < deadline,
|
||||
f"after {seconds} s: {len(healthy)} healthy api containers, {up} UP in HAProxy, need {replicas}")
|
||||
time.sleep(0.5)
|
||||
|
||||
|
||||
def replica_status(container, path):
|
||||
"""Код ответа реплики на GET path изнутри её контейнера, в обход балансировщика.
|
||||
|
||||
Так видно состояние самой реплики (жива ли, готова ли), когда балансировщик её уже исключил.
|
||||
Одна строка без переводов строк: так команда одинаково передаётся и на Windows, и на Linux.
|
||||
"""
|
||||
code = ("import http.client as h; c = h.HTTPConnection('127.0.0.1', 8080, timeout=5); "
|
||||
f"c.request('GET', '{path}'); print(c.getresponse().status)")
|
||||
return int(docker("exec", container, "python", "-c", code))
|
||||
|
||||
|
||||
def valkey_stats():
|
||||
"""keyspace_hits и keyspace_misses Valkey (пользователь health без пароля: только info/ping/dbsize)."""
|
||||
output = compose_output("exec", "-T", "valkey", "valkey-cli", "--user", "health", "--pass", "none",
|
||||
"--no-auth-warning", "info", "stats")
|
||||
stats = dict(line.strip().split(":", 1) for line in output.splitlines() if line.startswith("keyspace_"))
|
||||
return int(stats["keyspace_hits"]), int(stats["keyspace_misses"])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# make restore: после `docker compose up -d --wait` дождаться, пока HAProxy вернёт в работу
|
||||
# ВСЕ запущенные реплики (DNS + 2 удачные проверки готовности — ещё несколько секунд).
|
||||
replicas = len(api_containers())
|
||||
wait_balanced(replicas)
|
||||
print(f"all {replicas} api replicas are healthy and UP in HAProxy: {lb_summary()}")
|
||||
@@ -0,0 +1,164 @@
|
||||
"""Собственные тесты API (перенесены из lab1, переведены на пароль и Bearer).
|
||||
|
||||
Тесты «чёрного ящика»: шлют настоящие HTTP-запросы на уже запущенный стенд
|
||||
(BASE_URL, по умолчанию http://127.0.0.1:8080 из Makefile; с lab3 это балансировщик,
|
||||
и запросы обслуживают разные реплики). С lab3 POST сообщения несёт Idempotency-Key.
|
||||
Запуск вместе с остальными test_*.py одной командой: make student-test
|
||||
"""
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
from helpers import Client, basic, idempotency, read_history
|
||||
|
||||
PASSWORD = "Test-password-123"
|
||||
|
||||
|
||||
class MessengerApiTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.api = Client()
|
||||
cls.alice, cls.bob, cls.eve, cls.chat = cls.api.bootstrap() # eve не состоит в чате
|
||||
|
||||
def messages_path(self, chat_id):
|
||||
return f"/api/v1/chats/{chat_id}/messages"
|
||||
|
||||
def send(self, actor, chat_id, text, expected=201):
|
||||
schema = "Message" if expected == 201 else None # клиент разбирает JSON успешного ответа только со схемой
|
||||
return self.api.call("POST", self.messages_path(chat_id), expected, actor=actor,
|
||||
body={"text": text}, headers=idempotency(), schema=schema)
|
||||
|
||||
def new_chat(self):
|
||||
body = {"title": "Тест", "member_ids": [self.alice["id"], self.bob["id"]]}
|
||||
return self.api.call("POST", "/api/v1/chats", 201, actor=self.alice, body=body, schema="Chat")["json"]
|
||||
|
||||
def test_malformed_json_returns_400(self):
|
||||
json_header = {"Content-Type": "application/json"}
|
||||
for raw in (b'{"username": "abc",', b"not json", b""):
|
||||
self.api.call("POST", "/api/v1/users", 400, raw=raw, headers=json_header)
|
||||
self.api.call("POST", self.messages_path(self.chat["id"]), 400,
|
||||
actor=self.alice, raw=raw, headers={**json_header, **idempotency()})
|
||||
|
||||
def test_wrong_types_and_extra_fields_return_400(self):
|
||||
self.api.call("POST", "/api/v1/users", 400,
|
||||
body={"username": 123, "display_name": "x", "password": PASSWORD})
|
||||
self.api.call("POST", "/api/v1/users", 400,
|
||||
body={"username": "valid_name", "display_name": "x", "password": PASSWORD, "is_admin": True})
|
||||
self.api.call("POST", "/api/v1/users", 400,
|
||||
body={"username": "Bad Name!", "display_name": "x", "password": PASSWORD})
|
||||
# Отправителя нельзя подставить: он берётся из сессии.
|
||||
self.api.call("POST", self.messages_path(self.chat["id"]), 400, actor=self.alice,
|
||||
body={"text": "hi", "sender_id": self.bob["id"]}, headers=idempotency())
|
||||
|
||||
def test_outsider_gets_404_for_foreign_chat(self):
|
||||
chat_id = self.chat["id"]
|
||||
self.api.call("GET", f"/api/v1/chats/{chat_id}", 404, actor=self.eve)
|
||||
self.api.call("GET", self.messages_path(chat_id), 404, actor=self.eve)
|
||||
self.send(self.eve, chat_id, "чужое", expected=404)
|
||||
# Несуществующий чат выглядит так же, как чужой: существование не раскрывается.
|
||||
self.api.call("GET", f"/api/v1/chats/{uuid.uuid4()}", 404, actor=self.eve)
|
||||
|
||||
def test_auth_checked_before_access_and_body(self):
|
||||
# Без токена — всегда 401, даже если тело кривое или чат чужой: сначала «кто ты».
|
||||
self.api.call("POST", self.messages_path(self.chat["id"]), 401, raw=b"not json",
|
||||
headers={"Content-Type": "application/json", **idempotency()})
|
||||
self.api.call("GET", f"/api/v1/chats/{uuid.uuid4()}", 401)
|
||||
|
||||
def test_empty_blank_and_too_long_messages_return_400(self):
|
||||
for text in ("", " ", "\n\t "):
|
||||
self.send(self.alice, self.chat["id"], text, expected=400)
|
||||
self.send(self.alice, self.chat["id"], "я" * 4001, expected=400)
|
||||
self.send(self.alice, self.chat["id"], "я" * 4000) # ровно на границе — можно
|
||||
|
||||
def test_duplicate_username_returns_409(self):
|
||||
body = {"username": "dup_" + uuid.uuid4().hex[:12], "display_name": "Первый", "password": PASSWORD}
|
||||
self.api.call("POST", "/api/v1/users", 201, body=body)
|
||||
self.api.call("POST", "/api/v1/users", 409, body=dict(body, display_name="Второй"))
|
||||
|
||||
def test_unicode_roundtrip(self):
|
||||
text = "Привет 👋 你好 ﷽ é"
|
||||
sent = self.send(self.alice, self.chat["id"], text)["json"]
|
||||
self.assertEqual(sent["text"], text)
|
||||
history, _ = read_history(self.api, self.bob, self.chat["id"])
|
||||
self.assertIn(text, [m["text"] for m in history])
|
||||
# Длина считается в символах Unicode: 100 эмодзи можно, 101 — нет.
|
||||
name = "n_" + uuid.uuid4().hex[:12]
|
||||
self.api.call("POST", "/api/v1/users", 400,
|
||||
body={"username": name, "display_name": "👋" * 101, "password": PASSWORD})
|
||||
self.api.call("POST", "/api/v1/users", 201,
|
||||
body={"username": name, "display_name": "👋" * 100, "password": PASSWORD})
|
||||
|
||||
def test_nul_character_is_stored(self):
|
||||
# Замечание к MR: U+0000 допустим по контракту и должен сохраняться как есть, а не давать 500.
|
||||
name = "nul_" + uuid.uuid4().hex[:10]
|
||||
password = "Pass\u0000word-123"
|
||||
user = self.api.call("POST", "/api/v1/users", 201, schema="User",
|
||||
body={"username": name, "display_name": "A\u0000B", "password": password})["json"]
|
||||
self.assertEqual(user["display_name"], "A\u0000B")
|
||||
session = self.api.call("POST", "/api/v1/auth/sessions", 201, schema="Session",
|
||||
headers={"Authorization": basic(name, password)})["json"]
|
||||
self.assertEqual(session["user"]["display_name"], "A\u0000B")
|
||||
chat = self.api.call("POST", "/api/v1/chats", 201, actor=self.alice, schema="Chat",
|
||||
body={"title": "T\u0000itle", "member_ids": [self.alice["id"], self.bob["id"]]})["json"]
|
||||
self.assertEqual(chat["title"], "T\u0000itle")
|
||||
sent = self.send(self.alice, chat["id"], "hello\u0000world")["json"]
|
||||
self.assertEqual(sent["text"], "hello\u0000world")
|
||||
history, _ = read_history(self.api, self.bob, chat["id"])
|
||||
self.assertEqual([m["text"] for m in history], ["hello\u0000world"])
|
||||
got = self.api.call("GET", f"/api/v1/chats/{chat['id']}", actor=self.bob, schema="Chat")["json"]
|
||||
self.assertEqual(got["title"], "T\u0000itle")
|
||||
# username с U+0000 существовать не может: вход — обычный 401, а не 500.
|
||||
self.api.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": basic("ab\u0000c", password)})
|
||||
|
||||
def test_pagination_walks_several_pages(self):
|
||||
chat = self.new_chat()
|
||||
sent = [self.send(self.alice, chat["id"], f"msg {i}")["json"] for i in range(7)]
|
||||
history, pages = read_history(self.api, self.bob, chat["id"], limit=3)
|
||||
self.assertEqual(pages, 3) # 3 + 3 + 1
|
||||
self.assertEqual([m["id"] for m in history], [m["id"] for m in sent]) # без потерь, дублей и перестановок
|
||||
|
||||
def test_chat_list_pagination(self):
|
||||
created = [self.new_chat()["id"] for _ in range(3)]
|
||||
seen, cursor = [], None
|
||||
while True:
|
||||
query = "?limit=2" + (f"&cursor={cursor}" if cursor else "")
|
||||
page = self.api.call("GET", "/api/v1/chats" + query, actor=self.bob, schema="ChatPage")["json"]
|
||||
seen += [c["id"] for c in page["items"]]
|
||||
cursor = page["next_cursor"]
|
||||
if cursor is None:
|
||||
break
|
||||
self.assertEqual(len(seen), len(set(seen)))
|
||||
self.assertEqual(seen[-3:], created) # новые чаты в конце, порядок (created_at, id)
|
||||
|
||||
def test_bad_cursor_returns_400(self):
|
||||
chat_a, chat_b = self.new_chat(), self.new_chat()
|
||||
for i in range(2):
|
||||
self.send(self.alice, chat_a["id"], f"a{i}")
|
||||
first = self.api.call("GET", self.messages_path(chat_a["id"]) + "?limit=1",
|
||||
actor=self.alice, schema="MessagePage")["json"]
|
||||
foreign_cursor = first["next_cursor"]
|
||||
self.api.call("GET", self.messages_path(chat_b["id"]) + "?cursor=" + foreign_cursor, 400, actor=self.alice)
|
||||
self.api.call("GET", self.messages_path(chat_a["id"]) + "?cursor=garbage", 400, actor=self.alice)
|
||||
# Курсор правильной формы, но с испорченным временем/UUID: 400, а не ошибка БД (500).
|
||||
import base64
|
||||
import json
|
||||
scope = "messages:" + chat_a["id"]
|
||||
for bad in ([scope, "not-a-time", str(uuid.uuid4())],
|
||||
[scope, "2026-01-01T00:00:00.000000Z", "not-a-uuid"],
|
||||
[scope, "2026-01-01T00:00:00", str(uuid.uuid4())], # без часового пояса
|
||||
[scope, "0001-01-01T00:00:00+14:00", str(uuid.uuid4())], # в UTC это год 0
|
||||
[scope, "9999-12-31T23:59:59-14:00", str(uuid.uuid4())]): # в UTC это год 10000
|
||||
forged = base64.urlsafe_b64encode(json.dumps(bad).encode()).decode()
|
||||
self.api.call("GET", self.messages_path(chat_a["id"]) + "?cursor=" + forged, 400, actor=self.alice)
|
||||
for limit in ("0", "101", "abc"):
|
||||
self.api.call("GET", self.messages_path(chat_a["id"]) + "?limit=" + limit, 400, actor=self.alice)
|
||||
|
||||
def test_chat_membership_rules(self):
|
||||
alice, bob = self.alice["id"], self.bob["id"]
|
||||
for members in ([bob], [alice, alice], [alice, str(uuid.uuid4())]): # без себя, дубль, неизвестный
|
||||
self.api.call("POST", "/api/v1/chats", 400, actor=self.alice, body={"title": "x", "member_ids": members})
|
||||
chats = self.api.call("GET", "/api/v1/chats?limit=100", actor=self.eve, schema="ChatPage")["json"]
|
||||
self.assertNotIn(self.chat["id"], [c["id"] for c in chats["items"]])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,290 @@
|
||||
"""lab4–lab5: вложения через API (входит в make student-test; нужен только запущенный стенд).
|
||||
|
||||
С lab5 загрузка отвечает 202 queued, а ready выясняется опросом GET (worker обрабатывает асинхронно).
|
||||
Уровень 3: PNG и JPEG принимаются, после обработки оригинал скачивается побайтно, у каждого
|
||||
вложения ровно один набор вариантов; посторонний получает 404.
|
||||
Варианты по контракту: thumbnail — JPEG, вписан в 256×256 без увеличения (fixture 320×200 ->
|
||||
256×160); crop — JPEG 128×128 (маленькие увеличиваются); optimized — WebP, вписан в 1280×1280
|
||||
без увеличения. Размеры проверяются по самим байтам (заголовки JPEG и WebP), а не только по JSON.
|
||||
Без метаданных: в вариантах нет EXIF (APP1), ICC (APP2), блоков EXIF/XMP/ICCP у WebP.
|
||||
Уровень 4 (lab4, сохранено): слишком большой файл, «бомба» по пикселям, повреждённые файлы,
|
||||
подмена MIME, опасные filename, чужое attachment_id и вложение другого чата — точные коды, без 500.
|
||||
Замечание к MR (lab5): JPEG с ошибками в заголовках (SOS ссылается на компонент, которого нет в SOF,
|
||||
неопределённые таблицы, неверные параметры сканов, RST не по порядку и др.) — 415 сразу, а не 202 -> failed.
|
||||
lab5: failed-вложение нельзя прикрепить (409), его байты — 409; ровно 10 MiB и ровно 40 млн
|
||||
пикселей принимаются, на байт/пиксель больше — 413.
|
||||
"""
|
||||
import hashlib
|
||||
import unittest
|
||||
import uuid
|
||||
from urllib.parse import quote
|
||||
|
||||
from filegen import (PROGRESSIVE_JPEG, RESTART_JPEG, SAMPLE_JPEG, SAMPLE_PNG, bad_filter_png, bomb_png,
|
||||
broken_structure_jpegs, corrupt_crc, garbage_scan_jpeg, gray_png, jpeg_markers, png, png_exact_size,
|
||||
raw_upload, truncated, wait_status, webp_chunks, webp_size)
|
||||
from helpers import Client, idempotency
|
||||
from image_probe import jpeg_size
|
||||
|
||||
MAX = 10 * 1024 * 1024
|
||||
FIXTURE_VARIANTS = {"thumbnail": ("image/jpeg", 256, 160), "crop": ("image/jpeg", 128, 128),
|
||||
"optimized": ("image/webp", 320, 200)}
|
||||
|
||||
|
||||
class AttachmentTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.api = Client(timeout=30)
|
||||
cls.alice, cls.bob, cls.eve, cls.chat = cls.api.bootstrap()
|
||||
# Второй чат Алисы (с Евой) и чат Евы с Бобом: для проверок «чужое» и «из другого чата».
|
||||
cls.other_chat = cls.chat_of(cls.alice, cls.eve)
|
||||
cls.eve_chat = cls.chat_of(cls.eve, cls.bob)
|
||||
|
||||
@classmethod
|
||||
def chat_of(cls, creator, other):
|
||||
return cls.api.call("POST", "/api/v1/chats", 201, actor=creator, schema="Chat",
|
||||
body={"title": "lab5", "member_ids": [creator["id"], other["id"]]})["json"]
|
||||
|
||||
def upload(self, data, ctype="image/png", name="photo.png", expected=202, actor=None, chat=None):
|
||||
chat = chat or self.chat
|
||||
query = "" if name is None else "?filename=" + quote(name, safe="")
|
||||
return self.api.call("POST", f"/api/v1/chats/{chat['id']}/attachments{query}", expected,
|
||||
actor=actor or self.alice, raw=data, headers={"Content-Type": ctype},
|
||||
schema="Attachment" if expected == 202 else None)
|
||||
|
||||
def ready(self, attachment_id, actor=None):
|
||||
return wait_status(self.api, actor or self.bob, attachment_id, ("ready",))
|
||||
|
||||
def post_message(self, body, expected=201, key=None):
|
||||
return self.api.call("POST", f"/api/v1/chats/{self.chat['id']}/messages", expected, actor=self.alice,
|
||||
body=body, headers=idempotency(key), schema="Message" if expected == 201 else None)
|
||||
|
||||
def content(self, attachment_id, variant=None, expected=200, actor=None):
|
||||
suffix = "" if variant is None else "?variant=" + variant
|
||||
return self.api.call("GET", f"/api/v1/attachments/{attachment_id}/content{suffix}", expected,
|
||||
actor=actor or self.bob)
|
||||
|
||||
# ---------- уровень 3 ----------
|
||||
|
||||
def test_png_and_jpeg_roundtrip_for_member(self):
|
||||
for data, ctype, name in ((SAMPLE_PNG, "image/png", "sample.png"), (SAMPLE_JPEG, "image/jpeg", "кот 🐱.jpg")):
|
||||
att = self.upload(data, ctype, name)["json"]
|
||||
# 202 — снимок «принято в обработку»: статус queued, вариантов ещё нет.
|
||||
self.assertEqual((att["status"], att["variants"], att["error_code"]), ("queued", [], None))
|
||||
self.assertEqual((att["content_type"], att["filename"], att["size_bytes"]), (ctype, name, len(data)))
|
||||
self.assertEqual(att["sha256"], hashlib.sha256(data).hexdigest())
|
||||
meta = self.ready(att["id"])
|
||||
self.assertEqual((meta["status"], meta["error_code"]), ("ready", None))
|
||||
self.assertEqual([v["name"] for v in meta["variants"]], ["thumbnail", "crop", "optimized"])
|
||||
# size_bytes/sha256/content_type по-прежнему описывают ОРИГИНАЛ.
|
||||
self.assertEqual((meta["size_bytes"], meta["sha256"], meta["content_type"]),
|
||||
(att["size_bytes"], att["sha256"], att["content_type"]))
|
||||
got = self.content(att["id"])
|
||||
self.assertEqual(got["bytes"], data)
|
||||
self.assertEqual(got["headers"].get_content_type(), ctype)
|
||||
self.assertEqual(got["headers"].get("X-Content-Type-Options"), "nosniff")
|
||||
for suffix in ("", "/content", "/content?variant=thumbnail"): # посторонний не узнаёт, что вложение есть
|
||||
self.api.call("GET", f"/api/v1/attachments/{att['id']}{suffix}", 404, actor=self.eve)
|
||||
self.api.call("GET", f"/api/v1/attachments/{att['id']}{suffix}", 401)
|
||||
|
||||
def test_variants_follow_the_contract(self):
|
||||
att = self.upload(SAMPLE_PNG, name="variants.png")["json"]
|
||||
meta = self.ready(att["id"])
|
||||
for variant in meta["variants"]:
|
||||
name = variant["name"]
|
||||
ctype, width, height = FIXTURE_VARIANTS[name]
|
||||
self.assertEqual((variant["content_type"], variant["width"], variant["height"]), (ctype, width, height))
|
||||
got = self.content(att["id"], name)
|
||||
body = got["bytes"]
|
||||
self.assertEqual(got["headers"].get_content_type(), ctype)
|
||||
self.assertEqual((len(body), hashlib.sha256(body).hexdigest()), (variant["size_bytes"], variant["sha256"]))
|
||||
if ctype == "image/jpeg":
|
||||
self.assertEqual(jpeg_size(body), (width, height)) # реальный размер из заголовка JPEG
|
||||
markers = jpeg_markers(body)
|
||||
self.assertNotIn(0xE1, markers, f"{name}: EXIF/XMP (APP1) must be stripped")
|
||||
self.assertNotIn(0xE2, markers, f"{name}: ICC (APP2) must be stripped")
|
||||
else:
|
||||
self.assertEqual(webp_size(body), (width, height))
|
||||
self.assertFalse({b"EXIF", b"XMP ", b"ICCP"} & set(webp_chunks(body)), "WebP metadata must be stripped")
|
||||
# Маленький JPEG 48×32: thumbnail и optimized не увеличиваются, crop — увеличивается до 128×128.
|
||||
small = self.ready(self.upload(SAMPLE_JPEG, "image/jpeg", "small.jpg")["json"]["id"])
|
||||
sizes = {v["name"]: (v["width"], v["height"]) for v in small["variants"]}
|
||||
self.assertEqual(sizes, {"thumbnail": (48, 32), "crop": (128, 128), "optimized": (48, 32)})
|
||||
print(f"\n fixture 320×200 -> thumbnail 256×160 JPEG, crop 128×128 JPEG, optimized 320×200 WebP; "
|
||||
f"48×32 -> {sizes}")
|
||||
|
||||
def test_outsider_and_anonymous_cannot_upload(self):
|
||||
self.upload(SAMPLE_PNG, actor=self.eve, expected=404) # Ева не участник чата
|
||||
self.api.call("POST", f"/api/v1/chats/{self.chat['id']}/attachments?filename=a.png", 401,
|
||||
raw=SAMPLE_PNG, headers={"Content-Type": "image/png"})
|
||||
self.upload(SAMPLE_PNG, chat={"id": str(uuid.uuid4())}, expected=404)
|
||||
self.upload(SAMPLE_PNG, chat={"id": "not-a-uuid"}, expected=400)
|
||||
|
||||
# ---------- уровень 4: размер ----------
|
||||
|
||||
def test_too_large_is_413_before_reading(self):
|
||||
# Заявлено 10 MiB + 1 байт: ответ 413 приходит сразу, сервер тело не читает.
|
||||
reply = raw_upload(f"/api/v1/chats/{self.chat['id']}/attachments?filename=big.png",
|
||||
self.alice["token"], b"", content_length=MAX + 1)
|
||||
self.assertIsNotNone(reply, "no HTTP response")
|
||||
status, _, body = reply
|
||||
self.assertEqual((status, body["error"]["code"]), (413, "payload_too_large"))
|
||||
|
||||
def test_too_large_stream_is_413(self):
|
||||
# Тот же размер по частям (chunked, без Content-Length): сервер считает байты при чтении.
|
||||
data = SAMPLE_PNG + b"\x00" * (MAX + 1 - len(SAMPLE_PNG))
|
||||
reply = raw_upload(f"/api/v1/chats/{self.chat['id']}/attachments?filename=big.png",
|
||||
self.alice["token"], data, content_length=-1)
|
||||
self.assertIsNotNone(reply, "no HTTP response")
|
||||
status, _, body = reply
|
||||
self.assertEqual((status, body["error"]["code"]), (413, "payload_too_large"))
|
||||
|
||||
def test_exact_limits(self):
|
||||
# Ровно 10 485 760 байт и ровно 40 000 000 пикселей — принимаются; на 1 больше — 413.
|
||||
exact = png_exact_size(MAX)
|
||||
self.assertEqual(len(exact), MAX)
|
||||
self.ready(self.upload(exact, name="exact-10mib.png")["json"]["id"])
|
||||
self.upload(png_exact_size(MAX + 1), name="over.png", expected=413)
|
||||
self.ready(self.upload(gray_png(6400, 6250), name="exact-40mp.png")["json"]["id"])
|
||||
self.upload(gray_png(40_000_001, 1), name="over-40mp.png", expected=413)
|
||||
print("\n 10 485 760 байт и 6400×6250 = 40 000 000 px: 202 -> ready; на 1 байт/пиксель больше: 413")
|
||||
|
||||
def test_pixel_bomb_is_413(self):
|
||||
bomb = bomb_png()
|
||||
self.assertLess(len(bomb), MAX) # по байтам файл маленький
|
||||
reply = self.upload(bomb, expected=413)["json"]
|
||||
self.assertIn("пиксел", reply["error"]["message"]) # отклонён именно по пикселям
|
||||
|
||||
def test_large_real_image_within_limits_is_accepted(self):
|
||||
data = png(1600, 1200, noise=True) # ~5,8 МБ, 1,9 млн пикселей
|
||||
att = self.upload(data, name="noise.png")["json"]
|
||||
meta = self.ready(att["id"])
|
||||
got = self.content(att["id"])
|
||||
self.assertEqual(hashlib.sha256(got["bytes"]).hexdigest(), hashlib.sha256(data).hexdigest())
|
||||
sizes = {v["name"]: (v["width"], v["height"]) for v in meta["variants"]}
|
||||
self.assertEqual(sizes, {"thumbnail": (256, 192), "crop": (128, 128), "optimized": (1280, 960)})
|
||||
|
||||
# ---------- уровень 4: содержимое ----------
|
||||
|
||||
def test_corrupted_images_are_415(self):
|
||||
for data, ctype in ((truncated(SAMPLE_PNG), "image/png"), (corrupt_crc(SAMPLE_PNG), "image/png"),
|
||||
(truncated(SAMPLE_JPEG), "image/jpeg"), (b"\x89PNG\r\n\x1a\n" + b"x" * 100, "image/png"),
|
||||
(bytes(range(256)) * 10, "image/png"), (bad_filter_png(), "image/png"),
|
||||
(SAMPLE_PNG + b"<html>tail</html>", "image/png")):
|
||||
with self.subTest(size=len(data), ctype=ctype):
|
||||
self.assertEqual(self.upload(data, ctype, expected=415)["json"]["error"]["code"],
|
||||
"unsupported_media_type")
|
||||
self.upload(b"", expected=400) # пустое тело
|
||||
|
||||
def test_structurally_broken_jpeg_is_415(self):
|
||||
# Замечание к MR: первый SOS ссылался на компонент 250, которого нет в SOF, а API отвечал
|
||||
# 202 (потом failed/invalid_image). Теперь всё, что строгий декодер worker отвергает по
|
||||
# маркерам и заголовкам, отклоняется сразу: 415, в БД и S3 ничего не появляется.
|
||||
for name, data in broken_structure_jpegs():
|
||||
with self.subTest(name):
|
||||
reply = self.upload(data, "image/jpeg", "broken.jpg", expected=415)
|
||||
self.assertEqual(reply["json"]["error"]["code"], "unsupported_media_type")
|
||||
|
||||
def test_valid_jpeg_variants_are_accepted(self):
|
||||
# Обратная сторона: строгая проверка не отклоняет правильные progressive JPEG и JPEG
|
||||
# с маркерами RST — они проходят и доходят до ready с тремя вариантами.
|
||||
for name, data in (("progressive", PROGRESSIVE_JPEG), ("restart-markers", RESTART_JPEG)):
|
||||
with self.subTest(name):
|
||||
att = self.upload(data, "image/jpeg", f"{name}.jpg")["json"]
|
||||
ready = self.ready(att["id"])
|
||||
self.assertEqual(sorted(v["name"] for v in ready["variants"]), ["crop", "optimized", "thumbnail"])
|
||||
self.assertEqual(self.content(att["id"])["bytes"], data)
|
||||
|
||||
def test_mime_spoofing_is_415(self):
|
||||
cases = ((SAMPLE_PNG, "image/jpeg"), # PNG под видом JPEG
|
||||
(SAMPLE_JPEG, "image/png"), # JPEG под видом PNG
|
||||
(b"GIF89a" + b"\x00" * 50, "image/png"), # GIF под видом PNG
|
||||
(b"<svg xmlns='http://www.w3.org/2000/svg'/>", "image/png"),
|
||||
(SAMPLE_PNG, "image/gif"), (SAMPLE_PNG, "text/plain"),
|
||||
(SAMPLE_PNG, "application/x-www-form-urlencoded")) # по сути «Content-Type не указан»
|
||||
for data, ctype in cases:
|
||||
with self.subTest(ctype=ctype, head=data[:4]):
|
||||
self.upload(data, ctype, expected=415)
|
||||
|
||||
def test_dangerous_filenames_are_400(self):
|
||||
for name in (None, "", " ", "a/b.png", "..\\b.png", "a\x00b.png", "a\nb.png", "a\tb.png", "..",
|
||||
"photognp.exe", "c1\u0085.png", "line
break.png", "x" * 256):
|
||||
with self.subTest(name=repr(name)):
|
||||
self.upload(SAMPLE_PNG, name=name, expected=400)
|
||||
name = "отпуск 2026 (1).png" # Unicode и пробелы — можно
|
||||
self.assertEqual(self.upload(SAMPLE_PNG, name=name)["json"]["filename"], name)
|
||||
|
||||
def test_broken_scan_becomes_failed_and_cannot_be_attached(self):
|
||||
# Структура JPEG цела (API принимает: 202), но сжатые данные — мусор: worker при строгом
|
||||
# декодировании даёт постоянную ошибку -> failed с invalid_image, без повторов.
|
||||
att = self.upload(garbage_scan_jpeg(), "image/jpeg", "broken.jpg")["json"]
|
||||
failed = wait_status(self.api, self.bob, att["id"], ("failed",))
|
||||
self.assertEqual((failed["error_code"], failed["variants"]), ("invalid_image", []))
|
||||
self.content(att["id"], expected=409)
|
||||
self.content(att["id"], "thumbnail", expected=409)
|
||||
self.post_message({"text": "", "attachment_ids": [att["id"]]}, 409)
|
||||
good = self.upload(SAMPLE_PNG, name="good.png")["json"]["id"]
|
||||
self.post_message({"text": "x", "attachment_ids": [good, att["id"]]}, 409) # одно failed — отказ целиком
|
||||
self.post_message({"text": "x", "attachment_ids": [att["id"], str(uuid.uuid4())]}, 404) # неизвестное — 404
|
||||
|
||||
# ---------- уровень 4: привязка к сообщению ----------
|
||||
|
||||
def test_message_with_attachments(self):
|
||||
a1 = self.upload(SAMPLE_PNG)["json"]["id"]
|
||||
a2 = self.upload(SAMPLE_JPEG, "image/jpeg", "b.jpg")["json"]["id"]
|
||||
# Ещё не обработанное (queued/processing) вложение прикреплять можно (lab5).
|
||||
message = self.post_message({"text": "", "attachment_ids": [a2, a1]})["json"]
|
||||
self.assertEqual(message["attachment_ids"], [a2, a1]) # порядок сохраняется
|
||||
page = self.api.call("GET", f"/api/v1/chats/{self.chat['id']}/messages?limit=100", actor=self.bob,
|
||||
schema="MessagePage")["json"]
|
||||
self.assertIn(message, page["items"]) # история отдаёт те же attachment_ids
|
||||
again = self.post_message({"text": "то же вложение ещё раз", "attachment_ids": [a1]})["json"]
|
||||
self.assertEqual(again["attachment_ids"], [a1]) # одно вложение — в нескольких сообщениях
|
||||
plain = self.post_message({"text": "без вложений"})["json"]
|
||||
self.assertEqual(plain["attachment_ids"], [])
|
||||
|
||||
def test_attachment_rules_without_500(self):
|
||||
att = self.upload(SAMPLE_PNG)["json"]["id"]
|
||||
foreign = self.upload(SAMPLE_PNG, actor=self.eve, chat=self.eve_chat)["json"]["id"] # чужое
|
||||
other = self.upload(SAMPLE_PNG, chat=self.other_chat)["json"]["id"] # Алисы, но другой чат
|
||||
self.post_message({"text": "", "attachment_ids": [foreign]}, 404)
|
||||
self.post_message({"text": "", "attachment_ids": [other]}, 404)
|
||||
self.post_message({"text": "x", "attachment_ids": [att, str(uuid.uuid4())]}, 404) # одно неизвестное
|
||||
self.post_message({"text": ""}, 400) # пусто и без вложений
|
||||
self.post_message({"text": " ", "attachment_ids": []}, 400)
|
||||
self.post_message({"text": "x", "attachment_ids": [att, att]}, 400) # дубликаты
|
||||
self.post_message({"text": "x", "attachment_ids": [str(uuid.uuid4()) for _ in range(11)]}, 400)
|
||||
self.post_message({"text": "x", "attachment_ids": ["not-a-uuid"]}, 400)
|
||||
self.post_message({"text": "x", "attachment_ids": att}, 400) # не массив
|
||||
self.post_message({"attachment_ids": [att]}, 400) # нет text
|
||||
self.post_message({"text": None, "attachment_ids": [att]}, 400)
|
||||
self.post_message({"text": "x", "attachment_ids": None}, 400)
|
||||
# Провал не «занимает» сообщение: в истории нет ни одного из отклонённых.
|
||||
page = self.api.call("GET", f"/api/v1/chats/{self.chat['id']}/messages?limit=100", actor=self.alice,
|
||||
schema="MessagePage")["json"]["items"]
|
||||
self.assertFalse([m for m in page if foreign in m["attachment_ids"] or other in m["attachment_ids"]])
|
||||
|
||||
def test_idempotency_with_attachments(self):
|
||||
att = self.upload(SAMPLE_PNG)["json"]["id"]
|
||||
key = uuid.uuid4().hex
|
||||
first = self.post_message({"text": "фото"}, key=key)["json"]
|
||||
replay = self.post_message({"attachment_ids": [], "text": "фото"}, key=key)["json"] # [] == отсутствует
|
||||
self.assertEqual(first, replay)
|
||||
self.post_message({"text": "фото", "attachment_ids": [att]}, 409, key=key) # другое тело
|
||||
key2 = uuid.uuid4().hex
|
||||
with_att = self.post_message({"text": "", "attachment_ids": [att]}, key=key2)["json"]
|
||||
self.assertEqual(self.post_message({"text": "", "attachment_ids": [att]}, key=key2)["json"], with_att)
|
||||
|
||||
def test_variants_and_bad_ids(self):
|
||||
att = self.upload(SAMPLE_PNG)["json"]["id"]
|
||||
self.ready(att)
|
||||
path = f"/api/v1/attachments/{att}/content"
|
||||
self.assertEqual(self.api.call("GET", path + "?variant=original", actor=self.bob)["bytes"], SAMPLE_PNG)
|
||||
self.api.call("GET", path + "?variant=thumbnail", actor=self.bob)
|
||||
self.api.call("GET", path + "?variant=huge", 400, actor=self.bob)
|
||||
self.api.call("GET", "/api/v1/attachments/not-a-uuid", 400, actor=self.bob)
|
||||
self.api.call("GET", f"/api/v1/attachments/{uuid.uuid4()}/content", 404, actor=self.bob)
|
||||
self.api.call("GET", f"/api/v1/attachments/{uuid.uuid4()}", 404, actor=self.bob)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main(verbosity=2)
|
||||
@@ -0,0 +1,118 @@
|
||||
"""Собственные тесты аутентификации (уровень 4): пароль, Basic -> Bearer, logout.
|
||||
|
||||
Запуск: make student-test (вместе с test_api.py)
|
||||
"""
|
||||
import base64
|
||||
import datetime as dt
|
||||
import unittest
|
||||
import uuid
|
||||
|
||||
from helpers import Client, basic, login
|
||||
|
||||
PASSWORD = "Test-password-123"
|
||||
|
||||
|
||||
def iso(value):
|
||||
return dt.datetime.fromisoformat(value.replace("Z", "+00:00"))
|
||||
|
||||
|
||||
class AuthTest(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.api = Client()
|
||||
|
||||
def register(self, password=PASSWORD, expected=201):
|
||||
body = {"username": "a_" + uuid.uuid4().hex[:12], "display_name": "Auth", "password": password}
|
||||
user = self.api.call("POST", "/api/v1/users", expected, body=body,
|
||||
schema="User" if expected == 201 else None)["json"]
|
||||
return body, user
|
||||
|
||||
def me(self, token, expected=200):
|
||||
return self.api.call("GET", "/api/v1/users/me", expected, headers={"Authorization": "Bearer " + token},
|
||||
schema="User" if expected == 200 else None)
|
||||
|
||||
def test_login_returns_opaque_token_with_expiry(self):
|
||||
body, user = self.register()
|
||||
session = login(self.api, body["username"], body["password"])
|
||||
self.assertEqual(session["user"], user)
|
||||
token = session["token"]
|
||||
self.assertGreaterEqual(len(token), 43) # 32 случайных байта в base64url
|
||||
self.assertNotIn(body["username"], token)
|
||||
self.assertNotIn(user["id"], token)
|
||||
# Обычный стенд: TTL не меньше 300 с (по умолчанию 3600).
|
||||
left = iso(session["expires_at"]) - dt.datetime.now(dt.timezone.utc)
|
||||
self.assertGreater(left.total_seconds(), 290)
|
||||
self.assertEqual(self.me(token)["json"], user)
|
||||
|
||||
def test_user_never_contains_password(self):
|
||||
body, user = self.register()
|
||||
self.assertEqual(set(user), {"id", "username", "display_name", "created_at"})
|
||||
self.assertNotIn(body["password"], str(user))
|
||||
|
||||
def test_wrong_password_and_unknown_user_look_the_same(self):
|
||||
body, _ = self.register()
|
||||
wrong = login(self.api, body["username"], "Wrong-password-000", expected=401)
|
||||
unknown = login(self.api, "nobody_" + uuid.uuid4().hex[:8], body["password"], expected=401)
|
||||
# Одинаковый код и текст: по ответу нельзя узнать, существует ли username.
|
||||
self.assertEqual(wrong["error"]["code"], unknown["error"]["code"])
|
||||
self.assertEqual(wrong["error"]["message"], unknown["error"]["message"])
|
||||
|
||||
def test_malformed_basic_returns_401(self):
|
||||
path = "/api/v1/auth/sessions"
|
||||
no_colon = base64.b64encode(b"just_username").decode()
|
||||
for header in (None, "Basic", "Basic !!!not-base64!!!", "Basic " + no_colon, "Bearer something"):
|
||||
headers = {} if header is None else {"Authorization": header}
|
||||
self.api.call("POST", path, 401, headers=headers) # клиент проверяет WWW-Authenticate: Basic
|
||||
|
||||
def test_password_with_colon_and_unicode(self):
|
||||
password = "пароль:с:двоеточием 👋"
|
||||
body, user = self.register(password=password)
|
||||
session = login(self.api, body["username"], password)
|
||||
self.assertEqual(session["user"], user)
|
||||
|
||||
def test_password_length_rules(self):
|
||||
self.register(password="x" * 11, expected=400)
|
||||
self.register(password="x" * 129, expected=400)
|
||||
self.register(password=" " * 12, expected=400) # только пробелы — нельзя
|
||||
self.register(password="x" * 12)
|
||||
self.register(password="я" * 128) # 128 символов Unicode — можно
|
||||
|
||||
def test_bearer_required_on_business_endpoints(self):
|
||||
body, user = self.register()
|
||||
session = login(self.api, body["username"], body["password"])
|
||||
for headers in ({}, {"Authorization": basic(body["username"], body["password"])},
|
||||
{"X-User-Id": user["id"]}, {"Authorization": "Bearer " + "A" * 43},
|
||||
{"Authorization": "Bearer"}, {"Authorization": "Token " + session["token"]}):
|
||||
self.api.call("GET", "/api/v1/users/me", 401, headers=headers) # WWW-Authenticate: Bearer
|
||||
# Схема нечувствительна к регистру (RFC 7235).
|
||||
self.api.call("GET", "/api/v1/users/me", 200, headers={"Authorization": "bearer " + session["token"]})
|
||||
|
||||
def test_x_user_id_does_not_change_identity(self):
|
||||
body, user = self.register()
|
||||
_, other = self.register()
|
||||
session = login(self.api, body["username"], body["password"])
|
||||
me = self.api.call("GET", "/api/v1/users/me", headers={
|
||||
"Authorization": "Bearer " + session["token"], "X-User-Id": other["id"]}, schema="User")["json"]
|
||||
self.assertEqual(me["id"], user["id"])
|
||||
|
||||
def test_logout_revokes_only_current_session(self):
|
||||
body, _ = self.register()
|
||||
first = login(self.api, body["username"], body["password"])["token"]
|
||||
second = login(self.api, body["username"], body["password"])["token"]
|
||||
self.me(first) # запись попадает в кэш Valkey
|
||||
self.api.call("DELETE", "/api/v1/auth/sessions/current", 204, headers={"Authorization": "Bearer " + first})
|
||||
self.me(first, expected=401) # кэш инвалидирован: отозванный токен не принимается сразу
|
||||
self.api.call("DELETE", "/api/v1/auth/sessions/current", 401, headers={"Authorization": "Bearer " + first})
|
||||
self.me(second) # другая сессия того же пользователя продолжает работать
|
||||
|
||||
def test_relogin_after_logout(self):
|
||||
body, _ = self.register()
|
||||
token = login(self.api, body["username"], body["password"])["token"]
|
||||
self.api.call("DELETE", "/api/v1/auth/sessions/current", 204, headers={"Authorization": "Bearer " + token})
|
||||
again = login(self.api, body["username"], body["password"])["token"]
|
||||
self.assertNotEqual(token, again)
|
||||
self.me(again)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user